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

def data (self, index, role=QtCore.Qt.DisplayRole):
        """Return URL item data at given index for given role."""
        V = QtCore.QVariant
        if not index.isValid() or \
           not (0 <= index.row() < len(self.urls)):
            return EmptyQVariant
        urlitem = self.urls[index.row()]
        column = index.column()
        if role == QtCore.Qt.DisplayRole:
            return V(urlitem.display[column])
        elif role == QtCore.Qt.ToolTipRole:
            return V(urlitem.tooltips[column])
        elif role == QtCore.Qt.TextColorRole and column == 3:
            return QtGui.QColor(urlitem.result_color)
        else:
            return EmptyQVariant

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 stepChanged(self, val):
        value = self.palette().color(QtGui.QPalette.Window)
        for i in range(len(self.gradients)):
            for j in range(len(self.gradients[i])):
                self.gradients[i][j].setStyleSheet('QLabel {background-color: %s; color: %s;}' %
                                                    (value.name(), value.name()))
        if self.stepSpin.value() > 0:
            row = self.first_row
            for key in sorted(self.colours):
                self.colours[key][3] = gradient(self.colours[key][1], self.colours[key][2], self.stepSpin.value())
                for i in range(len(self.colours[key][3])):
                    value = QtGui.QColor(self.colours[key][3][i])
                    value.setAlphaF(self.opacitySpin.value())
                    self.gradients[row - self.first_row][i].setStyleSheet(
                                  'QLabel {background-color: %s; color: %s; opacity: 50}' %
                                  (value.name(), value.name()))
                    val = []
                    for j in range(3):
                        val.append(str(int(self.colours[key][3][i][j * 2 + 1:j * 2 + 3], base=16)))
                    val.append(str(self.opacitySpin.value() * 100))
                    it = 'QLabel {background-color: rgba(%s,%s,%s,%s%%); color: rgba(%s,%s,%s,%s%%)}' % \
                         (val[0], val[1], val[2], val[3], val[0], val[1], val[2], val[3])
                    self.gradients[row - self.first_row][i].setStyleSheet(it)
                row += 1
        self.resourceGrid()

def colourChanged(self):
        sender = str(self.sender().text()).split('_')
        key = sender[0]
        ndx = int(sender[1])
        if self.colours[key][ndx] != '':
            value = QtGui.QColor(self.colours[key][ndx])
            col = QtGui.QColorDialog.getColor(value)
        else:
            col = QtGui.QColorDialog.getColor(QtGui.QColor(''))
        if col.isValid():
            self.colours[key][ndx] = str(col.name())
            for i in range(len(self.btn)):
                if self.btn[i] == self.sender():
                    self.btn[i].setStyleSheet('QPushButton {background-color: %s; color: %s;}' % (col.name(), col.name()))
                    break
            self.stepChanged('a')

def showDialog(self):
        sender = self.sender()
        if sender.text()[-5:] == '_base':
            key = str(sender.text())[:-5]
            ndx = 1
        else:
            key = str(sender.text())
            ndx = 0
        if self.colours[key][ndx] != '':
            col = QtGui.QColorDialog.getColor(self.colours[key][ndx])
        else:
            col = QtGui.QColorDialog.getColor(QtGui.QColor(''))
        if col.isValid():
            if ndx == 0:
                self.colours[key] = [col, self.colours[key][1]]
            else:
                self.colours[key] = [self.colours[key][0], col]
            for i in range(len(self.btn)):
                if self.btn[i] == sender:
                    self.btn[i].setStyleSheet('QPushButton {background-color: %s; color: %s;}' % (col.name(), col.name()))
                    break

def mouseDoubleClickEvent(self, event):
        if self._move_grid:
            p = self.mapToLonLat(event.pos())
            self._grid_coord.append([p.y(), p.x()])
            self.delStation(self._station_to_move)
            self._station_to_move.grid_line = '(' + str(self._grid_coord[0][0]) + ',' + str(self._grid_coord[0][1]) + ')'
            for i in range(1, len(self._grid_coord)):
                self._station_to_move.grid_line += ',(' + str(self._grid_coord[i][0]) + ',' + str(self._grid_coord[i][1]) + ')'
            self.scene().addStation(self._station_to_move)
            if not self.scene().show_station_name:
                self.scene()._current_name.setText(self._station_to_move.name)
                pp = self.mapFromLonLat(QtCore.QPointF(self._station_to_move.lon, self._station_to_move.lat))
                self.scene()._current_name.setPos(pp + QtCore.QPointF(1.5, -0.5))
                if self._station_to_move.technology[:6] == 'Fossil':
                    self.scene()._current_name.setBrush(QtGui.QColor(self.scene().colors['fossil_name']))
                else:
                    self.scene()._current_name.setBrush(QtGui.QColor(self.scene().colors['station_name']))
            self._move_grid = False
            self._grid_start = None
            for itm in self._grid_line:
                self.scene().removeItem(itm)
            self._grid_line = None
            self._grid_coord = None
            self.scene().refreshGrid()

