コード例 #1
0
ファイル: ColorEdit.py プロジェクト: goph-R/TilePad
 def setColorText(self, text):
     text = str(text).upper().replace('#', '')
     color = QColor('#' + text)
     if not color.isValid():
         return
     self.box.setStyleSheet('background-color: #' + text + '; border: 1px solid black;')
     self.edit.setText(text)
     self.color = color
     return True
コード例 #2
0
ファイル: SyntaxHighlight.py プロジェクト: cmbant/CosmoMC
def txformat(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
コード例 #3
0
ファイル: qcolor_test.py プロジェクト: BadSingleton/pyside2
class QColorGetTest(unittest.TestCase):

    def setUp(self):
        self.color = QColor(20, 40, 60, 80)

    def testGetRgb(self):
        self.assertEqual(self.color.getRgb(), (20, 40, 60, 80))

    def testGetHslF(self):
        hls = colorsys.rgb_to_hls(20.0/255, 40.0/255, 60.0/255)
        hsla = hls[0], hls[2], hls[1], self.color.alphaF()
        for x, y in zip(self.color.getHslF(), hsla): # Due to rounding problems
            self.assert_(x - y < 1/100000.0)

    def testGetHsv(self):
        hsv = colorsys.rgb_to_hsv(20.0/255, 40.0/255, 60.0/255)
        hsva = int(hsv[0]*360.0), int(hsv[1]*255), int(hsv[2]*256), self.color.alpha()
        self.assertEqual(self.color.getHsv(), hsva)

    def testGetCmyk(self): # not supported by colorsys
        self.assertEqual(self.color.getCmyk(), (170, 85, 0, 195, 80))

    def testGetCmykF(self): # not supported by colorsys
        for x, y in zip(self.color.getCmykF(), (170/255.0, 85/255.0, 0, 195/255.0, 80/255.0)):
            self.assert_(x - y < 1/10000.0)
コード例 #4
0
ファイル: deepcopy_test.py プロジェクト: BadSingleton/pyside2
 def setUp(self):
     self.original = QColor.fromCmykF(0.2, 0.3, 0.4, 0.5, 0.6)
コード例 #5
0
    def paint(self, painter):
        """

        :param QPainter painter:
        :return:
        """

        if self.selected:
            painter.setPen(self._config.disasm_view_operand_select_color)
            painter.setBrush(self._config.disasm_view_operand_select_color)
            painter.drawRect(self.x, self.y, self.width, self.height)
        else:
            # should we highlight ourselves?
            if self.infodock.should_highlight_operand(self):
                painter.setPen(
                    self._config.disasm_view_operand_highlight_color)
                painter.setBrush(
                    self._config.disasm_view_operand_highlight_color)
                painter.drawRect(self.x, self.y, self.width, self.height)

        x = self.x

        if self._branch_target or self._branch_targets:
            if self._is_target_func:
                painter.setPen(self._config.disasm_view_target_addr_color)
            else:
                painter.setPen(self._config.disasm_view_antitarget_addr_color)
        else:
            if self.disasm_view.show_variable and self.variable is not None:
                # show-variable is enabled and this operand has a linked variable
                fallback = True
                if self.infodock.induction_variable_analysis is not None:
                    r = self.infodock.induction_variable_analysis.variables.get(
                        self.variable.ident, None)
                    if r is not None and r.expr.__class__.__name__ == "InductionExpr":
                        painter.setPen(Qt.darkYellow)
                        fallback = False

                if fallback:
                    painter.setPen(QColor(0xff, 0x14, 0x93))
            else:
                painter.setPen(QColor(0, 0, 0x80))
        painter.drawText(x, self.y + self._config.disasm_font_ascent,
                         self._label)

        x += self._label_width

        # draw additional branch targets
        if self._branch_targets_text:
            painter.setPen(Qt.darkYellow)
            x += self.BRANCH_TARGETS_SPACING
            painter.drawText(
                x,
                self.y + self._config.disasm_font_ascent,
                self._branch_targets_text,
            )
            x += self._branch_targets_text_width

        if self.variable is not None and self.disasm_view.show_variable_identifier:
            x += self.VARIABLE_IDENT_SPACING
            painter.setPen(Qt.darkGreen)
            painter.drawText(x, self.y + self._config.disasm_font_ascent,
                             self._variable_ident)
            x += self._variable_ident_width

        # restores the color
        painter.setPen(QColor(0, 0, 0x80))
コード例 #6
0
 def colorChanged(self, color: QColor, hue: float, sat: float,
                  bright: float) -> None:
     self.labColor.setStyleSheet("QLabel{background:%s;}" %
                                 color.name())
コード例 #7
0
    def __init__(self, parent=None):
        super(Form, self).__init__(parent)

        self.setWindowTitle("Backend Discord-GUI")
        self.changeStyle('fusion')

        palette = QPalette()
        palette.setColor(QPalette.Window, QColor(53, 53, 53))
        palette.setColor(QPalette.WindowText, Qt.white)
        palette.setColor(QPalette.Text, Qt.white)
        palette.setColor(QPalette.Button, QColor(60, 60, 60))
        palette.setColor(QPalette.ButtonText, Qt.white)
        palette.setColor(QPalette.Base, QColor(40, 40, 40))
        palette.setColor(QPalette.ToolTipBase, QColor(60, 60, 60))
        palette.setColor(QPalette.ToolTipText, Qt.white)
        palette.setColor(QPalette.PlaceholderText, QColor(100, 60, 60))
        palette.setColor(QPalette.BrightText, Qt.white)
        palette.setColor(QPalette.Highlight, QColor(106, 13, 173))
        palette.setColor(QPalette.HighlightedText, Qt.white)

        mainLayout = QVBoxLayout()
        hMainLayout = QHBoxLayout()
        passwordLayout = QHBoxLayout()

        self.username = QLineEdit(self)
        self.QUserLabel = QLabel("Username")
        self.username.setStyleSheet(
            "QToolTop { border: 0px; border-radius: 3px }")
        self.QUserLabel.setFont(QFont("Copperplate", 12))

        self.password = QLineEdit(self)
        self.QPasswordLabel = QLabel("Password")
        self.password.setStyleSheet(
            "QToolTip { border: 0px; border-radius: 3px }")
        self.QPasswordLabel.setFont(QFont("Copperplate", 12))
        self.showhideButton = QPushButton("Show")
        self.showhideButton.setCheckable(True)
        self.showhideButton.setChecked(False)
        self.showhideButton.clicked.connect(lambda: self.show_hide())
        self.password.setEchoMode(QLineEdit.Password)
        passwordLayout.addWidget(self.QPasswordLabel)
        passwordLayout.addWidget(self.password)
        passwordLayout.addWidget(self.showhideButton)

        self.btn_Submit = QPushButton("Login")

        shortcut = QShortcut(QKeySequence("Return"), self.btn_Submit)
        shortcut.activated.connect(lambda: self.do_nothing())
        shortcut.setEnabled(True)

        self.btn_SignUp = QPushButton("Sign Up")
        self.btn_SignUp.clicked.connect(lambda: window.openSignUp())

        layout = QFormLayout()
        layout.addRow(self.QUserLabel, self.username)
        layout.addRow(passwordLayout)
        layout.addRow(self.btn_Submit)
        layout.addRow(self.btn_SignUp)

        Label = QLabel("Welcome To The\nBackend Discord-GUI Development")
        Label.setFont(QFont("Copperplate", 15, QFont.Bold))
        Label.setAlignment(Qt.AlignCenter)

        mainLayout.addSpacing(80)
        mainLayout.addWidget(Label)
        mainLayout.addLayout(layout)
        mainLayout.addSpacing(100)

        hMainLayout.addSpacing(125)
        hMainLayout.addLayout(mainLayout)
        hMainLayout.addSpacing(125)
        self.setLayout(hMainLayout)

        QApplication.setPalette(palette)
コード例 #8
0
    def paint(self, painter, option, index):
        if index.column() == NUT_PERCENT_COL:

            progress_bar_option = QStyleOptionProgressBar()
            progress_bar_option.rect = option.rect
            progress_bar_option.minimum = 0
            progress_bar_option.maximum = 100
            progress_bar_option.textVisible = True

            progress = index.data(role=Qt.DisplayRole)

            p = QPalette()

            if progress is None:
                # A bug in the progress bar for the fusion style causes a thin vertical strip
                # of the progress bar chunk to be painted to the left of a progress bar with
                # less than 1% progess while drawn in a table view.
                # This strip is normally covered by the table's grid lines, but I have them disabled.
                # My workaround to display a completely empty progress bar without the strip
                # is to fill the progress bar and simply turn the color to white
                progress_bar_option.progress = 100
                progress_bar_option.text = "No data"
                p.setColor(QPalette.Highlight, QColor(Qt.white))
                p.setColor(QPalette.HighlightedText, Qt.darkGray)
                progress_bar_option.palette = p

            elif progress == -1:
                progress_bar_option.progress = 100
                progress_bar_option.text = "None set"
                p.setColor(QPalette.Highlight, QColor(Qt.white))
                p.setColor(QPalette.HighlightedText, Qt.darkGray)
                progress_bar_option.palette = p

            elif round(progress) == 0:
                progress_bar_option.progress = 100
                progress_bar_option.text = "0%"
                p.setColor(QPalette.Highlight, QColor(Qt.white))
                p.setColor(QPalette.HighlightedText, QColor(Qt.black))
                progress_bar_option.palette = p

            elif 0 < round(progress) < 100:
                rounded_string = '{number:.{digits}f}%'.format(number=progress,
                                                               digits=0)
                progress_bar_option.progress = round(progress)
                progress_bar_option.text = rounded_string

            elif 100 <= round(progress):
                rounded_string = '{number:.{digits}f}%'.format(number=progress,
                                                               digits=0)
                progress_bar_option.progress = 100
                progress_bar_option.text = rounded_string

            #p.setColor(QPalette.Highlight, QColor(247, 202, 202))
            #progress_bar_option.palette = p

            #QApplication.style().drawControl(QStyle.CE_ProgressBar, progress_bar_option, painter)
            QStyleFactory.create('fusion').drawControl(QStyle.CE_ProgressBar,
                                                       progress_bar_option,
                                                       painter)

        else:
            QStyledItemDelegate.paint(self, painter, option, index)
コード例 #9
0
 def __init__(self, color: QColor = QColor('green')):
     super().__init__()
     self.color = color
コード例 #10
0
    def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None):
        super().__init__(layer=layer, targetImage=targetImage, parent=parent)
        self.options = None
        pushButton1 = QPushButton(' Undo ')
        pushButton1.adjustSize()
        pushButton2 = QPushButton(' Redo ')
        pushButton2.adjustSize()

        pushButton1.clicked.connect(self.undo)
        pushButton2.clicked.connect(self.redo)

        spacingSlider = QSlider(Qt.Horizontal)
        spacingSlider.setObjectName('spacingSlider')
        spacingSlider.setRange(1,60)
        spacingSlider.setTickPosition(QSlider.TicksBelow)
        spacingSlider.setSliderPosition(10)
        spacingSlider.sliderReleased.connect(self.parent().label.brushUpdate)
        self.spacingSlider = spacingSlider

        jitterSlider = QSlider(Qt.Horizontal)
        jitterSlider.setObjectName('jitterSlider')
        jitterSlider.setRange(0, 100)
        jitterSlider.setTickPosition(QSlider.TicksBelow)
        jitterSlider.setSliderPosition(0)
        jitterSlider.sliderReleased.connect(self.parent().label.brushUpdate)
        self.jitterSlider = jitterSlider

        orientationSlider = QSlider(Qt.Horizontal)
        orientationSlider.setObjectName('orientationSlider')
        orientationSlider.setRange(0, 360)
        orientationSlider.setTickPosition(QSlider.TicksBelow)
        orientationSlider.setSliderPosition(180)
        orientationSlider.sliderReleased.connect(self.parent().label.brushUpdate)
        self.orientationSlider = orientationSlider

        # sample
        self.sample = QLabel()
        #self.sample.setMinimumSize(200, 100)
        pxmp = QPixmap(250,100)
        pxmp.fill(QColor(255, 255, 255, 255))
        self.sample.setPixmap(pxmp)
        qpp = QPainterPath()
        qpp.moveTo(QPointF(20, 50))
        qpp.cubicTo(QPointF(80, 25), QPointF(145, 70), QPointF(230, 60))  # c1, c2, endPoint
        self.samplePoly = qpp.toFillPolygon(QTransform())
        # we want an unclosed polygon
        self.samplePoly.removeLast()

        # layout
        l = QVBoxLayout()
        l.setAlignment(Qt.AlignTop)
        hl = QHBoxLayout()
        hl.setAlignment(Qt.AlignHCenter)
        hl.addWidget(pushButton1)
        hl.addWidget(pushButton2)
        l.addLayout(hl)
        l.addWidget(QLabel('Brush Dynamics'))
        hl1 = QHBoxLayout()
        hl1.addWidget(QLabel('Spacing'))
        hl1.addWidget(spacingSlider)
        l.addLayout(hl1)
        hl2 = QHBoxLayout()
        hl2.addWidget(QLabel('Jitter'))
        hl2.addWidget(jitterSlider)
        l.addLayout(hl2)
        hl3 = QHBoxLayout()
        hl3.addWidget(QLabel('Orientation'))
        hl3.addWidget(self.orientationSlider)
        l.addLayout(hl3)
        l.addWidget(self.sample)
        self.setLayout(l)
        self.adjustSize()

        self.setDefaults()
        self.setWhatsThis(
                        """
                        <b>Drawing :</b><br>
                          Choose a brush family, flow, hardness and opacity.
                        """
                        )  # end of setWhatsThis
