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