def format(color, style=''):
    """Return a QTextCharFormat with the given attributes.
    """
    _color = QColor()
    _color.setNamedColor(color)

    _format = QTextCharFormat()
    _format.setForeground(_color)
    if 'bold' in style:
        _format.setFontWeight(QFont.Bold)
    if 'italic' in style:
        _format.setFontItalic(True)

    return _format


# Syntax styles that can be shared by all languages

def _setupTowns(self):
        self._towns = {}
        self._towns = Towns(ul_lat=self.upper_left[3], ul_lon=self.upper_left[2],
                      lr_lat=self.lower_right[3], lr_lon=self.lower_right[2])
        for st in self._towns.towns:
            p = self.mapFromLonLat(QtCore.QPointF(st.lon, st.lat))
            el = QtGui.QGraphicsEllipseItem(p.x() - 1, p.y() - 1, 2, 2)   # here to adjust town circles
            el.setBrush(QtGui.QColor(self.colors['town']))
            el.setPen(QtGui.QColor(self.colors['town']))
            el.setZValue(0)
            self._townGroup.addToGroup(el)
            txt = QtGui.QGraphicsSimpleTextItem(st.name)
            new_font = txt.font()
            new_font.setPointSizeF(self.width() / 20)
            txt.setFont(new_font)
            txt.setPos(p + QtCore.QPointF(1.5, -0.5))
            txt.scale(0.1, 0.1)
            txt.setBrush(QtGui.QColor(self.colors['town_name']))
            txt.setZValue(0)
            self._townGroup.addToGroup(txt)
        return

def drawRect(self, coords=None):
        self.clear_Rect()
        self.rect_items = []
        color = QtGui.QColor()
        color.setNamedColor((self.scene().colors['border']))
        pen = QtGui.QPen(color, self.scene().line_width)
        pen.setJoinStyle(QtCore.Qt.RoundJoin)
        pen.setCapStyle(QtCore.Qt.RoundCap)
        fromm = self.mapFromLonLat(coords[0])
        too = self.mapFromLonLat(coords[1])
        self.rect_items.append(QtGui.QGraphicsRectItem(fromm.x(), fromm.y(),
            too.x() - fromm.x(), too.y() - fromm.y()))
        self.rect_items[-1].setPen(pen)
        self.rect_items[-1].setZValue(3)
        self.scene().addItem(self.rect_items[-1])
        if self.scene().center_on_grid:
            x = fromm.x() + (too.x() - fromm.x()) / 2
            y = fromm.y() + (too.y() - fromm.y()) / 2
            go_to = QtCore.QPointF(x, y)
            self.centerOn(go_to)
        rect = reproject([coords[0].y(), coords[0].y(), coords[1].y(), coords[1].y()],
                         [coords[0].x(), coords[1].x(), coords[1].x(), coords[0].x()])
        return '{:0,.0f}'.format(area_of_polygon(rect[0], rect[1])) + ' Km^2'

def drawMany(self):
        grids = GetMany.getList()
        if grids is None:
            return
        self.clear_Rect()
        self.rect_items = []
        color = QtGui.QColor()
        color.setNamedColor((self.scene().colors['border']))
        pen = QtGui.QPen(color, self.scene().line_width)
        pen.setJoinStyle(QtCore.Qt.RoundJoin)
        pen.setCapStyle(QtCore.Qt.RoundCap)
        for g in range(len(grids)):
            fromm = self.mapFromLonLat(QtCore.QPointF(grids[g][1], grids[g][0]))
            too = self.mapFromLonLat(QtCore.QPointF(grids[g][3], grids[g][2]))
            self.rect_items.append(QtGui.QGraphicsRectItem(fromm.x(), fromm.y(),
                                   too.x() - fromm.x(), too.y() - fromm.y()))
            self.rect_items[-1].setPen(pen)
            self.rect_items[-1].setZValue(3)
            self.scene().addItem(self.rect_items[-1])
        self.emit(QtCore.SIGNAL('statusmsg'), str(len(grids)) + ' Areas drawn')

def __define_section_line(self, line_wkt, width):
        self.__cleanup()
        if not line_wkt:
            return
        self.__highlighter = QgsRubberBand(self.__iface.mapCanvas(), QGis.Line)
        self.__highlighter.addGeometry(qgeom_from_wkt(line_wkt), None) # todo use section.line
        self.__highlighter.setWidth((2 * width) / self.__iface.mapCanvas().getCoordinateTransform().mapUnitsPerPixel())
        color = QColor(255, 0, 0, 128)
        self.__highlighter.setColor(color)

        if not len(self.layers()):
            return
        min_z = min((layer.extent().yMinimum() for layer in self.layers()))
        max_z = max((layer.extent().yMaximum() for layer in self.layers()))
        z_range = max_z - min_z
        self.setExtent(QgsRectangle(0, min_z - z_range * 0.1, self.__section.line.length, max_z + z_range * 0.1))

        if self.__z_auto_scale_enabled:
            self.z_autoscale(True)
        else:
            self.refresh()

