workspace/kwin/lib/kdecoration.cpp

   1 /*****************************************************************
   2 This file is part of the KDE project.
   3
   4 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
   5
   6 Permission is hereby granted, free of charge, to any person obtaining a
   7 copy of this software and associated documentation files (the "Software"),
   8 to deal in the Software without restriction, including without limitation
   9 the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10 and/or sell copies of the Software, and to permit persons to whom the
  11 Software is furnished to do so, subject to the following conditions:
  12
  13 The above copyright notice and this permission notice shall be included in
  14 all copies or substantial portions of the Software.
  15
  16 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22 DEALINGS IN THE SOFTWARE.
  23 ******************************************************************/
  24
  25 #include "kdecoration.h"
  26 #include "kdecoration_p.h"
  27
  28 #include <kdebug.h>
  29 #include <QApplication>
  30 #include <kglobal.h>
  31 #include <assert.h>
  32 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
  33 #include <X11/Xlib.h>
  34 #include <fixx11h.h>
  35 #include <QX11Info>
  36 #endif
  37
  38 #include "kdecorationfactory.h"
  39 #include "kdecorationbridge.h"
  40
  41 /*
  42
  43 Extending KDecoration:
  44 ======================
  45
  46 If KDecoration will ever need to be extended in a way that'd break binary compatibility
  47 (i.e. adding new virtual methods most probably), new class KDecoration2 should be
  48 inherited from KDecoration and those methods added there. Code that would depend
  49 on the new functionality could then dynamic_cast<> to KDecoration2 to check whether
  50 it is available and use it.
  51
  52 KCommonDecoration would have to be extended the same way, adding KCommonDecoration2
  53 inheriting KCommonDecoration and adding the new API matching KDecoration2.
  54
  55 */
  56
  57
  58 KDecorationOptions* KDecoration::options_;
  59
  60 KDecoration::KDecoration( KDecorationBridge* bridge, KDecorationFactory* factory )
  61     :   bridge_( bridge ),
  62         w_( NULL ),
  63         factory_( factory )
  64     {
  65     factory->addDecoration( this );
  66     }
  67
  68 KDecoration::~KDecoration()
  69     {
  70     factory()->removeDecoration( this );
  71     delete w_;
  72     }
  73
  74 const KDecorationOptions* KDecoration::options()
  75     {
  76     return options_;
  77     }
  78
  79 void KDecoration::createMainWidget( Qt::WFlags flags )
  80     {
  81     // FRAME check flags?
  82     QWidget *w = new QWidget( initialParentWidget(), initialWFlags() | flags );
  83     w->setObjectName("decoration widget");
  84     w->setAttribute( Qt::WA_PaintOnScreen );
  85     if ( options()->showTooltips() )
  86         w->setAttribute( Qt::WA_AlwaysShowToolTips );
  87     setMainWidget(w);
  88     }
  89
  90 void KDecoration::setMainWidget( QWidget* w )
  91     {
  92     assert( w_ == NULL );
  93     w_ = w;
  94     w->setMouseTracking( true );
  95     widget()->resize( geometry().size());
  96     }
  97
  98 QWidget* KDecoration::initialParentWidget() const
  99     {
 100     return bridge_->initialParentWidget();
 101     }
 102
 103 Qt::WFlags KDecoration::initialWFlags() const
 104     {
 105     return bridge_->initialWFlags();
 106     }
 107
 108 bool KDecoration::isActive() const
 109     {
 110     return bridge_->isActive();
 111     }
 112
 113 bool KDecoration::isCloseable() const
 114     {
 115     return bridge_->isCloseable();
 116     }
 117
 118 bool KDecoration::isMaximizable() const
 119     {
 120     return bridge_->isMaximizable();
 121     }
 122
 123 KDecoration::MaximizeMode KDecoration::maximizeMode() const
 124     {
 125     return bridge_->maximizeMode();
 126     }
 127
 128 bool KDecoration::isMinimizable() const
 129     {
 130     return bridge_->isMinimizable();
 131     }
 132
 133 bool KDecoration::providesContextHelp() const
 134     {
 135     return bridge_->providesContextHelp();
 136     }
 137
 138 int KDecoration::desktop() const
 139     {
 140     return bridge_->desktop();
 141     }
 142
 143 bool KDecoration::isModal() const
 144     {
 145     return bridge_->isModal();
 146     }
 147
 148 bool KDecoration::isShadeable() const
 149     {
 150     return bridge_->isShadeable();
 151     }
 152
 153 bool KDecoration::isShade() const
 154     {
 155     return bridge_->isShade();
 156     }
 157
 158 bool KDecoration::isSetShade() const
 159     {
 160     return bridge_->isSetShade();
 161     }
 162
 163 bool KDecoration::keepAbove() const
 164     {
 165     return bridge_->keepAbove();
 166     }
 167
 168 bool KDecoration::keepBelow() const
 169     {
 170     return bridge_->keepBelow();
 171     }
 172
 173 bool KDecoration::isMovable() const
 174     {
 175     return bridge_->isMovable();
 176     }
 177
 178 bool KDecoration::isResizable() const
 179     {
 180     return bridge_->isResizable();
 181     }
 182
 183 NET::WindowType KDecoration::windowType( unsigned long supported_types ) const
 184     { // this one is also duplicated in KDecorationFactory
 185     return bridge_->windowType( supported_types );
 186     }
 187
 188 QIcon KDecoration::icon() const
 189     {
 190     return bridge_->icon();
 191     }
 192
 193 QString KDecoration::caption() const
 194     {
 195     return bridge_->caption();
 196     }
 197
 198 void KDecoration::processMousePressEvent( QMouseEvent* e )
 199     {
 200     return bridge_->processMousePressEvent( e );
 201     }
 202
 203 void KDecoration::showWindowMenu( const QRect &pos )
 204     {
 205     bridge_->showWindowMenu( pos );
 206     }
 207
 208 void KDecoration::showWindowMenu( QPoint pos )
 209     {
 210     bridge_->showWindowMenu( pos );
 211     }
 212
 213 void KDecoration::performWindowOperation( WindowOperation op )
 214     {
 215     bridge_->performWindowOperation( op );
 216     }
 217
 218 void KDecoration::setMask( const QRegion& reg, int mode )
 219     {
 220     bridge_->setMask( reg, mode );
 221     }
 222
 223 void KDecoration::clearMask()
 224     {
 225     bridge_->setMask( QRegion(), 0 );
 226     }
 227
 228 bool KDecoration::isPreview() const
 229     {
 230     return bridge_->isPreview();
 231     }
 232
 233 QRect KDecoration::geometry() const
 234     {
 235     return bridge_->geometry();
 236     }
 237
 238 QRect KDecoration::iconGeometry() const
 239     {
 240     return bridge_->iconGeometry();
 241     }
 242
 243 QRegion KDecoration::unobscuredRegion( const QRegion& r ) const
 244     {
 245     return bridge_->unobscuredRegion( r );
 246     }
 247
 248 WId KDecoration::windowId() const
 249     {
 250     return bridge_->windowId();
 251     }
 252
 253 void KDecoration::closeWindow()
 254     {
 255     bridge_->closeWindow();
 256     }
 257
 258 void KDecoration::maximize( Qt::MouseButtons button )
 259     {
 260     performWindowOperation( options()->operationMaxButtonClick( button ));
 261     }
 262
 263 void KDecoration::maximize( MaximizeMode mode )
 264     {
 265     bridge_->maximize( mode );
 266     }
 267
 268 void KDecoration::minimize()
 269     {
 270     bridge_->minimize();
 271     }
 272
 273 void KDecoration::showContextHelp()
 274     {
 275     bridge_->showContextHelp();
 276     }
 277
 278 void KDecoration::setDesktop( int desktop )
 279     {
 280     bridge_->setDesktop( desktop );
 281     }
 282
 283 void KDecoration::toggleOnAllDesktops()
 284     {
 285     if( isOnAllDesktops())
 286         setDesktop( bridge_->currentDesktop());
 287     else
 288         setDesktop( NET::OnAllDesktops );
 289     }
 290
 291 void KDecoration::titlebarDblClickOperation()
 292     {
 293     bridge_->titlebarDblClickOperation();
 294     }
 295
 296 void KDecoration::titlebarMouseWheelOperation( int delta )
 297     {
 298     bridge_->titlebarMouseWheelOperation( delta );
 299     }
 300
 301 void KDecoration::setShade( bool set )
 302     {
 303     bridge_->setShade( set );
 304     }
 305
 306 void KDecoration::setKeepAbove( bool set )
 307     {
 308     bridge_->setKeepAbove( set );
 309     }
 310
 311 void KDecoration::setKeepBelow( bool set )
 312     {
 313     bridge_->setKeepBelow( set );
 314     }
 315
 316 void KDecoration::emitKeepAboveChanged( bool above )
 317     {
 318     keepAboveChanged( above );
 319     }
 320
 321 void KDecoration::emitKeepBelowChanged( bool below )
 322     {
 323     keepBelowChanged( below );
 324     }
 325
 326 bool KDecoration::drawbound( const QRect&, bool )
 327     {
 328     return false;
 329     }
 330
 331 bool KDecoration::windowDocked( Position )
 332     {
 333     return false;
 334     }
 335
 336 void KDecoration::reset( unsigned long )
 337     {
 338     }
 339
 340 void KDecoration::grabXServer()
 341     {
 342     bridge_->grabXServer( true );
 343     }
 344
 345 void KDecoration::ungrabXServer()
 346     {
 347     bridge_->grabXServer( false );
 348     }
 349
 350 KDecoration::Position KDecoration::mousePosition( const QPoint& p ) const
 351     {
 352     const int range = 16;
 353     int bleft, bright, btop, bbottom;
 354     borders( bleft, bright, btop, bbottom );
 355     btop = qMin( btop, 4 ); // otherwise whole titlebar would have resize cursor
 356
 357     Position m = PositionCenter;
 358
 359     if ( ( p.x() > bleft && p.x() < widget()->width() - bright )
 360          && ( p.y() > btop && p.y() < widget()->height() - bbottom ) )
 361         return PositionCenter;
 362
 363     if ( p.y() <= qMax( range, btop ) && p.x() <= qMax( range, bleft ))
 364         m = PositionTopLeft;
 365     else if ( p.y() >= widget()->height()- qMax( range, bbottom )
 366         && p.x() >= widget()->width()- qMax( range, bright ))
 367         m = PositionBottomRight;
 368     else if ( p.y() >= widget()->height()- qMax( range, bbottom ) && p.x() <= qMax( range, bleft ))
 369         m = PositionBottomLeft;
 370     else if ( p.y() <= qMax( range, btop ) && p.x() >= widget()->width()- qMax( range, bright ))
 371         m = PositionTopRight;
 372     else if ( p.y() <= btop )
 373         m = PositionTop;
 374     else if ( p.y() >= widget()->height()-bbottom )
 375         m = PositionBottom;
 376     else if ( p.x() <= bleft )
 377         m = PositionLeft;
 378     else if ( p.x() >= widget()->width()-bright )
 379         m = PositionRight;
 380     else
 381         m = PositionCenter;
 382     return m;
 383     }
 384
 385
 386 KDecorationUnstable::KDecorationUnstable( KDecorationBridge* bridge, KDecorationFactory* factory )
 387     : KDecoration( bridge, factory )
 388     {
 389     Q_ASSERT( dynamic_cast< KDecorationBridgeUnstable* >( bridge ));
 390     }
 391
 392 KDecorationUnstable::~KDecorationUnstable()
 393     {
 394     }
 395
 396 QList<QRect> KDecorationUnstable::shadowQuads( ShadowType type ) const
 397     {
 398     Q_UNUSED( type );
 399     return QList<QRect>();
 400     }
 401
 402 double KDecorationUnstable::shadowOpacity( ShadowType type ) const
 403     {
 404     if( isActive() && type == ShadowBorderedActive )
 405         return 1.0;
 406     else if( !isActive() && type == ShadowBorderedInactive )
 407         return 1.0;
 408     return 0.0;
 409     }
 410
 411 double KDecorationUnstable::shadowBrightness( ShadowType type ) const
 412     {
 413     Q_UNUSED( type );
 414     return 1.0;
 415     }
 416
 417 double KDecorationUnstable::shadowSaturation( ShadowType type ) const
 418     {
 419     Q_UNUSED( type );
 420     return 1.0;
 421     }
 422
 423 void KDecorationUnstable::repaintShadow()
 424     {
 425     static_cast< KDecorationBridgeUnstable* >( bridge_ )->repaintShadow();
 426     }
 427
 428 bool KDecorationUnstable::compositingActive() const
 429     {
 430     return static_cast< KDecorationBridgeUnstable* >( bridge_ )->compositingActive();
 431     }
 432
 433 bool KDecorationUnstable::shadowsActive() const
 434     {
 435     return static_cast< KDecorationBridgeUnstable* >( bridge_ )->shadowsActive();
 436     }
 437
 438 double KDecorationUnstable::opacity() const
 439     {
 440     return static_cast< KDecorationBridgeUnstable* >( bridge_ )->opacity();
 441     }
 442
 443
 444 KDecorationOptions::KDecorationOptions()
 445     : d( new KDecorationOptionsPrivate )
 446     {
 447     assert( KDecoration::options_ == NULL );
 448     KDecoration::options_ = this;
 449     }
 450
 451 KDecorationOptions::~KDecorationOptions()
 452     {
 453     assert( KDecoration::options_ == this );
 454     KDecoration::options_ = NULL;
 455     delete d;
 456     }
 457
 458 QColor KDecorationOptions::color(ColorType type, bool active) const
 459     {
 460     return(d->colors[type + (active ? 0 : NUM_COLORS)]);
 461     }
 462
 463 QFont KDecorationOptions::font(bool active, bool small) const
 464     {
 465     if ( small )
 466         return(active ? d->activeFontSmall : d->inactiveFontSmall);
 467     else
 468         return(active ? d->activeFont : d->inactiveFont);
 469     }
 470
 471 QPalette KDecorationOptions::palette(ColorType type, bool active) const
 472     {
 473     int idx = type + (active ? 0 : NUM_COLORS);
 474     if(d->pal[idx])
 475         return(*d->pal[idx]);
 476 #ifdef __GNUC__
 477 #warning KDE4 : why construct the palette this way?
 478 #endif
 479                 // TODO: Is this worth 'porting' to Qt4?
 480 //     d->pal[idx] = new QPalette(Qt::black, d->colors[idx], d->colors[idx].light(150),
 481 //                               d->colors[idx].dark(), d->colors[idx].dark(120),
 482 //                               Qt::black, QApplication::palette().active().
 483 //                               base());
 484     d->pal[idx] = new QPalette(d->colors[idx]);
 485     return(*d->pal[idx]);
 486     }
 487
 488 unsigned long KDecorationOptions::updateSettings( KConfig* config )
 489     {
 490     return d->updateSettings( config );
 491     }
 492
 493 bool KDecorationOptions::customButtonPositions() const
 494     {
 495     return d->custom_button_positions;
 496     }
 497
 498 QString KDecorationOptions::titleButtonsLeft() const
 499     {
 500     return d->title_buttons_left;
 501     }
 502
 503 QString KDecorationOptions::defaultTitleButtonsLeft()
 504     {
 505     return "MS";
 506     }
 507
 508 QString KDecorationOptions::titleButtonsRight() const
 509     {
 510     return d->title_buttons_right;
 511     }
 512
 513 QString KDecorationOptions::defaultTitleButtonsRight()
 514     {
 515     return "HIA__X";
 516     }
 517
 518 bool KDecorationOptions::showTooltips() const
 519     {
 520     return d->show_tooltips;
 521     }
 522
 523 KDecorationOptions::BorderSize KDecorationOptions::preferredBorderSize( KDecorationFactory* factory ) const
 524     {
 525     assert( factory != NULL );
 526     if( d->cached_border_size == BordersCount ) // invalid
 527         d->cached_border_size = d->findPreferredBorderSize( d->border_size,
 528             factory->borderSizes());
 529     return d->cached_border_size;
 530     }
 531
 532 bool KDecorationOptions::moveResizeMaximizedWindows() const
 533     {
 534     return d->move_resize_maximized_windows;
 535     }
 536
 537 KDecorationDefines::WindowOperation KDecorationOptions::operationMaxButtonClick( Qt::MouseButtons button ) const
 538     {
 539     return button == Qt::RightButton? d->opMaxButtonRightClick :
 540            button == Qt::MidButton?   d->opMaxButtonMiddleClick :
 541                                       d->opMaxButtonLeftClick;
 542     }
 543
 544 void KDecorationOptions::setOpMaxButtonLeftClick( WindowOperation op )
 545     {
 546     d->opMaxButtonLeftClick = op;
 547     }
 548
 549 void KDecorationOptions::setOpMaxButtonRightClick( WindowOperation op )
 550     {
 551     d->opMaxButtonRightClick = op;
 552     }
 553
 554 void KDecorationOptions::setOpMaxButtonMiddleClick( WindowOperation op )
 555     {
 556     d->opMaxButtonMiddleClick = op;
 557     }
 558
 559 void KDecorationOptions::setBorderSize( BorderSize bs )
 560     {
 561     d->border_size = bs;
 562     d->cached_border_size = BordersCount; // invalid
 563     }
 564
 565 void KDecorationOptions::setCustomButtonPositions( bool b )
 566     {
 567     d->custom_button_positions = b;
 568     }
 569
 570 void KDecorationOptions::setTitleButtonsLeft( const QString& b )
 571     {
 572     d->title_buttons_left = b;
 573     }
 574
 575 void KDecorationOptions::setTitleButtonsRight( const QString& b )
 576     {
 577     d->title_buttons_right = b;
 578     }
 579
 580 #include "kdecoration.moc"