Beispiel #1
0
 def get_color(cls,
               preset=None,
               allow_alpha: bool = False,
               parent=None) -> gui.Color:
     if isinstance(preset, str):
         preset = gui.Color(preset)
     if preset is None:
         preset = gui.Color()
     kwargs = dict(options=cls.ShowAlphaChannel) if allow_alpha else dict()
     return gui.Color(cls.getColor(preset, parent, **kwargs))
Beispiel #2
0
 def __init__(self, parent=None):
     super().__init__(parent)
     self.rules = []
     self.commentStart = core.RegExp("#")
     self.commentEnd = core.RegExp("\n|\r")
     self.commentFormat = gui.TextCharFormat()
     self.commentFormat.setFontItalic(True)
     self.commentFormat.set_foreground_color("darkgray")
     f = gui.TextCharFormat()
     r = core.RegExp()
     r.setMinimal(True)
     f.setFontWeight(gui.Font.Normal)
     f.set_foreground_color("blue")
     tag_list = ["\\btrue\\b", "\\bfalse\\b"]
     for tag in tag_list:
         r.setPattern(tag)
         self.rules.append((core.RegExp(r), gui.TextCharFormat(f)))
     f.setForeground(gui.Color(127, 64, 127))
     r.setPattern(r"\\d+")
     self.rules.append((core.RegExp(r), gui.TextCharFormat(f)))
     f.set_foreground_color("darkblue")
     r.setPattern(r"^\s*[_.\w]*\s*:")
     self.rules.append((core.RegExp(r), gui.TextCharFormat(f)))
     f.set_foreground_color("darkblue")
     r.setPattern(r":\s*:[_\.\w]*$|:\s*\@[_\.\w]*$")
     self.rules.append((core.RegExp(r), gui.TextCharFormat(f)))
     f.setFontWeight(gui.Font.Bold)
     f.set_foreground_color("darkred")
     r.setPattern(r"^\s*-")
     self.rules.append((core.RegExp(r), gui.TextCharFormat(f)))
     f.set_foreground_color("darkred")
     r.setPattern(r"^---$")
     self.rules.append((core.RegExp(r), gui.TextCharFormat(f)))
     f.set_foreground_color("darkgreen")
     r.setPattern(r"[\[\]\{\}\,]")
     self.rules.append((core.RegExp(r), gui.TextCharFormat(f)))
     f.setFontWeight(gui.Font.Normal)
     f.set_foreground_color("magenta")
     r.setPattern(r"\".*\"|\'.*\'")
     self.rules.append((core.RegExp(r), gui.TextCharFormat(f)))
     f.setForeground(gui.Color(127, 64, 127))
     r.setPattern(r"\\$\\(.*\\)")
     self.rules.append((core.RegExp(r), gui.TextCharFormat(f)))
     f.set_foreground_color("lightgray")
     r.setPattern(r"<!DOCTYPE.*>")
     self.rules.append((core.RegExp(r), gui.TextCharFormat(f)))
     r.setPattern(r"<\\?xml.*\\?>")
     self.rules.append((core.RegExp(r), gui.TextCharFormat(f)))
Beispiel #3
0
class Number(Rule):
    regex = [
        r"\b[+-]?[0-9]+[lL]?\b",
        r"\b[+-]?0[xX][0-9A-Fa-f]+[lL]?\b",
        r"\b[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\b",
    ]
    color = gui.Color(100, 150, 190)
Beispiel #4
0
 def paintEvent(self, event):
     painter = gui.Painter(self)
     painter.use_antialiasing()
     painter.set_pen("none")
     painter.set_transparent_background(False)
     painter.set_transparent_background(True)
     painter.set_brush(gui.Brush())
     with painter.paint_on(widgets.Widget()):
         pass
     painter.set_brush(gui.Color("red"))
     painter.fill_rect((0, 1, 3, 5), "transparent")
     painter.fill_rect(core.Rect(), "transparent")
     with pytest.raises(InvalidParamError):
         painter.fill_rect(core.Rect(), "transparent", "test")
     with pytest.raises(ValueError):
         painter.fill_rect(core.Rect(), "testus")
     painter.set_color("black")
     painter.set_composition_mode("source_atop")
     painter.get_composition_mode() == "source_atop"
     with pytest.raises(InvalidParamError):
         painter.set_composition_mode("test")
     painter.set_clip_path(gui.PainterPath(), "replace")
     with pytest.raises(InvalidParamError):
         painter.set_clip_path(gui.PainterPath(), "test")
     with pytest.raises(InvalidParamError):
         painter.set_pen(style="test")
     with painter.backup_state():
         pass
     assert painter.get_text_rect("test") is not None