def __init__(self, iface, sectionCanvas):
        QgsMapToolEmitPoint.__init__(self, sectionCanvas)
        self.__iface = iface
        self.__sectionCanvas = sectionCanvas

        self.canvasClicked.connect(self._new_point)
        self.activated.connect(self._reset)
        self.segments = []
        self.rubberband = QgsRubberBand(sectionCanvas)
        self.rubberband.setWidth(2)
        self.rubberband.setColor(QColor(255, 0, 0, 200))
        self.rubberband.addPoint(QgsPoint())
        self.rubberband.addPoint(QgsPoint())

        self._reset()

        self.graphLayer = None

def __init__(self, text='S', startp=Point(x=0.0, y=0.0),):
        """
        Initialisation of the class.
        """
        QGraphicsItem.__init__(self)

        self.setFlag(QGraphicsItem.ItemIsSelectable, False)

        self.text = text
        self.sc = 1.0
        self.startp = QtCore.QPointF(startp.x, -startp.y)

        pencolor = QColor(0, 200, 255)
        self.brush = QColor(0, 100, 255)

        self.pen = QPen(pencolor, 1, QtCore.Qt.SolidLine)
        self.pen.setCosmetic(True)

        self.path = QPainterPath()
        self.path.addText(QtCore.QPointF(0, 0),
                          QFont("Arial", 10/self.sc),
                          self.text)

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 draw_minimap(self, image):
        if self.window.display_settings_dialog.minimap.isChecked():
            movie_height, movie_width = self.movie_size()
            length_minimap = 100
            height_minimap = movie_height/movie_width*100
            #draw in the upper right corner, overview rectangle
            x = self.width() - length_minimap - 20
            y = 20
            painter = QtGui.QPainter(image)
            painter.setPen(QtGui.QColor('white'))
            painter.drawRect(x, y, length_minimap + 0, height_minimap + 0)
            painter.setPen(QtGui.QColor('yellow'))
            length = self.viewport_width()/movie_width*length_minimap
            height = self.viewport_height()/movie_height*height_minimap
            x_vp = self.viewport[0][1]/movie_width*length_minimap
            y_vp = self.viewport[0][0]/movie_height*length_minimap
            painter.drawRect(x+x_vp, y+y_vp, length + 0, height + 0)
        return image

def update_cursor(self):
        if self._mode == 'Zoom':
            self.unsetCursor()
        elif self._mode == 'Pick':
            diameter = self.window.tools_settings_dialog.pick_diameter.value()
            diameter = self.width() * diameter / self.viewport_width()
            pixmap_size = ceil(diameter)
            pixmap = QtGui.QPixmap(pixmap_size, pixmap_size)
            pixmap.fill(QtCore.Qt.transparent)
            painter = QtGui.QPainter(pixmap)
            painter.setPen(QtGui.QColor('white'))
            offset = (pixmap_size - diameter) / 2
            painter.drawEllipse(offset, offset, diameter, diameter)
            painter.end()
            cursor = QtGui.QCursor(pixmap)
            self.setCursor(cursor)

def changeEvent(self, event):
        if not event.type() == QtCore.QEvent.EnabledChange: return
        state = self.isEnabled()
        self.start_color = self._start_colors[state]
        self.end_color = self._end_colors[state]
        self.dial_bgd = self._dial_bgd_colors[state]
        self.dial_border = self._dial_border_colors[state]
        if self.gradient:
            self.fill_color = self.range_mid_colors[state] if self.center else self.range_full_colors[state]
        else:
            self.fill_color = QtGui.QColor(*self.setColor())
        self.fgd_color = self._fgd_colors[state]
        self.fgd_pen = QtGui.QPen(self.fgd_color, self.dial_size/50.)
        self.cursor_pen = QtGui.QPen(self.fgd_color, self.dial_size/30.)
        self.dial_color = self._dial_colors[state]
        self.dial_pen = QtGui.QPen(self.dial_color, self.dial_size/100.)
        self.update()
        self.cursor.setEnabled(state)

