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
  27 #include <kdebug.h>
  28 #include <QApplication>
  29 #include <kglobal.h>
  30 #include <assert.h>
  31 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
  32 #include <X11/Xlib.h>
  33 #include <fixx11h.h>
  34 #include <QX11Info>
  35 #endif
  36
  37 #include "kdecoration_p.h"
  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     setMainWidget(w);
  86     }
  87
  88 void KDecoration::setMainWidget( QWidget* w )
  89     {
  90     assert( w_ == NULL );
  91     w_ = w;
  92     w->setMouseTracking( true );
  93     widget()->resize( geometry().size());
  94     }
  95
  96 QWidget* KDecoration::initialParentWidget() const
  97     {
  98     return bridge_->initialParentWidget();
  99     }
 100
 101 Qt::WFlags KDecoration::initialWFlags() const
 102     {
 103     return bridge_->initialWFlags();
 104     }
 105
 106 bool KDecoration::isActive() const
 107     {
 108     return bridge_->isActive();
 109     }
 110
 111 bool KDecoration::isCloseable() const
 112     {
 113     return bridge_->isCloseable();
 114     }
 115
 116 bool KDecoration::isMaximizable() const
 117     {
 118     return bridge_->isMaximizable();
 119     }
 120
 121 KDecoration::MaximizeMode KDecoration::maximizeMode() const
 122     {
 123     return bridge_->maximizeMode();
 124     }
 125
 126 bool KDecoration::isMinimizable() const
 127     {
 128     return bridge_->isMinimizable();
 129     }
 130
 131 bool KDecoration::providesContextHelp() const
 132     {
 133     return bridge_->providesContextHelp();
 134     }
 135
 136 int KDecoration::desktop() const
 137     {
 138     return bridge_->desktop();
 139     }
 140
 141 bool KDecoration::isModal() const
 142     {
 143     return bridge_->isModal();
 144     }
 145
 146 bool KDecoration::isShadeable() const
 147     {
 148     return bridge_->isShadeable();
 149     }
 150
 151 bool KDecoration::isShade() const
 152     {
 153     return bridge_->isShade();
 154     }
 155
 156 bool KDecoration::isSetShade() const
 157     {
 158     return bridge_->isSetShade();
 159     }
 160
 161 bool KDecoration::keepAbove() const
 162     {
 163     return bridge_->keepAbove();
 164     }
 165
 166 bool KDecoration::keepBelow() const
 167     {
 168     return bridge_->keepBelow();
 169     }
 170
 171 bool KDecoration::isMovable() const
 172     {
 173     return bridge_->isMovable();
 174     }
 175
 176 bool KDecoration::isResizable() const
 177     {
 178     return bridge_->isResizable();
 179     }
 180
 181 NET::WindowType KDecoration::windowType( unsigned long supported_types ) const
 182     { // this one is also duplicated in KDecorationFactory
 183     return bridge_->windowType( supported_types );
 184     }
 185
 186 QIcon KDecoration::icon() const
 187     {
 188     return bridge_->icon();
 189     }
 190
 191 QString KDecoration::caption() const
 192     {
 193     return bridge_->caption();
 194     }
 195
 196 void KDecoration::processMousePressEvent( QMouseEvent* e )
 197     {
 198     return bridge_->processMousePressEvent( e );
 199     }
 200
 201 void KDecoration::showWindowMenu( const QRect &pos )
 202     {
 203     bridge_->showWindowMenu( pos );
 204     }
 205
 206 void KDecoration::showWindowMenu( QPoint pos )
 207     {
 208     bridge_->showWindowMenu( pos );
 209     }
 210
 211 void KDecoration::performWindowOperation( WindowOperation op )
 212     {
 213     bridge_->performWindowOperation( op );
 214     }
 215
 216 void KDecoration::setMask( const QRegion& reg, int mode )
 217     {
 218     bridge_->setMask( reg, mode );
 219     }
 220
 221 void KDecoration::clearMask()
 222     {
 223     bridge_->setMask( QRegion(), 0 );
 224     }
 225
 226 bool KDecoration::isPreview() const
 227     {
 228     return bridge_->isPreview();
 229     }
 230
 231 QRect KDecoration::geometry() const
 232     {
 233     return bridge_->geometry();
 234     }
 235
 236 QRect KDecoration::iconGeometry() const
 237     {
 238     return bridge_->iconGeometry();
 239     }
 240
 241 QRegion KDecoration::unobscuredRegion( const QRegion& r ) const
 242     {
 243     return bridge_->unobscuredRegion( r );
 244     }
 245
 246 WId KDecoration::windowId() const
 247     {
 248     return bridge_->windowId();
 249     }
 250
 251 void KDecoration::closeWindow()
 252     {
 253     bridge_->closeWindow();
 254     }
 255
 256 void KDecoration::maximize( Qt::MouseButtons button )
 257     {
 258     performWindowOperation( options()->operationMaxButtonClick( button ));
 259     }
 260
 261 void KDecoration::maximize( MaximizeMode mode )
 262     {
 263     bridge_->maximize( mode );
 264     }
 265
 266 void KDecoration::minimize()
 267     {
 268     bridge_->minimize();
 269     }
 270
 271 void KDecoration::showContextHelp()
 272     {
 273     bridge_->showContextHelp();
 274     }
 275
 276 void KDecoration::setDesktop( int desktop )
 277     {
 278     bridge_->setDesktop( desktop );
 279     }
 280
 281 void KDecoration::toggleOnAllDesktops()
 282     {
 283     if( isOnAllDesktops())
 284         setDesktop( bridge_->currentDesktop());
 285     else
 286         setDesktop( NET::OnAllDesktops );
 287     }
 288
 289 void KDecoration::titlebarDblClickOperation()
 290     {
 291     bridge_->titlebarDblClickOperation();
 292     }
 293
 294 void KDecoration::titlebarMouseWheelOperation( int delta )
 295     {
 296     bridge_->titlebarMouseWheelOperation( delta );
 297     }
 298
 299 void KDecoration::setShade( bool set )
 300     {
 301     bridge_->setShade( set );
 302     }
 303
 304 void KDecoration::setKeepAbove( bool set )
 305     {
 306     bridge_->setKeepAbove( set );
 307     }
 308
 309 void KDecoration::setKeepBelow( bool set )
 310     {
 311     bridge_->setKeepBelow( set );
 312     }
 313
 314 void KDecoration::emitKeepAboveChanged( bool above )
 315     {
 316     keepAboveChanged( above );
 317     }
 318
 319 void KDecoration::emitKeepBelowChanged( bool below )
 320     {
 321     keepBelowChanged( below );
 322     }
 323
 324 bool KDecoration::drawbound( const QRect&, bool )
 325     {
 326     return false;
 327     }
 328
 329 bool KDecoration::windowDocked( Position )
 330     {
 331     return false;
 332     }
 333
 334 void KDecoration::reset( unsigned long )
 335     {
 336     }
 337
 338 void KDecoration::grabXServer()
 339     {
 340     bridge_->grabXServer( true );
 341     }
 342
 343 void KDecoration::ungrabXServer()
 344     {
 345     bridge_->grabXServer( false );
 346     }
 347
 348 KDecoration::Position KDecoration::mousePosition( const QPoint& p ) const
 349     {
 350     const int range = 16;
 351     int bleft, bright, btop, bbottom;
 352     borders( bleft, bright, btop, bbottom );
 353     btop = qMin( btop, 4 ); // otherwise whole titlebar would have resize cursor
 354
 355     Position m = PositionCenter;
 356
 357     if ( ( p.x() > bleft && p.x() < widget()->width() - bright )
 358          && ( p.y() > btop && p.y() < widget()->height() - bbottom ) )
 359         return PositionCenter;
 360
 361     if ( p.y() <= qMax( range, btop ) && p.x() <= qMax( range, bleft ))
 362         m = PositionTopLeft;
 363     else if ( p.y() >= widget()->height()- qMax( range, bbottom )
 364         && p.x() >= widget()->width()- qMax( range, bright ))
 365         m = PositionBottomRight;
 366     else if ( p.y() >= widget()->height()- qMax( range, bbottom ) && p.x() <= qMax( range, bleft ))
 367         m = PositionBottomLeft;
 368     else if ( p.y() <= qMax( range, btop ) && p.x() >= widget()->width()- qMax( range, bright ))
 369         m = PositionTopRight;
 370     else if ( p.y() <= btop )
 371         m = PositionTop;
 372     else if ( p.y() >= widget()->height()-bbottom )
 373         m = PositionBottom;
 374     else if ( p.x() <= bleft )
 375         m = PositionLeft;
 376     else if ( p.x() >= widget()->width()-bright )
 377         m = PositionRight;
 378     else
 379         m = PositionCenter;
 380     return m;
 381     }
 382
 383 KDecorationOptions::KDecorationOptions()
 384     : d( new KDecorationOptionsPrivate )
 385     {
 386     assert( KDecoration::options_ == NULL );
 387     KDecoration::options_ = this;
 388     }
 389
 390 KDecorationOptions::~KDecorationOptions()
 391     {
 392     assert( KDecoration::options_ == this );
 393     KDecoration::options_ = NULL;
 394     delete d;
 395     }
 396
 397 QColor KDecorationOptions::color(ColorType type, bool active) const
 398     {
 399     return(d->colors[type + (active ? 0 : NUM_COLORS)]);
 400     }
 401
 402 QFont KDecorationOptions::font(bool active, bool small) const
 403     {
 404     if ( small )
 405         return(active ? d->activeFontSmall : d->inactiveFontSmall);
 406     else
 407         return(active ? d->activeFont : d->inactiveFont);
 408     }
 409
 410 QPalette KDecorationOptions::palette(ColorType type, bool active) const
 411     {
 412     int idx = type + (active ? 0 : NUM_COLORS);
 413     if(d->pal[idx])
 414         return(*d->pal[idx]);
 415 #ifdef __GNUC__
 416 #warning KDE4 : why construct the palette this way?
 417 #endif
 418                 // TODO: Is this worth 'porting' to Qt4?
 419 //     d->pal[idx] = new QPalette(Qt::black, d->colors[idx], d->colors[idx].light(150),
 420 //                               d->colors[idx].dark(), d->colors[idx].dark(120),
 421 //                               Qt::black, QApplication::palette().active().
 422 //                               base());
 423     d->pal[idx] = new QPalette(d->colors[idx]);
 424     return(*d->pal[idx]);
 425     }
 426
 427 unsigned long KDecorationOptions::updateSettings( KConfig* config )
 428     {
 429     return d->updateSettings( config );
 430     }
 431
 432 bool KDecorationOptions::customButtonPositions() const
 433     {
 434     return d->custom_button_positions;
 435     }
 436
 437 QString KDecorationOptions::titleButtonsLeft() const
 438     {
 439     return d->title_buttons_left;
 440     }
 441
 442 QString KDecorationOptions::defaultTitleButtonsLeft()
 443     {
 444     return "MS";
 445     }
 446
 447 QString KDecorationOptions::titleButtonsRight() const
 448     {
 449     return d->title_buttons_right;
 450     }
 451
 452 QString KDecorationOptions::defaultTitleButtonsRight()
 453     {
 454     return "HIA__X";
 455     }
 456
 457 bool KDecorationOptions::showTooltips() const
 458     {
 459     return d->show_tooltips;
 460     }
 461
 462 KDecorationOptions::BorderSize KDecorationOptions::preferredBorderSize( KDecorationFactory* factory ) const
 463     {
 464     assert( factory != NULL );
 465     if( d->cached_border_size == BordersCount ) // invalid
 466         d->cached_border_size = d->findPreferredBorderSize( d->border_size,
 467             factory->borderSizes());
 468     return d->cached_border_size;
 469     }
 470
 471 bool KDecorationOptions::moveResizeMaximizedWindows() const
 472     {
 473     return d->move_resize_maximized_windows;
 474     }
 475
 476 KDecorationDefines::WindowOperation KDecorationOptions::operationMaxButtonClick( Qt::MouseButtons button ) const
 477     {
 478     return button == Qt::RightButton? d->opMaxButtonRightClick :
 479            button == Qt::MidButton?   d->opMaxButtonMiddleClick :
 480                                       d->opMaxButtonLeftClick;
 481     }
 482
 483 void KDecorationOptions::setOpMaxButtonLeftClick( WindowOperation op )
 484     {
 485     d->opMaxButtonLeftClick = op;
 486     }
 487
 488 void KDecorationOptions::setOpMaxButtonRightClick( WindowOperation op )
 489     {
 490     d->opMaxButtonRightClick = op;
 491     }
 492
 493 void KDecorationOptions::setOpMaxButtonMiddleClick( WindowOperation op )
 494     {
 495     d->opMaxButtonMiddleClick = op;
 496     }
 497
 498 void KDecorationOptions::setBorderSize( BorderSize bs )
 499     {
 500     d->border_size = bs;
 501     d->cached_border_size = BordersCount; // invalid
 502     }
 503
 504 void KDecorationOptions::setCustomButtonPositions( bool b )
 505     {
 506     d->custom_button_positions = b;
 507     }
 508
 509 void KDecorationOptions::setTitleButtonsLeft( const QString& b )
 510     {
 511     d->title_buttons_left = b;
 512     }
 513
 514 void KDecorationOptions::setTitleButtonsRight( const QString& b )
 515     {
 516     d->title_buttons_right = b;
 517     }
 518
 519 #include "kdecoration.moc"