diff --git a/clients/oxygen/oxygenclient.cpp b/clients/oxygen/oxygenclient.cpp index 44833f451..0b2189b64 100644 --- a/clients/oxygen/oxygenclient.cpp +++ b/clients/oxygen/oxygenclient.cpp @@ -1,2038 +1,2038 @@ ////////////////////////////////////////////////////////////////////////////// // oxygenclient.cpp // ------------------- // // Copyright (c) 2009 Hugo Pereira Da Costa // Copyright (c) 2006, 2007 Casper Boemann // Copyright (c) 2006, 2007 Riccardo Iaconelli // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to // deal in the Software without restriction, including without limitation the // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or // sell copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS // IN THE SOFTWARE. ////////////////////////////////////////////////////////////////////////////// #include "oxygenclient.h" #include "oxygenclient.moc" #include "oxygenbutton.h" #include "oxygensizegrip.h" #include #include #include #include #include #include #include #include #include #include #include #include namespace Oxygen { //___________________________________________ Client::Client(KDecorationBridge *b, Factory *f): KCommonDecoration(b, f), _factory( f ), _sizeGrip( 0 ), _glowAnimation( new Animation( 200, this ) ), _titleAnimationData( new TitleAnimationData( this ) ), _glowIntensity(0), _initialized( false ), _forceActive( false ), _mouseButton( Qt::NoButton ), _itemData( this ), _sourceItem( -1 ), _shadowAtom( 0 ) { connect(options(), &KDecorationOptions::compositingChanged, this, &Client::updateCompositing); connect(options(), &KDecorationOptions::configChanged, this, &Client::updateConfig); } //___________________________________________ Client::~Client() { // delete sizegrip if any if( hasSizeGrip() ) deleteSizeGrip(); } //___________________________________________ QString Client::visibleName() const { return i18n("Oxygen"); } //___________________________________________ void Client::init() { // make sure valid configuration is set if( !_configuration ) _configuration = _factory->configuration( *this ); KCommonDecoration::init(); widget()->setAttribute(Qt::WA_NoSystemBackground ); widget()->setAutoFillBackground( false ); widget()->setAcceptDrops( true ); // setup glow animation _glowAnimation->setStartValue( glowBias() ); _glowAnimation->setEndValue( 1.0 ); _glowAnimation->setTargetObject( this ); _glowAnimation->setPropertyName( "glowIntensity" ); _glowAnimation->setEasingCurve( QEasingCurve::InOutQuad ); connect( _glowAnimation, SIGNAL(finished()), this, SLOT(clearForceActive()) ); // title animation data _titleAnimationData->initialize(); connect( _titleAnimationData, SIGNAL(pixmapsChanged()), SLOT(updateTitleRect()) ); // lists connect( _itemData.animation().data(), SIGNAL(finished()), this, SLOT(clearTargetItem()) ); // in case of preview, one wants to make the label used // for the central widget transparent. This allows one to have // the correct background (with gradient) rendered // Remark: this is minor (and safe) a hack. // This should be moved upstream (into kwin/lib/kdecoration) if( isPreview() ) { QList children( widget()->findChildren() ); foreach( QLabel* widget, children ) { widget->setAutoFillBackground( false ); } // also change shadow configuration size to something that fits in the preview list shadowCache().setShadowSize( QPalette::Active, 15 ); shadowCache().setShadowSize( QPalette::Inactive, 15 ); } setAlphaEnabled(!isMaximized()); _initialized = true; // first reset is needed to store Oxygen configuration updateConfig(); } //___________________________________________ void Client::updateCompositing() { // update window mask when compositing is changed if( !_initialized ) return; updateWindowShape(); widget()->update(); updateConfig(); } //___________________________________________ void Client::updateConfig() { if( !_initialized ) return; _configuration = _factory->configuration( *this ); // glow animations _glowAnimation->setDuration( _configuration->shadowAnimationsDuration() ); // title transitions _titleAnimationData->setDuration( _configuration->titleAnimationsDuration() ); // tabs _itemData.setAnimationsEnabled( animationsEnabled() && _configuration->tabAnimationsEnabled() ); _itemData.animation().data()->setDuration( _configuration->tabAnimationsDuration() ); // reset title transitions _titleAnimationData->reset(); // should also update animations for buttons resetButtons(); // also reset tab buttons for( int index = 0; index < _itemData.count(); index++ ) { ClientGroupItemData& item( _itemData[index] ); if( item._closeButton ) { item._closeButton.data()->reset(0); } } // reset tab geometry _itemData.setDirty( true ); // handle size grip if( _configuration->drawSizeGrip() && _configuration->frameBorder() == Configuration::BorderNone ) { if( !hasSizeGrip() ) createSizeGrip(); } else if( hasSizeGrip() ) deleteSizeGrip(); // needs to remove shadow property on window since shadows are handled by the decoration removeShadowHint(); } //___________________________________________ bool Client::decorationBehaviour(DecorationBehaviour behaviour) const { switch (behaviour) { case DB_MenuClose: return _configuration->closeWindowFromMenuButton(); case DB_WindowMask: return false; default: return KCommonDecoration::decorationBehaviour(behaviour); } } //_________________________________________________________ KCommonDecorationButton *Client::createButton(::ButtonType type) { switch (type) { case MenuButton: return new Button(*this, i18n("Window Actions Menu"), ButtonMenu); case AppMenuButton: return new Button(*this, i18n("Application Menu"), ButtonApplicationMenu); case HelpButton: return new Button(*this, i18n("Help"), ButtonHelp); case MinButton: return new Button(*this, i18n("Minimize"), ButtonMin); case MaxButton: return new Button(*this, i18n("Maximize"), ButtonMax); case CloseButton: return new Button(*this, i18n("Close"), ButtonClose); case AboveButton: return new Button(*this, i18n("Keep Above Others"), ButtonAbove); case BelowButton: return new Button(*this, i18n("Keep Below Others"), ButtonBelow); case OnAllDesktopsButton: return new Button(*this, i18n("On All Desktops"), ButtonSticky); case ShadeButton: return new Button(*this, i18n("Shade Button"), ButtonShade); default: break; } return NULL; } //_________________________________________________________ QRegion Client::calcMask( void ) const { if( isMaximized() ) { return widget()->rect(); } const QRect frame( widget()->rect().adjusted( layoutMetric( LM_OuterPaddingLeft ), layoutMetric( LM_OuterPaddingTop ), -layoutMetric( LM_OuterPaddingRight ), -layoutMetric( LM_OuterPaddingBottom ) ) ); QRegion mask; if( _configuration->frameBorder() == Configuration::BorderNone && !isShade() ) { if( hideTitleBar() ) mask = QRegion(); else if( compositingActive() ) mask = QRegion(); else mask = helper().roundedMask( frame, 1, 1, 1, 0 ); } else { if( compositingActive() ) mask = QRegion(); else mask = helper().roundedMask( frame ); } return mask; } //___________________________________________ int Client::layoutMetric(LayoutMetric lm, bool respectWindowState, const KCommonDecorationButton *btn) const { const bool maximized( isMaximized() ); const bool shaded( isShade() ); const bool narrowSpacing( _configuration->useNarrowButtonSpacing() ); const int frameBorder( this->frameBorder() ); const int buttonSize( hideTitleBar() ? 0 : this->buttonSize() ); switch (lm) { case LM_BorderLeft: case LM_BorderRight: { int border( frameBorder ); if( respectWindowState && maximized ) { border = 0; } else if( _configuration->frameBorder() < Configuration::BorderTiny ) { border = 0; } else if( !compositingActive() && _configuration->frameBorder() == Configuration::BorderTiny ) { border = qMax( frameBorder, 3 ); } return border; } case LM_BorderBottom: { int border( frameBorder ); if( (respectWindowState && maximized) || shaded ) { border = 0; } else if( _configuration->frameBorder() >= Configuration::BorderNoSide ) { // for tiny border, the convention is to have a larger bottom area in order to // make resizing easier border = qMax(frameBorder, 4); } else if( _configuration->frameBorder() < Configuration::BorderTiny ) { border = 0; } else if( !compositingActive() && _configuration->frameBorder() == Configuration::BorderTiny ) { border = qMax( frameBorder, 3 ); } return border; } case LM_TitleEdgeTop: { int border = 0; if( _configuration->frameBorder() == Configuration::BorderNone && hideTitleBar() ) { border = 0; } else if( !( respectWindowState && maximized )) { border = TFRAMESIZE; } return border; } case LM_TitleEdgeBottom: { return 0; } case LM_TitleEdgeLeft: case LM_TitleEdgeRight: { int border = 0; if( !(respectWindowState && maximized) ) { border = 4; } return border; } case LM_TitleBorderLeft: case LM_TitleBorderRight: { int border = 5; // if title outline is to be drawn, one adds the space needed to // separate title and tab border. namely the same value if( _configuration->drawTitleOutline() ) border += border; return border; } case LM_ButtonWidth: case LM_ButtonHeight: case LM_TitleHeight: { return buttonSize; } case LM_ButtonSpacing: return narrowSpacing ? 1:3; case LM_ButtonMarginTop: return 0; // outer margin for shadow/glow case LM_OuterPaddingLeft: case LM_OuterPaddingRight: case LM_OuterPaddingTop: case LM_OuterPaddingBottom: if( maximized ) return 0; else return shadowCache().shadowSize(); default: return KCommonDecoration::layoutMetric(lm, respectWindowState, btn); } } //_________________________________________________________ QRect Client::defaultTitleRect( bool active ) const { QRect titleRect( this->titleRect().adjusted( 0, -layoutMetric( LM_TitleEdgeTop ), 0, 0 ) ); // when drawing title outline, shrink the rect so that it matches the actual caption size if( active && _configuration->drawTitleOutline() && isActive() ) { if( _configuration->titleAlignment() == Configuration::AlignCenterFullWidth ) { titleRect.setLeft( widget()->rect().left() + layoutMetric( LM_OuterPaddingLeft ) ); titleRect.setRight( widget()->rect().right() - layoutMetric( LM_OuterPaddingRight ) ); } const QRect textRect( titleBoundingRect( options()->font( true, false), titleRect, caption() ) ); titleRect.setLeft( textRect.left() - layoutMetric( LM_TitleBorderLeft ) ); titleRect.setRight( textRect.right() + layoutMetric( LM_TitleBorderRight ) ); } else { // buttons are properly accounted for in titleBoundingRect method titleRect.setLeft( widget()->rect().left() + layoutMetric( LM_OuterPaddingLeft ) ); titleRect.setRight( widget()->rect().right() - layoutMetric( LM_OuterPaddingRight ) ); } return titleRect; } //_________________________________________________________ QRect Client::titleBoundingRect( const QFont& font, QRect rect, const QString& caption ) const { // get title bounding rect QRect boundingRect( QFontMetrics( font ).boundingRect( rect, titleAlignment() | Qt::AlignVCenter, caption ) ); // adjust to make sure bounding rect // 1/ has same vertical alignment as original titleRect // 2/ does not exceeds available horizontal space boundingRect.setTop( rect.top() ); boundingRect.setBottom( rect.bottom() ); // check bounding rect against input rect boundRectTo( boundingRect, rect ); if( _configuration->titleAlignment() == Configuration::AlignCenterFullWidth ) { /* check bounding rect against max available space, for buttons this is not needed if centerTitleOnFullWidth flag is set to false, because it was already done before calling titleBoundingRect */ boundRectTo( boundingRect, titleRect() ); } return boundingRect; } //_________________________________________________________ void Client::boundRectTo( QRect& rect, const QRect& bound ) const { if( bound.left() > rect.left() ) { rect.moveLeft( bound.left() ); if( bound.right() < rect.right() ) { rect.setRight( bound.right() ); } } else if( bound.right() < rect.right() ) { rect.moveRight( bound.right() ); if( bound.left() > rect.left() ) { rect.setLeft( bound.left() ); } } return; } //_________________________________________________________ void Client::clearTargetItem( void ) { if( _itemData.animationType() == AnimationLeave ) { _itemData.setDirty( true ); } } //_________________________________________________________ void Client::updateItemBoundingRects( bool alsoUpdate ) { // make sure items are not animated _itemData.animate( AnimationNone ); // maximum available space const QRect titleRect( this->titleRect() ); // get tabs const int items( tabCount() ); // make sure item data have the correct number of items while( _itemData.count() < items ) _itemData.push_back( ClientGroupItemData() ); while( _itemData.count() > items ) { if( _itemData.back()._closeButton ) delete _itemData.back()._closeButton.data(); _itemData.pop_back(); } assert( !_itemData.isEmpty() ); // create buttons if( _itemData.count() == 1 ) { // remove button if( _itemData.front()._closeButton ) { delete _itemData.front()._closeButton.data(); } // set active rect _itemData.front()._activeRect = titleRect.adjusted( 0, -layoutMetric( LM_TitleEdgeTop ), 0, 0 ); } else { int left( titleRect.left() ); const int width( titleRect.width()/items ); for( int index = 0; index < _itemData.count(); index++ ) { ClientGroupItemData& item(_itemData[index]); // make sure button exists if( !item._closeButton ) { item._closeButton = ClientGroupItemData::ButtonPointer( new Button( *this, QStringLiteral("Close this tab"), ButtonItemClose ) ); item._closeButton.data()->show(); item._closeButton.data()->installEventFilter( this ); } // set active rect QRect local( QPoint( left, titleRect.top() ), QSize( width, titleRect.height() ) ); local.adjust( 0, -layoutMetric( LM_TitleEdgeTop ), 0, 0 ); item._activeRect = local; left += width; } } if( _itemData.count() == 1 ) { _itemData.front().reset( defaultTitleRect() ); } else { for( int index = 0; index < _itemData.count(); index++ ) { _itemData[index].reset( _itemData[index]._activeRect ); } } // button activity _itemData.updateButtonActivity( currentTabId() ); // reset buttons location _itemData.updateButtons( alsoUpdate ); _itemData.setDirty( false ); return; } //_________________________________________________________ QColor Client::titlebarTextColor(const QPalette &palette) const { if( glowIsAnimated() ) return KColorUtils::mix( titlebarTextColor( palette, false ), titlebarTextColor( palette, true ), glowIntensity() ); else return titlebarTextColor( palette, isActive() ); } //_________________________________________________________ void Client::renderWindowBackground( QPainter* painter, const QRect& rect, const QWidget* widget, const QPalette& palette ) const { // window background if( _configuration->blendStyle() == Configuration::BlendNone || ( _configuration->blendStyle() == Configuration::BlendFromStyle && !helper().hasBackgroundGradient( windowId() ) ) ) { painter->fillRect( rect, palette.color( QPalette::Window ) ); } else { int offset = layoutMetric( LM_OuterPaddingTop ); // radial gradient positionning const int height = hideTitleBar() ? 0:buttonSize(); if( isMaximized() ) offset -= 3; const QWidget* window( isPreview() ? this->widget() : widget->window() ); helper().renderWindowBackground(painter, rect, widget, window, palette, offset, height ); } // background pixmap if( isPreview() || helper().hasBackgroundPixmap( windowId() ) ) { int offset = layoutMetric( LM_OuterPaddingTop ); // radial gradient positionning const int height = hideTitleBar() ? 0:buttonSize(); if( isMaximized() ) offset -= 3; // background pixmap QPoint backgroundPixmapOffset( layoutMetric( LM_OuterPaddingLeft ) + layoutMetric( LM_BorderLeft ), 0 ); helper().setBackgroundPixmapOffset( backgroundPixmapOffset ); const QWidget* window( isPreview() ? this->widget() : widget->window() ); helper().renderBackgroundPixmap(painter, rect, widget, window, offset, height ); } } //_________________________________________________________ void Client::renderWindowBorder( QPainter* painter, const QRect& clipRect, const QWidget* widget, const QPalette& palette ) const { // get coordinates relative to the client area // this is annoying. One could use mapTo if this was taking const QWidget* and not // const QWidget* as argument. const QWidget* window = (isPreview()) ? this->widget() : widget->window(); const QWidget* w = widget; QPoint position( 0, 0 ); while ( w != window && !w->isWindow() && w != w->parentWidget() ) { position += w->geometry().topLeft(); w = w->parentWidget(); } // save painter if( clipRect.isValid() ) { painter->save(); painter->setClipRegion(clipRect,Qt::IntersectClip); } QRect r = (isPreview()) ? this->widget()->rect():window->rect(); r.adjust( layoutMetric( LM_OuterPaddingLeft ), layoutMetric( LM_OuterPaddingTop ), -layoutMetric( LM_OuterPaddingRight ), -layoutMetric( LM_OuterPaddingBottom ) ); r.adjust(0,0, 1, 1); // base color QColor color( palette.window().color() ); // add alpha channel if( _itemData.count() == 1 && glowIsAnimated() ) { color = helper().alphaColor( color, glowIntensity() ); } // title height const int titleHeight( layoutMetric( LM_TitleEdgeTop ) + layoutMetric( LM_TitleEdgeBottom ) + layoutMetric( LM_TitleHeight ) ); // make titlebar background darker for tabbed, non-outline window if( ( tabCount() >= 2 || _itemData.isAnimated() ) && !(_configuration->drawTitleOutline() && isActive() ) ) { const QPoint topLeft( r.topLeft()-position ); const QRect rect( topLeft, QSize( r.width(), titleHeight ) ); QLinearGradient lg( rect.topLeft(), rect.bottomLeft() ); lg.setColorAt( 0, helper().alphaColor( Qt::black, 0.05 ) ); lg.setColorAt( 1, helper().alphaColor( Qt::black, 0.10 ) ); painter->setBrush( lg ); painter->setPen( Qt::NoPen ); painter->drawRect( rect ); } // horizontal line { const int shadowSize = 7; const int height = shadowSize-3; const QPoint topLeft( r.topLeft()+QPoint(0,titleHeight-height)-position ); QRect rect( topLeft, QSize( r.width(), height ) ); // adjustements to cope with shadow size and outline border. rect.adjust( -shadowSize, 0, shadowSize-1, 0 ); if( _configuration->drawTitleOutline() && ( isActive() || glowIsAnimated() ) && !isMaximized() ) { if( _configuration->frameBorder() == Configuration::BorderTiny ) rect.adjust( 1, 0, -1, 0 ); else if( _configuration->frameBorder() > Configuration::BorderTiny ) rect.adjust( HFRAMESIZE-1, 0, -HFRAMESIZE+1, 0 ); } if( rect.isValid() ) { helper().slab( color, 0, shadowSize )->render( rect, painter, TileSet::Top ); } } if( _configuration->drawTitleOutline() && ( isActive() || glowIsAnimated() ) ) { // save old hints and turn off anti-aliasing const QPainter::RenderHints hints( painter->renderHints() ); painter->setRenderHint( QPainter::Antialiasing, false ); // save mask and frame to where // grey window background is to be rendered QRegion mask; QRect frame; // bottom line const int leftOffset = qMin( layoutMetric( LM_BorderLeft ), int(HFRAMESIZE) ); const int rightOffset = qMin( layoutMetric( LM_BorderRight ), int(HFRAMESIZE) ); if( _configuration->frameBorder() > Configuration::BorderNone ) { const int height = qMax( 0, layoutMetric( LM_BorderBottom ) - HFRAMESIZE ); const int width = r.width() - leftOffset - rightOffset - 1; const QRect rect( r.bottomLeft()-position + QPoint( leftOffset, -layoutMetric( LM_BorderBottom ) ), QSize( width, height ) ); if( height > 0 ) { mask += rect; frame |= rect; } const QColor shadow( helper().calcDarkColor( color ) ); painter->setPen( shadow ); painter->drawLine( rect.bottomLeft()+QPoint(-1,1), rect.bottomRight()+QPoint(1,1) ); } // left and right const int topOffset = titleHeight; const int bottomOffset = qMin( layoutMetric( LM_BorderBottom ), int(HFRAMESIZE) ); const int height = r.height() - topOffset - bottomOffset - 1; if( _configuration->frameBorder() >= Configuration::BorderTiny ) { const QColor shadow( helper().calcLightColor( color ) ); painter->setPen( shadow ); // left int width = qMax( 0, layoutMetric( LM_BorderLeft ) - HFRAMESIZE ); QRect rect( r.topLeft()-position + QPoint( layoutMetric( LM_BorderLeft ) - width, topOffset ), QSize( width, height ) ); if( width > 0 ) { mask += rect; frame |= rect; } painter->drawLine( rect.topLeft()-QPoint(1,0), rect.bottomLeft()-QPoint(1, 0) ); // right width = qMax( 0, layoutMetric( LM_BorderRight ) - HFRAMESIZE ); rect = QRect(r.topRight()-position + QPoint( -layoutMetric( LM_BorderRight ), topOffset ), QSize( width, height )); if( width > 0 ) { mask += rect; frame |= rect; } painter->drawLine( rect.topRight()+QPoint(1,0), rect.bottomRight()+QPoint(1, 0) ); } // restore old hints painter->setRenderHints( hints ); // in preview mode also adds center square if( isPreview() ) { const QRect rect( r.topLeft()-position + QPoint( layoutMetric( LM_BorderLeft ), topOffset ), QSize(r.width()-layoutMetric( LM_BorderLeft )-layoutMetric( LM_BorderRight ),height) ); mask += rect; frame |= rect; } // paint if( !mask.isEmpty() ) { painter->setClipRegion( mask, Qt::IntersectClip); renderWindowBackground(painter, frame, widget, palette ); } } // restore painter if( clipRect.isValid() ) { painter->restore(); } } //_________________________________________________________ void Client::renderSeparator( QPainter* painter, const QRect& clipRect, const QWidget* widget, const QColor& color ) const { const QWidget* window = (isPreview()) ? this->widget() : widget->window(); // get coordinates relative to the client area // this is annoying. One could use mapTo if this was taking const QWidget* and not // const QWidget* as argument. QPoint position( 0, 0 ); { const QWidget* w = widget; while ( w != window && !w->isWindow() && w != w->parentWidget() ) { position += w->geometry().topLeft(); w = w->parentWidget(); } } // setup painter if (clipRect.isValid()) { painter->save(); painter->setClipRegion(clipRect,Qt::IntersectClip); } QRect r = (isPreview()) ? this->widget()->rect():window->rect(); r.adjust( layoutMetric( LM_OuterPaddingLeft ), layoutMetric( LM_OuterPaddingTop ), -layoutMetric( LM_OuterPaddingRight ), -layoutMetric( LM_OuterPaddingBottom ) ); // dimensions const int titleHeight = layoutMetric(LM_TitleHeight); const int titleTop = layoutMetric(LM_TitleEdgeTop) + r.top(); // set color QColor local( color ); if( glowIsAnimated() && _configuration->separatorMode() != Configuration::SeparatorAlways ) { local = helper().alphaColor( color, glowIntensity() ); } // render helper().drawSeparator( painter, QRect(r.top(), titleTop+titleHeight-1.5, r.width(), 2).translated( -position ), local, Qt::Horizontal); if (clipRect.isValid()) { painter->restore(); } } //_________________________________________________________ void Client::renderTitleOutline( QPainter* painter, const QRect& rect, const QPalette& palette ) const { // center (for active windows only) { painter->save(); QRect adjustedRect( rect.adjusted( 1, 1, -1, 1 ) ); // prepare painter mask QRegion mask( adjustedRect.adjusted( 1, 0, -1, 0 ) ); mask += adjustedRect.adjusted( 0, 1, 0, 0 ); painter->setClipRegion( mask, Qt::IntersectClip ); // draw window background renderWindowBackground(painter, adjustedRect, widget(), palette ); painter->restore(); } // shadow const int shadowSize( 7 ); const int offset( -3 ); const int voffset( 5-shadowSize ); const QRect adjustedRect( rect.adjusted(offset, voffset, -offset, shadowSize) ); QColor color( palette.color( widget()->backgroundRole() ) ); // add alpha channel if( _itemData.count() == 1 && glowIsAnimated() ) { color = helper().alphaColor( color, glowIntensity() ); } // render slab helper().slab( color, 0, shadowSize )->render( adjustedRect, painter, TileSet::Tiles(TileSet::Top|TileSet::Left|TileSet::Right) ); } //_________________________________________________________ void Client::renderTitleText( QPainter* painter, const QRect& rect, const QColor& color, const QColor& contrast ) const { if( !_titleAnimationData->isValid() ) { // contrast pixmap _titleAnimationData->reset( rect, renderTitleText( rect, caption(), color ), renderTitleText( rect, caption(), contrast ) ); } if( _titleAnimationData->isDirty() ) { // clear dirty flags _titleAnimationData->setDirty( false ); // finish current animation if running if( _titleAnimationData->isAnimated() ) { _titleAnimationData->finishAnimation(); } if( !_titleAnimationData->isLocked() ) { // set pixmaps _titleAnimationData->setPixmaps( rect, renderTitleText( rect, caption(), color ), renderTitleText( rect, caption(), contrast ) ); _titleAnimationData->startAnimation(); renderTitleText( painter, rect, color, contrast ); } else if( !caption().isEmpty() ) { renderTitleText( painter, rect, caption(), color, contrast ); } // lock animations (this must be done whether or not // animation was actually started, in order to extend locking // every time title get changed too rapidly _titleAnimationData->lockAnimations(); } else if( _titleAnimationData->isAnimated() ) { if( isMaximized() ) painter->translate( 0, 2 ); if( !_titleAnimationData->contrastPixmap().isNull() ) { painter->translate( 0, 1 ); painter->drawPixmap( rect.topLeft(), _titleAnimationData->contrastPixmap() ); painter->translate( 0, -1 ); } painter->drawPixmap( rect.topLeft(), _titleAnimationData->pixmap() ); if( isMaximized() ) painter->translate( 0, -2 ); } else if( !caption().isEmpty() ) { renderTitleText( painter, rect, caption(), color, contrast ); } } //_______________________________________________________________________ void Client::renderTitleText( QPainter* painter, const QRect& rect, const QString& caption, const QColor& color, const QColor& contrast, bool elide ) const { const Qt::Alignment alignment( titleAlignment() | Qt::AlignVCenter ); const QString local( elide ? QFontMetrics( painter->font() ).elidedText( caption, Qt::ElideRight, rect.width() ):caption ); // translate title down in case of maximized window if( isMaximized() ) painter->translate( 0, 2 ); if( contrast.isValid() ) { painter->setPen( contrast ); painter->translate( 0, 1 ); painter->drawText( rect, alignment, local ); painter->translate( 0, -1 ); } painter->setPen( color ); painter->drawText( rect, alignment, local ); // translate back if( isMaximized() ) painter->translate( 0, -2 ); } //_______________________________________________________________________ QPixmap Client::renderTitleText( const QRect& rect, const QString& caption, const QColor& color, bool elide ) const { if( !rect.isValid() ) return QPixmap(); QPixmap out( rect.size() ); out.fill( Qt::transparent ); if( caption.isEmpty() || !color.isValid() ) return out; QPainter painter( &out ); painter.setFont( options()->font(isActive(), false) ); const Qt::Alignment alignment( titleAlignment() | Qt::AlignVCenter ); const QString local( elide ? QFontMetrics( painter.font() ).elidedText( caption, Qt::ElideRight, rect.width() ):caption ); painter.setPen( color ); painter.drawText( out.rect(), alignment, local ); painter.end(); return out; } //_______________________________________________________________________ void Client::renderItem( QPainter* painter, int index, const QPalette& palette ) { const ClientGroupItemData& item( _itemData[index] ); // see if tag is active const int itemCount( _itemData.count() ); // check item bounding rect if( !item._boundingRect.isValid() ) return; // create rect in which text is to be drawn QRect textRect( item._boundingRect.adjusted( 0, layoutMetric( LM_TitleEdgeTop )-1, 0, -1 ) ); // add extra space needed for title outline if( itemCount > 1 || _itemData.isAnimated() ) { textRect.adjust( layoutMetric( LM_TitleBorderLeft ), 0, -layoutMetric(LM_TitleBorderRight), 0 ); } // add extra space for the button if( itemCount > 1 && item._closeButton && item._closeButton.data()->isVisible() ) { textRect.adjust( 0, 0, - buttonSize() - layoutMetric(LM_TitleEdgeRight), 0 ); } // check if current item is active const bool active( tabId(index) == currentTabId() ); // get current item caption and update text rect const QString caption( itemCount == 1 ? this->caption() : this->caption(index) ); if( _configuration->titleAlignment() != Configuration::AlignCenterFullWidth ) { boundRectTo( textRect, titleRect() ); } // adjust textRect textRect = titleBoundingRect( painter->font(), textRect, caption ); // title outline if( itemCount == 1 ) { // no title outline if the window caption is empty if( !caption.trimmed().isEmpty() ) { if( _itemData.isAnimated() ) { renderTitleOutline( painter, item._boundingRect, palette ); } else if( (isActive()||glowIsAnimated()) && _configuration->drawTitleOutline() ) { // adjusts boundingRect accordingly QRect boundingRect( item._boundingRect ); boundingRect.setLeft( textRect.left() - layoutMetric( LM_TitleBorderLeft ) ); boundingRect.setRight( textRect.right() + layoutMetric( LM_TitleBorderRight ) ); // render bounding rect around it with extra margins renderTitleOutline( painter, boundingRect, palette ); } } } else if( active ) { // in multiple tabs render title outline in all cases renderTitleOutline( painter, item._boundingRect, palette ); } // render text if( active || itemCount == 1 ) { // for active tab, current caption is "merged" with old caption, if any renderTitleText( painter, textRect, titlebarTextColor( palette ), titlebarContrastColor( palette ) ); } else { QColor background( backgroundPalette( widget(), palette ).color( widget()->window()->backgroundRole() ) ); // add extra shade (as used in renderWindowBorder if( !( isActive() && _configuration->drawTitleOutline() ) ) { background = KColorUtils::mix( background, Qt::black, 0.10 ); } // otherwise current caption is rendered directly renderTitleText( painter, textRect, caption, titlebarTextColor( backgroundPalette( widget(), palette ), false ), titlebarContrastColor( background ) ); } // render separators between inactive tabs if( !( active || itemCount == 1 ) && item._closeButton && item._closeButton.data()->isVisible() ) { // separators // draw Left separator const QColor color( backgroundPalette( widget(), palette ).window().color() ); const bool isFirstItem( index == 0 || (index == 1 && !_itemData[0]._boundingRect.isValid() ) ); if( !active && ( ( isFirstItem && buttonsLeftWidth() > 0 ) || _itemData.isTarget( index ) ) ) { const QRect local( item._boundingRect.topLeft()+QPoint(0,2), QSize( 2, item._boundingRect.height()-3 ) ); helper().drawSeparator( painter, local, color, Qt::Vertical); } // draw right separator if( ( index == itemCount-1 && buttonsRightWidth() > 0 ) || ( index+1 < itemCount && ( _itemData.isTarget( index+1 ) || !( tabId(index+1) == currentTabId() && _itemData[index+1]._boundingRect.isValid() ) ) ) ) { const QRect local( item._boundingRect.topRight()+QPoint(0,2), QSize( 2, item._boundingRect.height()-3 ) ); helper().drawSeparator( painter, local, color, Qt::Vertical); } } } //_______________________________________________________________________ void Client::renderTargetRect( QPainter* p, const QPalette& palette ) { if( _itemData.targetRect().isNull() || _itemData.isAnimationRunning() ) return; const QColor color = palette.color(QPalette::Highlight); p->setPen(KColorUtils::mix(color, palette.color(QPalette::Active, QPalette::WindowText))); p->setBrush( helper().alphaColor( color, 0.5 ) ); p->drawRect( QRectF(_itemData.targetRect()).adjusted( 4.5, 2.5, -4.5, -2.5 ) ); } //_______________________________________________________________________ void Client::renderCorners( QPainter* painter, const QRect& frame, const QPalette& palette ) const { const QColor color( backgroundColor( widget(), palette ) ); QLinearGradient lg = QLinearGradient(0, -0.5, 0, qreal( frame.height() )+0.5); lg.setColorAt(0.0, helper().calcLightColor( helper().backgroundTopColor(color) )); lg.setColorAt(0.51, helper().backgroundBottomColor(color) ); lg.setColorAt(1.0, helper().backgroundBottomColor(color) ); painter->setPen( QPen( lg, 1 ) ); painter->setBrush( Qt::NoBrush ); painter->drawRoundedRect( QRectF( frame ).adjusted( 0.5, 0.5, -0.5, -0.5 ), 3.5, 3.5 ); } //_______________________________________________________________________ void Client::renderFloatFrame( QPainter* painter, const QRect& frame, const QPalette& palette ) const { // shadow and resize handles if( !isMaximized() ) { if( _configuration->frameBorder() >= Configuration::BorderTiny ) { helper().drawFloatFrame( painter, frame, backgroundColor( widget(), palette ), !compositingActive(), isActive() && shadowCache().isEnabled( QPalette::Active ), KDecoration::options()->color(ColorTitleBar) ); } else { // for small borders, use a frame that matches the titlebar only const QRect local( frame.topLeft(), QSize( frame.width(), layoutMetric(LM_TitleHeight) + layoutMetric(LM_TitleEdgeTop) ) ); helper().drawFloatFrame( painter, local, backgroundColor( widget(), palette ), false, isActive() && shadowCache().isEnabled( QPalette::Active ), KDecoration::options()->color(ColorTitleBar) ); } } else if( isShade() ) { // for shaded maximized windows adjust frame and draw the bottom part of it helper().drawFloatFrame( painter, frame, backgroundColor( widget(), palette ), !( compositingActive() || _configuration->frameBorder() == Configuration::BorderNone ), isActive(), KDecoration::options()->color(ColorTitleBar), TileSet::Bottom ); } } //____________________________________________________________________________ void Client::renderDots( QPainter* painter, const QRect& frame, const QColor& color ) const { if( _configuration->frameBorder() >= Configuration::BorderTiny ) { // dimensions int x,y,w,h; frame.getRect(&x, &y, &w, &h); if( isResizable() && !isShade() && !isMaximized() ) { // Draw right side 3-dots resize handles const int cenY = (h / 2 + y) ; const int posX = (w + x - 3); helper().renderDot( painter, QPoint(posX, cenY - 3), color); helper().renderDot( painter, QPoint(posX, cenY), color); helper().renderDot( painter, QPoint(posX, cenY + 3), color); } // Draw bottom-right cornet 3-dots resize handles if( isResizable() && !isShade() && !_configuration->drawSizeGrip() ) { painter->save(); painter->translate(x + w-9, y + h-9); helper().renderDot( painter, QPoint(2, 6), color); helper().renderDot( painter, QPoint(5, 5), color); helper().renderDot( painter, QPoint(6, 2), color); painter->restore(); } } } //_________________________________________________________ void Client::activeChange( void ) { KCommonDecoration::activeChange(); _itemData.setDirty( true ); // reset animation if( shadowAnimationsEnabled() ) { _glowAnimation->setDirection( isActive() ? Animation::Forward : Animation::Backward ); if(!glowIsAnimated()) { _glowAnimation->start(); } } // update size grip so that it gets the right color // also make sure it is remaped to from z stack, // unless hidden if( hasSizeGrip() && !(isShade() || isMaximized() )) { sizeGrip().activeChange(); sizeGrip().update(); } } //_________________________________________________________ void Client::maximizeChange( void ) { if( hasSizeGrip() ) sizeGrip().setVisible( !( isShade() || isMaximized() ) ); setAlphaEnabled(!isMaximized()); KCommonDecoration::maximizeChange(); } //_________________________________________________________ void Client::shadeChange( void ) { if( hasSizeGrip() ) sizeGrip().setVisible( !( isShade() || isMaximized() ) ); KCommonDecoration::shadeChange(); } //_________________________________________________________ void Client::captionChange( void ) { KCommonDecoration::captionChange(); _itemData.setDirty( true ); if( titleAnimationsEnabled() ) { _titleAnimationData->setDirty( true ); } } //_________________________________________________________ QPalette Client::backgroundPalette( const QWidget* widget, QPalette palette ) const { if( _configuration->drawTitleOutline() ) { if( glowIsAnimated() && !isForcedActive() ) { const QColor inactiveColor( backgroundColor( widget, palette, false ) ); const QColor activeColor( backgroundColor( widget, palette, true ) ); const QColor mixed( KColorUtils::mix( inactiveColor, activeColor, glowIntensity() ) ); palette.setColor( QPalette::Window, mixed ); palette.setColor( QPalette::Button, mixed ); } else if( isActive() || isForcedActive() ) { const QColor color = options()->color( KDecorationDefines::ColorTitleBar, true ); palette.setColor( QPalette::Window, color ); palette.setColor( QPalette::Button, color ); } } return palette; } //_________________________________________________________ QColor Client::backgroundColor( const QWidget*, QPalette palette, bool active ) const { return ( _configuration->drawTitleOutline() && active ) ? options()->color( KDecorationDefines::ColorTitleBar, true ): palette.color( QPalette::Window ); } //________________________________________________________________ void Client::updateWindowShape() { if(isMaximized()) clearMask(); else setMask( calcMask() ); } //______________________________________________________________________________ bool Client::eventFilter( QObject* object, QEvent* event ) { // all dedicated event filtering is here to handle multiple tabs. bool state = false; switch( event->type() ) { case QEvent::Show: if( widget() == object ) { _itemData.setDirty( true ); } break; case QEvent::MouseButtonPress: if( widget() == object ) { state = mousePressEvent( static_cast< QMouseEvent* >( event ) ); } break; case QEvent::MouseButtonRelease: if( widget() == object ) state = mouseReleaseEvent( static_cast< QMouseEvent* >( event ) ); else if( Button *btn = qobject_cast< Button* >( object ) ) { QMouseEvent* mouseEvent( static_cast< QMouseEvent* >( event ) ); if( mouseEvent->button() == Qt::LeftButton && btn->rect().contains( mouseEvent->pos() ) ) { state = closeItem( btn ); } } break; case QEvent::MouseMove: state = mouseMoveEvent( static_cast< QMouseEvent* >( event ) ); break; case QEvent::DragEnter: if( widget() == object ) { state = dragEnterEvent( static_cast< QDragEnterEvent* >( event ) ); } break; case QEvent::DragMove: if( widget() == object ) { state = dragMoveEvent( static_cast< QDragMoveEvent* >( event ) ); } break; case QEvent::DragLeave: if( widget() == object ) { state = dragLeaveEvent( static_cast< QDragLeaveEvent* >( event ) ); } break; case QEvent::Drop: if( widget() == object ) { state = dropEvent( static_cast< QDropEvent* >( event ) ); } break; default: break; } return state || KCommonDecoration::eventFilter( object, event ); } //_________________________________________________________ void Client::resizeEvent( QResizeEvent* event ) { // prepare item data updates _itemData.setDirty( true ); // mark title animation as dirty if( event->oldSize().width() != event->size().width() ) { _titleAnimationData->setDirty( true ); } // resize backing store pixmap if( !compositingActive() ) { _pixmap = QPixmap( event->size() ); } // base class implementation KCommonDecoration::resizeEvent( event ); } //_________________________________________________________ void Client::paintBackground( QPainter& painter ) const { if( !compositingActive() ) { painter.drawPixmap( QPoint(), _pixmap ); } } //_________________________________________________________ QRegion Client::region( KDecorationDefines::Region r ) { // return empty region for anything but extended borders, when enabled if( !( r == KDecorationDefines::ExtendedBorderRegion && configuration()->useExtendedWindowBorders() ) ) { return QRegion(); } // return empty region for maximized windows if( isMaximized() ) return QRegion(); // return 3 pixels extended borders for sides that have no visible borders // also add the invisible pixels at the masked rounded corners, in non compositing mode if( configuration()->frameBorder() <= Configuration::BorderNoSide || !compositingActive() ) { QRect rect = widget()->rect().adjusted( layoutMetric( LM_OuterPaddingLeft ), layoutMetric( LM_OuterPaddingTop ), - layoutMetric( LM_OuterPaddingRight ), - layoutMetric( LM_OuterPaddingBottom ) ); rect.translate( -layoutMetric( LM_OuterPaddingLeft ), -layoutMetric( LM_OuterPaddingTop ) ); // mask QRegion mask( calcMask() ); if( mask.isEmpty() ) mask = rect; else mask.translate( -layoutMetric( LM_OuterPaddingLeft ), -layoutMetric( LM_OuterPaddingTop ) ); // only return non-empty region on the sides for which there is no border if( configuration()->frameBorder() == Configuration::BorderNone ) return QRegion( rect.adjusted( -3, 0, 3, 3 ) ) - mask; else if( configuration()->frameBorder() == Configuration::BorderNoSide ) return QRegion( rect.adjusted( -3, 0, 3, 0 ) ) - mask; else if( !compositingActive() ) return QRegion( rect ) - mask; } // fall back return QRegion(); } //_________________________________________________________ void Client::paintEvent( QPaintEvent* event ) { // factory if(!( _initialized && _factory->initialized() ) ) return; if( compositingActive() ) { QPainter painter(widget()); painter.setRenderHint(QPainter::Antialiasing); painter.setClipRegion( event->region() ); paint( painter ); // update buttons QList buttons( widget()->findChildren() ); foreach( Button* button, buttons ) { if( ( button->isVisible() || isPreview() ) && event->rect().intersects( button->geometry() ) ) { painter.save(); painter.setViewport( button->geometry() ); painter.setWindow( button->rect() ); button->paint( painter ); painter.restore(); } } } else { { // update backing store pixmap QPainter painter( &_pixmap ); painter.setRenderHint(QPainter::Antialiasing); painter.setClipRegion( event->region() ); paint( painter ); } QPainter painter( widget() ); painter.setClipRegion( event->region() ); painter.drawPixmap( QPoint(), _pixmap ); // update buttons QList buttons( widget()->findChildren() ); foreach( Button* button, buttons ) { if( event->rect().intersects( button->geometry() ) ) { button->update(); } } } } //_________________________________________________________ void Client::paint( QPainter& painter ) { // palette QPalette palette = KCommonDecoration::palette(); palette.setCurrentColorGroup( (isActive() ) ? QPalette::Active : QPalette::Inactive ); // define frame QRect frame = widget()->rect(); // base color QColor color = palette.window().color(); // draw shadows if( compositingActive() && shadowCache().shadowSize() > 0 && !isMaximized() ) { TileSet *tileSet( 0 ); const ShadowCache::Key key( this->key() ); if( shadowCache().isEnabled( QPalette::Active ) && glowIsAnimated() && !isForcedActive() ) { tileSet = shadowCache().tileSet( key, glowIntensity() ); } else { tileSet = shadowCache().tileSet( key ); } tileSet->render( frame, &painter, TileSet::Ring); } // adjust frame frame.adjust( layoutMetric(LM_OuterPaddingLeft), layoutMetric(LM_OuterPaddingTop), -layoutMetric(LM_OuterPaddingRight), -layoutMetric(LM_OuterPaddingBottom) ); // adjust mask if( compositingActive() || isPreview() ) { if( isMaximized() ) { painter.setClipRect( frame, Qt::IntersectClip ); } else { // multipliers const int left = 1; const int right = 1; const int top = 1; int bottom = 1; // disable bottom corners when border frame is too small and window is not shaded if( _configuration->frameBorder() == Configuration::BorderNone && !isShade() ) bottom = 0; QRegion mask( helper().roundedMask( frame, left, right, top, bottom ) ); renderCorners( &painter, frame, palette ); painter.setClipRegion( mask, Qt::IntersectClip ); } } // make sure ItemData and tabList are synchronized /* this needs to be done before calling RenderWindowBorder since some painting in there depend on the clientGroups state */ if( _itemData.isDirty() || _itemData.count() != tabCount() ) { updateItemBoundingRects( false ); } // window background renderWindowBackground( &painter, frame, widget(), backgroundPalette( widget(), palette ) ); // window border (for title outline) if( hasTitleOutline() ) renderWindowBorder( &painter, frame, widget(), palette ); // clipping if( compositingActive() ) { painter.setClipping(false); frame.adjust(-1,-1, 1, 1); } // float frame renderFloatFrame( &painter, frame, palette ); // resize handles renderDots( &painter, frame, backgroundColor( widget(), palette ) ); if( !hideTitleBar() ) { // title bounding rect painter.setFont( options()->font(isActive(), false) ); // draw ClientGroupItems const int itemCount( _itemData.count() ); for( int i = 0; i < itemCount; i++ ) renderItem( &painter, i, palette ); // draw target rect renderTargetRect( &painter, widget()->palette() ); // separator if( itemCount == 1 && !_itemData.isAnimated() && drawSeparator() ) { renderSeparator(&painter, frame, widget(), color ); } } } //_____________________________________________________________ bool Client::mousePressEvent( QMouseEvent* event ) { const QPoint point = event->pos(); if( tabIndexAt( point ) < 0 ) return false; _dragPoint = point; _mouseButton = event->button(); bool accepted( false ); if( buttonToWindowOperation( _mouseButton ) == TabDragOp ) { accepted = true; } else if( buttonToWindowOperation( _mouseButton ) == OperationsOp ) { QPoint point = event->pos(); const int clickedIndex( tabIndexAt( point ) ); _mouseButton = Qt::NoButton; if ( tabIndexAt( point ) > -1) { showWindowMenu( widget()->mapToGlobal( event->pos() ), tabId(clickedIndex) ); } accepted = true; // displayClientMenu can possibly destroy the deco... } return accepted; } //_____________________________________________________________ bool Client::mouseReleaseEvent( QMouseEvent* event ) { bool accepted( false ); if( _mouseButton == event->button() && buttonToWindowOperation( _mouseButton ) != OperationsOp ) { const QPoint point = event->pos(); const long visibleItem = currentTabId(); const int clickedIndex( tabIndexAt( point ) ); if( clickedIndex >= 0 && visibleItem != tabId(clickedIndex) ) { setCurrentTab( tabId(clickedIndex) ); setForceActive( true ); accepted = true; } } _mouseButton = Qt::NoButton; return accepted; } //_____________________________________________________________ bool Client::mouseMoveEvent( QMouseEvent* event ) { // check button and distance to drag point if( hideTitleBar() || _mouseButton == Qt::NoButton || ( event->pos() - _dragPoint ).manhattanLength() <= QApplication::startDragDistance() ) { return false; } bool accepted( false ); if( buttonToWindowOperation( _mouseButton ) == TabDragOp ) { const QPoint point = event->pos(); const int clickedIndex( tabIndexAt( point ) ); if( clickedIndex < 0 ) return false; _titleAnimationData->reset(); QDrag *drag = new QDrag( widget() ); QMimeData *groupData = new QMimeData(); groupData->setData( tabDragMimeType(), QByteArray().setNum( (qint64) tabId(clickedIndex) ) ); drag->setMimeData( groupData ); _sourceItem = tabIndexAt( _dragPoint ); // get tab geometry QRect geometry( _itemData[clickedIndex]._boundingRect ); // remove space used for buttons if( _itemData.count() > 1 ) { geometry.adjust( 0, 0, - buttonSize() - layoutMetric(LM_TitleEdgeRight), 0 ); } else if( !( isActive() && _configuration->drawTitleOutline() ) ) { geometry.adjust( buttonsLeftWidth() + layoutMetric( LM_TitleEdgeLeft ) , 0, -( buttonsRightWidth() + layoutMetric( LM_TitleEdgeRight )), 0 ); } // adjust geometry to include shadow size const int shadowSize( shadowCache().shadowSize() ); const bool drawShadow( compositingActive() && - KStyle::customStyleHint( QStringLiteral("SH_ArgbDndWindow"), widget() ) && + //KStyle::customStyleHint( QStringLiteral("SH_ArgbDndWindow"), widget() ) && shadowSize > 0 ); if( drawShadow ) { geometry.adjust( -shadowSize, -shadowSize, shadowSize, shadowSize ); } // compute pixmap and assign drag->setPixmap( itemDragPixmap( clickedIndex, geometry, drawShadow ) ); // note: the pixmap is moved just above the pointer on purpose // because overlapping pixmap and pointer slows down the pixmap a lot. QPoint hotSpot( QPoint( event->pos().x() - geometry.left(), -1 ) ); if( drawShadow ) hotSpot += QPoint( 0, shadowSize ); // make sure the horizontal hotspot position is not too far away (more than 1px) // from the pixmap if( hotSpot.x() < -1 ) hotSpot.setX(-1); if( hotSpot.x() > geometry.width() ) hotSpot.setX( geometry.width() ); drag->setHotSpot( hotSpot ); _dragStartTimer.start( 50, this ); drag->exec( Qt::MoveAction ); // detach tab from window if( drag->target() == 0 && _itemData.count() > 1 ) { _itemData.setDirty( true ); untab( tabId(_sourceItem), widget()->frameGeometry().adjusted( layoutMetric( LM_OuterPaddingLeft ), layoutMetric( LM_OuterPaddingTop ), -layoutMetric( LM_OuterPaddingRight ), -layoutMetric( LM_OuterPaddingBottom ) ).translated( QCursor::pos() - event->pos() + QPoint( layoutMetric( LM_OuterPaddingLeft ), layoutMetric( LM_OuterPaddingTop ))) ); } // reset button _mouseButton = Qt::NoButton; accepted = true; } return accepted; } //_____________________________________________________________ bool Client::dragEnterEvent( QDragEnterEvent* event ) { // check if drag enter is allowed if( !event->mimeData()->hasFormat( tabDragMimeType() ) || hideTitleBar() ) return false; // accept event event->acceptProposedAction(); // animate if( event->source() != widget() ) { _itemData.animate( AnimationEnter, tabIndexAt( event->pos(), true ) ); } else if( _itemData.count() > 1 ) { _itemData.animate( AnimationEnter|AnimationSameTarget, tabIndexAt( event->pos(), true ) ); } return true; } //_____________________________________________________________ bool Client::dragLeaveEvent( QDragLeaveEvent* ) { if( _itemData.animationType() & AnimationSameTarget ) { if( _dragStartTimer.isActive() ) _dragStartTimer.stop(); _itemData.animate( AnimationLeave|AnimationSameTarget, _sourceItem ); } else if( _itemData.isAnimated() ) { _itemData.animate( AnimationLeave ); } return true; } //_____________________________________________________________ bool Client::dragMoveEvent( QDragMoveEvent* event ) { // check format if( !event->mimeData()->hasFormat( tabDragMimeType() ) ) return false; // animate if( event->source() != widget() ) { _itemData.animate( AnimationMove, tabIndexAt( event->pos(), true ) ); } else if( _itemData.count() > 1 ) { if( _dragStartTimer.isActive() ) _dragStartTimer.stop(); _itemData.animate( AnimationMove|AnimationSameTarget, tabIndexAt( event->pos(), true ) ); } return false; } //_____________________________________________________________ bool Client::dropEvent( QDropEvent* event ) { const QPoint point = event->pos(); _itemData.animate( AnimationNone ); const QMimeData *groupData = event->mimeData(); if( !groupData->hasFormat( tabDragMimeType() ) ) return false; _itemData.setDirty( true ); if( widget() != event->source() ) setForceActive( true ); const long source = QString::fromUtf8( groupData->data( tabDragMimeType() ) ).toLong(); const int clickedIndex( tabIndexAt( point, true ) ); if( clickedIndex < 0 ) tab_A_behind_B( source, tabId(_itemData.count()-1) ); else tab_A_before_B( source, tabId(clickedIndex) ); // update title if( widget() == event->source() ) updateTitleRect(); _titleAnimationData->reset(); return true; } //_____________________________________________________________ void Client::timerEvent( QTimerEvent* event ) { if( event->timerId() != _dragStartTimer.timerId() ) { return KCommonDecoration::timerEvent( event ); } _dragStartTimer.stop(); // do nothing if there is only one tab if( _itemData.count() > 1 ) { _itemData.animate( AnimationMove|AnimationSameTarget, _sourceItem ); _itemData.animate( AnimationLeave|AnimationSameTarget, _sourceItem ); } } //_____________________________________________________________ bool Client::closeItem( const Button* button ) { for( int i=0; i < _itemData.count(); i++ ) { if( button == _itemData[i]._closeButton.data() ) { _itemData.setDirty( true ); closeTab( tabId(i) ); return true; } } return false; } //________________________________________________________________ QPixmap Client::itemDragPixmap( int index, QRect geometry, bool drawShadow ) { const bool itemValid( index >= 0 && index < tabCount() ); QPixmap pixmap( geometry.size() ); pixmap.fill( Qt::transparent ); QPainter painter( &pixmap ); painter.setRenderHints(QPainter::SmoothPixmapTransform|QPainter::Antialiasing); painter.translate( -geometry.topLeft() ); // draw shadows if( drawShadow ) { // shadow const int shadowSize( shadowCache().shadowSize() ); TileSet *tileSet( shadowCache().tileSet( ShadowCache::Key() ) ); tileSet->render( geometry, &painter, TileSet::Ring); geometry.adjust( shadowSize, shadowSize, -shadowSize, -shadowSize ); renderCorners( &painter, geometry, widget()->palette() ); } // mask painter.setClipRegion( helper().roundedMask( geometry ), Qt::IntersectClip ); // render window background renderWindowBackground( &painter, geometry, widget(), widget()->palette() ); // darken background if item is inactive const bool itemActive = (tabCount() <= 1) || !( itemValid && tabId(index) != currentTabId() ); if( !itemActive ) { QLinearGradient lg( geometry.topLeft(), geometry.bottomLeft() ); lg.setColorAt( 0, helper().alphaColor( Qt::black, 0.05 ) ); lg.setColorAt( 1, helper().alphaColor( Qt::black, 0.10 ) ); painter.setBrush( lg ); painter.setPen( Qt::NoPen ); painter.drawRect( geometry ); } // render title text painter.setFont( options()->font(isActive(), false) ); QRect textRect( geometry.adjusted( 0, layoutMetric( LM_TitleEdgeTop )-1, 0, -1 ) ); if( itemValid ) { textRect.adjust( layoutMetric( LM_TitleBorderLeft ), 0, -layoutMetric(LM_TitleBorderRight), 0 ); } const QString caption( itemValid ? this->caption(index) : this->caption() ); renderTitleText( &painter, textRect, caption, titlebarTextColor( widget()->palette(), isActive() && itemActive ), titlebarContrastColor( widget()->palette() ) ); // adjust geometry for floatFrame when compositing is on. if( drawShadow ) { geometry.adjust(-1, -1, 1, 1 ); } // floating frame helper().drawFloatFrame( &painter, geometry, widget()->palette().window().color(), !drawShadow, false, KDecoration::options()->color(ColorTitleBar) ); painter.end(); return pixmap; } //_________________________________________________________________ void Client::createSizeGrip( void ) { assert( !hasSizeGrip() ); if( ( isResizable() && windowId() != 0 ) || isPreview() ) { _sizeGrip = new SizeGrip( this ); sizeGrip().setVisible( !( isMaximized() || isShade() ) ); } } //_________________________________________________________________ void Client::deleteSizeGrip( void ) { assert( hasSizeGrip() ); _sizeGrip->deleteLater(); _sizeGrip = 0; } //_________________________________________________________________ void Client::removeShadowHint( void ) { // do nothing if no window id if( !windowId() ) return; // create atom if( !_shadowAtom ) { _shadowAtom = helper().createAtom( QStringLiteral( "_KDE_NET_WM_SHADOW" ) ); } xcb_delete_property( helper().xcbConnection(), (xcb_window_t) windowId(), _shadowAtom); } }