def __init__(self, parent, param_tuple, sub_par=None, *args, **kwargs):
        if len(param_tuple) == 7:
            full_range, values, name, short_name, family, attr, id = param_tuple
        else:
            full_range, values, name, short_name, family, attr = param_tuple
            id = None
        if 'name' in kwargs:
            short_name = kwargs.pop('name')
        if 'values' in kwargs:
            values = kwargs.pop('values')
        if 'value_list' in kwargs:
            values = kwargs.pop('value_list')
        if not (isinstance(values, list) or isinstance(values, tuple)):
            values = getattr(values, sub_par)
        Combo.__init__(self, parent=parent, value_list=values, name=short_name, *args, **kwargs)
        parent.object_dict[attr].add(self, sub_par)
        self.attr = attr
        self.main = parent
        self.indexChanged.connect(lambda id: setattr(self.main, self.attr, id if sub_par is None else (id, sub_par)))
        if id and id in (8, 24):
            for item_id in xrange(73, 86):
                item = self.model().item(item_id)
                setBold(item, False)
                setItalic(item, True)
                item.setData(QtGui.QColor('darkGray'), QtCore.Qt.ForegroundRole)

def __init__(self, parent):
        QtGui.QGraphicsView.__init__(self, parent)
        self.main = parent
        self.setFrameStyle(0)
        self.scene = QtGui.QGraphicsScene(self)
        self.setScene(self.scene)
        self.setStyleSheet('background: transparent')
        self.shadow = QtGui.QGraphicsDropShadowEffect()
        self.shadow.setBlurRadius(4)
        self.shadow.setOffset(1, 1)
        self.shadow.setColor(QtGui.QColor(100, 100, 100, 150))
        self.create_layout()
        self.setSizePolicy(QtGui.QSizePolicy.MinimumExpanding, QtGui.QSizePolicy.Preferred)

        for char in range(16):
            char_object = FakeObject(self)
            char_object.valueChanged.connect(lambda value, char=char: self.prog_name.setChar(char, value))
            parent.object_dict['Name_Char_{:02}'.format(char)].add(char_object)
        cat_object = FakeObject(self)
        cat_object.valueChanged.connect(lambda value: self.cat_name.setCat(value))
        parent.object_dict['Category'].add(cat_object)
        self.prog_name.letter_changed.connect(lambda id, char: setattr(self.main, 'Name_Char_{:02}'.format(id), char))

def __init__(self, main):
        QtGui.QMainWindow.__init__(self, parent=None)
        load_ui(self, 'editor.ui')
        self.setContentsMargins(2, 2, 2, 2)
        pal = self.palette()
        pal.setColor(self.backgroundRole(), QtGui.QColor(20, 20, 20))
        self.setPalette(pal)

        self.main = main
        self.blofeld_library = self.main.blofeld_library
        self.midi = self.main.midi
        self.input = self.midi.input
        self.output = self.midi.output
        self.graph = self.main.graph
        self.channel = 0
        self.octave = 0
        self.params = Params
        self.send = False
        self.notify = True
        self.save = False
        self._edited = False

        self.shown = False
        self.create_layout()
        self.setSoundDump()

def createDragData(self):
        if not self.selection: return
        start = self.selection[0]
        end = self.selection[-1]
        if start == end:
            self.waveobj_list[start].preview_rect.setSelected(True)
        self.drag = QtGui.QDrag(self)
        data = MimeData()
        data.setData('audio/waves', QtCore.QByteArray('{}:{}'.format(start, end)))
        data.setReferenceData(self.main)
        pixmap = QtGui.QPixmap(int(self.viewport().rect().width() / 64. * (end - start + 1)), self.height())
        pixmap.fill(QtGui.QColor(192, 192, 192, 128))
        qp = QtGui.QPainter(pixmap)
        qp.setRenderHints(qp.Antialiasing)
        x = self.mapFromScene(self.waveobj_list[start].preview_rect.pos()).x()
        width = self.mapFromScene(self.waveobj_list[end].preview_rect.pos()).x() + self.mapFromScene(self.waveobj_list[end].preview_rect.boundingRect().topRight()).x() - x
        self.render(qp, source=QtCore.QRect(x, self.wavegroup.boundingRect().y(), width, self.mapToScene(self.viewport().rect()).boundingRect().height()), mode=QtCore.Qt.IgnoreAspectRatio)
        qp.end()
        self.drag.setPixmap(pixmap)
        self.drag.setMimeData(data)
        self.drag.exec_()

def attrSelChanged(self):
        """something happened in the attribute list box"""
        colors=[QColor(255,0,0),QColor(0,255,0),QColor(0,0,255),QColor(255,255,0),QColor(255,0,255),QColor(0,255,255)]
        ci=0
        # iterate over list items and find checked ones
        # also calculates max range
        maxTotal=0
        for i in range(self.attrList.count()):
            if self.attrList.item(i).checkState()>0:
                self.attrList.item(i).setBackgroundColor(colors[ci%len(colors)])
                maxTotal=maxTotal+self.amax[self.attrList.item(i).text()];
                ci=ci+1
            else:
                self.attrList.item(i).setBackgroundColor(QColor(255,255,255))
        self.maxTotal=maxTotal
        self.showMinMax()

