void QDockWidgetPrivate::unplug(const QRect &rect) { Q_Q(QDockWidget); QRect r; if (!undockedGeometry.isNull()) { r = undockedGeometry; } else { r = rect; r.moveTopLeft(q->mapToGlobal(QPoint(0, 0))); QDockWidgetLayout *dwLayout = qobject_cast<QDockWidgetLayout*>(layout); if (dwLayout->nativeWindowDeco(true)) r.adjust(0, dwLayout->titleHeight(), 0, 0); } setWindowState(true, true, r); }
void BitmapImage::transform(QRect newBoundaries, bool smoothTransform) { mBounds = newBoundaries; newBoundaries.moveTopLeft(QPoint(0, 0)); QImage* newImage = new QImage(mBounds.size(), QImage::Format_ARGB32_Premultiplied); QPainter painter(newImage); painter.setRenderHint(QPainter::SmoothPixmapTransform, smoothTransform); painter.setCompositionMode(QPainter::CompositionMode_Source); painter.fillRect(newImage->rect(), QColor(0, 0, 0, 0)); painter.setCompositionMode(QPainter::CompositionMode_SourceOver); painter.drawImage(newBoundaries, *image()); painter.end(); mImage.reset(newImage); modification(); }
void KDEIntegrationTray::showNotes(bool active, const QPoint &pos) { Q_UNUSED(active) Menu menu; menu.addAction(actNew); menu.addSeparator(); QSettings s; QList<NoteListItem> notes = NoteManager::instance()->noteList( s.value("ui.menu-notes-amount", 15).toInt()); for (int i=0; i<notes.count(); i++) { menu.addAction(NoteManager::instance()->storage(notes[i].storageId)->noteIcon(), Utils::cuttedDots(notes[i].title, 48).replace('&', "&&") )->setData(i); } menu.show(); qtnote->activateWidget(&menu); QRect dr = QApplication::desktop()->availableGeometry(QCursor::pos()); QRect mr = menu.geometry(); mr.setSize(menu.sizeHint()); QPoint mp = pos - QPoint(mr.width() / 2, 0); if (pos.y() < dr.height()/2) { // icon at top-left mr.moveTopLeft(mp); } else { // icons at bottom-left mr.moveBottomLeft(mp); } // and now align to available desktop geometry if (mr.right() > dr.right()) { mr.moveRight(dr.right()); } if (mr.bottom() > dr.bottom()) { mr.moveBottom(dr.bottom()); } if (mr.left() < dr.left()) { mr.moveLeft(dr.left()); } if (mr.top() < dr.top()) { mr.moveTop(dr.top()); } QAction *act = menu.exec(mr.topLeft()); if (act && act != actNew) { NoteListItem ¬e = notes[act->data().toInt()]; emit showNoteTriggered(note.storageId, note.id); } }
bool QWSInputContext::translateIMQueryEvent(QWidget *w, const QWSIMQueryEvent *e) { Qt::InputMethodQuery type = static_cast<Qt::InputMethodQuery>(e->simpleData.property); QVariant result = w->inputMethodQuery(type); QWidget *tlw = w->window(); int winId = tlw->winId(); if ( type == Qt::ImMicroFocus ) { // translate to relative to tlw QRect mf = result.toRect(); mf.moveTopLeft(w->mapTo(tlw,mf.topLeft())); result = mf; } QPaintDevice::qwsDisplay()->sendIMResponse(winId, e->simpleData.property, result); return false; }
void CompositorHelper::handleLeaveEvent() { if (shouldCaptureMouse()) { //QWidget* mainWidget = (QWidget*)qApp->getWindow(); static auto renderingWidget = PluginContainer::getInstance().getPrimaryWidget(); static QWidget* mainWidget = nullptr; if (mainWidget == nullptr) { mainWidget = renderingWidget->parentWidget(); } QRect mainWidgetFrame; { mainWidgetFrame = renderingWidget->geometry(); auto topLeft = mainWidgetFrame.topLeft(); auto topLeftScreen = renderingWidget->mapToGlobal(topLeft); mainWidgetFrame.moveTopLeft(topLeftScreen); } QRect uncoveredRect = mainWidgetFrame; foreach(QWidget* widget, QApplication::topLevelWidgets()) { if (widget->isWindow() && widget->isVisible() && widget != mainWidget) { QRect widgetFrame = widget->frameGeometry(); if (widgetFrame.intersects(uncoveredRect)) { QRect intersection = uncoveredRect & widgetFrame; if (intersection.top() > uncoveredRect.top()) { uncoveredRect.setBottom(intersection.top() - 1); } else if (intersection.bottom() < uncoveredRect.bottom()) { uncoveredRect.setTop(intersection.bottom() + 1); } if (intersection.left() > uncoveredRect.left()) { uncoveredRect.setRight(intersection.left() - 1); } else if (intersection.right() < uncoveredRect.right()) { uncoveredRect.setLeft(intersection.right() + 1); } } } } _ignoreMouseMove = true; auto sendToPos = uncoveredRect.center(); QCursor::setPos(sendToPos); _lastKnownRealMouse = sendToPos; } }
/*! \internal Returns the rectangle occupied by this button, depending on \a child. */ QRect QAccessibleToolButton::rect(int child) const { if (!toolButton()->isVisible()) return QRect(); if (!child) return QAccessibleButton::rect(child); QStyleOptionToolButton opt; opt.init(widget()); QRect subrect = widget()->style()->subControlRect(QStyle::CC_ToolButton, &opt, QStyle::SC_ToolButtonMenu, toolButton()); if (child == ButtonExecute) subrect = QRect(0, 0, subrect.x(), widget()->height()); QPoint ntl = widget()->mapToGlobal(subrect.topLeft()); subrect.moveTopLeft(ntl); return subrect; }
void BitmapImage::transform(QRect newBoundaries, bool smoothTransform) { //if (boundaries != newBoundaries) //{ mBounds = newBoundaries; newBoundaries.moveTopLeft( QPoint(0,0) ); QImage* newImage = new QImage( mBounds.size(), QImage::Format_ARGB32_Premultiplied); //newImage->fill(QColor(255,255,255).rgb()); QPainter painter(newImage); painter.setRenderHint(QPainter::SmoothPixmapTransform, smoothTransform); painter.setCompositionMode(QPainter::CompositionMode_Source); painter.fillRect( newImage->rect(), QColor(0,0,0,0) ); painter.setCompositionMode(QPainter::CompositionMode_SourceOver); painter.drawImage(newBoundaries, *mImage ); painter.end(); //if (image != NULL) delete image; mImage = newImage; //} }
void QSplitterPrivate::setGeo(QSplitterLayoutStruct *sls, int p, int s, bool allowCollapse) { Q_Q(QSplitter); QWidget *w = sls->widget; QRect r; QRect contents = q->contentsRect(); if (orient == Qt::Horizontal) { r.setRect(p, contents.y(), s, contents.height()); } else { r.setRect(contents.x(), p, contents.width(), s); } sls->rect = r; int minSize = pick(qSmartMinSize(w)); if (orient == Qt::Horizontal && q->isRightToLeft()) r.moveRight(contents.width() - r.left()); if (allowCollapse) sls->collapsed = s <= 0 && minSize > 0 && !w->isHidden(); // Hide the child widget, but without calling hide() so that // the splitter handle is still shown. if (sls->collapsed) r.moveTopLeft(QPoint(-r.width()-1, -r.height()-1)); w->setGeometry(r); if (!sls->handle->isHidden()) { QSplitterHandle *h = sls->handle; QSize hs = h->sizeHint(); int left, top, right, bottom; h->getContentsMargins(&left, &top, &right, &bottom); if (orient==Qt::Horizontal) { if (q->isRightToLeft()) p = contents.width() - p + hs.width(); h->setGeometry(p-hs.width() - left, contents.y(), hs.width() + left + right, contents.height()); } else { h->setGeometry(contents.x(), p-hs.height() - top, contents.width(), hs.height() + top + bottom); } } }
QRect AnimationEffect::clipRect(const QRect &geo, const AniData &anim) const { QRect clip = geo; FPx2 ratio = anim.from + progress(anim) * (anim.to - anim.from); if (anim.from[0] < 1.0 || anim.to[0] < 1.0) { clip.setWidth(clip.width() * ratio[0]); } if (anim.from[1] < 1.0 || anim.to[1] < 1.0) { clip.setHeight(clip.height() * ratio[1]); } const QRect center = geo.adjusted(clip.width()/2, clip.height()/2, -(clip.width()+1)/2, -(clip.height()+1)/2 ); const int x[2] = { xCoord(center, metaData(SourceAnchor, anim.meta)), xCoord(center, metaData(TargetAnchor, anim.meta)) }; const int y[2] = { yCoord(center, metaData(SourceAnchor, anim.meta)), yCoord(center, metaData(TargetAnchor, anim.meta)) }; const QPoint d(x[0] + ratio[0]*(x[1]-x[0]), y[0] + ratio[1]*(y[1]-y[0])); clip.moveTopLeft(QPoint(d.x() - clip.width()/2, d.y() - clip.height()/2)); return clip; }
//----------------------------------------------------------------------------- //! //----------------------------------------------------------------------------- void tWindPlotPanel::ShowDataSources() { if( tProductSettings::Instance().FullSimnetAllowed() ) { QRect avoidRect = m_pWindPlotPanelWidget->rect(); QPoint pos = m_pWindPlotPanelWidget->mapToGlobal( QPoint( 0, 0 ) ); avoidRect.moveTopLeft( pos ); if( 0 == m_pNetworkSettingsMenuCommon ) { m_pNetworkSettingsMenuCommon = new tNetworkSettingsMenuCommon( this ); } m_pNetworkSettingsMenuCommon->ShowSimnetSources( pos, avoidRect ); } else { tDataSourcesPage::ShowDataSourcesPage( this ); } }
void LDesktop::UpdateDesktopPluginArea(){ QRegion visReg( bgWindow->geometry() ); //visible region (not hidden behind a panel) QRect rawRect = visReg.boundingRect(); //initial value (screen size) for(int i=0; i<PANELS.length(); i++){ QRegion shifted = visReg; QString loc = settings->value(PANELS[i]->prefix()+"location","top").toString().toLower(); int vis = PANELS[i]->visibleWidth(); if(loc=="top"){ if(!shifted.contains(QRect(rawRect.x(), rawRect.y(), rawRect.width(), vis))){ continue; } shifted.translate(0, (rawRect.top()+vis)-shifted.boundingRect().top() ); }else if(loc=="bottom"){ if(!shifted.contains(QRect(rawRect.x(), rawRect.bottom()-vis, rawRect.width(), vis))){ continue; } shifted.translate(0, (rawRect.bottom()-vis)-shifted.boundingRect().bottom()); }else if(loc=="left"){ if( !shifted.contains(QRect(rawRect.x(), rawRect.y(), vis,rawRect.height())) ){ continue; } shifted.translate((rawRect.left()+vis)-shifted.boundingRect().left() ,0); }else{ //right if(!shifted.contains(QRect(rawRect.right()-vis, rawRect.y(), vis,rawRect.height())) ){ continue; } shifted.translate((rawRect.right()-vis)-shifted.boundingRect().right(),0); } visReg = visReg.intersected( shifted ); } //Now make sure the desktop plugin area is only the visible area QRect rec = visReg.boundingRect(); //LSession::handle()->XCB->SetScreenWorkArea((unsigned int) desktopnumber, rec); //Now remove the X offset to place it on the current screen (needs widget-coords, not global) globalWorkRect = rec; //save this for later rec.moveTopLeft( QPoint( rec.x()-desktop->screenGeometry(desktopnumber).x() , rec.y() ) ); //qDebug() << "DPlug Area:" << rec.x() << rec.y() << rec.width() << rec.height(); if(rec == bgDesktop->geometry()){return; } //nothing changed bgDesktop->setGeometry( rec ); bgDesktop->setBackground( QBrush(Qt::NoBrush) ); bgDesktop->update(); //Re-paint the panels (just in case a plugin was underneath it and the panel is transparent) for(int i=0; i<PANELS.length(); i++){ PANELS[i]->update(); } //Also need to re-arrange any desktop plugins to ensure that nothing is out of the screen area AlignDesktopPlugins(); //Make sure to re-disable any WM control flags LSession::handle()->XCB->SetDisableWMActions(bgWindow->winId()); }
void Document::mouseMoveEvent(QMouseEvent *event) { event->accept(); if (m_mousePressIndex == -1) return; const Shape &shape = m_shapeList.at(m_mousePressIndex); QRect rect; if (m_resizeHandlePressed) { rect = QRect(shape.rect().topLeft(), event->pos() + m_mousePressOffset); } else { rect = shape.rect(); rect.moveTopLeft(event->pos() - m_mousePressOffset); } QSize size = rect.size().expandedTo(Shape::minSize); rect.setSize(size); m_undoStack->push(new SetShapeRectCommand(this, shape.name(), rect)); }
void QtDesignerChild::formGeometryChanged() { // set modified state bool loading = property( "loadingFile" ).toBool(); bool modified = !loading; // update property QDesignerPropertySheetExtension* sheet = qt_extension<QDesignerPropertySheetExtension*>( mDesignerManager->core()->extensionManager(), mHostWidget->formWindow() ); QRect geo = sheet->property( sheet->indexOf( "geometry" ) ).toRect(); geo.moveTopLeft( QPoint( 0, 0 ) ); delete sheet; mDesignerManager->core()->propertyEditor()->setPropertyValue( "geometry", geo, modified ); // update state mHostWidget->formWindow()->setDirty( modified ); setWindowModified( modified ); setProperty( "loadingFile", false ); // emit modified state emit modifiedChanged( modified ); emit contentChanged(); }
//----------------------------------------------------------------------------- //! Reimplemented //----------------------------------------------------------------------------- void tNASVirtualHead::contextMenuEvent( QContextMenuEvent* pEvent ) { // Restart inactivity timer. m_CloseOnUserInactivityTimer->start(); tMenu& menu = *new tMenu( this ); if( m_ShowButtons == true ) { menu.AddAction( m_pBackAct ); menu.AddAction( m_pRootAct ); } if ( m_pCloseAct != 0 ) { menu.AddAction( m_pCloseAct ); } QRect rect = contentsRect(); rect.moveTopLeft( mapToGlobal( QPoint( 0, 0 ) ) ); menu.SetAvoidRect( rect ); menu.ShowAndDeleteOnClose( mapToGlobal( pEvent->pos() ) ); }
void PopupMenu::show(const IntRect& r, FrameView* v, int index) { QWebPageClient* client = v->hostWindow()->platformPageClient(); populate(r); QRect rect = r; rect.moveTopLeft(v->contentsToWindow(r.topLeft())); rect.setHeight(m_popup->sizeHint().height()); if (QGraphicsView* view = qobject_cast<QGraphicsView*>(client->ownerWidget())) { if (!m_proxy) { m_proxy = new QGraphicsProxyWidget(qobject_cast<QGraphicsWebView*>(client->pluginParent())); m_proxy->setWidget(m_popup); } else m_proxy->setVisible(true); m_proxy->setGeometry(rect); } else { m_popup->setParent(client->ownerWidget()); m_popup->setGeometry(rect); } m_popup->setCurrentIndex(index); m_popup->exec(); }
int QDesktopWidget::screenNumber(const QWidget *widget) const { Q_D(const QDesktopWidget); if (!widget) return d->primaryScreen; QRect frame = widget->frameGeometry(); if (!widget->isWindow()) frame.moveTopLeft(widget->mapToGlobal(QPoint(0,0))); int maxSize = -1; int maxScreen = -1; for (int i = 0; i < d->screenCount; ++i) { QRect sect = d->rects->at(i).intersected(frame); int size = sect.width() * sect.height(); if (size > maxSize && sect.width() > 0 && sect.height() > 0) { maxSize = size; maxScreen = i; } } return maxScreen; }
void ConvertEffectsTest::addText_topLeftCorner() { QImage result(testImg); effects.setImage(&result); info.textPos = QPoint(0, 0); info.textUnitPair.first = Pixel; info.textUnitPair.second = Pixel; info.textFont.setFamily("DejaVu Sans"); info.textFont.setPointSize(20); info.textString = "test string"; info.textPosModifier = TopLeftCorner; info.textColor = Qt::green; info.textOpacity = 0.5; info.textRotation = 0; info.textFrame = false; effects.addText(); QImage expected(testImg); QPoint topLeftPoint(0, 0); QFontMetrics fontMetrics(info.textFont, &expected); QRect rect = fontMetrics.boundingRect(info.textString); const int dx = 5; const int dy = 1; rect.adjust(-dx, -dy, dx, dy); rect.moveTopLeft(topLeftPoint); QPainter p(&expected); p.setPen(info.textColor); p.setFont(info.textFont); p.setOpacity(info.textOpacity); p.drawText(rect, Qt::AlignCenter, info.textString); result.save(QDir::tempPath() + "/sir_test_addText_topLeftCorner_result.bmp"); expected.save(QDir::tempPath() + "/sir_test_addText_topLeftCorner_expected.bmp"); QCOMPARE(result, expected); }
void ImageLoader::run() { QString fn = m_url.toLocalFile(); int pos = fn.lastIndexOf('.'); QString ext; if (pos != -1) ext = fn.mid(pos).toUpper(); if (ext.isEmpty() || !QImageReader::supportedImageFormats().contains(ext.toLocal8Bit())) ext = QString(); QFile f(fn); if (!f.open(QIODevice::ReadOnly)) { qWarning("Could not read: %s", qPrintable(m_url.path())); return; } QByteArray bytes; while (!f.atEnd()) { QThread::yieldCurrentThread(); bytes.append(f.read(1024)); } QThread::yieldCurrentThread(); QImage im = ext.isEmpty() ? QImage::fromData(bytes) : QImage::fromData(bytes, qPrintable(ext)); if (im.isNull()) return; QString p = m_url.path(); p = p.section("/", -1); int max = qMax(im.width(), im.height()); QImage frm; if (max <= 64) frm = QImage(QSize(64, 64), QImage::Format_ARGB32); else if (max <= 128) frm = QImage(QSize(128, 128), QImage::Format_ARGB32); else if (max <= 256) frm = QImage(QSize(256, 256), QImage::Format_ARGB32); else if (max <= 512) frm = QImage(QSize(512, 512), QImage::Format_ARGB32); else frm = QImage(QSize(1024, 1024), QImage::Format_ARGB32); frm.fill(qRgba(0, 0, 0, 0)); QPainter ptr; ptr.begin(&frm); ptr.setBackgroundMode(Qt::TransparentMode); QRect r; if (max > 1024) { if (max == im.width()) { float h = float(1024) * float(im.height()) / float(im.width()); r.setSize(QSize(1024, h)); } else { float w = float(1024) * float(im.width()) / float(im.height()); r.setSize(QSize(w, 1024)); } } else { r.setSize(im.size()); } int left = (frm.width() - r.width()) / 2; int top = (frm.height() - r.height()) / 2; r.moveTopLeft(QPoint(left, top)); QThread::yieldCurrentThread(); ptr.drawImage(r, im); ptr.end(); emit imageLoaded(frm); }
void KDLToolTip::maybeTip (const QPoint& p) { if (!mParent->displayToolTips()) return; QString text; QRect rect; const QRect vert = mParent->verticalScrollBar()->geometry(); const QRect horiz = mParent->horizontalScrollBar()->geometry(); if (vert.contains(p)) { rect = vert; if (!mParent->commonToolTips()) text = mParent->verticalScrollBarTip(); else text = mParent->tooltip(); } else if (horiz.contains(p)) { rect = horiz; if (!mParent->commonToolTips()) text = mParent->horizontalScrollBarTip(); else text = mParent->tooltip(); } else { QPoint rp = mParent->viewport()->mapFromParent (p); QListViewItem* i = mParent->itemAt (rp); KSVItem* item = static_cast<KSVItem*> (i); rect = mParent->header()->geometry(); if (rect.contains (p)) { text = mParent->tooltip(); } else if (item) { rect = mParent->itemRect (i); rect.moveTopLeft (mParent->viewport()->mapToParent (rect.topLeft())); text = item->tooltip(); } else { rect = mParent->rect(); QListViewItem* last = mParent->lastItem(); if (last) rect.setTop (mParent->viewport()->mapToParent (mParent->itemRect(last).bottomRight()).y()); text = mParent->tooltip(); } } if (!text.isEmpty()) tip (rect, text); }
QRect MainWindow::panelGeometry() { QRect rect = m_mainPanel->geometry(); rect.moveTopLeft(m_mainPanel->mapToGlobal(QPoint(0,0))); return rect; }
void DeckButtonsLayout::setGeometry( const QRect& _r ) { QLayout::setGeometry( _r ); int left; int top; int right; int bottom; getContentsMargins( &left, &top, &right, &bottom ); const QRect r = _r.adjusted( left, top, right, bottom ); const QAbstractButton* button = backwardButton ? backwardButton : forwardButton; qreal factor = 1; if ( !button ) { if ( RoundButton ) { const int min = qMin( r.height(), r.width() ); QRect rect = QRect( QPoint(), QSize( min, min ) ); rect.moveCenter( r.center() ); RoundButton->setGeometry( rect ); } return; } else if ( backwardButton && forwardButton ) { factor = (qreal)r.width() /(qreal)( button->sizeHint().width() *2 ); } else if ( RoundButton ) { factor = (qreal)r.width() /(qreal)( button->sizeHint().width() +( RoundButton->sizeHint().width() /2 ) ); } else { factor = (qreal)r.width() /(qreal)( button->sizeHint().width() ); } if ( RoundButton ) { int height = (qreal)RoundButton->sizeHint().height() *factor; while ( height > r.height() ) { factor -= 0.1; height = (qreal)RoundButton->sizeHint().height() *factor; } QRect rect( QPoint(), QSize( height, height ) ); rect.moveCenter( r.center() ); if ( backwardButton && forwardButton ) { // nothing to do } else if ( backwardButton ) { rect.moveRight( r.right() ); } else if ( forwardButton ) { rect.moveLeft( r.left() ); } RoundButton->setGeometry( rect ); } else { int height = (qreal)button->sizeHint().height() *factor; while ( height > r.height() ) { factor -= 0.1; height = (qreal)button->sizeHint().height() *factor; } } const QSize bs = QSize( (qreal)button->sizeHint().width() *factor, (qreal)button->sizeHint().height() *factor ); if ( backwardButton ) { QRect gr = RoundButton ? QRect( QPoint(), RoundButton->size() ) : r; QRect rect = QRect( QPoint(), bs ); if ( RoundButton ) { gr.moveTopLeft( RoundButton->pos() ); } rect.moveCenter( gr.center() ); rect.moveRight( gr.center().x() +1 ); backwardButton->setGeometry( rect ); } if ( forwardButton ) { QRect gr = RoundButton ? QRect( QPoint(), RoundButton->size() ) : r; QRect rect = QRect( QPoint(), bs ); if ( RoundButton ) { gr.moveTopLeft( RoundButton->pos() ); } rect.moveCenter( gr.center() ); rect.moveLeft( gr.center().x() ); forwardButton->setGeometry( rect ); } if ( RoundButton ) { RoundButton->raise(); } }
void PluginItemDelegate::paint( QPainter *painter, const QStyleOptionViewItem& option, const QModelIndex& index ) const { Q_ASSERT( index.isValid() ); QRect rect = option.rect; QStyle *style = QApplication::style(); painter->save(); // Drawing the background QStyleOption background = option; style->drawPrimitive( QStyle::PE_PanelItemViewItem, &option, painter ); painter->translate( rect.topLeft() ); // rect is now represented in item coordinates rect.moveTopLeft( QPoint( 0, 0 ) ); // The point at the top left of the available drawing area. QPoint topLeft( 0, 0 ); // The point at the top right of the available drawing area. QPoint topRight( rect.topRight() ); QRect nameRect = rect; // Painting the checkbox QStyleOptionButton checkBox = checkboxOption( option, index, topLeft.x(), Qt::AlignLeft ); painter->save(); style->drawControl( QStyle::CE_CheckBox, &checkBox, painter ); painter->restore(); nameRect.setLeft( checkBox.rect.right() + 1 ); // Painting the About Button if ( index.data( RenderPlugin::AboutDialogAvailable ).toBool() ) { QStyleOptionButton button = buttonOption( option, index, PluginItemDelegate::About, topRight.x(), Qt::AlignRight ); style->drawControl( QStyle::CE_PushButton, &button, painter ); topRight -= QPoint( button.rect.width(), 0 ); } // Painting the Configure Button if ( index.data( RenderPlugin::ConfigurationDialogAvailable ).toBool() ) { QStyleOptionButton button = buttonOption( option, index, PluginItemDelegate::Configure, topRight.x(), Qt::AlignRight ); style->drawControl( QStyle::CE_PushButton, &button, painter ); topRight -= QPoint( button.rect.width(), 0 ); nameRect.setRight( button.rect.left() -1 ); } // Painting the Name string QString name = index.data( Qt::DisplayRole ).toString(); style->drawItemText( painter, nameRect, Qt::AlignLeft | Qt::AlignVCenter, option.palette, true, name ); painter->restore(); }
void EdgeWidget::move(const QPoint &position) { QRect newGeometry = geometry(); newGeometry.moveTopLeft(position); setPosition(newGeometry, true); }
void BaseWindowControl::posChanged(const QPoint &p) { QRect geom = objectGeometry(m_object); geom.moveTopLeft(p); setObjectGeometry(m_object, geom); }
void QWidgetResizeHandler::mouseMoveEvent(QMouseEvent *e) { QPoint pos = widget->mapFromGlobal(e->globalPos()); if (!moveResizeMode && !buttonDown) { if (pos.y() <= range && pos.x() <= range) mode = TopLeft; else if (pos.y() >= widget->height()-range && pos.x() >= widget->width()-range) mode = BottomRight; else if (pos.y() >= widget->height()-range && pos.x() <= range) mode = BottomLeft; else if (pos.y() <= range && pos.x() >= widget->width()-range) mode = TopRight; else if (pos.y() <= range) mode = Top; else if (pos.y() >= widget->height()-range) mode = Bottom; else if (pos.x() <= range) mode = Left; else if ( pos.x() >= widget->width()-range) mode = Right; else if (widget->rect().contains(pos)) mode = Center; else mode = Nowhere; if (widget->isMinimized() || !isActive(Resize)) mode = Center; #ifndef QT_NO_CURSOR setMouseCursor(mode); #endif return; } if (mode == Center && !movingEnabled) return; if (widget->testAttribute(Qt::WA_WState_ConfigPending)) return; QPoint globalPos = (!widget->isWindow() && widget->parentWidget()) ? widget->parentWidget()->mapFromGlobal(e->globalPos()) : e->globalPos(); if (!widget->isWindow() && !widget->parentWidget()->rect().contains(globalPos)) { if (globalPos.x() < 0) globalPos.rx() = 0; if (globalPos.y() < 0) globalPos.ry() = 0; if (sizeprotect && globalPos.x() > widget->parentWidget()->width()) globalPos.rx() = widget->parentWidget()->width(); if (sizeprotect && globalPos.y() > widget->parentWidget()->height()) globalPos.ry() = widget->parentWidget()->height(); } QPoint p = globalPos + invertedMoveOffset; QPoint pp = globalPos - moveOffset; // Workaround for window managers which refuse to move a tool window partially offscreen. if (QGuiApplication::platformName() == QLatin1String("xcb")) { const QRect desktop = QApplication::desktop()->availableGeometry(widget); pp.rx() = qMax(pp.x(), desktop.left()); pp.ry() = qMax(pp.y(), desktop.top()); p.rx() = qMin(p.x(), desktop.right()); p.ry() = qMin(p.y(), desktop.bottom()); } QSize ms = qSmartMinSize(childWidget); int mw = ms.width(); int mh = ms.height(); if (childWidget != widget) { mw += 2 * fw; mh += 2 * fw + extrahei; } QSize maxsize(childWidget->maximumSize()); if (childWidget != widget) maxsize += QSize(2 * fw, 2 * fw + extrahei); QSize mpsize(widget->geometry().right() - pp.x() + 1, widget->geometry().bottom() - pp.y() + 1); mpsize = mpsize.expandedTo(widget->minimumSize()).expandedTo(QSize(mw, mh)) .boundedTo(maxsize); QPoint mp(widget->geometry().right() - mpsize.width() + 1, widget->geometry().bottom() - mpsize.height() + 1); QRect geom = widget->geometry(); switch (mode) { case TopLeft: geom = QRect(mp, widget->geometry().bottomRight()) ; break; case BottomRight: geom = QRect(widget->geometry().topLeft(), p) ; break; case BottomLeft: geom = QRect(QPoint(mp.x(), widget->geometry().y()), QPoint(widget->geometry().right(), p.y())) ; break; case TopRight: geom = QRect(QPoint(widget->geometry().x(), mp.y()), QPoint(p.x(), widget->geometry().bottom())) ; break; case Top: geom = QRect(QPoint(widget->geometry().left(), mp.y()), widget->geometry().bottomRight()) ; break; case Bottom: geom = QRect(widget->geometry().topLeft(), QPoint(widget->geometry().right(), p.y())) ; break; case Left: geom = QRect(QPoint(mp.x(), widget->geometry().top()), widget->geometry().bottomRight()) ; break; case Right: geom = QRect(widget->geometry().topLeft(), QPoint(p.x(), widget->geometry().bottom())) ; break; case Center: geom.moveTopLeft(pp); break; default: break; } geom = QRect(geom.topLeft(), geom.size().expandedTo(widget->minimumSize()) .expandedTo(QSize(mw, mh)) .boundedTo(maxsize)); if (geom != widget->geometry() && (widget->isWindow() || widget->parentWidget()->rect().intersects(geom))) { if (mode == Center) widget->move(geom.topLeft()); else widget->setGeometry(geom); } }
void calculateGeometry() { // Convert to global points QObject* parent__ = parent(); if ( parent__ == NULL ) return; QWidget* parent_ = static_cast< QWidget* >( parent__ ); QRect parentRect = parent_ -> geometry(); parentRect.moveTopLeft( parent_ -> mapToGlobal(QPoint(0,0)) ); QRect widgetRect( parentRect ); QLayout* layout_ = layout(); if ( layout_ != NULL ) { QApplication::instance() -> sendPostedEvents(); layout_ -> activate(); layout_ -> update(); } QRect normalGeometry_ = normalGeometry(); // Use normal geometry if there is any if ( normalGeometry_.width() != 0 && normalGeometry_.height() != 0 ) { widgetRect.setWidth( normalGeometry_.width() ); widgetRect.setHeight( normalGeometry_.height() ); } if ( layout_ != 0 ) { QSize sizeHint = layout_ -> sizeHint(); if ( widgetRect.height() < sizeHint.height() ) widgetRect.setHeight( sizeHint.height() ); if ( widgetRect.width() < sizeHint.width() ) widgetRect.setWidth( sizeHint.width() ); widgetRect.setSize( sizeHint ); } QPoint bindTo; switch(parentCornerToAnchor_) { default: case Qt::TopLeftCorner: bindTo = parentRect.topLeft(); break; case Qt::TopRightCorner: bindTo = parentRect.topRight(); break; case Qt::BottomLeftCorner: bindTo = parentRect.bottomLeft(); break; case Qt::BottomRightCorner: bindTo = parentRect.bottomRight(); break; } switch(widgetCornerToAnchor_) { default: case Qt::TopLeftCorner: widgetRect.moveTopLeft( bindTo ); break; case Qt::TopRightCorner: widgetRect.moveTopRight( bindTo ); break; case Qt::BottomLeftCorner: widgetRect.moveBottomLeft( bindTo ); break; case Qt::BottomRightCorner: widgetRect.moveBottomRight( bindTo ); break; } QDesktopWidget desktopWidget; // If user only has one screen, ensure the popup doesn't go off screen // If multiple screens, this could be annoying as the popup can be viewed on a 2nd screen if ( desktopWidget.screenCount() == 1) widgetRect = desktopWidget.screenGeometry( parent_ ).intersected( widgetRect ); setGeometry( widgetRect ); }
void Style::drawTabBar(const QStyleOption *option, QPainter *painter, const QWidget *widget) const { ASSURE_OPTION(tbb, TabBarBase); if (!config.invert.headers) { if (tbb->selectedTabRect.isEmpty()) return; // only paint tab shapes if HAVE_OPTION(tbb2, TabBarBaseV2) { if (tbb2->documentMode) { return; // useless and adds confliciting horizintal lines } } SAVE_PAINTER(Pen|Alias); painter->setRenderHint(QPainter::Antialiasing, false); painter->setPen(QPen(FRAME_COLOR, FRAME_STROKE_WIDTH)); switch (tbb->shape) { case QTabBar::RoundedNorth: case QTabBar::TriangularNorth: painter->drawLine(RECT.x(), RECT.bottom(), tbb->selectedTabRect.x(), RECT.bottom()); painter->drawLine(tbb->selectedTabRect.right(), RECT.bottom(), RECT.right(), RECT.bottom()); break; case QTabBar::RoundedSouth: case QTabBar::TriangularSouth: painter->drawLine(RECT.x(), RECT.top(), tbb->selectedTabRect.x(), RECT.top()); painter->drawLine(tbb->selectedTabRect.right(), RECT.top(), RECT.right(), RECT.top()); break; case QTabBar::RoundedEast: case QTabBar::TriangularEast: painter->drawLine(RECT.x(), RECT.y(), RECT.x(), tbb->selectedTabRect.y()); painter->drawLine(RECT.x(), tbb->selectedTabRect.bottom(), RECT.x(), RECT.bottom()); break; case QTabBar::RoundedWest: case QTabBar::TriangularWest: painter->drawLine(RECT.right(), RECT.y(), RECT.right(), tbb->selectedTabRect.y()); painter->drawLine(RECT.right(), tbb->selectedTabRect.bottom(), RECT.right(), RECT.bottom()); break; } RESTORE_PAINTER return; } QWidget *win = 0; if (widget) { if (widget->parentWidget() && qobject_cast<QTabWidget*>(widget->parentWidget())) { if (widget->parentWidget()->style() == this) { return; // otherwise it's a proxystyle like on konqueror / kdevelop... } } else if (qobject_cast<const QTabBar*>(widget) || (appType == KDevelop && widget->inherits("QLabel"))) { return; // usually we alter the paintevent by eventfiltering } win = widget->window(); } else { if (painter->device()->devType() == QInternal::Widget) widget = static_cast<QWidget*>(painter->device()); else { QPaintDevice *dev = QPainter::redirected(painter->device()); if (dev && dev->devType() == QInternal::Widget) widget = static_cast<QWidget*>(dev); } if ( widget ) win = widget->window(); } QRect winRect; if (win) { winRect = win->rect(); winRect.moveTopLeft(widget->mapFrom(win, winRect.topLeft())); } // else // winRect = tbb->tabBarRect; // we set this from the eventfilter QEvent::Paint SAVE_PAINTER(Pen|Brush|Alias); painter->setBrush(PAL.color(QPalette::Active, QPalette::WindowText)); painter->setPen(Qt::NoPen); // TODO: half rounded rect? if (RECT.x() == winRect.x() || RECT.y() == winRect.y() || RECT.right() == winRect.right() || RECT.bottom() == winRect.bottom()) { painter->setRenderHint(QPainter::Antialiasing, false); painter->drawRect(RECT); } else { painter->setRenderHint(QPainter::Antialiasing, true); const int rnd = qMin(config.frame.roundness, verticalTabs(tbb->shape) ? RECT.width()/2 : RECT.height()/2); painter->drawRoundedRect(RECT, rnd, rnd); } RESTORE_PAINTER }
void patternPrinter::drawTitlePage(const patternMetadata& metadata) { QRect availableTextRect = printer_.pageRect(); // the availableTextRect is absolute with respect to the page, but // when we draw it's relative to availableTextRect - use draw coords availableTextRect.moveTopLeft(QPoint(0, 0)); if (metadata.title() != "") { drawTitleMetadata(metadata.titleFontSize(), true, metadata.title(), &availableTextRect); } if (metadata.patternBy() != "") { drawTitleMetadata(metadata.patternByFontSize(), false, metadata.patternBy(), &availableTextRect); } if (metadata.photoBy() != "") { drawTitleMetadata(metadata.photoByFontSize(), false, metadata.photoBy(), &availableTextRect); } // title margin availableTextRect.setTop(availableTextRect.top() + 5); painter_.save(); QPen pen(painter_.pen()); pen.setWidth(2); painter_.setPen(pen); //// draw the original image on this page const QImage original = originalImage_.scaled(availableTextRect.size(), Qt::KeepAspectRatio, Qt::SmoothTransformation); const int xStart = (availableTextRect.width() - original.width())/2; const int yStart = availableTextRect.top(); const QPoint originalStart(xStart, yStart); painter_.drawImage(originalStart, original); painter_.drawRect(QRect(originalStart, original.size())); printer_.newPage(); //// draw the squared image QRect usableRect = printer_.pageRect(); usableRect.moveTopLeft(QPoint(0, 0)); // figure out if gridding will be reasonable at the zoom level needed // to fit the page const QSize squareImageSize = squareImage_.size(); const int newSquareDim = ::computeGridForImageFit(squareImageSize, usableRect.size(), squareDim_); QImage squareImage; if (newSquareDim > 0) { const int newWidth = newSquareDim * squareImageSize.width()/squareDim_; const int newHeight = newSquareDim * squareImageSize.height()/squareDim_; squareImage = squareImage_.scaled(newWidth, newHeight, Qt::KeepAspectRatio, Qt::SmoothTransformation); squareImage = gridedImage(squareImage, squareDim_, squareImageSize.width(), squareImageSize.height(), .2); } else { // oops, we can't commit one (or more) pixels to each square of the pattern // and still draw it to fit inside our page bounds, so just scale to fit the // bounds - we definitely can't grid squareImage = squareImage_.scaled(usableRect.size(), Qt::KeepAspectRatio, Qt::SmoothTransformation); } const QPoint squareStart((usableRect.width() - squareImage.width())/2, 0); painter_.drawImage(squareStart, squareImage); painter_.drawRect(QRect(squareStart, squareImage.size())); painter_.restore(); printer_.newPage(); }
bool DockTabMotherWidget::getInsertionDirection(const QPoint &pos, QWidget *widget, Direction dockDir, InsertionDirection &insertDir) { auto insertionFromAbsoluteDir = [dockDir](Direction absDir)->InsertionDirection { switch (dockDir) { default: case Left: switch (absDir) { default: case Left: return PreviousSplitter; case Right: return NextSplitter; case Top: return Previous; case Bottom: return Next; } case Right: switch (absDir) { default: case Left: return NextSplitter; case Right: return PreviousSplitter; case Top: return Previous; case Bottom: return Next; } case Top: switch (absDir) { default: case Left: return Previous; case Right: return Next; case Top: return PreviousSplitter; case Bottom: return NextSplitter; } case Bottom: switch (absDir) { default: case Left: return Previous; case Right: return Next; case Top: return NextSplitter; case Bottom: return PreviousSplitter; } } }; auto isInInsertDist = [this](int x, int border)->bool { return border - insertDistance() <= x && x < border + insertDistance(); }; QRect rect = widget->rect(); rect.moveTopLeft(mapToAncestor(this, widget, rect.topLeft())); int left = rect.left(); int rightEnd = rect.left() + rect.width(); int top = rect.top(); int bottomEnd = rect.top() + rect.height(); int x = pos.x(); int y = pos.y(); if (left <= x && x < rightEnd) { if (isInInsertDist(top, y)) { insertDir = insertionFromAbsoluteDir(Top); return true; } if (isInInsertDist(bottomEnd, y)) { insertDir = insertionFromAbsoluteDir(Bottom); return true; } } if (top <= y && y < bottomEnd) { if (isInInsertDist(left, x)) { insertDir = insertionFromAbsoluteDir(Left); return true; } if (isInInsertDist(rightEnd, x)) { insertDir = insertionFromAbsoluteDir(Right); return true; } } return false; }
QRect QRangeSlider::getBBox() const { QRect bbox = geometry(); bbox.moveTopLeft(QPoint(0, 0)); return bbox; }