Beispiel #5
0
 def serialize_fields(self):
     offset = self.offset()
     return dict(
         blur_radius=self.blurRadius(),
         color=gui.Color(self.color()),
         offset=(offset.x(), offset.y()),
     )
Beispiel #6
0
def test_colordialog():
    dlg = widgets.ColorDialog()
    assert str(dlg.current_color()) == str(gui.Color("white"))
    with open("data.pkl", "wb") as jar:
        pickle.dump(dlg, jar)
    with open("data.pkl", "rb") as jar:
        dlg = pickle.load(jar)
Beispiel #7
0
def test_spanslider(qtbot, qttester):
    slider = custom_widgets.SpanSlider()
    qtbot.add_widget(slider)
    slider.show()
    slider.set_lower_value(10)
    slider.set_upper_value(20)
    slider.set_lower_pos(15)
    slider.set_lower_pos(15)
    slider.set_upper_pos(25)
    slider.set_upper_pos(25)
    assert slider.lower_value == 15
    assert slider.upper_value == 25
    slider.set_value((16, 24))
    assert slider.get_value() == (16, 24)
    slider.set_lower_value(12)
    slider.set_upper_pos(20)
    color = gui.Color("blue")
    slider.set_left_color(color)
    slider.set_right_color(color)
    slider._swap_controls()
    slider.trigger_action(slider.SliderAction.SliderNoAction, True)
    slider.trigger_action(slider.SliderAction.SliderSingleStepAdd, True)
    slider.repaint()
    slider._pixel_pos_to_value(100)
    slider._move_pressed_handle()
    qttester.send_mousepress(slider, QtCore.Qt.MouseButton.LeftButton)
    qttester.send_mousemove(slider, core.Point(20, 20))
    qttester.send_mousemove(slider, core.Point(0, 0), delay=10)
    assert slider.get_movement_mode() == "no_crossing"
    slider.set_movement_mode("no_overlap")
    slider.close()
Beispiel #8
0
def test_color():
    color = gui.Color()
    color.set_color("gray")
    with open("data.pkl", "wb") as jar:
        pickle.dump(color, jar)
    with open("data.pkl", "rb") as jar:
        color = pickle.load(jar)
    assert str(color) == "#808080"
Beispiel #9
0
 def set_color(self, color):
     if isinstance(color, str):
         self.current_color = gui.Color(color)
     else:
         self.current_color = color
     self.lineedit.set_text(self.current_color.name().upper())
     icon = gui.Icon.for_color(self.current_color)
     self.button.set_icon(icon)
Beispiel #10
0
 def set_text(self,
              text,
              color="black",
              h_align="center",
              v_align="bottom"):
     self.showMessage(text,
                      color=gui.Color(color),
                      alignment=H_ALIGNMENTS[h_align]
                      | V_ALIGNMENTS[v_align])
Beispiel #11
0
 def _check_selection(self, x: int):
     # Check if user clicked in video sample
     for sample in self.video_samples:
         if sample.start_pos < x < sample.end_pos:
             sample.color = gui.Color(PEN_COLOR)
             if self.selected_sample is not sample:
                 self.selected_sample = sample
                 self.selection_changed.emit(sample)
         else:
             sample.color = sample.def_color
Beispiel #12
0
 def fill_rect(self, rect, color, pattern="solid"):
     if isinstance(rect, tuple):
         rect = core.Rect(*rect)
     if isinstance(color, str):
         if color not in gui.Color.colorNames():
             raise ValueError("Invalid value for color.")
         color = gui.Color(color)
     if pattern != "solid":
         color = gui.Brush(color, PATTERNS[pattern])
     self.fillRect(rect, color)
Beispiel #13
0
def test_colorchooserbutton():
    btn = custom_widgets.ColorChooserButton()
    btn.set_color("green")
    with open("data.pkl", "wb") as jar:
        pickle.dump(btn, jar)
    with open("data.pkl", "rb") as jar:
        btn = pickle.load(jar)
    repr(btn)
    assert btn.get_value() == gui.Color("green")
    btn.set_value("blue")
    assert btn.is_valid()