def setFullscreen(self):

        thisPalette = self.palette()
        thisPalette.setColor(QtGui.QPalette.Window, QtGui.QColor(0,0,0))
        self.setPalette(thisPalette)

        self.clickSound.play()
        self.mrlLineEdit.setVisible(False)
        self.volumeSlider.setVisible(False)
        self.loadButton.setVisible(False)
        self.loadSubtitle.setVisible(False)
        self.fullScreenButton.setVisible(False)
        self.statusBar.setVisible(False)
        self.showFullScreen()
        self.setCursor(QtCore.Qt.BlankCursor)
        self.isFullScreen = True
        self.vBoxLayout.setContentsMargins(0,0,0,0)

def generate_nuc_sequences(self) :
        sequences = self.annotation.get_sequences_string()
        self.set_table(2, len(sequences[0]))

        for index, base in enumerate(self.annotation.get_sequence()) :
            item_ref = self.get_item(base.get_ref().upper())
            infotip_ref = "Posi %i" %index

            item_snp = self.get_item(base.get_base().upper())
            infotip_snp = "Posi %i" %index

            if base.has_snp() :
                item_snp.setBackgroundColor(QtGui.QColor("red"))
                infotip_snp += " - DP %i - AbHet %.2f" %(base.snp.dp, base.snp.abhet)

            item_ref.setToolTip(infotip_ref)
            item_snp.setToolTip(infotip_snp)        
            self.aligner.setItem(0, index, item_ref)
            self.aligner.setItem(1, index, item_snp)

def buildTable(self, snap):
        self.tableWidget.clear()
        self.tableWidget.setColumnCount(3)
        self.tableWidget.setRowCount(len(snap))
        self.tableWidget.setHorizontalHeaderLabels(["Attribute Name", "Read Value", "Write Value"])
        i=0
        for value in sorted(snap):
            item=QtGui.QTableWidgetItem("%s" % value[0])
            self.tableWidget.setItem(i, 0, item)
            if (type(value[1]) is not tuple):
                item1=QtGui.QTableWidgetItem("%s" % value[1])
                self.tableWidget.setItem(i, 1, item1)
                item2=QtGui.QTableWidgetItem("%s" %'None')
            else:
                item1=QtGui.QTableWidgetItem("%s" % value[1][0])
                self.tableWidget.setItem(i, 1, item1)
                item2=QtGui.QTableWidgetItem("%s" % value[1][1])
            self.tableWidget.setItem(i, 2, item2)
            if i%2==0:
                item.setBackgroundColor(QtGui.QColor(225,225,225))
                item1.setBackgroundColor(QtGui.QColor(225,225,225))
                item2.setBackgroundColor(QtGui.QColor(225,225,225))
            i=i+1
        self.tableWidget.resizeColumnsToContents()

def _draw_dots(self, points, color):
        # draw_dots using qt canvas
        r, g, b, o = color      

        if self.img_arr is None:
            self.img_arr = self.ref_pic.img_arr
        qImg = cvtrgb2qtimage(self.img_arr)
        image = QtGui.QPixmap(qImg)

        radx = 2
        rady = 2
        draw = QtGui.QPainter()
        draw.begin(image)
        draw.setBrush(QtGui.QColor(r, g, b, o))
        for p in points:
            center = QtCore.QPoint(p[1], p[0])
            draw.drawEllipse(center, radx, rady)
        draw.end()
        self.setPixmap(image)

def _draw_dots(self, points, color):
        # draw_dots using qt canvas
        r, g, b, o = color      

        if self.img_arr is None:
            self.img_arr = self.ref_pic.img_arr
        qImg = cvtrgb2qtimage(self.img_arr)
        image = QtGui.QPixmap(qImg)

        radx = 2
        rady = 2
        draw = QtGui.QPainter()
        draw.begin(image)
        draw.setBrush(QtGui.QColor(r, g, b, o))
        for p in points:
            center = QtCore.QPoint(p[1], p[0])
            draw.drawEllipse(center, radx, rady)
        draw.end()
        self.setPixmap(image)

def __init__(self, pos_x,pos_y,w_wdt,w_ht,parent=None):
        global name,home
        QtGui.QSystemTrayIcon.__init__(self, parent)
        #self.icon = QtGui.QLabel()
        icon_img = home+'/src/tray.png'
        self.right_menu = RightClickMenu(pos_x,pos_y,w_wdt,w_ht)
        self.setContextMenu(self.right_menu)

        self.activated.connect(self.onTrayIconActivated)
        self.p = QtGui.QPixmap(24,24)
        self.p.fill(QtGui.QColor("transparent"))
        painter = QtGui.QPainter(self.p)
        if os.path.exists(icon_img):
            self.setIcon(QtGui.QIcon(icon_img))
        else:
            self.setIcon(QtGui.QIcon(""))
        self.full_scr = 1
        del painter

