def draw_curved_line(painter_path, dx, dy, c1_frac, c1_amp, c2_frac, c2_amp): length = sqrt(dx * dx + dy * dy) angle = atan2(dy, dx) c1 = QPointF(*rotate_vector(angle, c1_frac * length, c1_amp * length)) c2 = QPointF(*rotate_vector(angle, c2_frac * length, c2_amp * length)) pos = painter_path.currentPosition() painter_path.cubicTo(pos + c1, pos + c2, pos + QPointF(dx, dy))
def _paint_circles(self, painter): painter.save() if self.position.x() > 0: painter.setBrush(Defaults.single_color) painter.drawEllipse(QPointF(self.width() / 2, 0), (self.width() / 4) * (self.position.x() / (self.width() / 2)) / 2, self.height() / 2 + self.height() * 0.1) else: painter.setBrush(Defaults.multi_color) painter.drawEllipse(QPointF(-self.width() / 2, 0), (self.width() / 4) * (self.position.x() / (self.width() / 2)) / 2, self.height() / 2 + self.height() * 0.1) if self.position.y() < 0: painter.setBrush(Defaults.skip_color) painter.drawEllipse(QPointF(0, -self.height() / 2), self.width() / 2 + self.width() * 0.1, (self.height() / 4) * (-self.position.y() / (self.height() / 2)) / 2) else: painter.setBrush(Defaults.skip_color) painter.drawEllipse(QPointF(0, self.height() / 2), self.width() / 2 + self.width() * 0.1, (self.height() / 4) * (-self.position.y() / (self.height() / 2)) / 2) painter.restore()
def recognize(self, gesture, watched, event): if event.type() == QEvent.MouseButtonPress: self.panning = True self.start_point = event.pos() gesture.setLastOffset(QPointF()) gesture.setOffset(QPointF()) return QGestureRecognizer.TriggerGesture if self.panning and event.type() == QEvent.MouseMove: gesture.setLastOffset(gesture.offset()) gesture.setOffset(event.pos() - self.start_point) return QGestureRecognizer.TriggerGesture if event.type() == QEvent.MouseButtonRelease: end_point = event.pos() if self.start_point == end_point: self.panning = False return QGestureRecognizer.CancelGesture self.panning = False gesture.setLastOffset(gesture.offset()) gesture.setOffset(end_point - self.start_point) return QGestureRecognizer.FinishGesture if event.type() == QEvent.MouseButtonDblClick: self.panning = False return QGestureRecognizer.FinishGesture if not event.type() == QEvent.MouseButtonPress or event.type( ) == QEvent.MouseMove or event.type( ) == QEvent.MouseButtonRelease or event.type( ) == QEvent.MouseButtonDblClick: return QGestureRecognizer.Ignore
def _reset(self, was_classified): if was_classified: self._show_title_card = False self.position = QPointF(0, 0) self.animation1 = QPropertyAnimation(self, b'opacity') self.animation1.setStartValue(0) self.animation1.setEndValue(1) self.animation1.setDuration(75) self.animation1.start() self.animation2 = QPropertyAnimation(self, b'scale') self.animation2.setStartValue(self.scale - 1) self.animation2.setEndValue(self.scale) self.animation2.setDuration(75) self.animation2.start() else: self.animation3 = QPropertyAnimation(self, b'position') self.animation3.setStartValue(self.position) self.animation3.setEndValue(QPointF(0, 0)) self.animation3.setEasingCurve(QEasingCurve.OutBack) self.animation3.setDuration( (np.linalg.norm([self.position.x(), self.position.y()]) / np.linalg.norm([self.width(), self.height()])) * 500) self.animation3.start()
def draw_selection_rect(self, painter): cr, sr = self.target, self.selection_state.rect painter.setPen(self.SELECT_PEN) painter.setRenderHint(QPainter.Antialiasing, False) if self.selection_state.current_mode == 'selected': # Shade out areas outside the selection rect for r in ( QRectF(cr.topLeft(), QPointF(sr.left(), cr.bottom())), # left QRectF(QPointF(sr.left(), cr.top()), sr.topRight()), # top QRectF(QPointF(sr.right(), cr.top()), cr.bottomRight()), # right QRectF(sr.bottomLeft(), QPointF(sr.right(), cr.bottom())), # bottom ): painter.fillRect(r, self.SHADE_COLOR) dr = self.get_drag_rect() if self.selection_state.in_selection and dr is not None: # Draw the resize rectangle painter.save() painter.setCompositionMode( QPainter.RasterOp_SourceAndNotDestination) painter.setClipRect(sr.adjusted(1, 1, -1, -1)) painter.drawRect(dr) painter.restore() # Draw the selection rectangle painter.setCompositionMode(QPainter.RasterOp_SourceAndNotDestination) painter.drawRect(sr)
def draw(self, painter): for l in self.layouts: if hasattr(l, 'draw'): # Etch effect for the text painter.save() painter.setPen(QColor(255, 255, 255, 125)) l.draw(painter, QPointF(1, 1)) painter.restore() l.draw(painter, QPointF())
def parseXML(self): self.shapes = [] assert self.filepath.endswith(XML_EXT), "Unsupport file format" parser = etree.XMLParser(encoding='utf-8') xmltree = ElementTree.parse(self.filepath, parser=parser).getroot() filename = xmltree.find('filename').text try: verified = xmltree.attrib['verified'] if verified == 'yes': self.verified = True except KeyError: self.verified = False for object_iter in xmltree.findall('object'): points = [] for vertex in object_iter.findall('vertex'): x = float(vertex.find('x').text) y = float(vertex.find('y').text) points.append((x, y)) ellipse_points = [] for vertex in object_iter.findall('ellipse_vertex'): x = float(vertex.find('x').text) y = float(vertex.find('y').text) ellipse_points.append((x, y)) label = object_iter.find('name').text lineWidth = int(object_iter.find('lineWidth').text) rotate = 0 try: rotate = int(object_iter.find('rotate').text) except AttributeError: rotate = 0 r1 = 0.0 r2 = 0.0 try: r1 = float(object_iter.find('r1').text) r2 = float(object_iter.find('r2').text) except AttributeError: r1 = 0 r2 = 0 center_item = None center = QPointF(0, 0) try: center_item = object_iter.find('center') except AttributeError: center_item = None if center_item is not None: x = float(center_item.find('x').text) y = float(center_item.find('y').text) center = QPointF(x, y) self.shapes.append((label, lineWidth, points, ellipse_points, rotate, r1, r2, center)) return True
def adjust_line(self): self.setPos(QPointF(0.5 * (self.stick.top[0] + self.stick.bottom[0]), 0.5 * (self.stick.top[1] + self.stick.bottom[1]))) vec = 0.5 * (self.stick.top - self.stick.bottom) self.line.setP1(QPointF(vec[0], vec[1])) self.line.setP2(-self.line.p1()) self.gline.setLine(self.line) self.adjust_handles() self.stick_label_text.setPos(self.line.p1() - QPointF(0.5 * self.stick_label_text.boundingRect().width(), 1.3 * self.stick_label_text.boundingRect().height())) self.update()
def brush(p, xmax, ymax): x = 0 y = 0 w = xmax/2 g = QLinearGradient(QPointF(x, y+w/3), QPointF(x, y+(2*w/3))) g.setColorAt(0, QColor('#f00')) g.setColorAt(0.5, QColor('#fff')) g.setColorAt(1, QColor('#00f')) g.setSpread(g.ReflectSpread) p.fillRect(x, y, w, w, QBrush(g)) p.drawRect(x, y, w, w)
def draw(self, painter): for l in self.layouts: if hasattr(l, 'draw'): # Etch effect for the text painter.save() painter.setRenderHints(QPainter.TextAntialiasing | QPainter.Antialiasing) painter.save() painter.setPen(QColor(255, 255, 255, 125)) l.draw(painter, QPointF(1, 1)) painter.restore() l.draw(painter, QPointF()) painter.restore()
def fset(self, xxx_todo_changeme): (x, y) = xxx_todo_changeme self._position = Point(x, y) if self.layouts: self.layouts[0].setPosition(QPointF(x, y)) y += self.layouts[0].boundingRect().height() for l in self.layouts[1:]: if isinstance(l, (int, float)): y += l else: l.setPosition(QPointF(x, y)) y += l.boundingRect().height()
def fset(self, new_pos): (x, y) = new_pos self._position = Point(x, y) if self.layouts: self.layouts[0].setPosition(QPointF(x, y)) y += self.layouts[0].boundingRect().height() for l in self.layouts[1:]: if isinstance(l, numbers.Number): y += l else: l.setPosition(QPointF(x, y)) y += l.boundingRect().height()
def draw_fold(x, m=1, corner=left_corner): ans = p = QPainterPath(QPointF(x, rtop)) draw_curved_line(p, rwidth*m, 0, 0.1, 0.1*m, 0.5, -0.2*m) fold_upper = p.currentPosition() p.lineTo(p.currentPosition() + QPointF(-deltax*m, height)) fold_corner = p.currentPosition() draw_curved_line(p, -rwidth*m, 0, 0.2, -0.1*m, 0.8, -0.1*m) draw_curved_line(p, deltax*m, -height, 0.2, 0.1*m, 0.8, 0.1*m) p = inner_fold = QPainterPath(corner) dp = fold_corner - p.currentPosition() draw_curved_line(p, dp.x(), dp.y(), 0.5, 0.3*m, 1, 0*m) p.lineTo(fold_upper), p.closeSubpath() return ans, inner_fold
def full(p, xmax, ymax): p.drawRect(0, 0, xmax, ymax) p.drawPolyline(QPoint(0, 0), QPoint(xmax, 0), QPoint(xmax, ymax), QPoint(0, ymax), QPoint(0, 0)) pp = QPainterPath() pp.addRect(0, 0, xmax, ymax) p.drawPath(pp) p.save() for i in range(3): col = [0, 0, 0, 200] col[i] = 255 p.setOpacity(0.3) p.fillRect(0, 0, xmax/10, xmax/10, QBrush(QColor(*col))) p.setOpacity(1) p.drawRect(0, 0, xmax/10, xmax/10) p.translate(xmax/10, xmax/10) p.scale(1, 1.5) p.restore() # p.scale(2, 2) # p.rotate(45) p.drawPixmap(0, 0, xmax/4, xmax/4, QPixmap(I('library.png'))) p.drawRect(0, 0, xmax/4, xmax/4) f = p.font() f.setPointSize(20) # f.setLetterSpacing(f.PercentageSpacing, 200) f.setUnderline(True) # f.setOverline(True) # f.setStrikeOut(True) f.setFamily('Calibri') p.setFont(f) # p.setPen(QColor(0, 0, 255)) # p.scale(2, 2) # p.rotate(45) p.drawText(QPoint(xmax/3.9, 30), 'Some—text not By’s ū --- Д AV ff ff') b = QBrush(Qt.HorPattern) b.setColor(QColor(Qt.blue)) pix = QPixmap(I('lt.png')) w = xmax/4 p.fillRect(0, ymax/3, w, w, b) p.fillRect(xmax/3, ymax/3, w, w, QBrush(pix)) x, y = 2*xmax/3, ymax/3 p.drawTiledPixmap(QRectF(x, y, w, w), pix, QPointF(10, 10)) x, y = 1, ymax/1.9 g = QLinearGradient(QPointF(x, y), QPointF(x+w, y+w)) g.setColorAt(0, QColor('#00f')) g.setColorAt(1, QColor('#fff')) p.fillRect(x, y, w, w, QBrush(g))
def __call__(self, painter, rect, color_theme, title_block, subtitle_block, footer_block): if not self.PATH_CACHE: from calibre.utils.speedups import svg_path_to_painter_path try: self.__class__.PATH_CACHE['corner'] = svg_path_to_painter_path( self.CORNER_VECTOR) except Exception: import traceback traceback.print_exc() p = painter painter.setRenderHint(QPainter.RenderHint.Antialiasing) g = QRadialGradient(QPointF(rect.center()), rect.width()) g.setColorAt(0, self.color1), g.setColorAt(1, self.color2) painter.fillRect(rect, QBrush(g)) painter.save() painter.setWindow(0, 0, *self.VIEWPORT) try: path = self.PATH_CACHE['corner'] except KeyError: path = QPainterPath() pen = p.pen() pen.setColor(self.ccolor1) p.setPen(pen) def corner(): b = QBrush(self.ccolor1) p.fillPath(path, b) p.rotate(90), p.translate(100, -100), p.scale(1, -1), p.translate( -103, -97) p.fillPath(path, b) p.setWorldTransform(QTransform()) # Top-left corner corner() # Top right corner p.scale(-1, 1), p.translate(-400, 0), corner() # Bottom left corner p.scale(1, -1), p.translate(0, -500), corner() # Bottom right corner p.scale(-1, -1), p.translate(-400, -500), corner() for y in (28.4, 471.7): p.drawLine(QPointF(160, y), QPointF(240, y)) for x in (31.3, 368.7): p.drawLine(QPointF(x, 155), QPointF(x, 345)) pen.setWidthF(1.8) p.setPen(pen) for y in (23.8, 476.7): p.drawLine(QPointF(160, y), QPointF(240, y)) for x in (26.3, 373.7): p.drawLine(QPointF(x, 155), QPointF(x, 345)) painter.restore() return self.ccolor2, self.ccolor2, self.ccolor1
def position(self): def fget(self): return self._position def fset(self, (x, y)): self._position = Point(x, y) if self.layouts: self.layouts[0].setPosition(QPointF(x, y)) y += self.layouts[0].boundingRect().height() for l in self.layouts[1:]: if isinstance(l, (int, float)): y += l else: l.setPosition(QPointF(x, y)) y += l.boundingRect().height()
def __init__(self, text='', width=0, font=None, img=None, max_height=100, align=Qt.AlignCenter): self.layouts = [] self._position = Point(0, 0) self.leading = self.line_spacing = 0 if font is not None: fm = QFontMetrics(font, img) self.leading = fm.leading() self.line_spacing = fm.lineSpacing() for text in text.split('<br>') if text else (): text, formats = parse_text_formatting(sanitize(text)) l = QTextLayout(unescape_formatting(text), font, img) l.setAdditionalFormats(formats) to = QTextOption(align) to.setWrapMode(QTextOption.WrapAtWordBoundaryOrAnywhere) l.setTextOption(to) l.beginLayout() height = 0 while height + 3*self.leading < max_height: line = l.createLine() if not line.isValid(): break line.setLineWidth(width) height += self.leading line.setPosition(QPointF(0, height)) height += line.height() max_height -= height l.endLayout() if self.layouts: self.layouts.append(self.leading) else: self._position = Point(l.position().x(), l.position().y()) self.layouts.append(l) if self.layouts: self.layouts.append(self.leading)
def isometric(x: float, y: float) -> QPointF: """Convert rectangular coordinates to isometric.""" # (iso_x + iso_y) * ISOMETRIC_HEIGHT1 = y # (iso_x - iso_y) * ISOMETRIC_WIDTH = x return QPointF(((y / ISOMETRIC_HEIGHT1) + (x / ISOMETRIC_WIDTH)), ((y / ISOMETRIC_HEIGHT1) - (x / ISOMETRIC_WIDTH))) / 2
def __init__(self, gui): QWidget.__init__(self, gui) self.setObjectName('jobs_pointer') self.setVisible(False) self.resize(100, 80) self.animation = QPropertyAnimation(self, "geometry", self) self.animation.setDuration(750) self.animation.setLoopCount(2) self.animation.setEasingCurve(QEasingCurve.Linear) self.animation.finished.connect(self.hide) taily, heady = 0, 55 self.arrow_path = QPainterPath(QPointF(40, taily)) self.arrow_path.lineTo(40, heady) self.arrow_path.lineTo(20, heady) self.arrow_path.lineTo(50, self.height()) self.arrow_path.lineTo(80, heady) self.arrow_path.lineTo(60, heady) self.arrow_path.lineTo(60, taily) self.arrow_path.closeSubpath() c = self.palette().color(QPalette.Active, QPalette.WindowText) self.color = QColor(c) self.color.setAlpha(100) self.brush = QBrush(self.color, Qt.SolidPattern)
def __init__(self, parent=None): super(WebView, self).__init__(parent) self._currentZoomLevel = 0 self._progress = 0 self._backgroundActivity = False self._clickedUrl = QUrl() self._clickedPos = QPointF() self._page = None # WebPage self._firstLoad = False # False self._rwhvqt = None # QPointer<QWidget> self._wheelHelper = WheelHelper() self.loadStarted.connect(lambda: WebView._slotLoadStarted(self)) self.loadProgress.connect(lambda progress: WebView._slotLoadProgress(self, progress)) self.loadFinished.connect(lambda ok: WebView._slotLoadFinished(self, ok)) self.iconChanged.connect(lambda: WebView._slotIconChanged(self)) self.urlChanged.connect(lambda url: WebView._slotUrlChanged(self, url)) self.titleChanged.connect(lambda title: WebView._slotTitleChanged(self, title)) self._currentZoomLevel = self.zoomLevels().index(100) self.setAcceptDrops(True) self.installEventFilter(self) if self.parentWidget(): self.parentWidget().installEventFilter(self) WebInspector.registerView(self)
def paintEvent(self, ev): if self.last_layout_rect != self.rect(): self.do_layout() p = QPainter(self) br = self.layout.boundingRect() y = 0 if br.height() < self.height(): y = (self.height() - br.height()) / 2 self.layout.draw(p, QPointF(0, y))
def click(self): pointf = self.target.mapToScene(QPointF(0.0, 0.0)) x = pointf.x() y = pointf.y() x += self.value_or_default("width", 0.0) / 2.0 y += self.value_or_default("height", 0.0) / 2.0 point = QPoint(x, y) root_widget = pqaut.server.get_root_widget() pqaut.server.clicker.click_on(root_widget.target, point)
def __call__(self, painter, rect, color_theme, title_block, subtitle_block, footer_block): painter.fillRect(rect, self.color1) top = title_block.position.y + 2 extra_spacing = subtitle_block.line_spacing // 2 if subtitle_block.line_spacing else title_block.line_spacing // 3 height = title_block.height + subtitle_block.height + extra_spacing + title_block.leading right = rect.right() - self.hmargin width = right - self.hmargin # Draw main banner p = main = QPainterPath(QPointF(self.hmargin, top)) draw_curved_line(p, rect.width() - 2 * self.hmargin, 0, 0.1, -0.1, 0.9, -0.1) deltax = self.GRADE * height p.lineTo(right + deltax, top + height) right_corner = p.currentPosition() draw_curved_line(p, - width - 2 * deltax, 0, 0.1, 0.05, 0.9, 0.05) left_corner = p.currentPosition() p.closeSubpath() # Draw fold rectangles rwidth = self.fold_width yfrac = 0.1 width23 = int(0.67 * rwidth) rtop = top + height * yfrac def draw_fold(x, m=1, corner=left_corner): ans = p = QPainterPath(QPointF(x, rtop)) draw_curved_line(p, rwidth*m, 0, 0.1, 0.1*m, 0.5, -0.2*m) fold_upper = p.currentPosition() p.lineTo(p.currentPosition() + QPointF(-deltax*m, height)) fold_corner = p.currentPosition() draw_curved_line(p, -rwidth*m, 0, 0.2, -0.1*m, 0.8, -0.1*m) draw_curved_line(p, deltax*m, -height, 0.2, 0.1*m, 0.8, 0.1*m) p = inner_fold = QPainterPath(corner) dp = fold_corner - p.currentPosition() draw_curved_line(p, dp.x(), dp.y(), 0.5, 0.3*m, 1, 0*m) p.lineTo(fold_upper), p.closeSubpath() return ans, inner_fold left_fold, left_inner = draw_fold(self.hmargin - width23) right_fold, right_inner = draw_fold(right + width23, m=-1, corner=right_corner) painter.save() painter.setRenderHint(QPainter.Antialiasing) pen = QPen(self.ccolor2) pen.setWidth(3) pen.setJoinStyle(Qt.RoundJoin) painter.setPen(pen) for r in (left_fold, right_fold): painter.fillPath(r, QBrush(self.color2)) painter.drawPath(r) for r in (left_inner, right_inner): painter.fillPath(r, QBrush(self.color2.darker())) painter.drawPath(r) painter.fillPath(main, QBrush(self.color2)) painter.drawPath(main) painter.restore() return self.ccolor2, self.ccolor2, self.ccolor1
def copy(self): ans = GraphicsState() ans.fill = QBrush(self.fill) ans.stroke = QPen(self.stroke) ans.opacity = self.opacity ans.transform = self.transform * QTransform() ans.brush_origin = QPointF(self.brush_origin) ans.clip_updated = self.clip_updated ans.do_fill, ans.do_stroke = self.do_fill, self.do_stroke return ans
def is_offscreen(self): first_child = pqaut.server.get_root_widget() root_width = first_child.value_or_default('width', 0.0) root_height = first_child.value_or_default('height', 0.0) pointf = self._target.mapToScene(QPointF(0.0, 0.0)) x = pointf.x() y = pointf.y() width = self.value_or_default("width", 0.0) height = self.value_or_default("height", 0.0) return x + width <= 0 or x >= root_width or y + height <= 0 or y >= root_height
def start(self): if config['disable_animations']: return self.setVisible(True) self.raise_() end = self.abspos(self.gui.jobs_button) end = QPointF( end.x() + self.gui.jobs_button.width()/3.0, end.y()+20) start = QPointF(end.x(), end.y() - 0.5*self.height()) self.path = QPainterPath(QPointF(start)) self.path.lineTo(end) self.path.closeSubpath() self.animation.setStartValue(self.rect_at(0.0)) self.animation.setEndValue(self.rect_at(1.0)) self.animation.setDirection(self.animation.Backward) num_keys = 100 for i in xrange(1, num_keys): i /= num_keys self.animation.setKeyValueAt(i, self.rect_at(i)) self.animation.start()
def __init__(self): self.fill = QBrush(Qt.white) self.stroke = QPen() self.opacity = 1.0 self.transform = QTransform() self.brush_origin = QPointF() self.clip_updated = False self.do_fill = False self.do_stroke = True self.qt_pattern_cache = {}
def from_json(self, json_properties): pattern = self.make() pattern.set_name(json_properties["name"]) width = json_properties["properties"]["size"][0] height = json_properties["properties"]["size"][1] for pattern_object in json_properties["properties"]["objects"]: x = pattern_object["offset"][0] * width y = -pattern_object["offset"][1] * height starfish_type = self.starfish_type_from_string( pattern_object["name"]) pattern.add_starfish_at_position(QPointF(x, y), starfish_type) return pattern
def get_starfish_at_position(self, position): for starfish in self._starfishes: top_left = QPointF( starfish.position().x() - PatternDrawer.IMAGE_SIZE[0] * 0.5, starfish.position().y() - PatternDrawer.IMAGE_SIZE[1] * 0.5) rect = QRectF( top_left, QSizeF(PatternDrawer.IMAGE_SIZE[0], PatternDrawer.IMAGE_SIZE[1])) if rect.contains(position): return starfish return None
def format_data(data): pointlist = [] index = 0 minitem = 0 maxitem = 0 for item in data: if item > maxitem: maxitem = item if item < minitem: minitem = item pointlist.append(QPointF(index, item)) index += 1 return pointlist, maxitem, minitem
def move_selection_rect(self, x, y): sr = self.selection_state.rect half_width = sr.width() / 2.0 half_height = sr.height() / 2.0 c = sr.center() nx = c.x() + x ny = c.y() + y minx = self.target.left() + half_width maxx = self.target.right() - half_width miny, maxy = self.target.top() + half_height, self.target.bottom() - half_height nx = max(minx, min(maxx, nx)) ny = max(miny, min(maxy, ny)) sr.moveCenter(QPointF(nx, ny))
class Curve(QWidget): ''' class Curve ''' def __init__(self, title, parent = None): super(Curve, self).__init__(parent) self._sheftCount = 100 self._points = QPointF() * 256 def setCount(self, count): self._points = QPointF() * count def count(self): return self._points.count() def append(self, point): pass def setSamples(self, points): pass def sheft(self, point): pass def sheftY(self, y): pass def samples(self): return self._points def sheftCount(self): return self._sheftCount def setSheftCount(self, value): self._sheftCount = value def setLinePen(self, pen): pass def update(self): pass
def setCount(self, count): self._points = QPointF() * count
def __init__(self, title, parent = None): super(Curve, self).__init__(parent) self._sheftCount = 100 self._points = QPointF() * 256