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;
}