def onChangePropertyType(self, evt=None):
        #print "onChangePropertyType"
        if self.defaultPropRbtn.isChecked():  self.conf = deepcopy(self.defaultConf)
        else: self.conf = deepcopy(self.fileConf)

        for ch in range(len(self.channels)):
            if ch < len(self.conf['plotColor']):
                self.channelCkbs[self.channels[ch]].setStyleSheet("QWidget { background-color: %s }" % QColor(self.conf['plotColor'][ch][0]).name())
            else:
                self.channelCkbs[self.channels[ch]].setStyleSheet("QWidget { background-color: %s }" % QColor(self.defaultConf['plotColor'][ch][0]).name())


    ###################################
    # Author: Lan
    # def: initUI(): updated 201509
    # Layout of MainControl

def INIT_CHAT_COMBO(self):

        # -------------------------------------------------------------------
        for LANG in self.CONF["USER"]["CHAT_LANGS"]:
            self.LANG_COMBO.addItem(LANG.upper());

        for i in xrange(0, self.LANG_COMBO.__len__()):

            self.LANG_COMBO.setItemData( i, QColor("#333"),Qt.BackgroundRole );
            self.LANG_COMBO.setItemData( i, QColor("#fff"),Qt.ForegroundRole );
            #self.LANG_COMBO.setItemData( i, QFont('monospace', 16, -1, False), Qt.FontRole);
        # -------------------------------------------------------------------

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

###################################################################################################

def CREATE_PAIRS_SELECTOR(self, ALL=False):

        # -------------------------------------------------------------------
        if not ALL:
            for PAIR in self.CONF["API"]["PAIRS"]:
                self.PAIR_COMBO.addItem(PAIR.upper());

        else:
            for PAIR in self.CONF["API"]["ALL_PAIRS"]:
                self.PAIR_COMBO.addItem(PAIR.upper());

        for i in xrange(0, self.PAIR_COMBO.__len__()):

            self.PAIR_COMBO.setItemData( i, QColor("#333"),Qt.BackgroundRole );
            self.PAIR_COMBO.setItemData( i, QColor("#fff"),Qt.ForegroundRole );
            #self.PAIR_COMBO.setItemData( i, QFont('monospace', 16, -1, False), Qt.FontRole);
        # -------------------------------------------------------------------

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

def paintEvent(self, event):

        # -------------------------------------------------------------------
        Painter = QPainter()
        Painter.begin(self)

        # -------------------------------------------------------------------
        # Draw CROSS-MOUSE-POS
        if self.DRAW_CROSS:

            Painter.setPen( QPen( QColor(255,255,255, 255), 1, Qt.DashLine ) );
            Painter.drawPolyline( QPoint(self.MOUSE_X-600, self.MOUSE_Y), QPoint( self.MOUSE_X+600, self.MOUSE_Y) ); 
            Painter.drawPolyline( QPoint(self.MOUSE_X, self.MOUSE_Y-400), QPoint( self.MOUSE_X, self.MOUSE_Y+400) ); 

        # -------------------------------------------------------------------
        Painter.end();
        # -------------------------------------------------------------------

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

def CREATE_PAIRS_SELECTOR(self, ALL=False):

        # -------------------------------------------------------------------
        if not ALL:
            for PAIR in self.CONF["API"]["PAIRS"]:
                self.PAIR_COMBO.addItem(PAIR.upper());

        else:
            for PAIR in self.CONF["API"]["ALL_PAIRS"]:
                self.PAIR_COMBO.addItem(PAIR.upper());

        for i in xrange(0, self.PAIR_COMBO.__len__()):

            self.PAIR_COMBO.setItemData( i, QColor("#333"),Qt.BackgroundRole );
            self.PAIR_COMBO.setItemData( i, QColor("#fff"),Qt.ForegroundRole );
            #self.PAIR_COMBO.setItemData( i, QFont('monospace', 16, -1, False), Qt.FontRole);
        # -------------------------------------------------------------------

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

def btnSelectEndpoint_clicked(self):
        # If no selection has been made
        if self.ui.tableWidgetKnownEndpoints.currentRow() == -1:
            # Show message box with error
            QtGui.QMessageBox.critical(self, 'Error', "Please select an endpoint from the list.", QtGui.QMessageBox.Close)

            return

        # TODO: Log if this is True
        self.setSelectedEndpointURLAsSetting()

        # Update table of stats in main window
        itemEndpoint = QtGui.QTableWidgetItem(Functions.getEndpointName())
        itemEndpoint.setTextAlignment(QtCore.Qt.AlignHCenter)
        itemEndpoint.setTextColor(QtGui.QColor(55, 122, 151)) #rgb numbers of hex #377a97 color
        boldFont = QFont(); boldFont.setBold(True)
        itemEndpoint.setFont(boldFont)
        window.ui.tableWidgetMyModelStats.setItem(0, 0, itemEndpoint)

        # Reload all tables in preferences
        self.loadAllTablesInPreferences()