コード例 #11
0
class ColorList:
    """
    A list of colors and a way to generate a next color and texture combination.

    Attributes:
        colors (:obj:`list`): List of colors used.
    """
    colors = [
        QColor(0, 0, 0),
        QColor(170, 0, 0),
        QColor(0, 85, 0),
        QColor(170, 85, 0),
        QColor(0, 170, 0),
        QColor(170, 170, 0),
        QColor(0, 255, 0),
        QColor(170, 255, 0),
        QColor(0, 0, 127),
        QColor(170, 0, 127),
        QColor(0, 85, 127),
        QColor(170, 85, 127),
        QColor(0, 170, 127),
        QColor(170, 170, 127),
        QColor(0, 255, 127),
        QColor(170, 255, 127),
        QColor(0, 0, 255),
        QColor(170, 0, 255),
        QColor(0, 85, 255),
        QColor(170, 85, 255),
        QColor(0, 170, 255),
        QColor(170, 170, 255),
        QColor(0, 255, 255),
        QColor(170, 255, 255),
        QColor(85, 0, 0),
        QColor(255, 0, 0),
        QColor(85, 85, 0),
        QColor(255, 85, 0),
        QColor(85, 170, 0),
        QColor(255, 170, 0),
        QColor(85, 255, 0),
        QColor(255, 255, 0),
        QColor(85, 0, 127),
        QColor(255, 0, 127),
        QColor(85, 85, 127),
        QColor(255, 85, 127),
        QColor(85, 170, 127),
        QColor(255, 170, 127),
        QColor(85, 255, 127),
        QColor(255, 255, 127),
        QColor(85, 0, 255),
        QColor(255, 0, 255),
        QColor(85, 85, 255),
        QColor(255, 85, 255),
        QColor(85, 170, 255),
        QColor(255, 170, 255),
        QColor(85, 255, 255),
        QColor(255, 255, 255)
    ]

    @classmethod
    def get_next_color_and_texture(cls, new_id, option):
        """
        Sets the color and texture for a polygon option.

        Args:
            new_id (int): The new id for the polygon display option.
            option (:obj:`PolygonOption`): The polygon display option to set.
        """
        num_colors = len(cls.colors)
        option.color = cls.colors[new_id % num_colors]
        option.texture = PolygonTexture(
            (int(option.texture) + int(new_id / num_colors)) %
            len(PolygonTexture))
