void UBGraphicsCompass::paint(QPainter *painter, const QStyleOptionGraphicsItem *styleOption, QWidget *widget)
{
Q_UNUSED(styleOption);
Q_UNUSED(widget);
mAntiScaleRatio = 1 / (UBApplication::boardController->systemScaleFactor() * UBApplication::boardController->currentZoom());
QTransform antiScaleTransform;
antiScaleTransform.scale(mAntiScaleRatio, mAntiScaleRatio);
mCloseSvgItem->setTransform(antiScaleTransform);
mCloseSvgItem->setPos(
closeButtonRect().center().x() - mCloseSvgItem->boundingRect().width() * mAntiScaleRatio / 2,
closeButtonRect().center().y() - mCloseSvgItem->boundingRect().height() * mAntiScaleRatio / 2);
mResizeSvgItem->setTransform(antiScaleTransform);
mResizeSvgItem->setPos(
resizeButtonRect().center().x() - mResizeSvgItem->boundingRect().width() * mAntiScaleRatio / 2,
resizeButtonRect().center().y() - mResizeSvgItem->boundingRect().height() * mAntiScaleRatio / 2);
painter->setPen(drawColor());
painter->drawRoundedRect(hingeRect(), 4, 4);
painter->fillPath(hingeShape(), middleFillColor());
painter->fillPath(needleShape(), middleFillColor());
painter->drawPath(needleShape());
painter->fillPath(needleBaseShape(), middleFillColor());
painter->drawPath(needleBaseShape());
QLinearGradient needleArmLinearGradient(
QPointF(rect().left() + sNeedleLength + sNeedleBaseLength, rect().center().y()),
QPointF(hingeRect().left(), rect().center().y()));
needleArmLinearGradient.setColorAt(0, edgeFillColor());
needleArmLinearGradient.setColorAt(1, middleFillColor());
painter->fillPath(needleArmShape(), needleArmLinearGradient);
painter->drawPath(needleArmShape());
QRectF hingeGripRect(rect().center().x() - 16, rect().center().y() - 16, 32, 32);
painter->drawEllipse(hingeGripRect);
if (mShowButtons)
paintAngleDisplay(painter);
QLinearGradient pencilArmLinearGradient(
QPointF(hingeRect().right(), rect().center().y()),
QPointF(rect().right() - sPencilLength - sPencilBaseLength, rect().center().y()));
pencilArmLinearGradient.setColorAt(0, middleFillColor());
pencilArmLinearGradient.setColorAt(1, edgeFillColor());
painter->fillPath(pencilArmShape(), pencilArmLinearGradient);
painter->drawPath(pencilArmShape());
if (scene()->isDarkBackground())
painter->fillPath(pencilShape(), UBApplication::boardController->penColorOnDarkBackground());
else
painter->fillPath(pencilShape(), UBApplication::boardController->penColorOnLightBackground());
painter->fillPath(pencilBaseShape(), middleFillColor());
painter->drawPath(pencilBaseShape());
if (mResizing || mRotating || mDrawing || (mShowButtons && rect().width() > sDisplayRadiusOnPencilArmMinLength))
paintRadiusDisplay(painter);
}
void UBGraphicsProtractor::paintButtons(QPainter *painter)
{
Q_UNUSED(painter);
if (mShowButtons)
{
qreal antiSc = antiScale();
qreal scale = buttonSizeReference().width() / mCloseSvgItem->boundingRect().width();
mCloseSvgItem->setPos(closeButtonRect().topLeft() + rect().center());
mCloseSvgItem->resetTransform();
mCloseSvgItem->translate(-closeButtonRect().left(),-closeButtonRect().top());
mCloseSvgItem->rotate(-mStartAngle);
mCloseSvgItem->translate(closeButtonRect().left(), closeButtonRect().top());
mCloseSvgItem->scale(scale * antiSc, scale * antiSc);//this do not impact the bounding box of thr svg item...
mResetSvgItem->setPos(resetButtonRect().topLeft() + rect().center());
mResetSvgItem->resetTransform();
mResetSvgItem->translate(-resetButtonRect().left(), -resetButtonRect().top());
mResetSvgItem->rotate(-mStartAngle);
mResetSvgItem->translate(resetButtonRect().left(), resetButtonRect().top());
mResetSvgItem->scale(scale * antiSc, scale * antiSc);//this do not impact the bounding box of thr svg item...
mResizeSvgItem->setPos(resizeButtonRect().topLeft() + rect().center());
mResizeSvgItem->resetTransform();
mResizeSvgItem->translate(-resizeButtonRect().left(), -resizeButtonRect().top());
mResizeSvgItem->rotate(-mStartAngle);
mResizeSvgItem->translate(resizeButtonRect().left(), resizeButtonRect().top());
mResizeSvgItem->scale(scale * antiSc, scale * antiSc);//this do not impact the bounding box of thr svg item...
mRotateSvgItem->setPos(rotateButtonRect().topLeft() + rect().center());
mRotateSvgItem->resetTransform();
mRotateSvgItem->translate(-rotateButtonRect().left(), -rotateButtonRect().top());
mRotateSvgItem->rotate(-mStartAngle);
mRotateSvgItem->translate(rotateButtonRect().left(), rotateButtonRect().top());
mRotateSvgItem->scale(scale, scale);//this do not impact the bounding box of thr svg item...
}
qreal scale = markerSizeReference().width()/mMarkerSvgItem->boundingRect().width();
mMarkerSvgItem->setPos(markerButtonRect().topLeft() + rect().center());
mMarkerSvgItem->resetTransform();
mMarkerSvgItem->translate(-markerButtonRect().left(), -markerButtonRect().top());
mMarkerSvgItem->rotate(- mStartAngle - mCurrentAngle);
mMarkerSvgItem->translate(markerButtonRect().left(), markerButtonRect().top());
mMarkerSvgItem->scale(scale, scale);//this do not impact the bounding box of thr svg item...
mCloseSvgItem->setVisible(mShowButtons);
mResetSvgItem->setVisible(mShowButtons);
mResizeSvgItem->setVisible(mShowButtons);
mRotateSvgItem->setVisible(mShowButtons);
mMarkerSvgItem->setVisible(true);
}
void UBGraphicsCompass::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
{
if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector &&
UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Play)
return;
mShowButtons = shape().contains(event->pos());
mCloseSvgItem->setVisible(mShowButtons);
mResizeSvgItem->setVisible(mShowButtons);
if (mShowButtons)
{
if (hingeRect().contains(event->pos()))
setCursor(rotateCursor());
else if (event->pos().x() > rect().right() - sPencilLength - sPencilBaseLength)
setCursor(drawCursor());
else if (resizeButtonRect().contains(event->pos()))
setCursor(resizeCursor());
else if (closeButtonRect().contains(event->pos()))
setCursor(closeCursor());
else
setCursor(moveCursor());
}
else
{
setCursor(mOuterCursor);
}
event->accept();
update();
}
bool QWaylandMaterialDecoration::handleTouch(QWaylandInputDevice *inputDevice, const QPointF &local,
const QPointF &global, Qt::TouchPointState state,
Qt::KeyboardModifiers mods)
{
Q_UNUSED(inputDevice);
Q_UNUSED(global);
Q_UNUSED(mods);
bool handled = state == Qt::TouchPointPressed;
if (handled) {
if (closeButtonRect().contains(local))
QWindowSystemInterface::handleCloseEvent(window());
else if (maximizeButtonRect().contains(local))
window()->setWindowState(waylandWindow()->isMaximized() ? Qt::WindowNoState
: Qt::WindowMaximized);
else if (minimizeButtonRect().contains(local))
window()->setWindowState(Qt::WindowMinimized);
else if (local.y() <= margins().top())
waylandWindow()->shellSurface()->move(inputDevice);
else
handled = false;
}
return handled;
}
void UBGraphicsRuler::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
if (mResizing)
{
mResizing = false;
event->accept();
}
else if (mRotating)
{
mRotating = false;
updateResizeCursor();
update(QRectF(rotationCenter(), QSizeF(sRotationRadius, sRotationRadius)));
event->accept();
}
else if (closeButtonRect().contains(event->pos()))
{
hide();
emit hidden();
event->accept();
}
else
{
QGraphicsItem::mouseReleaseEvent(event);
}
if (scene())
scene()->setModified(true);
}
UBGraphicsProtractor::Tool UBGraphicsProtractor::toolFromPos(QPointF pos)
{
pos = pos - rect().center();
QLineF line(QPointF(0,0), pos);
QTransform t;
t.rotate(mStartAngle);
QPointF p1 = t.map(pos);
t.rotate(mCurrentAngle);
QPointF p2 = t.map(pos);
if (resizeButtonRect().contains(p1))
return Resize;
else if (closeButtonRect().contains(p1))
return Close;
else if (resetButtonRect().contains(p1))
return Reset;
else if (rotateButtonRect().contains(p1))
return Rotate;
else if (markerButtonRect().contains(p2))
return MoveMarker;
else if (line.length() <= radius())
return Move;
else
return None;
}
bool QWaylandMaterialDecoration::handleMouse(QWaylandInputDevice *inputDevice, const QPointF &local,
const QPointF &global, Qt::MouseButtons b,
Qt::KeyboardModifiers mods)
{
Q_UNUSED(global);
// Figure out what area mouse is in
if (closeButtonRect().contains(local)) {
if (clickButton(b, Close))
QWindowSystemInterface::handleCloseEvent(window());
} else if (maximizeButtonRect().contains(local)) {
if (clickButton(b, Maximize))
window()->setWindowState(waylandWindow()->isMaximized() ? Qt::WindowNoState
: Qt::WindowMaximized);
} else if (minimizeButtonRect().contains(local)) {
if (clickButton(b, Minimize))
window()->setWindowState(Qt::WindowMinimized);
} else if (local.y() <= margins().top()) {
processMouseTop(inputDevice, local, b, mods);
} else if (local.y() > window()->height() - margins().bottom() + margins().top()) {
processMouseBottom(inputDevice, local, b, mods);
} else if (local.x() <= margins().left()) {
processMouseLeft(inputDevice, local, b, mods);
} else if (local.x() > window()->width() - margins().right() + margins().left()) {
processMouseRight(inputDevice, local, b, mods);
} else {
waylandWindow()->restoreMouseCursor(inputDevice);
setMouseButtons(b);
return false;
}
setMouseButtons(b);
return true;
}
void UBGraphicsTriangle::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
{
UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController ()->stylusTool ();
if (currentTool == UBStylusTool::Selector ||
currentTool == UBStylusTool::Play)
{
mCloseSvgItem->setVisible(mShowButtons);
mVFlipSvgItem->setVisible(mShowButtons);
mHFlipSvgItem->setVisible(mShowButtons);
mRotateSvgItem->setVisible(mShowButtons);
if (resize1Polygon().containsPoint(event->pos().toPoint(), Qt::OddEvenFill))
setCursor(resizeCursor1());
else if (resize2Polygon().containsPoint(event->pos().toPoint(), Qt::OddEvenFill))
setCursor(resizeCursor2());
else if (closeButtonRect().contains(event->pos()))
setCursor(closeCursor());
else if (hFlipRect().contains(event->pos())
|| vFlipRect().contains(event->pos()))
setCursor(flipCursor());
else if (rotateRect().contains(event->pos()))
setCursor(rotateCursor());
else
setCursor(moveCursor());
event->accept();
} else if (UBDrawingController::drawingController()->isDrawingTool()) {
event->accept();
}
}
void Window::mousePressed(gcn::MouseEvent &event)
{
// Let Guichan move window to top and figure out title bar drag
gcn::Window::mousePressed(event);
if (event.getButton() == gcn::MouseEvent::LEFT)
{
const int x = event.getX();
const int y = event.getY();
// Handle close button
if (mCloseButton)
{
gcn::Rectangle closeButtonRect(
getWidth() - mSkin->getCloseImage()->getWidth() - getPadding(),
getPadding(),
mSkin->getCloseImage()->getWidth(),
mSkin->getCloseImage()->getHeight());
if (closeButtonRect.isPointInRect(x, y))
close();
}
// Handle window resizing
mouseResize = getResizeHandles(event);
}
}
void UBGraphicsRuler::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
{
UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController ()->stylusTool ();
if (currentTool == UBStylusTool::Selector)
{
mCloseSvgItem->setVisible(mShowButtons);
mResizeSvgItem->setVisible(mShowButtons);
mRotateSvgItem->setVisible(mShowButtons);
if (resizeButtonRect().contains(event->pos()))
setCursor(resizeCursor());
else if (closeButtonRect().contains(event->pos()))
setCursor(closeCursor());
else if (rotateButtonRect().contains(event->pos()))
setCursor(rotateCursor());
else
setCursor(moveCursor());
event->accept();
}
else if (UBDrawingController::drawingController()->isDrawingTool())
{
event->accept();
}
}
QPainterPath UBGraphicsProtractor::shape() const
{
QPainterPath path = QGraphicsEllipseItem::shape();
QPainterPath buttonPath;
QRectF markerRect = markerButtonRect();
QPointF center = rect().center();
qreal centerX = center.x();
qreal centerY = center.y();
buttonPath.addRect(resizeButtonRect().adjusted(centerX, centerY, centerX, centerY));
if (!resizeButtonRect().contains(markerRect))
{
buttonPath.addRect(markerRect.adjusted(centerX - markerRect.left() * 2 - markerRect.width(), centerY
, centerX - markerRect.left() * 2 - markerRect.width(), centerY));
buttonPath.addRect(markerRect.adjusted(centerX, centerY, centerX, centerY));
}
buttonPath.addRect(closeButtonRect().adjusted(centerX, centerY, centerX, centerY));
buttonPath.addRect(resetButtonRect().adjusted(centerX, centerY, centerX, centerY));
QTransform t;
t.translate(centerX, centerY);
t.rotate(-mStartAngle);
t.translate(-centerX, -centerY);
buttonPath = t.map(buttonPath);
buttonPath = buttonPath.subtracted(path);
path.addPath(buttonPath);
return path;
}
void UBAbstractDrawRuler::paint()
{
mAntiScaleRatio = 1 / (UBApplication::boardController->systemScaleFactor() * UBApplication::boardController->currentZoom());
QTransform antiScaleTransform;
antiScaleTransform.scale(mAntiScaleRatio, mAntiScaleRatio);
mCloseSvgItem->setTransform(antiScaleTransform);
mCloseSvgItem->setPos(closeButtonRect().topLeft());
}
void RecSkinPushButton::resizeEvent(QResizeEvent *)
{
QSize closeButtonSize = m_closeButton->iconSize();
QRect closeButtonRect(rect().width()-closeButtonSize.width(),
0,
closeButtonSize.width(),
closeButtonSize.height());
m_closeButton->setGeometry(closeButtonRect);
m_closeButton->updateGeometry();
}
void Windowiki::mousePressed(gcn::MouseEvent &event)
{
// Let Guichan move window to top and figure out title bar drag
gcn::Window::mousePressed(event);
const int x = event.getX();
const int y = event.getY();
mMouseResize = 0;
// Activate resizing handles as appropriate
if (event.getSource() == this && isResizable() &&
event.getButton() == gcn::MouseEvent::LEFT &&
!getChildrenArea().isPointInRect(x, y))
{
mMouseResize |= (x > getWidth() - resizeBorderWidthiki) ? RIGHT :
(x < resizeBorderWidthiki) ? LEFT : 0;
mMouseResize |= (y > getHeight() - resizeBorderWidthiki) ? BOTTOM :
(y < resizeBorderWidthiki) ? TOP : 0;
}
else if (event.getSource() == mGrip)
{
mDragOffsetX = x + mGrip->getX();
mDragOffsetY = y + mGrip->getY();
mMouseResize |= BOTTOM | RIGHT;
mIsMoving = false;
}
if (event.getButton() == gcn::MouseEvent::LEFT)
{
const int x = event.getX();
const int y = event.getY();
// Handle close button
if (mCloseButton)
{
gcn::Rectangle closeButtonRect(
getWidth() - closeImage->getWidth() - getPadding(),
getPadding(),
closeImage->getWidth(),
closeImage->getHeight());
if (closeButtonRect.isPointInRect(x, y))
{
setVisible(false);
}
}
// Handle window resizing
}
}
void TPanelTitleBar::mouseMoveEvent(QMouseEvent *event) {
TDockWidget *dw = static_cast<TDockWidget *>(parentWidget());
if (dw->isFloating()) {
QPoint pos = event->pos();
QRect rect = this->rect();
QRect closeButtonRect(rect.right() - 18, rect.top() + 1, 18, 18);
if (closeButtonRect.contains(pos) && dw->isFloating())
m_closeButtonHighlighted = true;
else
m_closeButtonHighlighted = false;
}
update();
event->ignore();
}
QRect YaTabBarBase::tabTextRect(int index) const
{
QRect iconRect = this->tabIconRect(index);
QRect tabRect = this->tabRect(index);
QRect closeRect = closeButtonRect(index, tabRect);
QRect textRect(tabRect);
textRect.setHeight(cachedTextHeight_);
textRect.moveCenter(tabRect.center());
textRect.setLeft(iconRect.right() + margin());
if (closeRect.isNull())
textRect.setRight(textRect.right() - margin());
else
textRect.setRight(closeRect.left() - margin());
return textRect;
}
void TPanelTitleBar::mousePressEvent(QMouseEvent *event) {
TDockWidget *dw = static_cast<TDockWidget *>(parentWidget());
QPoint pos = event->pos();
if (dw->isFloating()) {
QRect rect = this->rect();
QRect closeButtonRect(rect.right() - 18, rect.top() + 1, 18, 18);
if (closeButtonRect.contains(pos) && dw->isFloating()) {
event->accept();
dw->hide();
m_closeButtonHighlighted = false;
emit closeButtonPressed();
return;
}
}
event->ignore();
}
QRectF UBGraphicsProtractor::boundingRect() const
{
QPointF center = rect().center();
qreal centerX = center.x();
qreal centerY = center.y();
QRectF bounds = resizeButtonRect().adjusted(centerX, centerY, centerX, centerY);
bounds = bounds.united(closeButtonRect().adjusted(centerX, centerY, centerX, centerY));
bounds = bounds.united(resetButtonRect().adjusted(centerX, centerY, centerX, centerY));
QTransform t;
t.translate(centerX, centerY);
t.rotate(-mStartAngle);
t.translate(-centerX, -centerY);
bounds = t.mapRect(bounds);
bounds = bounds.united(QGraphicsEllipseItem::boundingRect());
return bounds;
}
bool YaTabBarBase::event(QEvent* event)
{
if (event->type() == QEvent::ToolTip) {
QPoint pos = dynamic_cast<QHelpEvent *>(event)->globalPos();
QPoint localPos = dynamic_cast<QHelpEvent *>(event)->pos();
QString toolTip;
int tab = tabAt(localPos);
if (closeButtonRect(tab, tabRect(tab)).contains(localPos)) {
toolTip = tr("Close this tab");
}
else if (!tabTextFits(tab)) {
toolTip = tabText(tab);
}
PsiToolTip::showText(pos, toolTip, this);
return true;
}
return QTabBar::event(event);
}
void UBGraphicsCompass::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector &&
UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Play)
return;
if (mResizing)
{
event->accept();
}
else if (mRotating)
{
updateResizeCursor();
updateDrawCursor();
event->accept();
}
else if (mDrawing)
{
updateResizeCursor();
updateDrawCursor();
event->accept();
}
else if (closeButtonRect().contains(event->pos()))
{
hide();
emit hidden();
event->accept();
}
else
{
QGraphicsRectItem::mouseReleaseEvent(event);
}
mRotating = false;
mResizing = false;
mDrawing = false;
if (scene())
scene()->setModified(true);
}
CMessageBox::CMessageBox(const std::string& Text, bool lower, bool keymsg, bool leftbound, const FXState fx) :
CGUIDialog(GsRect<float>(0.1f, 0.1f, 0.8f, 0.8f), fx),
m_mustclose(false)
{
const char closeChar = 0x1F;
std::string closeString;
closeString = closeChar;
GsRect<float> closeButtonRect(0.0f, 0.0f, (0.06f)/0.8f, (0.06f)/0.8f);
GsRect<float> facRect( gVideoDriver.getGameResFactors() );
closeButtonRect.transformInverse(facRect);
mpTextCtrl = new CGUIText( Text );
// Those formulas work well with our constellation but I don't think they are perfect.
// They transform the Message Box the way the text fits perfectly in.
const float screenW = gVideoDriver.getGameResolution().w;
const float screenH = gVideoDriver.getGameResolution().h;
mRect.w = static_cast<float>( (mpTextCtrl->mTextDim.w+4)*8 )/screenW;
mRect.h = static_cast<float>( (mpTextCtrl->mTextDim.h+2)*8 )/screenH;
mRect.x = (1.0f - mRect.w)/2.0f;
mRect.y = (1.0f - mRect.h)/2.0f;
// now let's center that long text...
GsRect<float> TextRect;
TextRect.w = ((mpTextCtrl->mTextDim.w*8)/screenW) / mRect.w;
TextRect.h = ((mpTextCtrl->mTextDim.h*8)/screenH) / mRect.h;
TextRect.x = (2.5f*TextRect.w)/(static_cast<float>(mpTextCtrl->mTextDim.w));
TextRect.y = (1.0f*TextRect.h)/(static_cast<float>(mpTextCtrl->mTextDim.h));
if(lower) // if lower is enabled, try to snap the Dlg to the bottom off the screen.
{
mRect.y = 1.0f - mRect.h;
}
addControl( mpTextCtrl, TextRect );
updateBackground();
}
void UBGraphicsRuler::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
{
UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController ()->stylusTool ();
if (currentTool == UBStylusTool::Selector ||
currentTool == UBStylusTool::Play)
{
mCloseSvgItem->setParentItem(this);
mResizeSvgItem->setParentItem(this);
mRotateSvgItem->setParentItem(this);
mShowButtons = true;
mCloseSvgItem->setVisible(mShowButtons);
mResizeSvgItem->setVisible(mShowButtons);
mRotateSvgItem->setVisible(mShowButtons);
if (event->pos().x() >= resizeButtonRect().left())
{
setCursor(resizeCursor());
}
else
{
if (closeButtonRect().contains(event->pos()))
setCursor(closeCursor());
else if (rotateButtonRect().contains(event->pos()))
setCursor(rotateCursor());
else
setCursor(moveCursor());
}
event->accept();
update();
}
else if (UBDrawingController::drawingController()->isDrawingTool())
{
setCursor(drawRulerLineCursor());
UBDrawingController::drawingController()->mActiveRuler = this;
event->accept();
}
}
void UBGraphicsCompass::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector &&
UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Play)
return;
bool closing = false;
if (resizeButtonRect().contains(event->pos()))
{
mResizing = true;
mRotating = false;
event->accept();
}
else if (hingeRect().contains(event->pos()))
{
mRotating = true;
mResizing = false;
event->accept();
}
else if (!closeButtonRect().contains(event->pos()))
{
mDrawing = event->pos().x() > rect().right() - sPencilLength - sPencilBaseLength;
if (mDrawing)
{
mSpanAngleInDegrees = 0;
mSceneArcStartPoint = mapToScene(pencilPosition());
scene()->initStroke();
scene()->moveTo(mSceneArcStartPoint);
}
QGraphicsRectItem::mousePressEvent(event);
}
else
closing = true;
mResizeSvgItem->setVisible(mShowButtons && mResizing);
mCloseSvgItem->setVisible(mShowButtons && closing);
}
void QWaylandMaterialDecoration::paint(QPaintDevice *device)
{
QRect surfaceRect(QPoint(), window()->frameGeometry().size());
QRect top(QPoint(), QSize(window()->frameGeometry().width(), margins().top()));
QPainter p(device);
p.setRenderHint(QPainter::Antialiasing);
// Title bar
int radius = waylandWindow()->isMaximized() ? 0 : dp(3);
QPainterPath roundedRect;
roundedRect.addRoundedRect(0, 0, window()->frameGeometry().width(), margins().top() * 1.5,
radius, radius);
p.fillPath(roundedRect.simplified(), m_backgroundColor);
// Window icon
QIcon icon = waylandWindow()->windowIcon();
if (!icon.isNull()) {
QPixmap pixmap = icon.pixmap(QSize(128, 128));
QPixmap scaled = pixmap.scaled(22, 22, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
QRectF iconRect(0, 0, 22, 22);
p.drawPixmap(iconRect.adjusted(margins().left() + BUTTON_SPACING, 4,
margins().left() + BUTTON_SPACING, 4),
scaled, iconRect);
}
// Window title
QString windowTitleText = window()->title();
if (!windowTitleText.isEmpty()) {
if (m_windowTitle.text() != windowTitleText) {
m_windowTitle.setText(windowTitleText);
m_windowTitle.prepare();
}
QRect titleBar = top;
titleBar.setLeft(margins().left() + BUTTON_SPACING +
(icon.isNull() ? 0 : 22 + BUTTON_SPACING));
titleBar.setRight(minimizeButtonRect().left() - BUTTON_SPACING);
p.save();
p.setClipRect(titleBar);
p.setPen(m_textColor);
QSizeF size = m_windowTitle.size();
int dx = (top.width() - size.width()) / 2;
int dy = (top.height() - size.height()) / 2;
QFont font = p.font();
font.setBold(true);
font.setFamily("Roboto");
p.setFont(font);
QPoint windowTitlePoint(top.topLeft().x() + dx, top.topLeft().y() + dy);
p.drawStaticText(windowTitlePoint, m_windowTitle);
p.restore();
}
p.save();
p.setPen(m_iconColor);
// Close button
QBitmap closeIcon = buttonIcon("window-close");
p.drawPixmap(closeButtonRect(), closeIcon, closeIcon.rect());
// Maximize button
QBitmap maximizeIcon =
buttonIcon(waylandWindow()->isMaximized() ? "window-restore" : "window-maximize");
p.drawPixmap(maximizeButtonRect(), maximizeIcon, maximizeIcon.rect());
// Minimize button
QBitmap minimizeIcon = buttonIcon("window-minimize");
p.drawPixmap(minimizeButtonRect(), minimizeIcon, minimizeIcon.rect());
p.restore();
}
void UBGraphicsTriangle::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
if (mResizing1 || mResizing2 || mRotating)
{
if (mRotating)
updateResizeCursor();
mResizing1 = false;
mResizing2 = false;
mRotating = false;
event->accept();
}
else if (closeButtonRect().contains(event->pos()))
{
hide();
emit hidden();
event->accept();
}
else if (hFlipRect().contains(event->pos()))
{
switch(mOrientation)
{
case BottomLeft:
setOrientation(BottomRight);
break;
case BottomRight:
setOrientation(BottomLeft);
break;
case TopLeft:
setOrientation(TopRight);
break;
case TopRight:
setOrientation(TopLeft);
break;
}
}
else if (vFlipRect().contains(event->pos()))
{
switch(mOrientation)
{
case BottomLeft:
setOrientation(TopLeft);
break;
case BottomRight:
setOrientation(TopRight);
break;
case TopLeft:
setOrientation(BottomLeft);
break;
case TopRight:
setOrientation(BottomRight);
break;
}
}
else
{
QGraphicsItem::mouseReleaseEvent(event);
}
mShowButtons = true;
update();
if (scene())
scene()->setModified(true);
}
void UBGraphicsTriangle::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
{
painter->setPen(Qt::NoPen);
QPolygonF polygon;
QLinearGradient gradient1(QPointF(A1.x(), 0), QPointF(A2.x(), 0));
gradient1.setColorAt(0, edgeFillColor());
gradient1.setColorAt(1, middleFillColor());
painter->setBrush(gradient1);
polygon << A1 << A2 << B2 << B1;
painter->drawPolygon(polygon);
polygon.clear();
QLinearGradient gradient2(QPointF(0, B1.y()), QPointF(0, B2.y()));
gradient2.setColorAt(0, edgeFillColor());
gradient2.setColorAt(1, middleFillColor());
painter->setBrush(gradient2);
polygon << B1 << B2 << C2 << C1;
painter->drawPolygon(polygon);
polygon.clear();
QLinearGradient gradient3(CC, C2);
gradient3.setColorAt(0, edgeFillColor());
gradient3.setColorAt(1, middleFillColor());
painter->setBrush(gradient3);
polygon << C1 << C2 << A2 << A1;
painter->drawPolygon(polygon);
polygon.clear();
painter->setBrush(Qt::NoBrush);
painter->setPen(drawColor());
polygon << A1 << B1 << C1;
painter->drawPolygon(polygon);
polygon.clear();
polygon << A2 << B2 << C2;
painter->drawPolygon(polygon);
paintGraduations(painter);
mAntiScaleRatio = 1 / (UBApplication::boardController->systemScaleFactor() * UBApplication::boardController->currentZoom());
QTransform antiScaleTransform;
antiScaleTransform.scale(mAntiScaleRatio, mAntiScaleRatio);
mCloseSvgItem->setTransform(antiScaleTransform);
mHFlipSvgItem->setTransform(antiScaleTransform);
mVFlipSvgItem->setTransform(antiScaleTransform);
mRotateSvgItem->setTransform(antiScaleTransform);
mCloseSvgItem->setPos(closeButtonRect().topLeft());
mHFlipSvgItem->setPos(hFlipRect().topLeft());
mVFlipSvgItem->setPos(vFlipRect().topLeft());
mRotateSvgItem->setPos(rotateRect().topLeft());
if (mShowButtons || mResizing1 || mResizing2)
{
painter->setBrush(QColor(0, 0, 0));
if (mShowButtons || mResizing1)
painter->drawPolygon(resize1Polygon());
if (mShowButtons || mResizing2)
painter->drawPolygon(resize2Polygon());
}
}
void QWaylandMaterialDecoration::paint(QPaintDevice *device)
{
const QRect frameGeometry = window()->frameGeometry();
QRect top(QPoint(WINDOW_BORDER, WINDOW_BORDER), QSize(frameGeometry.width(), margins().top()));
QPainter p(device);
p.setRenderHint(QPainter::Antialiasing);
// Title bar
int radius = waylandWindow()->isMaximized() ? 0 : dp(3);
QPainterPath roundedRect;
roundedRect.addRoundedRect(0, 0, frameGeometry.width(), margins().top() * 1.5,
radius, radius);
p.fillPath(roundedRect.simplified(), m_backgroundColor);
// Borders
QPainterPath borderPath;
borderPath.addRect(0, margins().top(), margins().left(), frameGeometry.height() - margins().top());
borderPath.addRect(0, frameGeometry.height() - margins().bottom(), frameGeometry.width(), margins().bottom());
borderPath.addRect(frameGeometry.width() - margins().right(), margins().top(), margins().right(), frameGeometry.height() - margins().bottom());
p.fillPath(borderPath, m_backgroundColor);
// Window title
QString windowTitleText = window()->title();
if (!windowTitleText.isEmpty()) {
if (m_windowTitle.text() != windowTitleText) {
m_windowTitle.setText(windowTitleText);
m_windowTitle.prepare();
}
QRect titleBar = top;
titleBar.setLeft(margins().left() + BUTTON_SPACING);
titleBar.setRight(minimizeButtonRect().left() - BUTTON_SPACING);
p.save();
p.setClipRect(titleBar);
p.setPen(m_textColor);
QSizeF size = m_windowTitle.size();
int dx = (top.width() - size.width()) / 2;
int dy = (top.height() - size.height()) / 2;
QFont font = p.font();
font.setBold(true);
font.setFamily("Roboto");
p.setFont(font);
QPoint windowTitlePoint(top.topLeft().x() + dx, top.topLeft().y() + dy);
p.drawStaticText(windowTitlePoint, m_windowTitle);
p.restore();
}
p.save();
p.setPen(m_iconColor);
// Close button
QBitmap closeIcon = buttonIcon("window-close");
p.drawPixmap(closeButtonRect(), closeIcon, closeIcon.rect());
// Maximize button
if (window()->flags() & Qt::WindowMaximizeButtonHint) {
QBitmap maximizeIcon =
buttonIcon(waylandWindow()->isMaximized() ? "window-restore" : "window-maximize");
p.drawPixmap(maximizeButtonRect(), maximizeIcon, maximizeIcon.rect());
}
// Minimize button
if (window()->flags() & Qt::WindowMinimizeButtonHint) {
QBitmap minimizeIcon = buttonIcon("window-minimize");
p.drawPixmap(minimizeButtonRect(), minimizeIcon, minimizeIcon.rect());
}
p.restore();
}