def createRubberBand(self, geomType):
        settings = QSettings()

        rb = QgsRubberBand(self.canvas, geomType)
        rb.setWidth(settings.value('/qgis/digitizing/line_width', 1, type=int))
        color = QColor(settings.value('/qgis/digitizing/line_color_red', 255, type=int),
                       settings.value('/qgis/digitizing/line_color_green', 0, type=int),
                       settings.value('/qgis/digitizing/line_color_blue', 0, type=int))
        alpha = settings.value('/qgis/digitizing/line_color_alpha', 200, type=int) / 255.0
        color.setAlphaF(alpha)
        rb.setColor(color)
        return rb

def redirect_stderr(self):
        """ Redirect standard error to the QTextEdit """
        sys.stderr = OutLog(self.textEdit, sys.stderr, QtGui.QColor(255, 0, 0))

def __init__(self, iface, parent):
        super(GeodesicMeasureDialog, self).__init__(parent)
        self.setupUi(self)
        self.iface = iface
        self.canvas = iface.mapCanvas()
        settings = QSettings()

        self.restoreGeometry(settings.value("ShapeTools/MeasureDialogGeometry",
                                        QByteArray(), type=QByteArray))
        self.closeButton.clicked.connect(self.closeDialog)
        self.newButton.clicked.connect(self.newDialog)

        self.unitsComboBox.addItems(UNITS)

        self.tableWidget.setColumnCount(3)
        self.tableWidget.setSortingEnabled(False)
        self.tableWidget.setHorizontalHeaderLabels(['Heading To', 'Heading From', 'Distance'])

        self.unitsComboBox.activated.connect(self.unitsChanged)

        self.capturedPoints = []
        self.distances = []
        self.geod = Geodesic.WGS84
        self.activeMeasuring = True
        self.unitsChanged()
        self.currentDistance = 0.0

        color = QColor(222, 167, 67, 150)
        self.pointRb = QgsRubberBand(self.canvas, QGis.Point)
        self.pointRb.setColor(color)
        self.pointRb.setIconSize(10)
        self.lineRb = QgsRubberBand(self.canvas, QGis.Line)
        self.lineRb.setColor(color)
        self.lineRb.setWidth(3)
        self.tempRb = QgsRubberBand(self.canvas, QGis.Line)
        self.tempRb.setColor(color)
        self.tempRb.setWidth(3)

def updateVarStatsTree(self):
        self.varStatsTreeWidget.clear()
        self.varStatsTreeWidget.headerItem().setText(0,QtGui.QApplication.translate("MainWindow", "Variable", None, QtGui.QApplication.UnicodeUTF8))
        self.varStatsTreeWidget.headerItem().setText(1,QtGui.QApplication.translate("MainWindow", "Values", None, QtGui.QApplication.UnicodeUTF8))

        variableStats=self.controller.getVariableStats()
        sort1=variableStats.keys()
        sort1.sort()
        for tg in sort1:
            target=QtCore.QStringList()
            target.append(tg)
            targetTree=QtGui.QTreeWidgetItem(target)
            self.varStatsTreeWidget.addTopLevelItem(targetTree)
            sort2=variableStats[tg].keys()
            sort2.sort()
            for pt in sort2:
                path=QtCore.QStringList()
                path.append(pt)
                pathTree=QtGui.QTreeWidgetItem(path)
                pathTree.setTextColor(0,QtGui.QColor(0,0,200))
                font=pathTree.font(0)
                font.setBold(True)
                pathTree.setFont(0,font)
                targetTree.addChild(pathTree)
                sort3=variableStats[tg][pt].keys()
                sort3.sort()
                for vr in sort3:
                    variable=QtCore.QStringList()
                    variable.append(vr)
                    values=""                   
                    for vls in variableStats[tg][pt][vr].keys():
                        values+=urllib.unquote(vls)+"\n"
                    variable.append(values)
                    variableTree=QtGui.QTreeWidgetItem(variable)
                    pathTree.addChild(variableTree)

def updateReqStatsTree(self):
        self.reqStatsTreeWidget.clear()
        self.reqStatsTreeWidget.headerItem().setText(0,QtGui.QApplication.translate("MainWindow", "Request", None, QtGui.QApplication.UnicodeUTF8))
        self.reqStatsTreeWidget.headerItem().setText(1,QtGui.QApplication.translate("MainWindow", "Variable set", None, QtGui.QApplication.UnicodeUTF8))

        reqStats=self.controller.getReqStats()
        sort1=reqStats.keys()
        sort1.sort()
        for tg in sort1:
            target=QtCore.QStringList()
            target.append(tg)
            targetTree=QtGui.QTreeWidgetItem(target)
            self.reqStatsTreeWidget.addTopLevelItem(targetTree)
            sort2=reqStats[tg].items()
            sort2.sort()
            for k,l in sort2:
                path=QtCore.QStringList()
                path.append(k)
                sets=""
                for set in l:
                    sets+=join(set[0],',')+'\n'
                path.append(sets)
                pathTree=QtGui.QTreeWidgetItem(path)
                pathTree.setTextColor(0,QtGui.QColor(0,0,200))
                font=pathTree.font(0)
                font.setBold(True)
                pathTree.setFont(0,font)
                targetTree.addChild(pathTree)