コード例 #12
0
class nDisplayMonitor(QAbstractTableModel):
    ''' This will monitor the status of the nDisplay nodes, in particular regarding sync.
    It polls the listener at the specified rate and the UI should update with this info.
    '''

    ColorWarning = QColor(0x70, 0x40, 0x00)
    ColorNormal = QColor(0x3d, 0x3d, 0x3d)

    def __init__(self, parent):
        QAbstractTableModel.__init__(self, parent)

        self.polling_period_ms = 1000
        self.devicedatas = OrderedDict(
        )  # ordered so that we can map row indices to devices

        self.timer = QTimer(self)
        self.timer.timeout.connect(self.poll_sync_status)

        headerdata = [
            ('Node', 'The cluster name of this device'),
            ('Host', 'The URL of the remote PC'),
            ('Connected', 'If we are connected to the listner of this device'),
            ('Driver', 'GPU driver version'),
            ('FlipMode',
             'Current presentation mode. Only available once the render node process is running. Expects "Hardware Composed: Independent Flip"'
             ),
            ('Gpus', 'Informs if GPUs are synced.'),
            ('Displays',
             'Detected displays and whether they are in sync or not'),
            ('Fps', 'Sync Frame Rate'),
            ('HouseSync',
             'Presence of an external sync signal connected to the remote Quadro Sync card'
             ),
            ('SyncSource', 'The source of the GPU sync signal'),
            ('Mosaics', 'Display grids and their resolutions'),
            ('Taskbar',
             'Whether the taskbar is set to auto hide or always on top. It is recommended to be consistent across the cluster'
             ),
            ('InFocus',
             'Whether nDisplay instance window is in Focus. It is recommended to be in focus.'
             ),
            ('ExeFlags',
             'It is recommended to disable fullscreen opimizations on the unreal executable. Only available once the render node process is running. Expects "DISABLEDXMAXIMIZEDWINDOWEDMODE"'
             ),
        ]

        self.colnames = [hd[0] for hd in headerdata]
        self.tooltips = [hd[1] for hd in headerdata]

    def color_for_column(self, colname, value, data):
        ''' Returns the background color for the given cell
        '''

        if data['Connected'].lower() == 'no':
            if colname == 'Connected':
                return self.ColorWarning
            return self.ColorNormal

        if colname == 'FlipMode':
            good_string = 'Hardware Composed: Independent Flip'
            return self.ColorNormal if good_string in value else self.ColorWarning

        if colname == 'Gpus':
            return self.ColorNormal if 'Synced' in value and 'Free' not in value else self.ColorWarning

        if colname == 'InFocus':
            return self.ColorNormal if 'yes' in value else self.ColorWarning

        if colname == 'ExeFlags':
            good_string = 'DISABLEDXMAXIMIZEDWINDOWEDMODE'
            return self.ColorNormal if good_string in value else self.ColorWarning

        if colname == 'Displays':
            is_normal = ('Slave' in value
                         or 'Master' in value) and 'Unsynced' not in value
            return self.ColorNormal if is_normal else self.ColorWarning

        return self.ColorNormal

    def reset_device_data(self, device, data):
        ''' Sets device data to unconnected state
        '''

        for colname in self.colnames:
            data[colname] = 'n/a'

        data['Host'] = str(device.ip_address)
        data['Node'] = device.name
        data[
            'Connected'] = 'yes' if device.unreal_client.is_connected else 'no'

        # extra data not in columns
        data['TimeLastFlipGlitch'] = time.time()

    def added_device(self, device):
        ''' Called by the plugin when a new nDisplay device has been added.
        '''

        data = {}

        self.reset_device_data(device, data)
        self.devicedatas[device.device_hash] = {
            'device': device,
            'data': data,
            'time_last_update': 0,
            'stale': True
        }

        # notify the UI of the change
        self.layoutChanged.emit()

        # start/continue polling since there is at least one device
        if not self.timer.isActive():
            self.timer.start(self.polling_period_ms)

    def removed_device(self, device):
        ''' Called by the plugin when an nDisplay device has been removed.
        '''

        self.devicedatas.pop(device.device_hash)

        # notify the UI of the change
        self.layoutChanged.emit()

        # turn off the timer if there are no devices left
        if not self.devicedatas:
            self.timer.stop()

    def handle_stale_device(self, devicedata, deviceIdx):
        '''Detects if the device is stale, and resets the data if so as to not mislead the user
        '''

        # if already flagged as stale, no need to do anything
        if devicedata['stale']:
            return

        # check if it has been too long
        time_elapsed_since_last_update = time.time(
        ) - devicedata['time_last_update']

        timeout_factor = 4

        if time_elapsed_since_last_update < timeout_factor * self.polling_period_ms * 1e-3:
            return

        # if we're here, it has been too long since the last update
        self.reset_device_data(devicedata['device'], devicedata['data'])
        devicedata['stale'] = True

        # notify the UI
        row = deviceIdx + 1
        self.dataChanged.emit(self.createIndex(row, 1),
                              self.createIndex(row, len(
                                  self.colnames)))  # [Qt.EditRole]

    def handle_connection_change(self, devicedata, deviceIdx):
        ''' Detects if device connection changed and notifies the UI if a disconnection happens.
        '''

        device = devicedata['device']
        data = devicedata['data']

        is_connected = device.unreal_client.is_connected
        was_connected = True if data['Connected'] == 'yes' else False

        data['Connected'] = 'yes' if is_connected else 'no'

        if was_connected != is_connected:

            if not is_connected:
                self.reset_device_data(device, data)

            row = deviceIdx + 1
            self.dataChanged.emit(self.createIndex(row, 1),
                                  self.createIndex(row, len(self.colnames)))

    def poll_sync_status(self):
        ''' Polls sync status for all nDisplay devices
        '''

        for deviceIdx, devicedata in enumerate(self.devicedatas.values()):
            device = devicedata['device']

            # detect connection changes (a disconnection invalidates data)
            self.handle_connection_change(devicedata, deviceIdx)

            # detect stale devices
            self.handle_stale_device(devicedata, deviceIdx)

            # no point in continuing of not connected to listener
            if not device.unreal_client.is_connected:
                continue

            # create message

            try:
                program_id = device.program_start_queue.running_puuids_named(
                    'unreal')[-1]
            except IndexError:
                program_id = '00000000-0000-0000-0000-000000000000'

            _, msg = message_protocol.create_get_sync_status_message(
                program_id)

            # send get sync status message
            device.unreal_client.send_message(msg)

    def devicedata_from_device(self, device):
        ''' Retrieves the devicedata and index for given device
        '''
        for deviceIdx, hash_devicedata in enumerate(self.devicedatas.items()):
            device_hash, devicedata = hash_devicedata[0], hash_devicedata[1]
            if device_hash == device.device_hash:
                return (deviceIdx, devicedata)

        raise KeyError

    def populate_sync_data(self, devicedata, message):
        ''' Populates model data with message contents, which comes from 'get sync data' command.
        '''

        data = devicedata['data']
        device = devicedata['device']

        #
        # Sync Topology
        #

        syncStatus = message['syncStatus']
        syncTopos = syncStatus['syncTopos']

        # Build Gpus, informing which Gpus in each Sync group are in sync

        Gpus = []

        for syncTopo in syncTopos:
            gpu_sync_oks = [gpu['bIsSynced'] for gpu in syncTopo['syncGpus']]
            gpu_sync_yesno = map(lambda x: "Synced"
                                 if x else 'Free', gpu_sync_oks)
            Gpus.append('%s' % (', '.join(gpu_sync_yesno)))

        data['Gpus'] = '\n'.join(Gpus)

        # Build Displays, informing which Display in each Sync group are in sync.

        Displays = []

        bpc_strings = {1: 6, 2: 8, 3: 10, 4: 12, 5: 16}

        for syncTopo in syncTopos:
            display_sync_states = [
                f"{syncDisplay['syncState']}({bpc_strings.get(syncDisplay['bpc'], '??')}bpc)"
                for syncDisplay in syncTopo['syncDisplays']
            ]
            Displays.append(', '.join(display_sync_states))

        data['Displays'] = '\n'.join(Displays)

        # Build Fps
        refreshRates = [
            f"{syncTopo['syncStatusParams']['refreshRate']*1e-4:.3f}"
            for syncTopo in syncTopos
        ]
        data['Fps'] = '\n'.join(refreshRates)

        # Build House Sync
        house_fpss = [
            syncTopo['syncStatusParams']['houseSyncIncoming'] * 1e-4
            for syncTopo in syncTopos
        ]
        house_syncs = [
            syncTopo['syncStatusParams']['bHouseSync']
            for syncTopo in syncTopos
        ]
        house_sync_fpss = map(lambda x: f"{x[1]:.3f}" if x[0] else 'no',
                              zip(house_syncs, house_fpss))
        data['HouseSync'] = '\n'.join(house_sync_fpss)

        # Build Sync Source
        source_str = {0: 'Vsync', 1: 'House'}
        sync_sources = [
            syncTopo['syncControlParams']['source'] for syncTopo in syncTopos
        ]
        sync_sources = [
            source_str.get(sync_source, 'Unknown')
            for sync_source in sync_sources
        ]
        bInternalSlaves = [
            syncTopo['syncStatusParams']['bInternalSlave']
            for syncTopo in syncTopos
        ]

        sync_slaves = []

        for i in range(len(sync_sources)):
            if bInternalSlaves[i] and sync_sources[i] == 'Vsync':
                sync_slaves.append('Vsync(daisy)')
            else:
                sync_slaves.append(sync_sources[i])

        data['SyncSource'] = '\n'.join(sync_slaves)

        #
        # Mosaic Topology
        #

        mosaicTopos = syncStatus['mosaicTopos']

        mosaicTopoLines = []

        for mosaicTopo in mosaicTopos:
            displaySettings = mosaicTopo['displaySettings']
            width_per_display = displaySettings['width']
            height_per_display = displaySettings['height']

            width = mosaicTopo['columns'] * width_per_display
            height = mosaicTopo['rows'] * height_per_display

            # Ignoring displaySettings['freq'] because it seems to be fixed and ignores sync frequency.
            line = f"{width}x{height} {displaySettings['bpp']}bpp"
            mosaicTopoLines.append(line)

        data['Mosaics'] = '\n'.join(mosaicTopoLines)

        # Build FlipMode.
        #
        flip_history = syncStatus['flipModeHistory']

        if len(flip_history) > 0:
            data['FlipMode'] = flip_history[-1]

        # Detect FlipMode glitches
        if len(set(flip_history)) > 1:
            data['FlipMode'] = 'GLITCH!'
            data['TimeLastFlipGlitch'] = time.time()

        # Write time since last glitch
        if data['FlipMode'] != 'n/a':
            time_since_flip_glitch = time.time() - data['TimeLastFlipGlitch']

            # Let the user know for 1 minute that there was a glitch in the flip mode
            if time_since_flip_glitch < 1 * 60:
                data['FlipMode'] = data['FlipMode'].split(
                    '\n')[0] + '\n' + str(int(time_since_flip_glitch))

        # Window in focus or not
        data['InFocus'] = 'no'
        for prog in device.program_start_queue.running_programs_named(
                'unreal'):
            if prog.pid and prog.pid == syncStatus['pidInFocus']:
                data['InFocus'] = 'yes'
                break

        # Show Exe flags (like Disable Fullscreen Optimization)
        data['ExeFlags'] = '\n'.join(
            [layer for layer in syncStatus['programLayers'][1:]])

        # Driver version
        driver = syncStatus['driverVersion']
        data['Driver'] = f'{int(driver/100)}.{driver % 100}'

        # Taskbar visibility
        data['Taskbar'] = syncStatus['taskbar']

    def on_get_sync_status(self, device, message):
        ''' Called when the listener has sent a message with the sync status
        '''

        # check ack
        try:
            if message['bAck'] == False:
                return
        except KeyError:
            LOGGER.error(
                f"Error parsing 'get sync status' looking for 'bAck' flag")
            return

        # ok, we expect this to be a valid message, let's parse and update the model.

        deviceIdx, devicedata = self.devicedata_from_device(device)
        devicedata['time_last_update'] = time.time()
        devicedata['stale'] = False

        try:
            self.populate_sync_data(devicedata=devicedata, message=message)
        except KeyError:
            LOGGER.error(
                f"Error parsing 'get sync status' message and populating model data\n\n=== Traceback BEGIN ===\n{traceback.format_exc()}=== Traceback END ===\n"
            )
            return

        row = deviceIdx + 1
        self.dataChanged.emit(self.createIndex(row, 1),
                              self.createIndex(row, len(self.colnames)))

    #~ QAbstractTableModel interface begin

    def rowCount(self, parent=QModelIndex()):
        return len(self.devicedatas)

    def columnCount(self, parent=QModelIndex()):
        return len(self.colnames)

    def headerData(self, section, orientation, role):

        if role == Qt.DisplayRole:
            if orientation == Qt.Horizontal:
                return self.colnames[section]
            else:
                return "{}".format(section)

        if role == Qt.ToolTipRole:
            return self.tooltips[section]

        return None

    def data(self, index, role=Qt.DisplayRole):

        column = index.column()
        row = index.row()

        # get column name
        colname = self.colnames[column]

        # grab device data from ordered dict
        _, devicedata = list(self.devicedatas.items())[
            row]  # returns key, value. Where key is the device_hash.
        data = devicedata['data']
        value = data[colname]

        if role == Qt.DisplayRole:
            return value

        elif role == Qt.BackgroundRole:
            return self.color_for_column(colname=colname,
                                         value=value,
                                         data=data)

        elif role == Qt.TextAlignmentRole:
            return Qt.AlignRight

        return None

    @QtCore.Slot()
    def btnForceFocus_clicked(self):
        ''' Forces focus on the nDisplay window if not already in focus
        '''
        for devicedata in self.devicedatas.values():
            device = devicedata['device']
            data = devicedata['data']

            if data['InFocus'] != 'yes':
                device.force_focus()

    @QtCore.Slot()
    def btnFixExeFlags_clicked(self):
        ''' Tries to force the correct UE4Editor.exe flags
        '''
        for devicedata in self.devicedatas.values():
            device = devicedata['device']
            data = devicedata['data']

            good_string = 'DISABLEDXMAXIMIZEDWINDOWEDMODE'

            if good_string not in data['ExeFlags']:
                device.fix_exe_flags()

    @QtCore.Slot()
    def btnSoftKill_clicked(self):
        ''' Kills the cluster by sending a message to the master.
        '''
        devices = [
            devicedata['device'] for devicedata in self.devicedatas.values()
        ]
        if len(devices):
            try:
                devices[0].__class__.soft_kill_cluster(devices)
            except:
                LOGGER.warning("Could not soft kill cluster")