Beispiel #14
0
def test_palette():
    pal = gui.Palette()
    assert len(pal.get_colors()) == 21
    assert len(pal.get_brushes()) == 21
    color = gui.Color("red")
    pal.set_brush("window", "red")
    assert pal.get_brush("window") == color
    pal.highlight_inactive()
    pal.set_color("window", "red")
    pal["button"] = color
    assert pal["button"] == color
    bytes(pal)
Beispiel #15
0
 def set_text(
     self,
     text: str,
     color: types.ColorType = "black",
     h_align: constants.HorizontalAlignmentStr = "center",
     v_align: constants.VerticalAlignmentStr = "bottom",
 ):
     self.showMessage(
         text,
         color=gui.Color(color),
         alignment=constants.H_ALIGNMENT[h_align] | constants.V_ALIGNMENT[v_align],
     )
Beispiel #16
0
    def paint(self, painter, option, widget):
        path = QtGui.QPainterPath()
        path.addRoundedRect(self.rect, 5, 5)

        anchor = self.mapFromParent(self.chart.mapToPosition(self.anchor))
        if not self.rect.contains(anchor):
            point1 = QtCore.QPointF()
            point2 = QtCore.QPointF()

            # establish the position of the anchor point in relation to self.rect
            above = anchor.y() <= self.rect.top()
            above_center = self.rect.top() < anchor.y() <= self.rect.center(
            ).y()
            below_center = self.rect.center().y() < anchor.y(
            ) <= self.rect.bottom()
            below = anchor.y() > self.rect.bottom()

            on_left = anchor.x() <= self.rect.left()
            left_of_center = self.rect.left() < anchor.x() <= self.rect.center(
            ).x()
            right_of_center = self.rect.center().x() < anchor.x(
            ) <= self.rect.right()
            on_right = anchor.x() > self.rect.right()

            # get the nearest self.rect corner.
            x = (on_right + right_of_center) * self.rect.width()
            y = (below + below_center) * self.rect.height()
            corner_case = (above and on_left) or (above and on_right) or (
                below and on_left) or (below and on_right)
            vertical = abs(anchor.x() - x) > abs(anchor.y() - y)

            x1 = x + left_of_center * 10 - right_of_center * 20 + \
                corner_case * (not vertical) * (on_left * 10 - on_right * 20)
            y1 = y + above_center * 10 - below_center * 20 + \
                corner_case * vertical * (above * 10 - below * 20)
            point1.setX(x1)
            point1.setY(y1)

            x2 = x + left_of_center * 20 - right_of_center * 10 + \
                corner_case * (not vertical) * (on_left * 20 - on_right * 10)
            y2 = y + above_center * 20 - below_center * 10 + \
                corner_case * vertical * (above * 20 - below * 10)
            point2.setX(x2)
            point2.setY(y2)

            path.moveTo(point1)
            path.lineTo(anchor)
            path.lineTo(point2)
            path = path.simplified()
            painter.setBrush(gui.Color(255, 255, 255))
        painter.drawPath(path)
        painter.drawText(self.text_rect, self.text)
Beispiel #17
0
def get_color(color: types.ColorType) -> gui.Color:
    """Get gui.Color instance for given parameter.

    named colors are 'aliceblue', 'antiquewhite', 'aqua', 'aquamarine',
    'azure', 'beige', 'bisque', 'black', 'blanchedalmond', 'blue', 'blueviolet',
    'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral',
    'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan',
    'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki',
    'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred',
    'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey',
    'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey',
    'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'fuchsia', 'gainsboro',
    'ghostwhite', 'gold', 'goldenrod', 'gray', 'green', 'greenyellow', 'grey',
    'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender',
    'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral',
    'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey',
    'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray',
    'lightslategrey', 'lightsteelblue', 'lightyellow', 'lime', 'limegreen', 'linen',
    'magenta', 'maroon', 'mediumaquamarine', 'mediumblue', 'mediumorchid',
    'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen',
    'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose',
    'moccasin', 'navajowhite', 'navy', 'oldlace', 'olive', 'olivedrab', 'orange',
    'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise',
    'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum',
    'powderblue', 'purple', 'red', 'rosybrown', 'royalblue', 'saddlebrown',
    'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'silver', 'skyblue',
    'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue',
    'tan', 'teal', 'thistle', 'tomato', 'transparent', 'turquoise', 'violet',
    'wheat', 'white', 'whitesmoke', 'yellow', 'yellowgreen'

    Args:
        color (ColorType): color to create gui.Icon from

    Returns:
        gui.Color: color instance
    """
    if isinstance(color, (tuple, list)):
        return gui.Color(*color)
    return gui.Color(color)
