// Forme englobante
QRectF Mur::boundingRect() const
{
QRectF boite;
switch(mur_)
{
case 0 :
boite.setRect(scene()->width() - 50, 50, 1, scene()->height() - 100);
break;
case 1 :
boite.setRect(50, scene()->height() - 50, scene()->width() - 100, 1);
break;
case 2 :
boite.setRect(50, 50, 1, scene()->height() - 100);
break;
case 3 :
boite.setRect(50, 50, scene()->width() - 100, 1);
break;
}
return boite;
}
void ZoomTool::scaleView(const QPointF ¢erPos)
{
QTransform transform;
transform.scale(m_currentScale, m_currentScale);
view()->setTransform(transform);
QPointF adjustedCenterPos = centerPos;
QSize rectSize(view()->rect().width() / m_currentScale,
view()->rect().height() / m_currentScale);
QRectF sceneRect;
if (qAbs(m_currentScale - 1.0f) < Constants::ZoomSnapDelta) {
adjustedCenterPos.rx() = rectSize.width() / 2;
adjustedCenterPos.ry() = rectSize.height() / 2;
}
if (m_currentScale < 1.0f) {
adjustedCenterPos.rx() = rectSize.width() / 2;
adjustedCenterPos.ry() = rectSize.height() / 2;
sceneRect.setRect(view()->rect().width() / 2 -rectSize.width() / 2,
view()->rect().height() / 2 -rectSize.height() / 2,
rectSize.width(),
rectSize.height());
} else {
sceneRect.setRect(adjustedCenterPos.x() - rectSize.width() / 2,
adjustedCenterPos.y() - rectSize.height() / 2,
rectSize.width(),
rectSize.height());
}
view()->setSceneRect(sceneRect);
}
/*!
\return Bounding rectangle of all samples.
For an empty series the rectangle is invalid.
*/
QRectF QwtPlotMultiBarChart::boundingRect() const
{
const size_t numSamples = dataSize();
if ( numSamples == 0 )
return QwtPlotSeriesItem::boundingRect();
const double baseLine = baseline();
QRectF rect;
if ( d_data->style != QwtPlotMultiBarChart::Stacked )
{
rect = QwtPlotSeriesItem::boundingRect();
if ( rect.height() >= 0 )
{
if ( rect.bottom() < baseLine )
rect.setBottom( baseLine );
if ( rect.top() > baseLine )
rect.setTop( baseLine );
}
}
else
{
double xMin, xMax, yMin, yMax;
xMin = xMax = 0.0;
yMin = yMax = baseLine;
const QwtSeriesData<QwtSetSample> *series = data();
for ( size_t i = 0; i < numSamples; i++ )
{
const QwtSetSample sample = series->sample( i );
if ( i == 0 )
{
xMin = xMax = sample.value;
}
else
{
xMin = qMin( xMin, sample.value );
xMax = qMax( xMax, sample.value );
}
const double y = baseLine + sample.added();
yMin = qMin( yMin, y );
yMax = qMax( yMax, y );
}
rect.setRect( xMin, yMin, xMax - xMin, yMax - yMin );
}
if ( orientation() == Qt::Horizontal )
rect.setRect( rect.y(), rect.x(), rect.height(), rect.width() );
return rect;
}
void SSlider::paintEvent(QPaintEvent*) {
// This whole function is suboptimal
QPainter painter(this);
painter.setRenderHints(QPainter::Antialiasing);
auto widthActual = ((width()-20-30)/maximum())*maximum();
mWidthActual = widthActual;
auto xActual = 10+(width()-20-widthActual)/2;
mXActual = xActual;
auto jump = widthActual/maximum();
mJump = jump;
auto xpos = (jump*value())+xActual;
cursor = new QRectF(xpos,0,mControlSize,mControlSize);
QRectF pilot(xActual,0, widthActual+mControlSize, mControlSize);
painter.setPen(QPen(QColor("#161616")));
painter.setBrush(QBrush(QColor("#240128")));
painter.drawRoundedRect(pilot, mHalfWidth,mHalfWidth);
QRectF highlight;
auto startX = mStart*mJump+mXActual;
if(xpos == startX) {
highlight.setRect(0,0,0,0);
} else if(xpos > startX) {
highlight.setRect(startX,0, xpos+mControlSize-startX, mControlSize);
} else {
highlight.setRect(xpos,0, startX-(xpos)+mControlSize, mControlSize);
}
painter.setBrush(QBrush(QColor("#6E047C")));
QLinearGradient gradient;
gradient.setStart(highlight.width() / 2, 0);
gradient.setFinalStop(highlight.width() / 2, highlight.height());
gradient.setColorAt(0, "#B64FC4");
gradient.setColorAt(1, "#6E047C");
painter.setBrush(QBrush(gradient));
painter.drawRoundedRect(highlight, mHalfWidth,mHalfWidth);
if(mGrabbed) {
painter.setBrush(QBrush(QColor("#D24CE3")));
} else {
painter.setBrush(QBrush(QColor("#8E06A0")));
}
painter.setPen(QPen(QColor("#52015B")));
painter.drawEllipse(*cursor);
painter.setPen(QPen(QColor("#B1B7E6")));
}
/*!
\brief Render the plot to a QSvgGenerator
If the generator has a view box, the plot will be rendered into it.
If it has no viewBox but a valid size the target coordinates
will be (0, 0, generator.width(), generator.height()). Otherwise
the target rectangle will be QRectF(0, 0, 800, 600);
\param plot Plot to be rendered
\param generator SVG generator
*/
void QwtPolarRenderer::renderTo(
QwtPolarPlot *plot, QSvgGenerator &generator ) const
{
QRectF rect = generator.viewBoxF();
if ( rect.isEmpty() )
rect.setRect( 0, 0, generator.width(), generator.height() );
if ( rect.isEmpty() )
rect.setRect( 0, 0, 800, 600 ); // something
QPainter p( &generator );
render( plot, &p, rect );
}
/*!
\return Bounding rectangle of all samples.
For an empty series the rectangle is invalid.
*/
QRectF QwtPlotIntervalCurve::boundingRect() const
{
QRectF rect = QwtPlotSeriesItem<QwtIntervalSample>::boundingRect();
if ( rect.isValid() && orientation() == Qt::Vertical )
rect.setRect( rect.y(), rect.x(), rect.height(), rect.width() );
return rect;
}
/*!
\return Bounding rectangle of all samples.
For an empty series the rectangle is invalid.
*/
QRectF QwtPlotTradingCurve::boundingRect() const
{
QRectF rect = QwtPlotSeriesItem::boundingRect();
if ( orientation() == Qt::Vertical )
rect.setRect( rect.y(), rect.x(), rect.height(), rect.width() );
return rect;
}
QRectF PositionCursor::bbox() const
{
QRectF r;
qreal h = _sv->score()->spatium() * 2;
switch(_type) {
case CursorType::LOOP_IN:
r.setRect(_rect.x(), _rect.y(), h, _rect.height());
break;
case CursorType::LOOP_OUT:
r.setRect(_rect.x() - h, _rect.y(), h, _rect.height());
break;
default:
r = _rect;
break;
}
return r.adjusted(-2, -2, 2, 2);
}
void QgsComposerUtils::relativeResizeRect( QRectF& rectToResize, const QRectF& boundsBefore, const QRectF& boundsAfter )
{
//linearly scale rectToResize relative to the scaling from boundsBefore to boundsAfter
double left = relativePosition( rectToResize.left(), boundsBefore.left(), boundsBefore.right(), boundsAfter.left(), boundsAfter.right() );
double right = relativePosition( rectToResize.right(), boundsBefore.left(), boundsBefore.right(), boundsAfter.left(), boundsAfter.right() );
double top = relativePosition( rectToResize.top(), boundsBefore.top(), boundsBefore.bottom(), boundsAfter.top(), boundsAfter.bottom() );
double bottom = relativePosition( rectToResize.bottom(), boundsBefore.top(), boundsBefore.bottom(), boundsAfter.top(), boundsAfter.bottom() );
rectToResize.setRect( left, top, right - left, bottom - top );
}
/***********************************************************************
*Funtion : Get the handle rect
*Return : QRectF handle rect.
*Parameter: handle id.
**********************************************************************/
QRectF SamDrawItemBase::getHandleRect(int iHandleID, QRectF &qrcBondingRect)
{
QRectF qrRect;
// get the center of the handle in logical coords
QPointF qpPoint = getHandle(iHandleID, qrcBondingRect);
/*Set the rect and normalize it*/
qrRect.setRect(qpPoint.rx()-SAMDRAW_TRACKER_POS_OFT, qpPoint.ry()-SAMDRAW_TRACKER_POS_OFT, SAMDRAW_TRACKER_SIZE, SAMDRAW_TRACKER_SIZE);
qrRect = qrRect.normalized();
return qrRect;
}
void KBBLevelConfigurationPreview::drawBackground(QPainter* painter, const QRectF&)
{
QRectF rectBackground;
// TODO: This is duplication of code from the class KBBScalableGraphicWidget. Try to fix this.
const qreal sW = scene()->width();
const qreal sH = scene()->height();
const qreal wW = width();
const qreal wH = height();
const qreal offset = (sH+sW)/100 ;
if (sH*wW > sW*wH) {
// The widget is larger than the scene
qreal w = wW*sH/wH;
rectBackground.setRect((sW-w)/2-offset, -offset, w + 2*offset, sH + 2*offset);
} else {
// The scene is larger than the widget (or as large)
qreal h = wH*sW/wW;
rectBackground.setRect(-offset, (sH-h)/2-offset, sW + 2*offset, h + 2*offset);
}
m_themeManager->svgRenderer()->render(painter, m_themeManager->elementId(KBBScalableGraphicWidget::background), rectBackground);
}
void GraphNode::paint(QPainter *painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
{
QPen pen(Qt::black, 2);
QBrush brush(Qt::red);
painter->setPen(pen);
painter->setBrush(brush);
painter->drawEllipse(rect());
painter->drawText(rect(), Qt::AlignCenter, label);
if (!subscript.isEmpty()) {
QRectF subRect;
subRect.setRect(cx - 1.65*r, cy + 1.15*r, 15, 15);
painter->drawText(subRect, Qt::AlignCenter, subscript);
scene()->update(subRect);
}
}
QRectF KPathShape::loadOdfViewbox(const KXmlElement & element) const
{
QRectF viewbox;
QString data = element.attributeNS(KOdfXmlNS::svg, "viewBox");
if (! data.isEmpty()) {
data.replace(',', ' ');
QStringList coordinates = data.simplified().split(' ', QString::SkipEmptyParts);
if (coordinates.count() == 4) {
viewbox.setRect(coordinates[0].toDouble(), coordinates[1].toDouble(),
coordinates[2].toDouble(), coordinates[3].toDouble());
}
}
return viewbox;
}
/*!
\return Bounding rectangle of all samples.
For an empty series the rectangle is invalid.
*/
QRectF QwtPlotBarChart::boundingRect() const
{
const size_t numSamples = dataSize();
if ( numSamples == 0 )
return QwtPlotSeriesItem::boundingRect();
const double baseLine = baseline();
QRectF rect = QwtPlotSeriesItem::boundingRect();
if ( rect.bottom() < baseLine )
rect.setBottom( baseLine );
if ( rect.top() > baseLine )
rect.setTop( baseLine );
if ( rect.isValid() && ( orientation() == Qt::Horizontal ) )
rect.setRect( rect.y(), rect.x(), rect.height(), rect.width() );
return rect;
}
void Note::mouseMoveEvent(QGraphicsSceneMouseEvent * event) {
if (m_spaceBarWasPressed) {
event->ignore();
return;
}
if (m_inResize) {
double minWidth = emptyMinWidth;
double minHeight = emptyMinHeight;
QSizeF gripSize = m_resizeGrip->boundingRect().size();
QSizeF minSize = m_graphicsTextItem->document()->size() + gripSize + gripSize;
if (minSize.height() > minHeight) minHeight = minSize.height();
QRectF rect = boundingRect();
rect.moveTopLeft(this->pos());
double oldX1 = rect.x();
double oldY1 = rect.y();
double newX = event->scenePos().x() + m_inResize->resizeOffset().x();
double newY = event->scenePos().y() + m_inResize->resizeOffset().y();
QRectF newR;
if (newX - oldX1 < minWidth) {
newX = oldX1 + minWidth;
}
if (newY - oldY1 < minHeight) {
newY = oldY1 + minHeight;
}
newR.setRect(0, 0, newX - oldX1, newY - oldY1);
prepareGeometryChange();
m_rect = newR;
positionGrip();
event->accept();
return;
}
ItemBase::mouseMoveEvent(event);
}
void ezQGridBarWidget::paintEvent(QPaintEvent* e)
{
if (!MapFromSceneFunc.IsValid())
{
QWidget::paintEvent(e);
return;
}
QPainter Painter(this);
QPainter* painter = &Painter;
painter->setRenderHint(QPainter::Antialiasing);
painter->setRenderHint(QPainter::TextAntialiasing);
painter->setRenderHint(QPainter::HighQualityAntialiasing);
QRect areaRect = rect();
// background
painter->fillRect(areaRect, palette().button());
painter->translate(0.5, 0.5);
// render fine grid stop lines
{
double fSceneMinX, fSceneMaxX;
ezWidgetUtils::ComputeGridExtentsX(m_viewportSceneRect, m_fFineGridStops, fSceneMinX, fSceneMaxX);
fSceneMinX = ezMath::Max(fSceneMinX, 0.0);
painter->setPen(palette().buttonText().color());
ezHybridArray<QLine, 100> lines;
// some overcompensation for the case that the GraphicsView displays a scrollbar at the side
for (double x = fSceneMinX; x <= fSceneMaxX + m_fTextGridStops; x += m_fFineGridStops)
{
const QPoint pos = MapFromSceneFunc(QPointF(x, 0));
QLine& l = lines.ExpandAndGetRef();
l.setLine(pos.x(), areaRect.bottom() - 3, pos.x(), areaRect.bottom());
}
painter->drawLines(lines.GetData(), lines.GetCount());
}
// Grid Stop Value Text
{
double fSceneMinX, fSceneMaxX;
ezWidgetUtils::ComputeGridExtentsX(m_viewportSceneRect, m_fTextGridStops, fSceneMinX, fSceneMaxX);
fSceneMinX = ezMath::Max(fSceneMinX, 0.0);
QTextOption textOpt(Qt::AlignCenter);
QRectF textRect;
painter->setPen(palette().buttonText().color());
ezStringBuilder tmp;
for (double x = fSceneMinX; x <= fSceneMaxX; x += m_fTextGridStops)
{
const QPoint pos = MapFromSceneFunc(QPointF(x, 0));
textRect.setRect(pos.x() - 50, areaRect.top(), 99, areaRect.height());
tmp.Format("{0}", ezArgF(x));
painter->drawText(textRect, tmp.GetData(), textOpt);
}
}
}
QRectF KColorTable::hueLightRect()
{
QRectF drawRt = rect();
drawRt.setRect(0, 0, width(), height() - HEIGHT_SATUATION - DISTANCE_HLS);
return drawRt;
}
QRectF KColorTable::satuationRect()
{
QRectF drawRt = rect();
drawRt.setRect(0, height() - HEIGHT_SATUATION, width(), HEIGHT_SATUATION);
return drawRt;
}
QString Pad::makeLayerSvg(ViewLayer::ViewLayerID viewLayerID, double mmW, double mmH, double milsW, double milsH)
{
Q_UNUSED(milsW);
Q_UNUSED(milsH);
switch (viewLayerID) {
case ViewLayer::Copper0:
case ViewLayer::Copper1:
break;
default:
return "";
}
double wpx = mmW > 0 ? GraphicsUtils::mm2pixels(mmW) : OriginalWidth;
double hpx = mmH > 0 ? GraphicsUtils::mm2pixels(mmH) : OriginalHeight;
QString connectAt = m_modelPart->localProp("connect").toString();
QRectF terminal;
double minW = qMin((double) 1.0, wpx / 3);
double minH = qMin((double) 1.0, hpx / 3);
if (connectAt.compare("center", Qt::CaseInsensitive) == 0) {
terminal.setRect(2, 2, wpx, hpx);
}
else if (connectAt.compare("north", Qt::CaseInsensitive) == 0) {
terminal.setRect(2, 2, wpx, minH);
}
else if (connectAt.compare("south", Qt::CaseInsensitive) == 0) {
terminal.setRect(2, 2 + hpx - minH, wpx, minH);
}
else if (connectAt.compare("east", Qt::CaseInsensitive) == 0) {
terminal.setRect(2 + wpx - minW, 2, minW, hpx);
}
else if (connectAt.compare("west", Qt::CaseInsensitive) == 0) {
terminal.setRect(2, 2, minW, hpx);
}
QString blockerColor = (viewLayerID == ViewLayer::Copper0) ? "#A26A00" : "#aF8B33";
QString copperColor = (viewLayerID == ViewLayer::Copper0) ? ViewLayer::Copper0Color : ViewLayer::Copper1Color;
QString svg = QString("<svg version='1.1' xmlns='http://www.w3.org/2000/svg' x='0px' y='0px' width='%1px' height='%2px' viewBox='0 0 %1 %2'>\n"
"<g id='%5'>\n"
"<rect id='%8pad' x='2' y='2' fill='%6' fill-opacity='%7' stroke='%9' stroke-width='%10' width='%3' height='%4'/>\n"
)
.arg(wpx + TheOffset)
.arg(hpx + TheOffset)
.arg(wpx)
.arg(hpx)
.arg(ViewLayer::viewLayerXmlNameFromID(viewLayerID))
.arg(copperBlocker() ? blockerColor : copperColor)
.arg(copperBlocker() ? 0.0 : 1.0)
.arg(copperBlocker() ? "zzz" : "connector0")
.arg(copperBlocker() ? blockerColor : "none")
.arg(copperBlocker() ? TheOffset : 0)
;
if (copperBlocker()) {
svg += QString("<line stroke='%5' stroke-width='1' x1='%1' y1='%2' x2='%3' y2='%4'/>\n")
.arg(0)
.arg(0)
.arg(wpx + TheOffset)
.arg(hpx + TheOffset)
.arg(blockerColor)
;
svg += QString("<line stroke='%5' stroke-width='1' x1='%1' y1='%2' x2='%3' y2='%4'/>\n")
.arg(wpx + TheOffset)
.arg(0)
.arg(0)
.arg(hpx + TheOffset)
.arg(blockerColor)
;
}
else {
svg += QString("<rect id='%12terminal' x='%1' y='%2' fill='none' stroke='none' stroke-width='0' width='%3' height='%4'/>\n")
.arg(terminal.left())
.arg(terminal.top())
.arg(terminal.width())
.arg(terminal.height())
;
}
svg += "</g>\n</svg>";
//DebugDialog::debug("pad svg: " + svg);
return svg;
}
void GLabel::paintEvent(QPaintEvent *e)
{
if (people == GLabel::She) {
QRectF rectangle(50.0, 10.0, this->width() - 20 - 40, this->height() - 20);
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setBrush(QBrush(QColor(255, 255, 255)));
painter.drawRoundedRect(rectangle, 10, 10);
QPointF points[3] = {
QPointF(40, 33),
QPointF(51, 29),
QPointF(50, 38),
};
QPen pen;
pen.setColor(QColor(255, 255, 255));
painter.setPen(pen);
painter.drawPolygon(points, 3);
QPen pen1;
pen1.setColor(Qt::black);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setPen(pen1);
painter.drawLine(points[0], points[1]);
painter.drawLine(points[0], points[2]);
}
else if(people == GLabel::Me)
{
QRectF rectangle;
// if (this->width() > 300) {
// rectangle.setRect(10.0, 10.0, 300, this->height() - 20);
// } else {
// rectangle.setRect(10.0, 10.0, this->width() - 20 - 40, this->height() - 20);
// }
rectangle.setRect(10.0, 10.0, this->width() - 20 - 40, this->height() - 20);
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setBrush(QBrush(QColor(0, 255, 0)));
painter.drawRoundedRect(rectangle, 10, 10);
QPointF points[3] = {
QPointF(this->width()-40, 33),
QPointF(this->width()-51, 28),
QPointF(this->width()-51, 38),
};
QPen pen;
pen.setColor(QColor(0, 255, 0));
painter.setPen(pen);
painter.drawPolygon(points, 3);
QPen pen1;
pen.setColor(Qt::black);
painter.setPen(pen1);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.drawLine(points[0], points[1]);
painter.drawLine(points[0], points[2]);
label_people->setGeometry(this->width() - 30, 18, 30, 30);
// if (this->width() > 300) {
// this->setGeometry(((QWidget*)this->parent())->width()- 15 - this->width(), this->y(), 360, (this->height()));
// } else {
// this->setGeometry(((QWidget*)this->parent())->width()- 15 - this->width(), this->y(), this->width(), (this->height()));
// }
this->setGeometry(((QWidget*)this->parent())->width()- 15 - this->width(), this->y(), this->width(), (this->height()));
}
}
void KUnitItem::slotMouseMove(QGraphicsSceneMouseEvent *event)
{
if (myMode == MouseMode_RESIZE)
{
QPointF curPoint(event->scenePos());
QPointF curPointItem = this->mapFromScene(curPoint);
bool flagx = lastPoint.x() > oppositePos.x();
bool flagx1 = curPointItem.x() > oppositePos.x();
bool flagy = lastPoint.y() > oppositePos.y();
bool flagy1 = curPointItem.y() > oppositePos.y();
qreal dist = 0;
QRectF rectf;
rectf.setRect(m_frame.x()
, m_frame.y()
, m_frame.width()
, m_frame.height());
KResizeFocus::PosInHost pos = curResizeFocus->getInHost();
if (pos == KResizeFocus::NORTH_MIDDLE)
{
QPointF br = dashRect->rect().bottomRight();
dist = Util::GetPointDistLine(oppositePos,br,curPointItem);
if (dist < 20 || flagy != flagy1)
{
if (flagy)
{
curPointItem.setY(oppositePos.y() + 20);
}
else
{
curPointItem.setY(oppositePos.y() - 20);
}
dist = 20;
}
rectf.setY(curPointItem.y());
rectf.setHeight(dist);
}
else if(pos == KResizeFocus::SOUTH_MIDDLE)
{
QPointF br = dashRect->rect().topRight();
dist = Util::GetPointDistLine(oppositePos,br,curPointItem);
if (dist < 20 || flagy != flagy1)
{
if (flagy)
{
curPointItem.setY(oppositePos.y() + 20);
}
else
{
curPointItem.setY(oppositePos.y() - 20);
}
dist = 20;
}
rectf.setHeight(dist);
}
else if(pos == KResizeFocus::EAST_MIDDLE)
{
QPointF br = dashRect->rect().bottomLeft();
dist = Util::GetPointDistLine(oppositePos,br,curPointItem);
if (dist < 20 || flagx != flagx1)
{
if (flagx)
{
curPointItem.setX(oppositePos.x() + 20);
}
else
{
curPointItem.setX(oppositePos.x() - 20);
}
dist = 20;
}
rectf.setWidth(dist);
}
else if(pos == KResizeFocus::WEST_MIDDLE)
{
QPointF br = dashRect->rect().bottomRight();
dist = Util::GetPointDistLine(oppositePos,br,curPointItem);
if (dist < 20 || flagx != flagx1)
{
if (flagx)
{
curPointItem.setX(oppositePos.x() + 20);
}
else
{
curPointItem.setX(oppositePos.x() - 20);
}
dist = 20;
}
rectf.setX(curPointItem.x());
rectf.setWidth(dist);
}
else if(pos == KResizeFocus::NORTH_WEST)
{
QPointF topRight = dashRect->rect().topRight();
QPointF bottomLeft = dashRect->rect().bottomLeft();
qreal distx = Util::GetPointDistLine(oppositePos,topRight,curPointItem);
qreal disty = Util::GetPointDistLine(oppositePos,bottomLeft,curPointItem);
if (distx < 20 || flagx != flagx1)
{
if (flagx)
{
curPointItem.setX(oppositePos.x() + 20);
}
else
{
curPointItem.setX(oppositePos.x() - 20);
}
distx = 20;
}
if (disty < 20 || flagy != flagy1)
{
if (flagy)
{
curPointItem.setY(oppositePos.y() + 20);
}
else
{
curPointItem.setY(oppositePos.y() - 20);
}
disty = 20;
}
rectf.setTopLeft(curPointItem);
}
else if(pos == KResizeFocus::NORTH_EAST)
{
QPointF topLeft = dashRect->rect().topLeft();
QPointF bottomRight = dashRect->rect().bottomRight();
qreal distx = Util::GetPointDistLine(oppositePos,topLeft,curPointItem);
qreal disty = Util::GetPointDistLine(oppositePos,bottomRight,curPointItem);
if (distx < 20 || flagx != flagx1)
{
if (flagx)
{
curPointItem.setX(oppositePos.x() + 20);
}
else
{
curPointItem.setX(oppositePos.x() - 20);
}
distx = 20;
}
if (disty < 20 || flagy != flagy1)
{
if (flagy)
{
curPointItem.setY(oppositePos.y() + 20);
}
else
{
curPointItem.setY(oppositePos.y() - 20);
}
disty = 20;
}
rectf.setTopRight(curPointItem);
}
else if(pos == KResizeFocus::SOUTH_EAST)
{
QPointF topRight = dashRect->rect().topRight();
QPointF bottomLeft = dashRect->rect().bottomLeft();
qreal disty = Util::GetPointDistLine(oppositePos,topRight,curPointItem);
qreal distx = Util::GetPointDistLine(oppositePos,bottomLeft,curPointItem);
if (distx < 20 || flagx != flagx1)
{
if (flagx)
{
curPointItem.setX(oppositePos.x() + 20);
}
else
{
curPointItem.setX(oppositePos.x() - 20);
}
distx = 20;
}
if (disty < 20 || flagy != flagy1)
{
if (flagy)
{
curPointItem.setY(oppositePos.y() + 20);
}
else
{
curPointItem.setY(oppositePos.y() - 20);
}
disty = 20;
}
rectf.setBottomRight(curPointItem);
}
else if(pos == KResizeFocus::SOUTH_WEST)
{
QPointF topLeft = dashRect->rect().topLeft();
QPointF bottomRight = dashRect->rect().bottomRight();
qreal disty = Util::GetPointDistLine(oppositePos,topLeft,curPointItem);
qreal distx = Util::GetPointDistLine(oppositePos,bottomRight,curPointItem);
if (distx < 20 || flagx != flagx1)
{
if (flagx)
{
curPointItem.setX(oppositePos.x() + 20);
}
else
{
curPointItem.setX(oppositePos.x() - 20);
}
distx = 20;
}
if (disty < 20 || flagy != flagy1)
{
if (flagy)
{
curPointItem.setY(oppositePos.y() + 20);
}
else
{
curPointItem.setY(oppositePos.y() - 20);
}
disty = 20;
}
rectf.setBottomLeft(curPointItem);
}
dashRect->setRect(rectf);
}
else if(myMode == MouseMode_ROTATE)
{
QPointF curPos = event->scenePos();
QPointF cpos = this->mapToScene(frame().center());
// qDebug()<<cpos;
qreal angleLast = Util::ComputeAngle(mLastRotatePoint, cpos);
qreal angleCur = Util::ComputeAngle(curPos, cpos);
qreal angle = angleCur - angleLast;
setAngle(angle);
mLastRotatePoint = curPos;
onRotate();
}
else if(myMode == MouseMode_MOVE)
{
onMoving();
}
else
{
QGraphicsItem::mouseMoveEvent(event);
}
}
void QwtScaleWidget::drawTitle( QPainter *painter,
QwtScaleDraw::Alignment align, const QRectF &rect ) const
{
QRectF r = rect;
double angle;
int flags = d_data->title.renderFlags() &
~( Qt::AlignTop | Qt::AlignBottom | Qt::AlignVCenter );
switch ( align )
{
case QwtScaleDraw::LeftScale:
angle = -90.0;
flags |= Qt::AlignTop;
r.setRect( r.left(), r.bottom(),
r.height(), r.width() - d_data->titleOffset );
break;
case QwtScaleDraw::RightScale:
angle = -90.0;
flags |= Qt::AlignTop;
r.setRect( r.left() + d_data->titleOffset, r.bottom(),
r.height(), r.width() - d_data->titleOffset );
break;
case QwtScaleDraw::BottomScale:
angle = 0.0;
flags |= Qt::AlignBottom;
r.setTop( r.top() + d_data->titleOffset );
break;
case QwtScaleDraw::TopScale:
default:
angle = 0.0;
flags |= Qt::AlignTop;
r.setBottom( r.bottom() - d_data->titleOffset );
break;
}
if ( d_data->layoutFlags & TitleInverted )
{
if ( align == QwtScaleDraw::LeftScale
|| align == QwtScaleDraw::RightScale )
{
angle = -angle;
r.setRect( r.x() + r.height(), r.y() - r.width(),
r.width(), r.height() );
}
}
painter->save();
painter->setFont( font() );
painter->setPen( palette().color( QPalette::Text ) );
painter->translate( r.x(), r.y() );
if ( angle != 0.0 )
painter->rotate( angle );
QwtText title = d_data->title;
title.setRenderFlags( flags );
title.draw( painter, QRectF( 0.0, 0.0, r.width(), r.height() ) );
painter->restore();
}
void Widget::paintEvent(QPaintEvent *event)
{
Q_UNUSED(event);
QPainter painter(this);
QRectF rect;
QFont font("Arial");
QRectF rects;
painter.setRenderHint(QPainter::Antialiasing,true);
painter.setPen(ftColor[0]);
painter.setFont(font);
rects.setRect(300,0,100,50);
painter.setBrush(QBrush(bkColor[0],Qt::SolidPattern));
painter.drawText(rects, Qt::AlignCenter, "点击‘a’是菜单");
int i,j,key;
for( i = 0; i < 4; i++)
{
for(j = 0;j < 4;j++)
{
key = array[i][j];
if(key != 0 )
key = qLn(key) / qLn(2);
// draw backgroud
painter.setBrush(QBrush(bkColor[key],Qt::SolidPattern));
painter.setPen(QPen(bk,rectSize * 0.1));
rect.setRect(j * rectSize, i * rectSize, rectSize, rectSize);
painter.drawRoundedRect(rect,30,30);
// draw number
if( array[i][j] <= 0)
continue;
// choose a suitable font size
int digit = 0;
int a = array[i][j];
while(a)
{
a /= 10;
digit ++;
}
switch (digit) {
case 1:
case 2:
font.setPointSize(rectSize * 0.35);
break;
case 3:
font.setPointSize(rectSize * 0.3);
break;
case 4:
font.setPointSize(rectSize * 0.22);
break;
default:
font.setPointSize(rectSize * 0.18);
break;
}
painter.setPen(ftColor[key]);
painter.setFont(font);
painter.drawText(rect,Qt::AlignCenter,QString::number(array[i][j]));
}
}
}