int SCIrisWipeEffectStrategyBase::findMaxScaling(const SCPageEffect::Data &data) { const int width = data.m_widget->width(); const int height = data.m_widget->height(); QPainterPath widget; widget.addRect(0, 0, width, height); int pathMaxMeasure; int maxMeasure; //We find whether the screen is taller or wider so that we can start searching //from a closer point if(width > height) { pathMaxMeasure = m_shape.boundingRect().width(); maxMeasure = width; } else { pathMaxMeasure = m_shape.boundingRect().height(); maxMeasure = height; } //We now search from the previous point and incressing over and over till the shape fills //the widget given int halfWidth = width / 2; int halfHeight = height / 2; QPainterPath path; while(!path.contains(widget)) { QTransform matrix; matrix.translate(halfWidth, halfHeight); double maxScaling = (double) maxMeasure / (double) pathMaxMeasure; matrix.scale(maxScaling, maxScaling); path = matrix.map(m_shape); maxMeasure += 5;//we don't need to be very precise } return maxMeasure; }
void CityItemWidget::paintEvent(QPaintEvent *event) { QPainter painter(this); painter.setRenderHint(QPainter::Antialiasing, true); if (m_mouseHover) { QPainterPath path; path.addRect(QRectF(this->rect().x(), this->rect().y(), this->rect().width(), this->rect().height())); painter.setOpacity(1.0); painter.fillPath(path, QColor("#f5fbff")); if (!m_data.active) { m_defaultBtn->setVisible(true); } else { m_defaultBtn->setVisible(false); } } else { m_defaultBtn->setVisible(false); } }
/*! \internal Checks if item collides with the path and mode, but also checks that if it doesn't collide, maybe its frame rect will. */ bool QGraphicsSceneIndexPrivate::itemCollidesWithPath(const QGraphicsItem *item, const QPainterPath &path, Qt::ItemSelectionMode mode) { if (item->collidesWithPath(path, mode)) return true; if (item->isWidget()) { // Check if this is a window, and if its frame rect collides. const QGraphicsWidget *widget = static_cast<const QGraphicsWidget *>(item); if (widget->isWindow()) { QRectF frameRect = widget->windowFrameRect(); QPainterPath framePath; framePath.addRect(frameRect); bool intersects = path.intersects(frameRect); if (mode == Qt::IntersectsItemShape || mode == Qt::IntersectsItemBoundingRect) return intersects || path.contains(frameRect.topLeft()) || framePath.contains(path.elementAt(0)); return !intersects && path.contains(frameRect.topLeft()); } } return false; }
bool intersect(const QGraphicsItem *item, const QRectF &exposeRect, Qt::ItemSelectionMode mode, const QTransform &deviceTransform) const { QRectF brect = item->boundingRect(); _q_adjustRect(&brect); // ### Add test for this (without making things slower?) Q_UNUSED(exposeRect); bool keep = false; const QGraphicsItemPrivate *itemd = QGraphicsItemPrivate::get(item); if (itemd->itemIsUntransformable()) { // Untransformable items; map the scene point to item coordinates. const QTransform transform = item->deviceTransform(deviceTransform); QPointF itemPoint = (deviceTransform * transform.inverted()).map(scenePoint); keep = brect.contains(itemPoint); if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) { QPainterPath pointPath; pointPath.addRect(QRectF(itemPoint, QSizeF(1, 1))); keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, pointPath, mode); } } else { Q_ASSERT(!itemd->dirtySceneTransform); QRectF sceneBoundingRect = itemd->sceneTransformTranslateOnly ? brect.translated(itemd->sceneTransform.dx(), itemd->sceneTransform.dy()) : itemd->sceneTransform.mapRect(brect); keep = sceneBoundingRect.intersects(QRectF(scenePoint, QSizeF(1, 1))); if (keep) { QPointF p = itemd->sceneTransformTranslateOnly ? QPointF(scenePoint.x() - itemd->sceneTransform.dx(), scenePoint.y() - itemd->sceneTransform.dy()) : itemd->sceneTransform.inverted().map(scenePoint); keep = item->contains(p); } } return keep; }
/*! Draws the first \a rectCount rectangles in the buffer \a rects. The default implementation of this function calls drawPath() or drawPolygon() depending on the feature set of the paint engine. */ void QPaintEngine::drawRects(const QRectF *rects, int rectCount) { if (hasFeature(PainterPaths) && !state->penNeedsResolving() && !state->brushNeedsResolving()) { for (int i=0; i<rectCount; ++i) { QPainterPath path; path.addRect(rects[i]); if (path.isEmpty()) continue; drawPath(path); } } else { for (int i=0; i<rectCount; ++i) { QRectF rf = rects[i]; QPointF pts[4] = { QPointF(rf.x(), rf.y()), QPointF(rf.x() + rf.width(), rf.y()), QPointF(rf.x() + rf.width(), rf.y() + rf.height()), QPointF(rf.x(), rf.y() + rf.height()) }; drawPolygon(pts, 4, ConvexMode); } } }
QPainterPath PolaroidBorderDrawer::path(const QPainterPath & path) { QPainterPath temp; QRectF r = path.boundingRect(); m_text_rect.setTop(r.bottom()); r.setTop(r.top()-m_width); r.setBottom(r.bottom()+m_width*5); r.setLeft(r.left()-m_width); r.setRight(r.right()+m_width); m_text_rect.setBottom(r.bottom()); m_text_rect.setLeft(r.left()); m_text_rect.setRight(r.right()); temp.addRect(r); temp -= path; m_path = temp; return m_path; }
void RenderArea::paintEvent(QPaintEvent *) { QPainter painter(this); painter.setPen(Qt::NoPen); painter.setRenderHint(QPainter::Antialiasing); if(currentBrush->style() == Qt::LinearGradientPattern) { currentBrush = new QBrush(QLinearGradient(0, 0, width(), 60)); } else if(currentBrush->style() == Qt::RadialGradientPattern) { QRadialGradient radial(width() / 2, 30, width() / 2, width() / 2, 30); radial.setColorAt(0, Qt::white); radial.setColorAt(1, Qt::black); currentBrush = new QBrush(radial); } else if(currentBrush->style() == Qt::ConicalGradientPattern) { currentBrush = new QBrush(QConicalGradient(width() / 2, 30, 90)); } painter.setBrush(*currentBrush); QPainterPath path; path.addRect(0, 0, parentWidget()->width(), 60); painter.drawPath(path); }
void TwoDModelScene::reshapeItem(QGraphicsSceneMouseEvent *event) { setX2andY2(event); if (mGraphicsItem && mGraphicsItem->editable()) { const QPointF oldBegin(mGraphicsItem->x1(), mGraphicsItem->y1()); const QPointF oldEnd(mGraphicsItem->x2(), mGraphicsItem->y2()); if (mGraphicsItem->dragState() != graphicsUtils::AbstractItem::None) { mView->setDragMode(QGraphicsView::NoDrag); } mGraphicsItem->resizeItem(event); QPainterPath shape; for (RobotItem * const robotItem : mRobots.values()) { shape.addRect(robotItem->realBoundingRect()); } if (dynamic_cast<items::WallItem *>(mGraphicsItem) && mGraphicsItem->realShape().intersects(shape)) { mGraphicsItem->reverseOldResizingItem(oldBegin, oldEnd); } } }
void QtVSGCommentItem::mouseMoveEvent(QGraphicsSceneMouseEvent* event) { if(m_inResizeMode) { QPointF delta = pos() - event->scenePos(); qreal x = round(delta.x() / getGridSize()) * getGridSize(); qreal y = round(delta.y() / getGridSize()) * getGridSize(); x = qAbs(qMin(x, qreal(-32.f))); y = qAbs(qMin(y, qreal(-32.f))); QPainterPath painter; painter.addRect(QRectF(QPointF(0, 0), QPointF(x, y))); setPath(painter); m_textItem->setY(y); } else { QGraphicsItem::mouseMoveEvent(event); } }
void Box::draw(QPainter* painter) const { if (score() && score()->printing()) return; if (selected() || editMode || dropTarget() || score()->showFrames()) { qreal w = spatium() * .15; QPainterPathStroker stroker; stroker.setWidth(w); stroker.setJoinStyle(Qt::MiterJoin); stroker.setCapStyle(Qt::SquareCap); QVector<qreal> dashes ; dashes.append(1); dashes.append(3); stroker.setDashPattern(dashes); QPainterPath path; w *= .5; path.addRect(bbox().adjusted(w, w, -w, -w)); QPainterPath stroke = stroker.createStroke(path); painter->setBrush(Qt::NoBrush); painter->fillPath(stroke, (selected() || editMode || dropTarget()) ? MScore::selectColor[0] : MScore::frameMarginColor); } }
/*! \fn QPainterPath NmHsWidget::shape() Called by home screen fw to check widget boundaries, needed to draw outside widget boundingRect. /return QPainterPath path describing actual boundaries of widget including child items */ QPainterPath NmHsWidget::shape() const { NM_FUNCTION; QPainterPath path; path.setFillRule(Qt::WindingFill); if (mWidgetContainer){ //add mWidgetContainer using geometry to get //correct point for top-left-corner QRectF widgetRect = mWidgetContainer->geometry(); path.addRect(widgetRect); //then fetch shape from title row QPainterPath titlepath; titlepath.addPath(mTitleRow->shape()); //translate it's location to be inside mWidgetContainer titlepath.translate(widgetRect.topLeft()); //and finally add it to path path.addPath(titlepath); } //simplified path, i.e. only outlines return path.simplified(); }
QPainterPath IsometricRenderer::shape(const MapObject *object) const { QPainterPath path; if (!object->cell().isEmpty() || object->shape() == MapObject::Text) { path.addRect(boundingRect(object)); } else { switch (object->shape()) { case MapObject::Ellipse: case MapObject::Rectangle: path.addPolygon(pixelRectToScreenPolygon(object->bounds())); break; case MapObject::Point: path = pointShape(object); break; case MapObject::Polygon: case MapObject::Polyline: { const QPointF &pos = object->position(); const QPolygonF polygon = object->polygon().translated(pos); const QPolygonF screenPolygon = pixelToScreenCoords(polygon); if (object->shape() == MapObject::Polygon) { path.addPolygon(screenPolygon); } else { for (int i = 1; i < screenPolygon.size(); ++i) { path.addPolygon(lineToPolygon(screenPolygon[i - 1], screenPolygon[i])); } path.setFillRule(Qt::WindingFill); } break; } case MapObject::Text: break; // already handled above } } return path; }
void QSanCommandProgressBar::paintEvent(QPaintEvent *e) { m_mutex.lock(); int val = this->m_val; int max = this->m_max; m_mutex.unlock(); int width = this->width(); int height = this->height(); QPainter painter(this); painter.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform); if (orientation() == Qt::Vertical) { painter.translate(0, height); qSwap(width, height); painter.rotate(-90); } painter.drawPixmap(0, 0, width, height, m_progBg); double percent = 1 - (double)val / (double)max; QRectF rect = QRectF(0, 0, percent * width, height); //ÒÔrectµÄÓÒ±ßΪÖÐÖᣬ7Ϊ°ë¾¶»Ò»¸öÍÖÔ² QRectF ellipseRect; ellipseRect.setTopLeft(QPointF(rect.right() - 7, rect.top())); ellipseRect.setBottomRight(QPointF(rect.right() + 7, rect.bottom())); QPainterPath rectPath; QPainterPath ellipsePath; rectPath.addRect(rect); ellipsePath.addEllipse(ellipseRect); QPainterPath polygonPath = rectPath.united(ellipsePath); painter.setClipPath(polygonPath); painter.drawPixmap(0, 0, width, height, m_prog); }
void FramelessWin2::paintEvent(QPaintEvent *evt) { /* 添加阴影效果 :param args: :param kwargs: :return: */ QStyleOption opt; opt.init(this); QPainter painter(this); QStyle *style = this->style(); style->drawPrimitive(QStyle::PE_Widget,&opt,&painter,this); QPainterPath path; path.setFillRule(Qt::WindingFill); path.addRect(10,10,width()-20,height()-20); painter.setRenderHint(QPainter::Antialiasing,true); painter.fillPath(path,QBrush(Qt::white)); QColor color(0,0,0,50); int i = 0; //for i in xrange(10): for (i = 0 ; i < 10; i++) { QPainterPath path2; path2.setFillRule(Qt::WindingFill); path2.addRect(10-i,10-i,width()-(10-i)*2,height()-(10-i)*2); color.setAlpha(150 - sqrt((float)i)*50); painter.setPen(color); painter.drawPath(path2); } QPixmap back("./UI/skin.png"); i = 0; painter.drawPixmap(10-i,10-i,width()-(10-i)*2,height()-(10-i)*2,back); }
SGraphicsPathItem::SGraphicsPathItem(const QPainterPath& path, const QPen& pen, QGraphicsItem *parent):QGraphicsPathItem(path, parent) { mPen = pen; QGraphicsPathItem::setPen(mPen); setCacheMode(QGraphicsItem::DeviceCoordinateCache); setFlag(QGraphicsItem::ItemIsSelectable, true); setFlag(QGraphicsItem::ItemIsMovable, true); setFlag(QGraphicsItem::ItemIsFocusable, true); setFlag(QGraphicsItem::ItemSendsGeometryChanges, true); mSelectionWidth = 1; mIconSize = 20; mSelectionPen.setWidth(mSelectionWidth); mSelectionPen.setColor(QColor(0, 0, 255, 255)); mInitRect = QGraphicsPathItem::boundingRect(); mWidth = mInitRect.width(); mHeight = mInitRect.height(); mX = mInitRect.x(); mY = mInitRect.y(); QPainterPath pa; pa.addRect(boundingRect()); mSelectionShape = pa; mpSelectionRect = new SSelectionRect(this, 0); }
virtual void paintEvent(QPaintEvent* event) { QPainter painter(this); painter.setClipRect(event->rect()); if (m_fill) { m_checkerPainter.paint(painter, rect()); QSharedPointer<KoGradientBackground> gradientFill = qSharedPointerDynamicCast<KoGradientBackground>(m_fill); if (gradientFill) { const QGradient * gradient = gradientFill->gradient(); QGradient * defGradient = KoGradientHelper::defaultGradient(gradient->type(), gradient->spread(), gradient->stops()); QBrush brush(*defGradient); delete defGradient; painter.setBrush(brush); painter.setPen(Qt::NoPen); painter.drawRect(rect()); } else { // use the background to draw painter.setPen(Qt::NoPen); QPainterPath p; p.addRect(rect()); KoViewConverter converter; KoShapePaintingContext context; m_fill->paint(painter, converter, context, p); } } else { painter.setFont(KGlobalSettings::smallestReadableFont()); painter.setBrush(Qt::black); painter.setPen(Qt::black); painter.drawText(rect(), Qt::AlignCenter, i18nc("The style has no fill", "None")); } painter.end(); //QPushButton::paintEvent( event ); }
/** * @brief Changes the position of the rectangle the user is drawing or moving. * * If the specified area is the same as before, nothing is done. * * @param new_area new position of the rectangle. */ void TilesetView::set_current_area(const QRect& area) { if (current_area_item->rect().toRect() == area) { // No change. return; } current_area_item->setRect(area); if (state == State::DRAWING_RECTANGLE) { // Select items strictly in the rectangle. scene->clearSelection(); QPainterPath path; path.addRect(QRect(area.topLeft() - QPoint(1, 1), area.size() + QSize(2, 2))); scene->setSelectionArea(path, Qt::ContainsItemBoundingRect); } if (state == State::MOVING_PATTERN) { // Check overlapping existing patterns. if (!area.isEmpty() && sceneRect().contains(area) && get_items_intersecting_current_area().isEmpty() && model->get_selection_count() == 1 && !is_read_only()) { current_area_item->setPen(QPen(Qt::yellow)); } else { current_area_item->setPen(QPen(Qt::red)); } } // Re-select items that were already selected if Ctrl or Shift was pressed. for (QGraphicsItem* item : initially_selected_items) { item->setSelected(true); } }
void TableGesture::paintCellSelection(QPainter* p) { if (!m_table || !m_canvas || !p) return; p->save(); p->scale(m_canvas->scale(), m_canvas->scale()); p->translate(-m_doc->minCanvasCoordinate.x(), -m_doc->minCanvasCoordinate.y()); p->setTransform(m_table->getTransform(), true); p->setRenderHint(QPainter::Antialiasing); p->setPen(QPen(QColor(100, 200, 255), 3.0 / m_canvas->scale(), Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin)); p->setBrush(QColor(100, 200, 255, 50)); /* * The code below makes selectionPath a union of the cell rectangles of the selected cells. * Since the cell rectangles are adjacent, they must be expanded slightly (1.0) for the * uniting to work. This may not be the fastest way to compose the path of the selection, * but it makes for some very simple code. And the result looks good. */ const QPointF offset = m_table->gridOffset(); QPainterPath selectionPath; foreach (const TableCell& cell, m_table->selectedCells()) { QRectF cellRect = cell.boundingRect(); cellRect.translate(offset); cellRect.adjust(-1.0, -1.0, 1.0, 1.0); QPainterPath cellPath; cellPath.addRect(cellRect); selectionPath = selectionPath.united(cellPath); } p->drawPath(selectionPath); p->restore(); }
QPainterPath Shapes::restore(const QRectF &bound, Style style) { _S(3) _S(4) _S(8) QPainterPath path; switch (style) { case Square: path.addRect(bound); path.addRect(bound.adjusted(0, 0, -s4, -s4)); path.addRect(bound.adjusted(0, 0, -2*s3, -2*s3)); break; case LasseKongo: path.addEllipse(bound); path.addRect(bound.adjusted(s3,0,-s3,0)); path.addRect(bound.adjusted(0,s3,-2*s3,-s3)); path.addRect(bound.adjusted(2*s3,s3,0,-s3)); break; default: case Round: path.moveTo(bound.center()); path.arcTo(bound, 225, 180); path.closeSubpath(); break; case TheRob: path.moveTo(bound.center()); path.arcTo(bound, 225, 180); path.closeSubpath(); path.moveTo(bound.center()); path.arcTo(bound.adjusted(s8,s8,-s8,-s8), 225, 180); path.closeSubpath(); path.addEllipse(bound.adjusted(s4,s4,-s4,-s4)); break; } return path; }
QPainterPath ZigZagWipeStrategy::clipPath(int step, const QRect &area) { const int zigZagCount = 10; const qreal zigZagHeight = area.height() / static_cast<qreal>(zigZagCount); const qreal zigZagWidth = area.width() / static_cast<qreal>(zigZagCount); qreal percent = static_cast<qreal>(step) / static_cast<qreal>(StepCount); if(reverse()) percent = static_cast<qreal>(StepCount-step) / static_cast<qreal>(StepCount); int stepx = static_cast<int>((area.width() + 2*zigZagWidth) * percent); int stepy = static_cast<int>((area.height() + 2*zigZagHeight) * percent); qreal zigZagHeight_2 = 0.5 * zigZagHeight; qreal zigZagWidth_2 = 0.5 * zigZagWidth; QPainterPath path; switch(subType()) { case ZigZagWipeEffectFactory::FromTop: case ZigZagWipeEffectFactory::FromBottom: { qreal zigZagBase = stepy - zigZagHeight; qreal zigZagTip = stepy; path.moveTo(area.topLeft() - QPointF(0, zigZagHeight)); path.lineTo(QPointF(area.left(), zigZagBase)); for(int i = 0; i < zigZagCount; ++i) { path.lineTo(area.topLeft() + QPointF((2*i+1) * zigZagWidth_2, zigZagTip)); path.lineTo(area.topLeft() + QPointF((i+1) * zigZagWidth, zigZagBase)); } path.lineTo(area.topRight() - QPointF(0, zigZagHeight)); break; } case ZigZagWipeEffectFactory::FromLeft: case ZigZagWipeEffectFactory::FromRight: { qreal zigZagBase = stepx - zigZagWidth; qreal zigZagTip = stepx; path.moveTo(area.topLeft() - QPointF(zigZagWidth, 0)); path.lineTo(QPointF(zigZagBase, area.top())); for(int i = 0; i < zigZagCount; ++i) { path.lineTo(area.topLeft() + QPointF(zigZagTip, (2*i+1) * zigZagHeight_2)); path.lineTo(area.topLeft() + QPointF(zigZagBase, (i+1) * zigZagHeight)); } path.lineTo(area.bottomLeft() - QPointF(zigZagWidth, 0)); break; } default: return QPainterPath(); } path.closeSubpath(); if(reverse()) { QPainterPath areaPath; areaPath.addRect(area); path = areaPath.subtracted(path); } return path; }
/*! Draw a rectangular frame \param painter Painter \param rect Frame rectangle \param palette Palette \param foregroundRole Foreground role used for QFrame::Plain \param frameWidth Frame width \param midLineWidth Used for QFrame::Box \param frameStyle bitwise OR´ed value of QFrame::Shape and QFrame::Shadow */ void QwtPainter::drawFrame( QPainter *painter, const QRectF &rect, const QPalette &palette, QPalette::ColorRole foregroundRole, int frameWidth, int midLineWidth, int frameStyle ) { if ( frameWidth <= 0 || rect.isEmpty() ) return; const int shadow = frameStyle & QFrame::Shadow_Mask; painter->save(); if ( shadow == QFrame::Plain ) { const QRectF outerRect = rect.adjusted( 0.0, 0.0, -1.0, -1.0 ); const QRectF innerRect = outerRect.adjusted( frameWidth, frameWidth, -frameWidth, -frameWidth ); QPainterPath path; path.addRect( outerRect ); path.addRect( innerRect ); painter->setPen( Qt::NoPen ); painter->setBrush( palette.color( foregroundRole ) ); painter->drawPath( path ); } else { const int shape = frameStyle & QFrame::Shape_Mask; if ( shape == QFrame::Box ) { const QRectF outerRect = rect.adjusted( 0.0, 0.0, -1.0, -1.0 ); const QRectF midRect1 = outerRect.adjusted( frameWidth, frameWidth, -frameWidth, -frameWidth ); const QRectF midRect2 = midRect1.adjusted( midLineWidth, midLineWidth, -midLineWidth, -midLineWidth ); const QRectF innerRect = midRect2.adjusted( frameWidth, frameWidth, -frameWidth, -frameWidth ); QPainterPath path1; path1.moveTo( outerRect.bottomLeft() ); path1.lineTo( outerRect.topLeft() ); path1.lineTo( outerRect.topRight() ); path1.lineTo( midRect1.topRight() ); path1.lineTo( midRect1.topLeft() ); path1.lineTo( midRect1.bottomLeft() ); QPainterPath path2; path2.moveTo( outerRect.bottomLeft() ); path2.lineTo( outerRect.bottomRight() ); path2.lineTo( outerRect.topRight() ); path2.lineTo( midRect1.topRight() ); path2.lineTo( midRect1.bottomRight() ); path2.lineTo( midRect1.bottomLeft() ); QPainterPath path3; path3.moveTo( midRect2.bottomLeft() ); path3.lineTo( midRect2.topLeft() ); path3.lineTo( midRect2.topRight() ); path3.lineTo( innerRect.topRight() ); path3.lineTo( innerRect.topLeft() ); path3.lineTo( innerRect.bottomLeft() ); QPainterPath path4; path4.moveTo( midRect2.bottomLeft() ); path4.lineTo( midRect2.bottomRight() ); path4.lineTo( midRect2.topRight() ); path4.lineTo( innerRect.topRight() ); path4.lineTo( innerRect.bottomRight() ); path4.lineTo( innerRect.bottomLeft() ); QPainterPath path5; path5.addRect( midRect1 ); path5.addRect( midRect2 ); painter->setPen( Qt::NoPen ); QBrush brush1 = palette.dark().color(); QBrush brush2 = palette.light().color(); if ( shadow == QFrame::Raised ) qSwap( brush1, brush2 ); painter->setBrush( brush1 ); painter->drawPath( path1 ); painter->drawPath( path4 ); painter->setBrush( brush2 ); painter->drawPath( path2 ); painter->drawPath( path3 ); painter->setBrush( palette.mid() ); painter->drawPath( path5 ); } #if 0 // qDrawWinPanel doesn't result in something nice // on a scalable document like PDF. Better draw a // Panel. else if ( shape == QFrame::WinPanel ) { painter->setRenderHint( QPainter::NonCosmeticDefaultPen, true ); qDrawWinPanel ( painter, rect.toRect(), palette, frameStyle & QFrame::Sunken ); } else if ( shape == QFrame::StyledPanel ) { } #endif else { const QRectF outerRect = rect.adjusted( 0.0, 0.0, -1.0, -1.0 ); const QRectF innerRect = outerRect.adjusted( frameWidth - 1.0, frameWidth - 1.0, -( frameWidth - 1.0 ), -( frameWidth - 1.0 ) ); QPainterPath path1; path1.moveTo( outerRect.bottomLeft() ); path1.lineTo( outerRect.topLeft() ); path1.lineTo( outerRect.topRight() ); path1.lineTo( innerRect.topRight() ); path1.lineTo( innerRect.topLeft() ); path1.lineTo( innerRect.bottomLeft() ); QPainterPath path2; path2.moveTo( outerRect.bottomLeft() ); path2.lineTo( outerRect.bottomRight() ); path2.lineTo( outerRect.topRight() ); path2.lineTo( innerRect.topRight() ); path2.lineTo( innerRect.bottomRight() ); path2.lineTo( innerRect.bottomLeft() ); painter->setPen( Qt::NoPen ); QBrush brush1 = palette.dark().color(); QBrush brush2 = palette.light().color(); if ( shadow == QFrame::Raised ) qSwap( brush1, brush2 ); painter->setBrush( brush1 ); painter->drawPath( path1 ); painter->setBrush( brush2 ); painter->drawPath( path2 ); } } painter->restore(); }
void ManhattanStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option, QPainter *painter, const QWidget *widget) const { if (!panelWidget(widget)) return d->style->drawPrimitive(element, option, painter, widget); bool animating = (option->state & State_Animating); int state = option->state; QRect rect = option->rect; QRect oldRect; QRect newRect; if (widget && (element == PE_PanelButtonTool) && !animating) { QWidget *w = const_cast<QWidget *> (widget); int oldState = w->property("_q_stylestate").toInt(); oldRect = w->property("_q_stylerect").toRect(); newRect = w->rect(); w->setProperty("_q_stylestate", (int)option->state); w->setProperty("_q_stylerect", w->rect()); // Determine the animated transition bool doTransition = ((state & State_On) != (oldState & State_On) || (state & State_MouseOver) != (oldState & State_MouseOver)); if (oldRect != newRect) { doTransition = false; d->animator.stopAnimation(widget); } if (doTransition) { QImage startImage(option->rect.size(), QImage::Format_ARGB32_Premultiplied); QImage endImage(option->rect.size(), QImage::Format_ARGB32_Premultiplied); Animation *anim = d->animator.widgetAnimation(widget); QStyleOption opt = *option; opt.state = (QStyle::State)oldState; opt.state |= (State)State_Animating; startImage.fill(0); Transition *t = new Transition; t->setWidget(w); QPainter startPainter(&startImage); if (!anim) { drawPrimitive(element, &opt, &startPainter, widget); } else { anim->paint(&startPainter, &opt); d->animator.stopAnimation(widget); } QStyleOption endOpt = *option; endOpt.state |= (State)State_Animating; t->setStartImage(startImage); d->animator.startAnimation(t); endImage.fill(0); QPainter endPainter(&endImage); drawPrimitive(element, &endOpt, &endPainter, widget); t->setEndImage(endImage); t->setDuration(130); t->setStartTime(QTime::currentTime()); } } switch (element) { case PE_PanelLineEdit: { painter->save(); if (option->state & State_Enabled) drawCornerImage(d->lineeditImage, painter, option->rect, 2, 2, 2, 2); else drawCornerImage(d->lineeditImage_disabled, painter, option->rect, 2, 2, 2, 2); if (option->state & State_HasFocus || option->state & State_MouseOver) { QColor hover = StyleHelper::baseColor(); if (state & State_HasFocus) hover.setAlpha(100); else hover.setAlpha(50); painter->setPen(QPen(hover, 1)); painter->drawRect(option->rect.adjusted(1, 1, -2 ,-2)); } painter->restore(); } break; case PE_FrameStatusBarItem: break; case PE_PanelButtonTool: { Animation *anim = d->animator.widgetAnimation(widget); if (!animating && anim) { anim->paint(painter, option); } else { bool pressed = option->state & State_Sunken || option->state & State_On; QColor shadow(0, 0, 0, 30); painter->setPen(shadow); if (pressed) { QColor shade(0, 0, 0, 40); painter->fillRect(rect, shade); painter->drawLine(rect.topLeft() + QPoint(1, 0), rect.topRight() - QPoint(1, 0)); painter->drawLine(rect.topLeft(), rect.bottomLeft()); painter->drawLine(rect.topRight(), rect.bottomRight()); // painter->drawLine(rect.bottomLeft() + QPoint(1, 0), rect.bottomRight() - QPoint(1, 0)); QColor highlight(255, 255, 255, 30); painter->setPen(highlight); } else if (option->state & State_Enabled && option->state & State_MouseOver) { QColor lighter(255, 255, 255, 37); painter->fillRect(rect, lighter); } } } break; case PE_PanelStatusBar: { painter->save(); QLinearGradient grad(option->rect.topLeft(), QPoint(rect.center().x(), rect.bottom())); QColor startColor = StyleHelper::shadowColor().darker(164); QColor endColor = StyleHelper::baseColor().darker(130); grad.setColorAt(0, endColor); grad.setColorAt(1, endColor); painter->fillRect(option->rect, grad); painter->setPen(QColor(255, 255, 255, 60)); painter->drawLine(rect.topLeft() + QPoint(0,1), rect.topRight()+ QPoint(0,1)); painter->setPen(StyleHelper::borderColor().darker(110)); painter->drawLine(rect.topLeft(), rect.topRight()); painter->restore(); } break; case PE_IndicatorToolBarSeparator: { QColor separatorColor = StyleHelper::borderColor(); separatorColor.setAlpha(100); painter->setPen(separatorColor); const int margin = 3; if (option->state & State_Horizontal) { const int offset = rect.width()/2; painter->drawLine(rect.bottomLeft().x() + offset, rect.bottomLeft().y() - margin, rect.topLeft().x() + offset, rect.topLeft().y() + margin); } else { //Draw vertical separator const int offset = rect.height()/2; painter->setPen(QPen(option->palette.background().color().darker(110))); painter->drawLine(rect.topLeft().x() + margin , rect.topLeft().y() + offset, rect.topRight().x() - margin, rect.topRight().y() + offset); } } break; case PE_IndicatorToolBarHandle: { bool horizontal = option->state & State_Horizontal; painter->save(); QPainterPath path; int x = option->rect.x() + horizontal ? 2 : 6; int y = option->rect.y() + horizontal ? 6 : 2; static const int RectHeight = 2; if (horizontal) { while (y < option->rect.height() - RectHeight - 6) { path.moveTo(x, y); path.addRect(x, y, RectHeight, RectHeight); y += 6; } } else { while (x < option->rect.width() - RectHeight - 6) { path.moveTo(x, y); path.addRect(x, y, RectHeight, RectHeight); x += 6; } } painter->setPen(Qt::NoPen); QColor dark = StyleHelper::borderColor(); dark.setAlphaF(0.4); QColor light = StyleHelper::baseColor(); light.setAlphaF(0.4); painter->fillPath(path, light); painter->save(); painter->translate(1, 1); painter->fillPath(path, dark); painter->restore(); painter->translate(3, 3); painter->fillPath(path, light); painter->translate(1, 1); painter->fillPath(path, dark); painter->restore(); } break; case PE_IndicatorArrowUp: case PE_IndicatorArrowDown: case PE_IndicatorArrowRight: case PE_IndicatorArrowLeft: { // From windowsstyle but modified to enable AA if (option->rect.width() <= 1 || option->rect.height() <= 1) break; QRect r = option->rect; int size = qMin(r.height(), r.width()); QPixmap pixmap; QString pixmapName; pixmapName.sprintf("%s-%s-%d-%d-%d-%lld", "$qt_ia", metaObject()->className(), uint(option->state), element, size, option->palette.cacheKey()); if (!QPixmapCache::find(pixmapName, pixmap)) { int border = size/5; int sqsize = 2*(size/2); QImage image(sqsize, sqsize, QImage::Format_ARGB32); image.fill(Qt::transparent); QPainter imagePainter(&image); imagePainter.setRenderHint(QPainter::Antialiasing, true); imagePainter.translate(0.5, 0.5); QPolygon a; switch (element) { case PE_IndicatorArrowUp: a.setPoints(3, border, sqsize/2, sqsize/2, border, sqsize - border, sqsize/2); break; case PE_IndicatorArrowDown: a.setPoints(3, border, sqsize/2, sqsize/2, sqsize - border, sqsize - border, sqsize/2); break; case PE_IndicatorArrowRight: a.setPoints(3, sqsize - border, sqsize/2, sqsize/2, border, sqsize/2, sqsize - border); break; case PE_IndicatorArrowLeft: a.setPoints(3, border, sqsize/2, sqsize/2, border, sqsize/2, sqsize - border); break; default: break; } int bsx = 0; int bsy = 0; if (option->state & State_Sunken) { bsx = pixelMetric(PM_ButtonShiftHorizontal); bsy = pixelMetric(PM_ButtonShiftVertical); } QRect bounds = a.boundingRect(); int sx = sqsize / 2 - bounds.center().x() - 1; int sy = sqsize / 2 - bounds.center().y() - 1; imagePainter.translate(sx + bsx, sy + bsy); if (!(option->state & State_Enabled)) { QColor foreGround(150, 150, 150, 150); imagePainter.setBrush(option->palette.mid().color()); imagePainter.setPen(option->palette.mid().color()); } else { QColor shadow(0, 0, 0, 100); imagePainter.translate(0, 1); imagePainter.setPen(shadow); imagePainter.setBrush(shadow); QColor foreGround(255, 255, 255, 210); imagePainter.drawPolygon(a); imagePainter.translate(0, -1); imagePainter.setPen(foreGround); imagePainter.setBrush(foreGround); } imagePainter.drawPolygon(a); imagePainter.end(); pixmap = QPixmap::fromImage(image); QPixmapCache::insert(pixmapName, pixmap); } int xOffset = r.x() + (r.width() - size)/2; int yOffset = r.y() + (r.height() - size)/2; painter->drawPixmap(xOffset, yOffset, pixmap); } break; default: d->style->drawPrimitive(element, option, painter, widget); break; } }
void Shape2DRectangle::addToPath(QPainterPath& path) const { path.addRect(m_boundingRect.toQRectF()); }
//! [2] QPainterPath Mouse::shape() const { QPainterPath path; path.addRect(-10, -20, 20, 40); return path; }
QPainterPath NodeItem::shape() const { QPainterPath path; path.addRect(boundingRect()); return path; }
bool HoverPoints::eventFilter(QObject *object, QEvent *event) { if (object == m_widget && m_enabled) { switch (event->type()) { case QEvent::MouseButtonPress: { if (!m_fingerPointMapping.isEmpty()) return true; QMouseEvent *me = (QMouseEvent *) event; QPointF clickPos = me->pos(); int index = -1; for (int i=0; i<m_points.size(); ++i) { QPainterPath path; if (m_shape == CircleShape) path.addEllipse(pointBoundingRect(i)); else path.addRect(pointBoundingRect(i)); if (path.contains(clickPos)) { index = i; break; } } if (me->button() == Qt::LeftButton) { if (index == -1) { if (!m_editable) return false; int pos = 0; // Insert sort for x or y if (m_sortType == XSort) { for (int i=0; i<m_points.size(); ++i) if (m_points.at(i).x() > clickPos.x()) { pos = i; break; } } else if (m_sortType == YSort) { for (int i=0; i<m_points.size(); ++i) if (m_points.at(i).y() > clickPos.y()) { pos = i; break; } } m_points.insert(pos, clickPos); m_locks.insert(pos, 0); m_currentIndex = pos; firePointChange(); } else { m_currentIndex = index; } return true; } else if (me->button() == Qt::RightButton) { if (index >= 0 && m_editable) { if ((m_points.size() - 1) < m_minCountPoints) return true; if (m_locks[index] == 0) { m_locks.remove(index); m_points.remove(index); } firePointChange(); return true; } } } break; case QEvent::MouseButtonRelease: if (!m_fingerPointMapping.isEmpty()) return true; m_currentIndex = -1; break; case QEvent::MouseMove: if (!m_fingerPointMapping.isEmpty()) return true; if (m_currentIndex >= 0) movePoint(m_currentIndex, ((QMouseEvent *)event)->pos()); break; case QEvent::TouchBegin: case QEvent::TouchUpdate: { const QTouchEvent *const touchEvent = static_cast<const QTouchEvent*>(event); const QList<QTouchEvent::TouchPoint> points = touchEvent->touchPoints(); const qreal pointSize = qMax(m_pointSize.width(), m_pointSize.height()); Q_FOREACH (const QTouchEvent::TouchPoint &touchPoint, points) { const int id = touchPoint.id(); switch (touchPoint.state()) { case Qt::TouchPointPressed: { // find the point, move it QSet<int> activePoints = QSet<int>::fromList(m_fingerPointMapping.values()); int activePoint = -1; qreal distance = -1; const int pointsCount = m_points.size(); const int activePointCount = activePoints.size(); if (pointsCount == 2 && activePointCount == 1) { // only two points activePoint = activePoints.contains(0) ? 1 : 0; } else { for (int i=0; i<pointsCount; ++i) { if (activePoints.contains(i)) continue; qreal d = QLineF(touchPoint.pos(), m_points.at(i)).length(); if ((distance < 0 && d < 12 * pointSize) || d < distance) { distance = d; activePoint = i; } } } if (activePoint != -1) { m_fingerPointMapping.insert(touchPoint.id(), activePoint); movePoint(activePoint, touchPoint.pos()); } } break; case Qt::TouchPointReleased: { // move the point and release QHash<int,int>::iterator it = m_fingerPointMapping.find(id); movePoint(it.value(), touchPoint.pos()); m_fingerPointMapping.erase(it); } break; case Qt::TouchPointMoved: { // move the point const int pointIdx = m_fingerPointMapping.value(id, -1); if (pointIdx >= 0) // do we track this point? movePoint(pointIdx, touchPoint.pos()); } break; default: break; } } if (m_fingerPointMapping.isEmpty()) { event->ignore(); return false; } else { return true; } } break; case QEvent::TouchEnd: if (m_fingerPointMapping.isEmpty()) { event->ignore(); return false; } return true; break; case QEvent::Resize: { QResizeEvent *e = (QResizeEvent *) event; if (e->oldSize().width() == 0 || e->oldSize().height() == 0) break; qreal stretch_x = e->size().width() / qreal(e->oldSize().width()); qreal stretch_y = e->size().height() / qreal(e->oldSize().height()); for (int i=0; i<m_points.size(); ++i) { QPointF p = m_points[i]; movePoint(i, QPointF(p.x() * stretch_x, p.y() * stretch_y), false); } firePointChange(); break; } case QEvent::Paint: { QWidget *that_widget = m_widget; m_widget = 0; QApplication::sendEvent(object, event); m_widget = that_widget; paintPoints(); return true; } default: break; } } return false; }
QPainterPath Object::shape() const { QPainterPath path; path.addRect(-12, -12, 24, 24); return path; }
//virtual QVariant AbstractGroupItem::itemChange(GraphicsItemChange change, const QVariant &value) { if (change == ItemPositionChange && scene()) { // calculate new position. const int trackHeight = KdenliveSettings::trackheight(); QPointF start = sceneBoundingRect().topLeft(); QPointF newPos = value.toPointF(); //kDebug()<<"REAL:"<<start.x()<<", PROPOSED:"<<(int)(start.x() - pos().x() + newPos.x()); int xpos = projectScene()->getSnapPointForPos((int)(start.x() + newPos.x() - pos().x()), KdenliveSettings::snaptopoints()); xpos = qMax(xpos, 0); //kDebug()<<"GRP XPOS:"<<xpos<<", START:"<<start.x()<<",NEW:"<<newPos.x()<<"; SCENE:"<<scenePos().x()<<",POS:"<<pos().x(); newPos.setX((int)(pos().x() + xpos - (int) start.x())); //int startTrack = (start.y() + trackHeight / 2) / trackHeight; int realTrack = (start.y() + newPos.y() - pos().y()) / trackHeight; int proposedTrack = newPos.y() / trackHeight; int correctedTrack = qMin(realTrack, projectScene()->tracksCount() - (int)(boundingRect().height() + 5) / trackHeight); correctedTrack = qMax(correctedTrack, 0); proposedTrack += (correctedTrack - realTrack); // Check if top item is a clip or a transition int offset = 0; int topTrack = -1; QList<QGraphicsItem *> children = childItems(); for (int i = 0; i < children.count(); i++) { int currentTrack = (int)(children.at(i)->scenePos().y() / trackHeight); if (children.at(i)->type() == AVWIDGET) { if (topTrack == -1 || currentTrack <= topTrack) { offset = 0; topTrack = currentTrack; } } else if (children.at(i)->type() == TRANSITIONWIDGET) { if (topTrack == -1 || currentTrack < topTrack) { offset = (int)(trackHeight / 3 * 2 - 1); topTrack = currentTrack; } } } newPos.setY((int)((proposedTrack) * trackHeight) + offset); //if (newPos == start) return start; /*if (newPos.x() < 0) { // If group goes below 0, adjust position to 0 return QPointF(pos().x() - start.x(), pos().y()); }*/ QPainterPath shape = groupShape(newPos - pos()); QList<QGraphicsItem*> collindingItems = scene()->items(shape, Qt::IntersectsItemShape); for (int i = 0; i < children.count(); i++) { collindingItems.removeAll(children.at(i)); } if (collindingItems.isEmpty()) return newPos; else { bool forwardMove = xpos > start.x(); int offset = 0; for (int i = 0; i < collindingItems.count(); i++) { QGraphicsItem *collision = collindingItems.at(i); if (collision->type() == AVWIDGET) { // Collision //kDebug()<<"// COLLISION WIT:"<<collision->sceneBoundingRect(); if (newPos.y() != pos().y()) { // Track change results in collision, restore original position return pos(); } AbstractClipItem *item = static_cast <AbstractClipItem *>(collision); if (forwardMove) { // Moving forward, determine best pos QPainterPath clipPath; clipPath.addRect(item->sceneBoundingRect()); QPainterPath res = shape.intersected(clipPath); offset = qMax(offset, (int)(res.boundingRect().width() + 0.5)); } else { // Moving backward, determine best pos QPainterPath clipPath; clipPath.addRect(item->sceneBoundingRect()); QPainterPath res = shape.intersected(clipPath); offset = qMax(offset, (int)(res.boundingRect().width() + 0.5)); } } } if (offset > 0) { if (forwardMove) { newPos.setX(newPos.x() - offset); } else { newPos.setX(newPos.x() + offset); } // If there is still a collision after our position adjust, restore original pos collindingItems = scene()->items(groupShape(newPos - pos()), Qt::IntersectsItemShape); for (int i = 0; i < children.count(); i++) { collindingItems.removeAll(children.at(i)); } for (int i = 0; i < collindingItems.count(); i++) if (collindingItems.at(i)->type() == AVWIDGET) return pos(); } return newPos; } } return QGraphicsItemGroup::itemChange(change, value); }
QPainterPath BouncyLogo::shape() const { QPainterPath path; path.addRect(boundingRect()); return path; }
QPainterPath TBlock::shape() const { QPainterPath path; if (angle == 0) { path.addRect(x() + BLOCK_SIZE + 1, y() + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); path.addRect(x() + 1, y() + BLOCK_SIZE + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); path.addRect(x() + BLOCK_SIZE + 1, y() + BLOCK_SIZE + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); path.addRect(x() + (BLOCK_SIZE * 2) + 1, y() + BLOCK_SIZE + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); } else if (angle == 90) { path.addRect(x() + 1, y() + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); path.addRect(x() + 1, y() + BLOCK_SIZE + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); path.addRect(x() + 1, y() + (BLOCK_SIZE * 2) + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); path.addRect(x() + BLOCK_SIZE + 1, y() + BLOCK_SIZE + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); } else if (angle == 180) { path.addRect(x() + 1, y() + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); path.addRect(x() + BLOCK_SIZE + 1, y() + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); path.addRect(x() + (BLOCK_SIZE * 2) + 1, y() + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); path.addRect(x() + BLOCK_SIZE + 1, y() + BLOCK_SIZE + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); } else if (angle == 270) { path.addRect(x() + 1, y() + BLOCK_SIZE + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); path.addRect(x() + BLOCK_SIZE + 1, y() + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); path.addRect(x() + BLOCK_SIZE + 1, y() + BLOCK_SIZE + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); path.addRect(x() + BLOCK_SIZE + 1, y() + (BLOCK_SIZE * 2) + 1, BLOCK_SIZE - 1, BLOCK_SIZE - 1); } return path; }