def __init__ (self, parent=None):
        """Set Scintilla options for font, colors, etc."""
        super(Editor, self).__init__(parent)
        # Use Courier font with fixed width
        font = QtGui.QFont("Consolas", 11)
        font.setFixedPitch(True)

        # Set the default font of the editor
        # and take the same font for line numbers
        self.setFont(font)
        self.setMarginsFont(font)

        # line number margin for 4 digits (plus 2px extra space)
        margin = QtGui.QFontMetrics(font).width("0"*4)+2
        # Display line numbers, margin 0 is for line numbers
        self.setMarginWidth(0, margin)
        self.setMarginLineNumbers(0, True)

        # Show whitespace to help detect whitespace errors
        self.setWhitespaceVisibility(True)

        # Use boxes as folding visual
        self.setFolding(self.BoxedTreeFoldStyle)

        # Braces matching
        self.setBraceMatching(self.SloppyBraceMatch)

        # Editing line color
        self.setCaretLineVisible(True)
        self.setCaretLineBackgroundColor(QtGui.QColor("#e5e5cb"))

        # line numbers margin colors
        self.setMarginsBackgroundColor(QtGui.QColor("#e5e5e5"))
        self.setMarginsForegroundColor(QtGui.QColor("#333333"))

        # folding margin colors (foreground,background)
        self.setFoldMarginColors(QtGui.QColor("#f5f5dc"),
                                 QtGui.QColor("#aaaaaa"))

def highlightCurrentLine (self):
        """Highlight the current line."""
        extraSelections = []
        if not self.isReadOnly():
            selection = QtGui.QTextEdit.ExtraSelection()
            lineColor = QtGui.QColor(QtCore.Qt.yellow).lighter(160)
            selection.format.setBackground(lineColor)
            selection.format.setProperty(QtGui.QTextFormat.FullWidthSelection, True)
            selection.cursor = self.textCursor()
            selection.cursor.clearSelection()
            extraSelections.append(selection)
        self.setExtraSelections(extraSelections)

def setContent(self, text):
        """????"""
        if text == DIRECTION_LONG or text == DIRECTION_NET:
            self.setForeground(QtGui.QColor('red'))
        elif text == DIRECTION_SHORT:
            self.setForeground(QtGui.QColor('green'))
        self.setText(text)


########################################################################

def __init__(self, text=None, mainEngine=None):
        """Constructor"""
        super(BidCell, self).__init__()
        self.data = None

        self.setForeground(QtGui.QColor('black'))
        self.setBackground(QtGui.QColor(255,174,201))

        if text:
            self.setContent(text)

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

def __init__(self, text=None, mainEngine=None):
        """Constructor"""
        super(AskCell, self).__init__()
        self.data = None

        self.setForeground(QtGui.QColor('black'))
        self.setBackground(QtGui.QColor(160,255,160))

        if text:
            self.setContent(text)

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

def set_color(self):
        self.setBackgroundColor(QColor(OrListWidgetItem.COLOR[self.active]))

def defaultColor(self, style):
                if style == self.Default:
                        return QColor('#000000')
                elif style == self.Comment:
                        return QColor('#228B22')
                return QsciLexerCustom.defaultColor(self, style)

def setup(self):
        # Set the default font
        font = QFont()
        font.setFamily('Courier')
        font.setFixedPitch(True)
        font.setPointSize(10)
        self.setFont(font)
        self.setMarginsFont(font)
        fontmetrics = QFontMetrics(font)
        self.setMarginsFont(font)
        self.setMarginWidth(0, fontmetrics.width('0000'))
        self.setMarginLineNumbers(0, True)
        self.setMarginsBackgroundColor(QColor('#cccccc'))
        self.setMarginSensitivity(1, True)
        self.marginClicked.connect(self.on_margin_clicked)
        self.markerDefine(QsciScintilla.RightTriangle, self.ARROW_MARKER_NUM)
        self.setMarkerBackgroundColor(QColor('#ee1111'), self.ARROW_MARKER_NUM)
        self.markerDefine(QsciScintilla.Circle, self.REC_MARKER_NUM)
        self.setMarkerBackgroundColor(QColor('#87CEEB'), self.REC_MARKER_NUM)
        self.setBraceMatching(QsciScintilla.SloppyBraceMatch)
        self.setCaretLineVisible(True)
        self.setCaretLineBackgroundColor(QColor('#FFA07A'))
        self.my_lexer = OrLexer(self)
        self.setLexer(self.my_lexer)
        self.setAutoCompletionThreshold(1)
        self.setAutoCompletionSource(QsciScintilla.AcsAPIs)
        self.tracking_marker = None