Beispiel #18
0
    def highlight_current_line(self):
        extra_selections = []

        if not self.isReadOnly():
            selection = widgets.TextEdit.ExtraSelection()
            line_color = gui.Color("yellow").lighter(160)
            selection.format.setBackground(line_color)
            selection.format.setProperty(QtGui.QTextFormat.FullWidthSelection, True)
            selection.cursor = self.textCursor()
            selection.cursor.clearSelection()
            extra_selections.append(selection)

        self.setExtraSelections(extra_selections)
Beispiel #19
0
 def create_dark_palette(cls) -> Palette:
     pal = cls()
     pal.set_color("window", gui.Color(53, 53, 53))
     pal.set_color("window_text", "white")
     pal.set_color("window_text", "grey", group="disabled")
     pal.set_color("base", gui.Color(25, 25, 25))
     pal.set_color("alternate_base", gui.Color(53, 53, 53))
     pal.set_color("tool_tip_base", "slategrey")
     pal.set_color("tool_tip_base", "slategrey", group="inactive")
     pal.set_color("tool_tip_text", "white")
     pal.set_color("tool_tip_text", "white", group="inactive")
     pal.set_color("text", "white")
     pal.set_color("text", "grey", group="disabled")
     pal.set_color("button", gui.Color(53, 53, 53))
     pal.set_color("button_text", "white")
     pal.set_color("button_text", "grey", group="disabled")
     pal.set_color("bright_text", "red")
     pal.set_color("link", "dodgerblue")
     pal.set_color("highlight", "dodgerblue")
     pal.set_color("highlight", gui.Color(80, 80, 80), group="disabled")
     pal.set_color("highlighted_text", "black")
     pal.set_color("highlighted_text", "grey", group="disabled")
     return pal
Beispiel #20
0
 def create_dot(cls,
                color: types.ColorType = "black",
                size: int = 16) -> Pixmap:
     col = colors.get_color(color)
     px = cls(size, size)
     px.fill(QtCore.Qt.GlobalColor.transparent)  # type: ignore
     px_size = px.rect().adjusted(1, 1, -1, -1)
     with gui.Painter(px) as painter:
         painter.use_antialiasing()
         painter.setBrush(col)
         pen_color = gui.Color(15, 15, 15)
         painter.set_pen(color=pen_color, width=1)
         painter.drawEllipse(px_size)
     return px
Beispiel #21
0
 def __init__(
     self, color: types.ColorType = None, parent: QtWidgets.QWidget | None = None
 ):
     super().__init__(parent)
     layout = widgets.BoxLayout("horizontal", self)
     layout.set_margin(0)
     self.lineedit = widgets.LineEdit()
     self.lineedit.set_regex_validator(r"^#(?:[0-9a-fA-F]{6})$")
     layout.add(self.lineedit)
     action = widgets.Action(icon="mdi.format-color-fill")
     action.triggered.connect(self.choose_color)
     self.button = widgets.ToolButton()
     self.button.setDefaultAction(action)
     layout.add(self.button)
     self._current_color: gui.Color = gui.Color("white")
     if color is not None:
         self.set_current_color(color)
Beispiel #22
0
 def current_line_color(self, count_distance, total_lines, trailFadePerc,
                        min_opacity, colorinput):
     color = gui.Color(colorinput)
     if count_distance == 0:
         return color
     min_alpha_f = min_opacity / 100.0
     dist_threshold = int(
         math.ceil((total_lines - 1) * trailFadePerc / 100.0))
     if count_distance > dist_threshold:
         color.setAlphaF(min_alpha_f)
     else:
         alpha_diff = color.alphaF() - min_alpha_f
         gradient = alpha_diff / float(dist_threshold + 1)
         result_alpha = color.alphaF() - gradient * count_distance
         # If alpha is out of bounds, clip it.
         result_alpha = min(1.0, max(0.0, result_alpha))
         color.setAlphaF(result_alpha)
     return color