コード例 #13
0
class GridDisplay(GameDisplay):
    background_colour = QColor.fromRgb(0x009E0B)
    line_colour = QColor.fromRgb(0x000000)
    player1_colour = QColor.fromRgb(0x000000)
    player2_colour = QColor.fromRgb(0xFFFFFF)

    def __init__(self, start_state: GridGameState):
        super().__init__(start_state)
        self.start_state: GridGameState = start_state
        self.spaces = []  # self.spaces[i][j] holds row i, column j
        self.column_dividers = []
        self.row_dividers = []
        self.column_labels = []
        self.row_labels = []
        self.text_x = self.text_y = 0

        ui = self.ui = Ui_GridControls()
        ui.setupUi(self)
        scene = QGraphicsScene()
        ui.game_display.setScene(scene)
        scene.setBackgroundBrush(self.background_colour)
        self.player1_icon = self.create_icon(self.player1_colour)
        self.player2_icon = self.create_icon(self.player2_colour)
        ui.black_count_pixmap.setText('')
        ui.white_count_pixmap.setText('')
        ui.black_count.setText('')
        ui.white_count.setText('')

        for _ in range(start_state.board_height - 1):
            self.row_dividers.append(scene.addLine(0, 0, 1, 1))
        for _ in range(start_state.board_width - 1):
            self.column_dividers.append(scene.addLine(0, 0, 1, 1))
        for i in range(start_state.board_height):
            self.row_labels.append(scene.addSimpleText(f'{i + 1}'))
        for j in range(start_state.board_width):
            self.column_labels.append(scene.addSimpleText(chr(65 + j)))
        self.to_move = scene.addEllipse(0,
                                        0,
                                        1,
                                        1,
                                        brush=self.get_player_brush(
                                            self.start_state.X_PLAYER))
        self.to_move.setVisible(False)
        self.move_text = ui.move_text
        for i in range(self.start_state.board_height):
            row: typing.List[QGraphicsItem] = []
            self.spaces.append(row)
            for j in range(self.start_state.board_width):
                piece = GraphicsPieceItem(i, j, self)
                scene.addItem(piece)
                piece.setBrush(self.background_colour)
                piece.setPen(self.background_colour)
                row.append(piece)
        self.debug_message = ''

    def resizeEvent(self, event: QResizeEvent):
        super().resizeEvent(event)
        game_display = self.ui.game_display
        view_size = game_display.contentsRect()
        width = view_size.width()
        height = view_size.height()
        extra_columns = 0
        margin = 1 if self.show_coordinates else 0
        cell_size = min(
            width // (self.start_state.board_width + extra_columns + margin),
            height // (self.start_state.board_height + margin))
        size = cell_size * self.start_state.board_width
        x0 = (width - cell_size *
              (self.start_state.board_width + extra_columns + margin)) // 2
        y0 = (height - cell_size *
              (self.start_state.board_height + margin)) // 2
        x0 += margin * cell_size
        y0 += margin * cell_size
        font = QFont(self.default_font)
        font_size = max(1, int(cell_size // 2))
        font.setPointSize(font_size)
        for i in range(self.start_state.board_height - 1):
            r = cell_size * (i + 1)
            self.row_dividers[i].setLine(x0, y0 + r, x0 + size, y0 + r)
        for i in range(self.start_state.board_width - 1):
            r = cell_size * (i + 1)
            self.column_dividers[i].setLine(x0 + r, y0, x0 + r, y0 + size)
        for i, label in enumerate(self.row_labels):
            r = cell_size * (2 * i + 1) // 2
            label.setFont(font)
            text_x = x0 - cell_size // 2
            text_y = y0 + r
            center_text_item(label, text_x, text_y)
        for i, label in enumerate(self.column_labels):
            r = cell_size * (2 * i + 1) // 2
            label.setFont(font)
            center_text_item(label, x0 + r, y0 - cell_size // 2)
        font_size = max(1, int(cell_size * extra_columns // 6))
        font.setPointSize(font_size)
        self.text_x = x0 + size + cell_size * extra_columns // 2
        self.text_y = (y0 + cell_size * self.start_state.board_height // 2 +
                       cell_size * extra_columns // 5)
        self.update_move_text()

        for i, row in enumerate(self.spaces):
            for j, piece in enumerate(row):
                x = x0 + j * cell_size + cell_size // 8
                y = y0 + i * cell_size + cell_size // 8
                piece.setRect(x, y, cell_size * 3 // 4, cell_size * 3 // 4)
        self.scene().setSceneRect(0, 0, width, height)

    def scene(self) -> QGraphicsScene:
        return self.ui.game_display.scene()

    @staticmethod
    def create_icon(player_colour: QColor) -> QPixmap:
        size = 200
        icon = QPixmap(size, size)
        icon.fill(Qt.transparent)
        painter = QPainter(icon)
        try:
            painter.setBrush(player_colour)
            pen = QPen()
            pen.setWidth(3)
            painter.setPen(pen)
            painter.drawEllipse(1, 1, size - 2, size - 2)
        finally:
            painter.end()
        return icon

    def update_board(self, state: GameState):
        assert isinstance(state, GridGameState)
        self.current_state = state
        self.valid_moves = self.current_state.get_valid_moves()
        is_ended = self.current_state.is_ended()
        spaces = self.current_state.get_spaces()
        for i in range(self.current_state.board_height):
            for j in range(self.current_state.board_width):
                player = spaces[i][j]
                piece = self.spaces[i][j]
                if player == self.current_state.NO_PLAYER:
                    if is_ended:
                        piece.setVisible(False)
                    else:
                        piece.setVisible(True)
                        piece.setBrush(self.background_colour)
                        piece.setPen(self.background_colour)
                else:
                    piece.setVisible(True)
                    piece.setBrush(self.get_player_brush(player))
                    piece.setPen(self.line_colour)
                piece.setOpacity(1)
        self.ui.player_pixmap.setVisible(True)
        for label in itertools.chain(self.row_labels, self.column_labels):
            label.setVisible(self.show_coordinates)
        if is_ended:
            if self.current_state.is_win(self.current_state.X_PLAYER):
                self.update_move_text('wins')
                self.ui.player_pixmap.setPixmap(self.player1_icon)
            elif self.current_state.is_win(self.current_state.O_PLAYER):
                self.update_move_text('wins')
                self.to_move.setBrush(
                    self.get_player_brush(self.current_state.O_PLAYER))
            else:
                self.update_move_text('draw')
                self.ui.player_pixmap.clear()
        else:
            self.update_move_text(self.choose_active_text())
            active_player = self.current_state.get_active_player()
            self.ui.player_pixmap.setPixmap(
                self.get_player_icon(active_player))

    def get_player_brush(self, player):
        return QBrush(self.player1_colour if player ==
                      self.start_state.X_PLAYER else self.player2_colour)

    def get_player_icon(self, player: int) -> QPixmap:
        return (self.player1_icon
                if player == self.start_state.X_PLAYER else self.player2_icon)

    def update_move_text(self, text: str = None):
        if self.debug_message:
            self.move_text.setText(self.debug_message)
        elif text is not None:
            self.move_text.setText(text)

    def on_hover_enter(self, piece_item: GraphicsPieceItem):
        if self.is_piece_played(piece_item):
            return
        if not self.can_move():
            return
        move = self.calculate_move(piece_item.row, piece_item.column)
        is_valid = self.valid_moves[move]
        if not is_valid:
            return
        piece_item.setBrush(
            self.get_player_brush(self.current_state.get_active_player()))
        piece_item.setPen(self.line_colour)
        piece_item.setOpacity(0.5)

    def on_hover_leave(self, piece_item: GraphicsPieceItem):
        if self.is_piece_played(piece_item):
            return
        piece_item.setBrush(self.background_colour)
        piece_item.setPen(self.background_colour)
        piece_item.setOpacity(1)

    def on_click(self, piece_item: GraphicsPieceItem):
        if not self.can_move():
            return
        move = self.calculate_move(piece_item.row, piece_item.column)
        is_valid = self.valid_moves[move]
        if is_valid:
            self.make_move(move)

    def calculate_move(self, row, column):
        move = row * self.start_state.board_width + column
        return move

    def is_piece_played(self, piece_item):
        current_spaces = self.current_state.get_spaces()
        hovered_player = current_spaces[piece_item.row][piece_item.column]
        return hovered_player != self.start_state.NO_PLAYER

    def close(self):
        super().close()
        scene = self.ui.game_display.scene()
        if scene is not None:
            scene.clear()
コード例 #14
0
        widget = QWidget()
        widget.setLayout(layout)

        # Set the central widget of the Window. Widget will expand
        # to take up all the space in the window by default.
        self.setCentralWidget(widget)


# tag::appStyle[]
app = QApplication(sys.argv)
app.setStyle("Fusion")
# end::appStyle[]

darkPalette = app.palette()
darkPalette.setColor(QPalette.Window, QColor(53, 53, 53))
darkPalette.setColor(QPalette.WindowText, Qt.white)
darkPalette.setColor(QPalette.Disabled, QPalette.WindowText,
                     QColor(127, 127, 127))
darkPalette.setColor(QPalette.Base, QColor(42, 42, 42))
darkPalette.setColor(QPalette.AlternateBase, QColor(66, 66, 66))
darkPalette.setColor(QPalette.ToolTipBase, Qt.white)
darkPalette.setColor(QPalette.ToolTipText, Qt.white)
darkPalette.setColor(QPalette.Text, Qt.white)
darkPalette.setColor(QPalette.Disabled, QPalette.Text, QColor(127, 127, 127))
darkPalette.setColor(QPalette.Dark, QColor(35, 35, 35))
darkPalette.setColor(QPalette.Shadow, QColor(20, 20, 20))
darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ButtonText, Qt.white)
darkPalette.setColor(QPalette.Disabled, QPalette.ButtonText,
                     QColor(127, 127, 127))
コード例 #15
0
class DigitalCircle(QQuickPaintedItem):
    def __init__(self, parent=None):
        QQuickPaintedItem.__init__(self, parent)
        self._oroborusFlag = True
        self._cycleFlag = True
        self._radius = 100
        self._borderOffset = 15
        self._digitsList = []
        self._scale = 0
        self._posX = 0
        self._posY = 0
        self._speedRatio = 1.0
        self._timerInterval = 25 * self._speedRatio
        self._animationIndex = 0
        self._timer = QTimer()
        QObject.connect(self._timer, SIGNAL('timeout()'), self,
                        SLOT('requestSpecialUpdate()'))
        self._dotColor = QColor(Qt.green)
        self._lineWidth = 1
        self._lineColor = QColor(Qt.black)

    @Slot(result='QString')
    def exportJson(self):
        from PySide2.QtCore import QJsonDocument, QByteArray, QJsonArray
        jDoc = QJsonDocument()
        jObj = dict()
        if self._oroborusFlag == False:
            jObj["oroborusFlag"] = self._oroborusFlag
        if self._cycleFlag == False:
            jObj["cycleFlag"] = self._cycleFlag
        if self._radius != 100:
            jObj["radius"] = self._radius
        if self._speedRatio != 1.0:
            jObj["speedRatio"] = self._speedRatio
        if self._lineWidth != 1:
            jObj["lineWidth"] = self._lineWidth
        digitsArray = QJsonArray()
        for d in self._digitsList:
            digitsArray.append(int(d))
        jObj["digits"] = digitsArray
        jObj["scale"] = self._scale

        if self._dotColor != QColor(Qt.green):
            jObj["dotColor"] = self._dotColor.name()
        if self._lineColor != QColor(Qt.black):
            jObj["lineColor"] = self._lineColor.name()
        jDoc.setObject(jObj)
        jsonString = jDoc.toJson(QJsonDocument.Compact).data().decode()
        return jsonString

    @Slot('QString')
    def importJson(self, jsonString):
        import json
        jObj = json.loads(jsonString)
        if "oroborusFlag" in jObj:
            self._oroborusFlag = jObj["oroborusFlag"]
        else:
            self._oroborusFlag = True
        if "cycleFlag" in jObj:
            self._cycleFlag = jObj["cycleFlag"]
        else:
            self._cycleFlag = True
        if "radius" in jObj:
            self._radius = jObj["radius"]
        else:
            self._radius = 100
        if "speedRatio" in jObj:
            self._speedRatio = jObj["speedRatio"]
        else:
            self._speedRatio = 1.0
        if "lineWidth" in jObj:
            self._lineWidth = jObj["lineWidth"]
        else:
            self._lineWidth = 1
        if "dotColor" in jObj:
            self._dotColor = QColor(jObj["dotColor"])
        else:
            self._dotColor = QColor(Qt.green)
        if "lineColor" in jObj:
            self._lineColor = QColor(jObj["lineColor"])
        else:
            self._lineColor = QColor(Qt.green)
        try:
            self._digitsList = jObj["digits"]
            self._scale = int(jObj["scale"])
        except:
            print("failed to load digits: ", jObj)
        self.update()

    @Slot(float)
    def setSpeedRatio(self, newRate):
        self._speedRatio = newRate
        self._timerInterval = 25 * self._speedRatio
        self._timer.setInterval(self._timerInterval)

    @Slot('QColor')
    def setDotColor(self, newColor):
        self._dotColor = newColor

    @Slot('QColor')
    def setLineColor(self, newColor):
        self._lineColor = newColor

    @Slot(int)
    def setLineWidth(self, newLineWidth):
        self._lineWidth = newLineWidth

    @Slot('QVariant', int, bool, bool)
    def set(self, digitsList, scale, cycleFlag, oroborusFlag):
        if type(digitsList) is QJSValue:
            digitsList = digitsList.toVariant()
        self._digitsList = digitsList
        self._scale = scale
        self._cycleFlag = cycleFlag
        self._oroborusFlag = oroborusFlag
        self.update()

    def paint(self, painter):
        brushBackup = painter.brush()
        self.paintWithoutNotation(painter)
        self.drawNotation(painter)
        painter.setBrush(brushBackup)

    def paintWithoutNotation(self, painter):
        brushBackup = painter.brush()
        penBackup = painter.pen()
        localPen = QPen(self._lineColor)
        localPen.setWidth(self._lineWidth)
        painter.setPen(localPen)
        painter.drawEllipse(self._borderOffset, self._borderOffset,
                            self._radius * 2, self._radius * 2)
        if self._scale == 0 or len(self._digitsList) == 0:
            return
        for i in range(1, len(self._digitsList)):
            prevDigit = self._digitsList[i - 1]
            currentDigit = self._digitsList[i]
            self.drawLine(painter, prevDigit, currentDigit)
        if self._cycleFlag:
            firstDigit = self._digitsList[0]
            lastDigit = self._digitsList[-1]
            self.drawLine(painter, lastDigit, firstDigit)
        painter.setBrush(self._dotColor)
        painter.drawEllipse(
            self._radius - self._posX + self._borderOffset - 10 / 2,
            self._radius - self._posY + self._borderOffset - 10 / 2, 10, 10)
        painter.setBrush(brushBackup)
        painter.setPen(penBackup)

    def drawLine(self, painter, start, end):
        scale = self._scale
        radius = self._radius
        if self._oroborusFlag == True:
            scale -= 1
        degree1 = (scale - start) * 360.0 / scale
        y1 = radius * cos(degree1 * 3.14159265 / 180.0)
        x1 = radius * sin(degree1 * 3.14159265 / 180.0)
        degree2 = (scale - end) * 360.0 / scale
        y2 = radius * cos(degree2 * 3.14159265 / 180.0)
        x2 = radius * sin(degree2 * 3.14159265 / 180.0)
        radius += self._borderOffset
        painter.drawLine(radius - x1, radius - y1, radius - x2, radius - y2)

    def drawNotation(self, painter):
        if len(self._digitsList) == 0:
            return

        scale = self._scale
        radius = self._radius
        if self._oroborusFlag == True:
            scale -= 1
        for i in range(0, scale):
            degree = (scale - i) * 360.0 / scale
            x = radius * sin(degree * 3.14159265 / 180.0)
            y = radius * cos(degree * 3.14159265 / 180.0)
            xWide = (radius + 12) * sin(degree * 3.14159265 / 180.0)
            yWide = (radius + 12) * cos(degree * 3.14159265 / 180.0)
            painter.drawEllipse(radius - x + self._borderOffset,
                                radius - y + self._borderOffset, 3, 3)

            if self._digitsList[0] == i or self._digitsList[-1] == i:
                if self._digitsList[0] == i:
                    painter.setBrush(Qt.white)
                else:
                    painter.setBrush(Qt.black)
                painter.drawEllipse(radius - x + self._borderOffset - 10 / 2,
                                    radius - y + self._borderOffset - 10 / 2,
                                    10, 10)

            if i == 0 and self._oroborusFlag == True:
                digitText = str(scale)
            else:
                digitText = str(i)
            painter.drawText(radius - xWide + self._borderOffset - 12 / 2,
                             radius - yWide + self._borderOffset - 12 / 2, 20,
                             20, 0, digitText)

    def tracePositions(self, x1, y1, x2, y2, steps):
        result = []
        deltaX = x2 - x1
        deltaY = y2 - y1
        stepX = deltaX / steps
        stepY = deltaY / steps
        for s in range(0, steps):
            anotherPosition = [x1 + stepX * s, y1 + stepY * s]
            result.append(anotherPosition)
        return result

    def prepareAnimation(self):
        scale = self._scale
        radius = self._radius
        if self._oroborusFlag == True:
            scale -= 1
        stepsBetweenNodes = 20
        digitsPositions = []
        for digit in self._digitsList:
            degree = (scale - digit) * 360.0 / scale
            x = radius * sin(degree * 3.14159265 / 180.0)
            y = radius * cos(degree * 3.14159265 / 180.0)
            anotherPosition = [x, y]
            digitsPositions.append(anotherPosition)
        traces = []
        for i in range(0, len(digitsPositions) - 1):
            x1 = digitsPositions[i][0]
            y1 = digitsPositions[i][1]
            x2 = digitsPositions[i + 1][0]
            y2 = digitsPositions[i + 1][1]
            anotherTrace = self.tracePositions(x1, y1, x2, y2,
                                               stepsBetweenNodes)
            traces.extend(anotherTrace)
        x1 = digitsPositions[-1][0]
        y1 = digitsPositions[-1][1]
        x2 = digitsPositions[0][0]
        y2 = digitsPositions[0][1]
        anotherTrace = self.tracePositions(x1, y1, x2, y2, stepsBetweenNodes)
        traces.extend(anotherTrace)
        self._animationTrace = traces

    @Slot()
    def startAnimation(self):
        if len(self._digitsList) == 0:
            return
        self.prepareAnimation()
        self._timer.setInterval(self._timerInterval)
        self._timer.start()

    @Slot()
    def requestSpecialUpdate(self):
        self.requestSpecialUpdateSafe()
        self.update()

    @Slot()
    def requestSpecialUpdateSafe(self):
        newX = self._animationTrace[self._animationIndex][0]
        newY = self._animationTrace[self._animationIndex][1]
        self._posX = newX
        self._posY = newY
        self._animationIndex += 1
        if self._animationIndex >= len(self._animationTrace):
            self._animationIndex = 0

    @Slot()
    def stopAnimation(self):
        self._timer.stop()
        self.resetAnimation()

    @Slot()
    def pauseAnimation(self):
        self._timer.stop()

    @Slot(result='bool')
    def animationIsRunning(self):
        return self._timer.isActive()

    @Slot()
    def resetAnimation(self):
        self._animationIndex = 0

    @Slot(int)
    def setRadius(self, newRadius):
        self._radius = newRadius
        self.update()

    def getRadius(self):
        return self._radius

    def setBorderOffset(self, newBorderOffset):
        self._borderOffset = newBorderOffset
        self.update()

    def getBorderOffset(self):
        return self._borderOffset

    radius = Property(int, getRadius, setRadius)
    borderOffset = Property(int, getBorderOffset, setBorderOffset)
コード例 #16
0
ファイル: activeDS.py プロジェクト: KevinUTAT/active_data_set
 def double_click_data(self, item):
     if self.in_task:
         # make the data unfinished
         self.current_task.mark_as_unfinished(item.text())
         # remove the visual highlight
         item.setBackground(QBrush(QColor("#ffffff")))
コード例 #17
0
ファイル: temp.py プロジェクト: Alexsik76/Beetroot
from PySide2.QtWidgets import *
from PySide2.QtCore import Slot, Qt
from PySide2.QtGui import QPalette, QColor

app = QApplication([])
app.setStyle('Fusion')
default_palette = QPalette()
# Style needed for palette to work
# Dark Palette (found on github, couldn't track the original author)
dark_palette = QPalette()
dark_palette.setColor(QPalette.Window, QColor(53, 53, 53))
dark_palette.setColor(QPalette.WindowText, Qt.white)
dark_palette.setColor(QPalette.Base, QColor(25, 25, 25))
dark_palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
dark_palette.setColor(QPalette.ToolTipBase, Qt.white)
dark_palette.setColor(QPalette.ToolTipText, Qt.white)
dark_palette.setColor(QPalette.Text, Qt.white)
dark_palette.setColor(QPalette.Button, QColor(53, 53, 53))
dark_palette.setColor(QPalette.ButtonText, Qt.white)
dark_palette.setColor(QPalette.BrightText, Qt.red)
dark_palette.setColor(QPalette.Link, QColor(42, 130, 218))
dark_palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
dark_palette.setColor(QPalette.HighlightedText, Qt.black)
window = QWidget()
layout = QGridLayout()
# Make a few Dials and buttons:
for i in range(0, 4):
    Dial = QDial()
    Button = QPushButton('Button ' + str(i))
    Dial.setNotchesVisible(True)
    layout.addWidget(Button, 0, i)
コード例 #18
0
ファイル: qcolor_test.py プロジェクト: BadSingleton/pyside2
 def setUp(self):
     self.color = QColor(20, 40, 60, 80)
コード例 #19
0
from PySide2.QtGui import QColor
import os

CURRENT_DIR         = os.getcwd()
RESOURCES_PATH      = os.path.join(CURRENT_DIR,     'Resources')
IMAGE_FOLDERS_PATH  = os.path.join(CURRENT_DIR,     'Images')
DATA_PATH           = os.path.join(CURRENT_DIR,     'data.csv')
LABELS_PATH         = os.path.join(CURRENT_DIR,     'labels.txt')
ICON_PATH           = os.path.join(RESOURCES_PATH,  'logo.ico')
CHECKED_PATH        = os.path.join(RESOURCES_PATH,  'checked.png')
UNCHECKED_PATH      = os.path.join(RESOURCES_PATH,  'unchecked.png')

TOP_BAR     = 'rgba(70,70,70,255)'
LABEL       = 'rgba(200,200,200,255)'
LABEL_DARK  = 'rgba(20,20,20,255)'
ACCENT      = 'rgba(237,182,234,255)'
BG          = 'rgba(30,30,30,255)'
BG_L1       = 'rgba(40,40,40,255)'
BG_L2       = 'rgba(50,50,50,255)'

ACCENT_QC               = QColor(237,182,234,255)
ACCENT_LOW_OPACITY_QC   = QColor(237,182,234,40)
ACCENT_VLOW_OPACITY_QC  = QColor(237,182,234,25)
LABEL_QC                = QColor(200,200,200,255)
LABEL_LOW_OPACITY_QC    = QColor(200,200,200,70)
BG_L2_QC                = QColor(50,50,50,255)
コード例 #20
0
ファイル: qcolor_test.py プロジェクト: BadSingleton/pyside2
 def testStrFunction(self):
     c = QColor('red')
     c2 = eval(c.__str__())
     self.assertEqual(c, c2)
コード例 #21
0
    def _create_line_indicator(self, addr, item_map, color=Qt.yellow, show_frontier=False, z=None, z_frontier=None):
        """
        Generate a cursor at a given address.
        """
        pos_x = self._get_pos_from_addr(addr)
        if pos_x is None:
            return

        pen = QPen(color)
        brush = QBrush(color)
        height = self.height

        tri_width = 7
        tri_height = 4

        pos_x = int(pos_x - tri_width / 2)  # Center drawing
        center = pos_x + int(tri_width / 2)
        pos_y = 0
        frontier_width = int(0.15 * max(self.width, self.height))

        if show_frontier:
            # Draw frontier gradients
            r = QRectF(center - frontier_width, pos_y, frontier_width, height)
            bg = QLinearGradient(r.topLeft(), r.topRight())
            color = Qt.red
            top_color = QColor(color)
            top_color.setAlpha(0)
            bg.setColorAt(0, top_color)
            bottom_color = QColor(color)
            bottom_color.setAlpha(180)
            bg.setColorAt(1, bottom_color)

            i = QGraphicsRectItem(r, parent=self)
            i.setPen(Qt.NoPen)
            i.setBrush(bg)
            if z_frontier is not None:
                i.setZValue(z_frontier)
            item_map.append(i)

            r = QRectF(center, pos_y, frontier_width, height)
            bg = QLinearGradient(r.topLeft(), r.topRight())
            color = Qt.blue
            top_color = QColor(color)
            bg.setColorAt(0, top_color)
            bottom_color = QColor(color)
            bottom_color.setAlpha(0)
            bg.setColorAt(1, bottom_color)

            i = QGraphicsRectItem(r, parent=self)
            i.setPen(Qt.NoPen)
            i.setBrush(bg)
            if z_frontier is not None:
                i.setZValue(z_frontier)
            item_map.append(i)

        # Draw line
        i = QGraphicsLineItem(center, 0, center, height, parent=self)
        i.setPen(pen)
        if z is not None:
            i.setZValue(z)
        item_map.append(i)

        # Draw top and bottom triangles
        t = QPolygonF()
        t.append(QPointF(pos_x, pos_y))
        t.append(QPointF(pos_x + tri_width - 1, pos_y))
        t.append(QPointF(center, pos_y + tri_height - 1))
        t.append(QPointF(pos_x, pos_y))

        pos_y += height - 1
        b = QPolygonF()
        b.append(QPointF(pos_x, pos_y))
        b.append(QPointF(center, pos_y - tri_height + 1))
        b.append(QPointF(pos_x + tri_width - 1, pos_y))
        b.append(QPointF(pos_x, pos_y))

        for i in [QGraphicsPolygonItem(t, parent=self),
                  QGraphicsPolygonItem(b, parent=self)]:
            i.setPen(pen)
            i.setBrush(brush)
            if z is not None:
                i.setZValue(z)
            item_map.append(i)
コード例 #22
0
 def updateSample(self):
     pxmp = self.sample.pixmap()
     pxmp.fill(QColor(0,0,0,0))
     brushFamily.brushStrokePoly(pxmp, self.samplePoly, self.layer.brushDict)
     self.sample.repaint()
コード例 #23
0
    def drawForeground(self, painter, rect):
        """Draws all connections and borders around selected items."""

        # DRAW CONNECTIONS
        for ni in self.all_node_instances:
            for o in ni.outputs:
                for cpi in o.connected_port_instances:
                    path = self.connection_path(o.gate.get_scene_center_pos(),
                                                cpi.gate.get_scene_center_pos())
                    w = path.boundingRect().width()
                    h = path.boundingRect().height()
                    gradient = QRadialGradient(path.boundingRect().center(),
                                               pythagoras(w, h) / 2)

                    pen = Design.flow_theme.get_flow_conn_pen_inst(o.type_)
                    c = pen.color()

                    # highlight hovered connections
                    if self.hovered_port_inst_gate == o.gate or self.hovered_port_inst_gate is cpi.gate:
                        c = QColor('#c5c5c5')
                        pen.setWidth(5)

                    c_r = c.red()
                    c_g = c.green()
                    c_b = c.blue()
                    gradient.setColorAt(0.0, QColor(c_r, c_g, c_b, 255))
                    gradient.setColorAt(0.75, QColor(c_r, c_g, c_b, 200))
                    gradient.setColorAt(0.95, QColor(c_r, c_g, c_b, 0))
                    gradient.setColorAt(1.0, QColor(c_r, c_g, c_b, 0))
                    pen.setBrush(gradient)
                    painter.setPen(pen)
                    painter.drawPath(path)

        # DRAW CURRENTLY DRAGGED CONNECTION
        if self.dragging_connection:
            pen = QPen('#101520')
            pen.setWidth(3)
            pen.setStyle(Qt.DotLine)
            painter.setPen(pen)
            gate_pos = self.gate_selected.get_scene_center_pos()
            if self.gate_selected.parent_port_instance.direction == 'output':
                painter.drawPath(
                    self.connection_path(gate_pos,
                                         self.last_mouse_move_pos)
                )
            else:
                painter.drawPath(
                    self.connection_path(self.last_mouse_move_pos, gate_pos)
                )

        # DRAW SELECTED NIs BORDER
        for ni in self.selected_node_instances():
            pen = QPen(QColor('#245d75'))
            pen.setWidth(3)
            painter.setPen(pen)
            painter.setBrush(Qt.NoBrush)

            size_factor = 1.2
            x = ni.pos().x() - ni.boundingRect().width() / 2 * size_factor
            y = ni.pos().y() - ni.boundingRect().height() / 2 * size_factor
            w = ni.boundingRect().width() * size_factor
            h = ni.boundingRect().height() * size_factor
            painter.drawRoundedRect(x, y, w, h, 10, 10)

        # DRAW SELECTED DRAWINGS BORDER
        for p_o in self.selected_drawings():
            pen = QPen(QColor('#a3cc3b'))
            pen.setWidth(2)
            painter.setPen(pen)
            painter.setBrush(Qt.NoBrush)

            size_factor = 1.05
            x = p_o.pos().x() - p_o.width / 2 * size_factor
            y = p_o.pos().y() - p_o.height / 2 * size_factor
            w = p_o.width * size_factor
            h = p_o.height * size_factor
            painter.drawRoundedRect(x, y, w, h, 6, 6)
            painter.drawEllipse(p_o.pos().x(), p_o.pos().y(), 2, 2)
コード例 #24
0
    def __init__(self, parent=None):
        super(SignUpForm, self).__init__(parent)

        self.checkedPass = 0

        self.setWindowTitle("Backend Discord-GUI")
        self.changeStyle('fusion')

        palette = QPalette()
        palette.setColor(QPalette.Window, QColor(53, 53, 53))
        palette.setColor(QPalette.WindowText, Qt.white)
        palette.setColor(QPalette.Text, Qt.white)
        palette.setColor(QPalette.Button, QColor(60, 60, 60))
        palette.setColor(QPalette.ButtonText, Qt.white)
        palette.setColor(QPalette.Base, QColor(40, 40, 40))
        palette.setColor(QPalette.ToolTipBase, QColor(60, 60, 60))
        palette.setColor(QPalette.ToolTipText, Qt.white)
        palette.setColor(QPalette.PlaceholderText, QColor(100, 60, 60))
        palette.setColor(QPalette.BrightText, Qt.white)
        palette.setColor(QPalette.Highlight, QColor(106, 13, 173))
        palette.setColor(QPalette.HighlightedText, Qt.white)

        mainLayout = QVBoxLayout()
        hMainLayout = QHBoxLayout()
        passwordLayout = QHBoxLayout()

        entryBG = QPalette()
        gradient = QGradient()
        gradient.setColorAt(0.0, QColor(30, 30, 30))
        gradient.setColorAt(0.4, QColor(30, 30, 30))
        gradient.setColorAt(1.0, QColor(70, 70, 70))
        gradient.setSpread(QGradient.RepeatSpread)
        entryBG.setBrush(QPalette.Button, QBrush(gradient))

        self.name = QLineEdit(self)
        self.name.setFixedHeight(24)
        self.name.setToolTip("Max 64 Characters")
        self.name.setStyleSheet(
            "QToolTip { border: 0px; border-radius: 3px; }")
        self.name.setPalette(entryBG)
        self.QNameLabel = QLabel("Full Name")
        self.QNameLabel.setFont(QFont("Copperplate", 12))
        self.name.setMaxLength(64)

        self.email = QLineEdit(self)
        self.email.setFixedHeight(24)
        self.email.setToolTip(
            "Max 128 Characters, Example - [email protected]")
        self.email.setStyleSheet(
            "QToolTip { border: 0px; border-radius: 3px }")
        self.email.setPalette(entryBG)
        self.QEmailLabel = QLabel("Email")
        self.QEmailLabel.setFont(QFont("Copperplate", 12))
        self.email.setMaxLength(128)

        self.username = QLineEdit(self)
        self.username.setFixedHeight(24)
        self.username.setToolTip("Max 16 Characters")
        self.username.setStyleSheet(
            "QToolTip { border: 0px; border-radius: 3px }")
        self.username.setPalette(entryBG)
        self.QUserLabel = QLabel("Username")
        self.QUserLabel.setFont(QFont("Copperplate", 12))
        self.username.setMaxLength(16)

        self.password = QLineEdit(self)
        self.password.setFixedHeight(24)
        self.password.setToolTip(
            "Max 32 Characters, Must Include = Uppercase Letter,\nNumber and Special Character"
        )
        self.password.setStyleSheet(
            "QToolTip { border: 0px; border-radius: 3px }")
        self.password.setPalette(entryBG)
        self.QPasswordLabel = QLabel("Password ")
        self.password.setMaxLength(32)
        self.QPasswordLabel.setFont(QFont("Copperplate", 12))
        self.showhideButton = QPushButton("Show")
        self.showhideButton.setCheckable(True)
        self.showhideButton.setChecked(False)
        self.showhideButton.clicked.connect(lambda: self.show_hide())
        self.password.setEchoMode(QLineEdit.Password)
        passwordLayout.addWidget(self.QPasswordLabel)
        passwordLayout.addWidget(self.password)
        passwordLayout.addWidget(self.showhideButton)

        self.btn_SignUp = QPushButton("Sign Up")
        self.btn_SignUp.clicked.connect(lambda: self.signUpWindow())

        shortcut = QShortcut(QKeySequence("Return"), self.btn_SignUp)
        shortcut.activated.connect(lambda: self.signUpWindow())
        shortcut.setEnabled(True)

        self.btn_cancel = QPushButton("Cancel")
        self.btn_cancel.clicked.connect(lambda: self.cancel())

        layout = QFormLayout()
        layout.addRow(self.QNameLabel, self.name)
        layout.addRow(self.QEmailLabel, self.email)
        layout.addRow(self.QUserLabel, self.username)
        layout.addRow(passwordLayout)
        layout.addRow(self.btn_SignUp)
        layout.addRow(self.btn_cancel)

        Label = QLabel("Sign Up To The\nBackend Discord-GUI Development")
        Label.setFont(QFont("Copperplate", 15, QFont.Bold))
        Label.setAlignment(Qt.AlignCenter)

        mainLayout.addSpacing(40)
        mainLayout.addWidget(Label)
        mainLayout.addLayout(layout)
        mainLayout.addSpacing(60)

        hMainLayout.addSpacing(115)
        hMainLayout.addLayout(mainLayout)
        hMainLayout.addSpacing(115)
        self.setLayout(hMainLayout)

        QApplication.setPalette(palette)
コード例 #25
0
 def testReduceRGB(self):
     self.reduceColor(QColor.fromRgbF(0.1, 0.2, 0.3, 0.4))
コード例 #26
0
ファイル: detailed_view.py プロジェクト: Theodhor21/Pr-Pla
class DetailedView(QWidget):
    title_text_size = 18
    content_text_size = 14
    border_color = QColor(112,112,112)
    back_color = QColor(255,255,255)

    visible_widgets = []

    def __init__(self, title="", content="", _parent=None):
        super(DetailedView, self).__init__(overview.Overview.get_instance())

        self._parent = _parent
        self.widget_resolution = overview.Overview.get_instance().frameGeometry()

        QCoreApplication.instance()
        # init
        self.layout = QVBoxLayout()

        self.lable_title = QLabel(title)
        self.lable_content = QLabel(content)

        # font
        title_font = self.lable_title.font()
        title_font.setPixelSize(self.title_text_size)
        content_font = self.lable_content.font()
        content_font.setPixelSize(self.content_text_size)

        self.lable_title.setFont(title_font)
        self.lable_content.setFont(content_font)

        # layout
        self.layout.addWidget(self.lable_title)
        self.layout.addWidget(self.lable_content)

        self.setLayout(self.layout)

        # flags
        self.setMouseTracking(True)



    def calc_min_size(self):
        # width
        if self.lable_title.sizeHint().width() > self.lable_content.sizeHint().width():
            self.setMinimumWidth(self.lable_title.sizeHint().width() + (self.layout.margin() * 2))
        else:
            self.setMinimumWidth(self.lable_content.sizeHint().width() + (self.layout.margin() * 2))

        # height
        height = self.lable_title.sizeHint().height()
        height += self.lable_content.sizeHint().height()
        self.setMinimumHeight(height + (self.layout.margin() * 2))


    def set_title(self, title):
        """
        set title
        :param title: str
        :return:
        """
        self.lable_title.setText(title)
        self.calc_min_size()

    def set_content(self, content):
        """
        set content
        :param content: str
        :return:
        """
        self.lable_content.setText(content)
        self.calc_min_size()


    def move_to_mouse(self):
        """
        moves self to mouse and show
        :return:
        """

        # turn if out of dekstop
        pos = self.cursor().pos()
        pos = overview.Overview.get_instance().mapFromGlobal(pos)

        if pos.x() + self.rect().width() > self.widget_resolution.width():
            pos.setX(pos.x()-self.rect().width())
        if pos.y() + self.rect().height() > self.widget_resolution.height():
            pos.setY(pos.y()-self.rect().height())

        #move
        self.move(pos)
        # if self.isVisible():
        #     if not self.isActiveWindow():
        #         # back to foreground
        #         self.activateWindow()
        # else:
        DetailedView.close_all()
        DetailedView.add_to_visible(self)
        self.show()

    def ask_close(self):
        """
        parent can ask for close
        :return:
        """
        if not self.mouse_is_over_parent():
            DetailedView.remove_visible(self)
            self.close()

    def close(self):
        DetailedView.remove_visible(self)
        super().close()

    def mouse_is_over_parent(self):
        """
        returns if mouse if over _parent
        :return: bool
        """
        mouse_pos = self._parent.mapFromGlobal(QCursor.pos())
        margin = 1
        return mouse_pos.x() > margin and mouse_pos.y() > margin and mouse_pos.x() < self._parent.rect().width() - margin and mouse_pos.y() < self._parent.rect().height() - margin

    def mouseMoveEvent(self, event:QMouseEvent):
        """
        mouse move event
        :param event:
        :return:
        """
        if self.mouse_is_over_parent():
            self.move_to_mouse()
        else:
            self.close()

    def deleteLater(self):
        DetailedView.remove_visible(self)
        super().deleteLater()

    def mousePressEvent(self, event:QMouseEvent):
        """
        redirect mouse press to _parent
        :param event:
        :return:
        """
        self._parent.mousePressEvent(event)


    def paintEvent(self, event:QPaintEvent):
        """
        draws background
        :param event:
        :return: None
        """
        custom_painter = QPainter(self)
        custom_painter.fillRect(self.rect(), self.back_color)

        custom_painter.setPen(self.border_color)
        custom_painter.drawRect(0,0, self.rect().width()-1, self.rect().height()-1)

    def resizeEvent(self, event:QResizeEvent):
        self.widget_resolution = overview.Overview.get_instance().frameGeometry()
        super().resizeEvent(event)

    @staticmethod
    def add_to_visible(detailed_view):
        if not detailed_view in DetailedView.visible_widgets:
            DetailedView.visible_widgets.append(detailed_view)

    @staticmethod
    def remove_visible(detailed_view):
        if detailed_view in DetailedView.visible_widgets:
            DetailedView.visible_widgets.remove(detailed_view)

    @staticmethod
    def close_all():
        for detailed_view in DetailedView.visible_widgets:
            detailed_view.ask_close()
コード例 #27
0
 def testReduceHsv(self):
     self.reduceColor(QColor.fromHsvF(0.1, 0.2, 0.3, 0.4))
コード例 #28
0
 def change_data(self):
     for i in range(10, 50):
         self._model.setData(self._model.index(i, 1), QColor(Qt.blue),
                             Qt.BackgroundRole)
コード例 #29
0
 def setRandColor(self):
     self.setColor(QColor(qrand() % 256, qrand() % 256, qrand() % 256))
コード例 #30
0
def fill_selection(option, painter):
    colour = QColor("lightblue")
    colour.setAlpha(100)
    painter.fillRect(option.rect, colour)
コード例 #31
0
    def updateColor(self, color: QColor, value: float, percent: float) -> None:
        item: ColorPanelBar = self.sender()
        index: int = self.__items.index(item)

        if index is 0:
            # 获取当前HSB处的颜色值
            self.__items[1].topColor = color
            self.__items[2].topColor = color
            self.__items[1].borderColor = color
            self.__items[2].borderColor = color
        elif index is 1:
            self.__items[2].topColor = color
            self.__items[2].borderColor = color
        elif index is 2:
            self.__items[1].topColor = color
            self.__items[1].borderColor = color
        elif index == 3:
            self.__items[6].percent = 100 - percent
        elif index == 4:
            self.__items[7].percent = 100 - percent
        elif index == 5:
            self.__items[8].percent = 100 - percent
        elif index == 6:
            self.__items[3].percent = 100 - percent
        elif index == 7:
            self.__items[4].percent = 100 - percent
        elif index == 8:
            self.__items[5].percent = 100 - percent

        # 如果是HSB变化则CMY和RGB变化
        if index < 3:
            hue: float = self.__items[0].percent / 100
            sat: float = self.__items[1].percent / 100
            bright: float = self.__items[2].percent / 100

            # 组合HSB当前值,然后转为CMY和RGB计算百分比进行设置
            color: QColor = QColor.fromHsvF(hue, sat, bright)
            percentRed: float = color.redF() * 100
            percentGreen: float = color.greenF() * 100
            percentBlue: float = color.blueF() * 100

            self.__items[3].percent = 100 - percentRed
            self.__items[4].percent = 100 - percentGreen
            self.__items[5].percent = 100 - percentBlue
            self.__items[6].percent = percentRed
            self.__items[7].percent = percentGreen
            self.__items[8].percent = percentBlue

        # 根据百分比获取颜色值
        red: float = self.__items[6].percent / 100
        green: float = self.__items[7].percent / 100
        blue: float = self.__items[8].percent / 100
        currentColor: QColor = QColor.fromRgbF(red, green, blue)
        self.colorChanged.emit(currentColor, self.__items[0].value,
                               self.__items[1].percent,
                               self.__items[2].percent)

        # 如果是CMY或者RGB变化则HSB变化
        if index >= 3:
            # hue活出现负数=白色,要矫正
            percentHue: float = currentColor.hueF() * 100
            if percentHue < 0:
                percentHue = 0

            percentSat: float = currentColor.saturationF() * 100
            percentBright: float = currentColor.lightnessF() * 100

            # 计算当前值所占百分比
            self.__items[0].percent = percentHue
            self.__items[1].percent = percentSat
            self.__items[2].percent = percentBright

            self.__items[1].topColor = currentColor
            self.__items[2].topColor = currentColor
            self.__items[1].borderColor = currentColor
            self.__items[2].borderColor = currentColor
コード例 #32
0
 def testReduceCMYK(self):
     self.reduceColor(QColor.fromCmykF(0.1, 0.2, 0.3, 0.4, 0.5))
コード例 #33
0
    customPlot.resize(800, 600)
    customPlot.setWindowTitle('Parametric Curves Demo')

    # pass the data to the curves; we know t (i in loop above) is ascending, so set alreadySorted=true (saves an extra internal sort):
    fermatSpiral1 = QCPCurve(customPlot.xAxis, customPlot.yAxis)
    fermatSpiral1.setData(dataSpiral1X, dataSpiral1Y)

    fermatSpiral2 = QCPCurve(customPlot.xAxis, customPlot.yAxis)
    fermatSpiral2.setData(dataSpiral2X, dataSpiral2Y)

    deltoidRadial = QCPCurve(customPlot.xAxis, customPlot.yAxis)
    deltoidRadial.setData(dataDeltoidX, dataDeltoidY)

    # color the curves:
    fermatSpiral1.setPen(QPen(Qt.blue))
    fermatSpiral1.setBrush(QBrush(QColor(0, 0, 255, 20)))
    fermatSpiral2.setPen(QPen(QColor(255, 120, 0)))
    fermatSpiral2.setBrush(QBrush(QColor(255, 120, 0, 30)))

    radialGrad = QRadialGradient(QPointF(310, 180), 200)
    radialGrad.setColorAt(0, QColor(170, 20, 240, 100))
    radialGrad.setColorAt(0.5, QColor(20, 10, 255, 40))
    radialGrad.setColorAt(1, QColor(120, 20, 240, 10))
    deltoidRadial.setPen(QPen(QColor(170, 20, 240)))
    deltoidRadial.setBrush(QBrush(radialGrad))

    # set some basic customPlot config:
    customPlot.setInteractions(QCP.iRangeDrag | QCP.iRangeZoom
                               | QCP.iSelectPlottables)
    customPlot.axisRect().setupFullAxesBox()
    customPlot.rescaleAxes()
コード例 #34
0
ファイル: bug_606.py プロジェクト: BadSingleton/pyside2
 def testQColorToTuple(self):
     c = QColor(0, 0, 255)
     c.setRgb(1, 2, 3)
     self.assertEqual((1, 2, 3, 255), c.toTuple())
コード例 #35
0
ファイル: bindings.py プロジェクト: hrabbit2000/smb_client
 def __init__(self, parent=None):
     QQuickPaintedItem.__init__(self, parent)
     self._name = u''
     self._color = QColor()
コード例 #36
0
ファイル: deepcopy_test.py プロジェクト: BadSingleton/pyside2
 def setUp(self):
     self.original = QColor.fromHsvF(0.2, 0.3, 0.4, 0.5)
コード例 #37
0
ファイル: q_datedemo.py プロジェクト: SBGit-2019/Pyside-QCP
if __name__ == '__main__':
    # Create the Qt Application
    app = QApplication(sys.argv)

    customPlot = QCustomPlot()
    customPlot.resize(800, 600)
    customPlot.setWindowTitle('Date Demo')

    # set locale to english, so we get english month names:
    customPlot.setLocale(QLocale(QLocale.English, QLocale.UnitedKingdom))
    # seconds of current time, we'll use it as starting point in time for data:
    now = QDateTime.currentDateTime().toTime_t()
    # create multiple graphs:
    for gi in range(0, 5):
        customPlot.addGraph()
        color = QColor(20 + 200 / 4.0 * gi, 70 * (1.6 - gi / 4.0), 150, 150)
        customPlot.graph().setLineStyle(QCPGraph.lsLine)
        customPlot.graph().setPen(QPen(color.lighter(200)))
        customPlot.graph().setBrush(QBrush(color))
        timeDataX = [0.0] * 250
        timeDataY = [0.0] * 250
        # generate random walk data:
        for i in range(0, 250):
            timeDataX[i] = now + 24 * 3600 * i
            if i == 0:
                timeDataY[i] = (float(i) / 50.0 + 1) * uniform(-0.5, 0.5)
            else:
                timeDataY[i] = math.fabs(timeDataY[i - 1]) * (
                    1 + 0.02 / 4.0 *
                    (4 - gi)) + (float(i) / 50.0 + 1) * uniform(-0.5, 0.5)
        customPlot.graph().setData(timeDataX, timeDataY)
コード例 #38
0
ファイル: bug_617.py プロジェクト: BadSingleton/pyside2
 def testRepr(self):
     c = QColor.fromRgb(1, 2, 3, 4)
     s = c.spec()
     self.assertEqual(repr(s), repr(QColor.Rgb))
コード例 #39
0
        def initForm(self):
            self.navLabel11.arrowPosition = NavLabel.ArrowPosition.ArrowPosition_Left
            self.navLabel12.arrowPosition = NavLabel.ArrowPosition.ArrowPosition_Left
            self.navLabel13.arrowPosition = NavLabel.ArrowPosition.ArrowPosition_Left

            self.navLabel21.arrowPosition = NavLabel.ArrowPosition.ArrowPosition_Right
            self.navLabel22.arrowPosition = NavLabel.ArrowPosition.ArrowPosition_Right
            self.navLabel23.arrowPosition = NavLabel.ArrowPosition.ArrowPosition_Right

            self.navLabel31.arrowPosition = NavLabel.ArrowPosition.ArrowPosition_Top
            self.navLabel32.arrowPosition = NavLabel.ArrowPosition.ArrowPosition_Top
            self.navLabel33.arrowPosition = NavLabel.ArrowPosition.ArrowPosition_Top

            self.navLabel41.arrowPosition = NavLabel.ArrowPosition.ArrowPosition_Bottom
            self.navLabel42.arrowPosition = NavLabel.ArrowPosition.ArrowPosition_Bottom
            self.navLabel43.arrowPosition = NavLabel.ArrowPosition.ArrowPosition_Bottom

            self.navLabel12.background = QColor(255, 107, 107)
            self.navLabel13.background = QColor(24, 189, 155)
            self.navLabel21.background = QColor(225, 102, 255)
            self.navLabel22.background = QColor(45, 62, 80)
            self.navLabel23.background = QColor(210, 84, 0)

            self.navLabel32.background = QColor(255, 107, 107)
            self.navLabel33.background = QColor(24, 189, 155)
            self.navLabel41.background = QColor(225, 102, 255)
            self.navLabel42.background = QColor(45, 62, 80)
            self.navLabel43.background = QColor(210, 84, 0)

            self.navLabel51.borderRadius = 0
            self.navLabel52.borderRadius = 0
            self.navLabel53.borderRadius = 0
            self.navLabel51.background = QColor(80, 80, 80)
            self.navLabel52.background = QColor(80, 80, 80)
            self.navLabel53.background = QColor(80, 80, 80)
            self.navLabel52.showTriangle = True
            self.navLabel53.showTriangle = True
            self.navLabel53.showArrow = False
コード例 #40
0
ファイル: qcolor_test.py プロジェクト: BadSingleton/pyside2
 def testReprFunction(self):
     c = QColor(100, 120, 200)
     c2 = eval(c.__repr__())
     self.assertEqual(c, c2)
コード例 #41
0
    def paint(self, painter, option, widget=None):

        painter.setRenderHint(QPainter.Antialiasing)
        brush = QBrush(QColor(100, 100, 100, 150))  # QBrush(QColor('#3B9CD9'))
        painter.setBrush(brush)
        std_pen = QPen(
            QColor(30, 43, 48)
        )  # QColor(30, 43, 48)  # used for header title and minimal std dark border
        std_pen.setWidthF(1.5)
        # painter.setPen(std_pen)

        if self.parent_node.design_style == 'extended':

            if GlobalStorage.storage['design style'] == 'dark std':
                c = self.parent_node.color

                # main rect
                body_gradient = QRadialGradient(
                    self.boundingRect().topLeft(),
                    self.flow.pythagoras(self.height, self.width))
                body_gradient.setColorAt(
                    0,
                    QColor(c.red() / 10 + 100,
                           c.green() / 10 + 100,
                           c.blue() / 10 + 100, 200))
                body_gradient.setColorAt(
                    1,
                    QColor(c.red() / 10 + 100,
                           c.green() / 10 + 100,
                           c.blue() / 10 + 100, 0))

                painter.setBrush(body_gradient)
                painter.setPen(Qt.NoPen)
                painter.drawRoundedRect(self.boundingRect(), 12, 12)

                header_gradient = QLinearGradient(
                    self.get_header_rect().topRight(),
                    self.get_header_rect().bottomLeft())
                header_gradient.setColorAt(
                    0, QColor(c.red(), c.green(), c.blue(), 255))
                header_gradient.setColorAt(
                    1, QColor(c.red(), c.green(), c.blue(), 0))
                painter.setBrush(header_gradient)
                painter.setPen(Qt.NoPen)
                painter.drawRoundedRect(self.get_header_rect(), 12, 12)

            elif GlobalStorage.storage['design style'] == 'dark tron':
                # main rect
                c = QColor('#212224')
                painter.setBrush(c)
                pen = QPen(self.parent_node.color)
                pen.setWidth(2)
                painter.setPen(pen)
                body_path = self.get_extended_body_path_TRON_DESIGN(10)
                painter.drawPath(body_path)
                # painter.drawRoundedRect(self.boundingRect(), 12, 12)

                c = self.parent_node.color
                header_gradient = QLinearGradient(
                    self.get_header_rect().topRight(),
                    self.get_header_rect().bottomLeft())
                header_gradient.setColorAt(
                    0, QColor(c.red(), c.green(), c.blue(), 255))
                header_gradient.setColorAt(
                    0.5, QColor(c.red(), c.green(), c.blue(), 100))
                header_gradient.setColorAt(
                    1, QColor(c.red(), c.green(), c.blue(), 0))
                painter.setBrush(header_gradient)
                header_path = self.get_extended_header_path_TRON_DESIGN(10)
                painter.drawPath(header_path)

            painter.setFont(self.display_name_font)
            painter.setPen(std_pen)

            painter.drawText(self.get_title_rect(),
                             Qt.AlignVCenter | Qt.AlignLeft,
                             self.parent_node.title)
            painter.setBrush(Qt.NoBrush)
            painter.setPen(QPen(Qt.white, 1))
            # painter.drawRect(self.get_header_rect())
        elif self.parent_node.design_style == 'minimalistic':
            path = QPainterPath()
            path.moveTo(-self.width / 2, 0)
            if GlobalStorage.storage['design style'] == 'dark std':
                path.cubicTo(-self.width / 2, -self.height / 2,
                             -self.width / 2, -self.height / 2, 0,
                             -self.height / 2)
                path.cubicTo(+self.width / 2, -self.height / 2,
                             +self.width / 2, -self.height / 2,
                             +self.width / 2, 0)
                path.cubicTo(+self.width / 2, +self.height / 2,
                             +self.width / 2, +self.height / 2, 0,
                             +self.height / 2)
                path.cubicTo(-self.width / 2, +self.height / 2,
                             -self.width / 2, +self.height / 2,
                             -self.width / 2, 0)
                path.closeSubpath()

                c = self.parent_node.color
                body_gradient = QLinearGradient(
                    self.boundingRect().bottomLeft(),
                    self.boundingRect().topRight())
                # 2*self.flow.pythagoras(self.height, self.width))
                body_gradient.setColorAt(
                    0, QColor(c.red(), c.green(), c.blue(), 150))
                body_gradient.setColorAt(
                    1, QColor(c.red(), c.green(), c.blue(), 80))

                painter.setBrush(body_gradient)
                painter.setPen(std_pen)

            elif GlobalStorage.storage['design style'] == 'dark tron':
                corner_size = 10
                path.lineTo(-self.width / 2 + corner_size / 2,
                            -self.height / 2 + corner_size / 2)
                path.lineTo(0, -self.height / 2)
                path.lineTo(+self.width / 2 - corner_size / 2,
                            -self.height / 2 + corner_size / 2)
                path.lineTo(+self.width / 2, 0)
                path.lineTo(+self.width / 2 - corner_size / 2,
                            +self.height / 2 - corner_size / 2)
                path.lineTo(0, +self.height / 2)
                path.lineTo(-self.width / 2 + corner_size / 2,
                            +self.height / 2 - corner_size / 2)
                path.closeSubpath()

                c = QColor('#36383B')
                painter.setBrush(c)
                pen = QPen(self.parent_node.color)
                pen.setWidth(2)
                painter.setPen(pen)

            painter.drawPath(path)

            painter.setFont(self.display_name_font)
            painter.drawText(self.boundingRect(), Qt.AlignCenter,
                             self.parent_node.title)
コード例 #42
0
    def _generateChartImage(self):
        chart = QtCharts.QChart()

        chart.legend().setVisible(False)
        chart.setBackgroundBrush(QBrush(QColor("transparent")))
        chart.setMargins(QMargins(0, 0, 0, 0))
        chart.setTitleBrush(QBrush(Loader.QSSColor("@dark")))

        axis_pen = QPen(Loader.QSSColor("@dark"))
        axis_pen.setWidth(4)

        grid_line_pen = QPen(Loader.QSSColor("@light-gray"))

        labels_font = QFont(Loader.QSSVariable("@font"))
        labels_font.setPointSize(18)

        axis_x = QtCharts.QValueAxis()
        axis_y = QtCharts.QValueAxis()

        for axis in (axis_x, axis_y):
            axis.setLinePen(axis_pen)
            axis.setLabelFormat("%d")
            axis.setGridLinePen(grid_line_pen)
            axis.setLabelsFont(labels_font)

        chart.addAxis(axis_x, Qt.AlignBottom)
        chart.addAxis(axis_y, Qt.AlignLeft)
        

        current_series = {}
        max_s = 0
        for i, m in self._analysis.parameters().selectedMorphotypes().items():
            current_series[i] = QtCharts.QSplineSeries()
            current_series[i].setName(m.name())
            current_series[i].setColor(m.color())

            s = 0
            current_series[i].append(0, 0)
            for k, img in enumerate(self._analysis.processedImages()):
                s += img.detectionsCount().get(i, 0)
                current_series[i].append(k + 1, s)
            max_s = max(s, max_s)
            
            chart.addSeries(current_series[i])

            current_series[i].attachAxis(axis_x)
            current_series[i].attachAxis(axis_y)

            pen = current_series[i].pen()
            pen.setWidth(5)
            current_series[i].setPen(pen)

        chart.axisX().setRange(0, max(len(self._analysis.processedImages()), 4))
        chart.axisY().setRange(0, max(round(max_s), 4)*1.05)

        chart_view = QtCharts.QChartView(chart)
        chart_view.setRenderHint(QPainter.Antialiasing)
        chart_view.resize(QSize(1080, 500))

        chart_pixmap = chart_view.grab()
        self._analysis.setBase64ChartImage(ImageConverter.QPixmapToBase64(chart_pixmap, "png"))
コード例 #43
0
 def get_color_for(cls, port_type):
     try:
         return cls.colors[port_type]
     except KeyError:
         return QColor("#000000")