Beispiel #23
0
    def paint(
        self,
        painter: gui.Painter,
        rect: QtCore.QRect,
        mode: QtGui.QIcon.Mode,
        state: QtGui.QIcon.State,
        options: list[dict[str, Any]],
    ):
        color_str, char = COLOR_OPTIONS[state][mode]
        for opt in options:
            painter.save()
            color = gui.Color(opt[color_str])
            painter.setPen(color)

            # A 16 pixel-high icon yields a font size of 14, which is pixel perfect
            # for font-awesome. 16 * 0.875 = 14
            # The reason why the glyph size is smaller than the icon size is to
            # account for font bearing.

            draw_size = round(0.875 * rect.height() * opt["scale_factor"])
            # Animation setup hook
            if (animation := opt.get("animation")) is not None:
                animation.setup(painter, rect)
            font = self.fonts[opt["prefix"]].get_font(draw_size)
            painter.setFont(font)
            if "offset" in opt:
                rect.translate(
                    round(opt["offset"][0] * rect.width()),
                    round(opt["offset"][1] * rect.height()),
                )
            x_center = rect.width() * 0.5
            y_center = rect.height() * 0.5
            painter.translate(x_center, y_center)
            transform = gui.Transform()
            if opt.get("vflip") is True:
                transform.scale(1, -1)
            if opt.get("hflip") is True:
                transform.scale(-1, 1)
            if "rotated" in opt:
                transform.rotate(opt["rotated"])
            painter.setTransform(transform, True)
            painter.translate(-x_center, -y_center)
            if (opacity := opt.get("opacity")) is not None:
                painter.setOpacity(opacity)
Beispiel #24
0
    def __init__(self, parent, modality=QtCore.Qt.NonModal):
        super().__init__(parent=parent)

        # WAS IN initialize()
        self._color = gui.Color("black")
        self._roundness = 100.0
        self._minimum_trail_opacity = 3.14159265358979323846
        self._trail_fade_percentage = 80.0
        self._revolutions_per_second = 1.57079632679489661923
        self._line_num = 20
        self._line_length = 10
        self._line_width = 2
        self._inner_radius = 10
        self._current_counter = 0
        self._is_spinning = False

        self._timer = core.Timer(self)
        self._timer.timeout.connect(self.rotate)
        self.update_size()
        self.update_timer()
        self.hide()
        # END initialize()

        self.setWindowModality(modality)
Beispiel #25
0
 def _current_line_color(
     self,
     count_distance: int,
     total_lines: int,
     fade_perc: float,
     min_opacity: float,
     color: gui.Color,
 ) -> gui.Color:
     color = gui.Color(color)
     if count_distance == 0:
         return color
     min_alpha_f = min_opacity / 100
     dist_threshold = int(math.ceil((total_lines - 1) * fade_perc / 100))
     if count_distance > dist_threshold:
         color.setAlphaF(min_alpha_f)
     else:
         alpha = color.alphaF()
         alpha_diff = alpha - min_alpha_f
         gradient = alpha_diff / (dist_threshold + 1)
         result_alpha = alpha - gradient * count_distance
         # If alpha is out of bounds, clip it.
         result_alpha = min(1.0, max(0.0, result_alpha))
         color.setAlphaF(result_alpha)
     return color
Beispiel #26
0
def test_spanslider(qtbot):
    slider = custom_widgets.SpanSlider()
    qtbot.addWidget(slider)
    slider.set_lower_value(10)
    slider.set_upper_value(20)
    slider.set_lower_pos(15)
    slider.set_upper_pos(25)
    assert slider.lower_value == 15
    assert slider.upper_value == 25
    slider.set_lower_value(12)
    slider.set_upper_pos(20)
    color = gui.Color("blue")
    slider.set_left_color(color)
    slider.set_right_color(color)
    slider.swap_controls()
    slider.trigger_action(slider.SliderNoAction, True)
    slider.trigger_action(slider.SliderSingleStepAdd, True)
    slider.paintEvent(None)
    slider.pixel_pos_to_value(100)
    slider.draw_span(gui.Painter(), core.Rect())
    slider.move_pressed_handle()
    qtbot.mouseClick(slider, QtCore.Qt.LeftButton)
    qtbot.mouseMove(slider, core.Point(20, 20))
    assert slider.movement_mode == "free"
Beispiel #27
0
 def serialize_fields(self):
     return dict(strength=self.strength(), color=gui.Color(self.color()))
Beispiel #28
0
 def get_color(self, role: RoleStr, group: GroupStr = "active") -> gui.Color:
     return gui.Color(self.color(GROUP[group], ROLE[role]))
Beispiel #29
0
 def set_foreground_color(self, color_name):
     color = gui.Color()
     color.set_color(color_name)
     self.setForeground(color)
Beispiel #30
0
 def set_color(self, color):
     if isinstance(color, str):
         color = gui.Color(color)
     self.setColor(color)