workspace/kwin/effects/boxswitch.cpp

   1 /********************************************************************
   2  KWin - the KDE window manager
   3  This file is part of the KDE project.
   4
   5 Copyright (C) 2007 Philip Falkner <philip.falkner@gmail.com>
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 *********************************************************************/
  20
  21 #include <kwinconfig.h>
  22
  23 #include "boxswitch.h"
  24
  25 #include <QCursor>
  26 #include <QMouseEvent>
  27 #include <QPainter>
  28 #include <QSize>
  29
  30 #include <kapplication.h>
  31 #include <kcolorscheme.h>
  32
  33 #ifdef KWIN_HAVE_OPENGL_COMPOSITING
  34 #include <GL/gl.h>
  35 #endif
  36
  37 namespace KWin
  38 {
  39
  40 KWIN_EFFECT( boxswitch, BoxSwitchEffect )
  41
  42 BoxSwitchEffect::BoxSwitchEffect()
  43     : mActivated( 0 )
  44     , mMode( 0 )
  45     , selected_window( 0 )
  46     , painting_desktop( 0 )
  47     {
  48     frame_margin = 10;
  49     highlight_margin = 5;
  50 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
  51     alphaFormat = XRenderFindStandardFormat( display(), PictStandardARGB32 );
  52 #endif
  53     color_frame = KColorScheme( QPalette::Active, KColorScheme::Window ).background().color();
  54     color_frame.setAlphaF( 0.9 );
  55     color_highlight = KColorScheme( QPalette::Active, KColorScheme::Selection ).background().color();
  56     color_highlight.setAlphaF( 0.9 );
  57     color_text = KColorScheme( QPalette::Active, KColorScheme::Window ).foreground().color();
  58     }
  59
  60 BoxSwitchEffect::~BoxSwitchEffect()
  61     {
  62     }
  63
  64 void BoxSwitchEffect::prePaintWindow( EffectWindow* w, WindowPrePaintData& data, int time )
  65     {
  66     if( mActivated )
  67         {
  68         if( mMode == TabBoxWindowsMode )
  69             {
  70             if( windows.contains( w ))
  71                 {
  72                 if( w != selected_window )
  73                     data.setTranslucent();
  74                 w->enablePainting( EffectWindow::PAINT_DISABLED_BY_MINIMIZE );
  75                 }
  76             }
  77         else
  78             {
  79             if( painting_desktop )
  80                 {
  81                 if( w->isOnDesktop( painting_desktop ))
  82                     w->enablePainting( EffectWindow::PAINT_DISABLED_BY_DESKTOP );
  83                 else
  84                     w->disablePainting( EffectWindow::PAINT_DISABLED_BY_DESKTOP );
  85                 }
  86             }
  87         }
  88     effects->prePaintWindow( w, data, time );
  89     }
  90
  91 void BoxSwitchEffect::paintScreen( int mask, QRegion region, ScreenPaintData& data )
  92     {
  93     effects->paintScreen( mask, region, data );
  94     if( mActivated )
  95         {
  96         if( mMode == TabBoxWindowsMode )
  97             {
  98             paintFrame();
  99
 100             foreach( EffectWindow* w, windows.keys())
 101                 {
 102                 if( w == selected_window )
 103                     {
 104                     paintHighlight( windows[ w ]->area );
 105                     }
 106                 paintWindowThumbnail( w );
 107                 paintWindowIcon( w );
 108                 }
 109             paintText( selected_window->caption() );
 110             }
 111         else
 112             {
 113             if( !painting_desktop )
 114                 {
 115                 paintFrame();
 116
 117                 foreach( painting_desktop, desktops.keys())
 118                     {
 119                     if( painting_desktop == selected_desktop )
 120                         {
 121                         paintHighlight( desktops[ painting_desktop ]->area ); //effects->desktopName( painting_desktop )
 122                         }
 123
 124                     paintDesktopThumbnail( painting_desktop );
 125                     }
 126                 paintText( effects->desktopName( selected_desktop ));
 127                 painting_desktop = 0;
 128                 }
 129             }
 130         }
 131     }
 132
 133 void BoxSwitchEffect::paintWindow( EffectWindow* w, int mask, QRegion region, WindowPaintData& data )
 134     {
 135     if( mActivated )
 136         {
 137         if( mMode == TabBoxWindowsMode )
 138             {
 139             if( windows.contains( w ) && w != selected_window )
 140                 {
 141                 data.opacity *= 0.2;
 142                 }
 143             }
 144         }
 145     effects->paintWindow( w, mask, region, data );
 146     }
 147
 148 void BoxSwitchEffect::windowInputMouseEvent( Window w, QEvent* e )
 149     {
 150     assert( w == mInput );
 151     if( e->type() != QEvent::MouseButtonPress )
 152         return;
 153     QPoint pos = static_cast< QMouseEvent* >( e )->pos();
 154     pos += frame_area.topLeft();
 155
 156     // determine which item was clicked
 157     if( mMode == TabBoxWindowsMode )
 158         {
 159         foreach( EffectWindow* w, windows.keys())
 160             {
 161             if( windows[ w ]->clickable.contains( pos ))
 162                 {
 163                 effects->setTabBoxWindow( w );
 164                 }
 165             }
 166         }
 167     else
 168         {
 169         foreach( int i, desktops.keys())
 170             {
 171             if( desktops[ i ]->clickable.contains( pos ))
 172                 {
 173                 effects->setTabBoxDesktop( i );
 174                 }
 175             }
 176         }
 177     }
 178
 179 void BoxSwitchEffect::windowDamaged( EffectWindow* w, const QRect& damage )
 180     {
 181     if( mActivated )
 182         {
 183         if( mMode == TabBoxWindowsMode )
 184             {
 185             if( windows.contains( w ))
 186                 {
 187                 effects->addRepaint( windows[ w ]->area );
 188                 }
 189             }
 190         else
 191             {
 192             if( w->isOnAllDesktops())
 193                 {
 194                 foreach( ItemInfo* info, desktops )
 195                     effects->addRepaint( info->area );
 196                 }
 197             else
 198                 {
 199                 effects->addRepaint( desktops[ w->desktop() ]->area );
 200                 }
 201             }
 202         }
 203     }
 204
 205 void BoxSwitchEffect::windowGeometryShapeChanged( EffectWindow* w, const QRect& old )
 206     {
 207     if( mActivated )
 208         {
 209         if( mMode == TabBoxWindowsMode )
 210             {
 211             if( windows.contains( w ) && w->size() != old.size())
 212                 {
 213                 effects->addRepaint( windows[ w ]->area );
 214                 }
 215             }
 216         else
 217             {
 218             if( w->isOnAllDesktops())
 219                 {
 220                 foreach( ItemInfo* info, desktops )
 221                     effects->addRepaint( info->area );
 222                 }
 223             else
 224                 {
 225                 effects->addRepaint( desktops[ w->desktop() ]->area );
 226                 }
 227             }
 228         }
 229     }
 230
 231 void BoxSwitchEffect::tabBoxAdded( int mode )
 232     {
 233     if( !mActivated )
 234         {
 235         if( mode == TabBoxWindowsMode )
 236             {
 237             if( effects->currentTabBoxWindowList().count() > 0 )
 238                 {
 239                 mMode = mode;
 240                 effects->refTabBox();
 241                 setActive();
 242                 }
 243             }
 244         else
 245             { // DesktopMode
 246             if( effects->currentTabBoxDesktopList().count() > 0 )
 247                 {
 248                 mMode = mode;
 249                 painting_desktop = 0;
 250                 effects->refTabBox();
 251                 setActive();
 252                 }
 253             }
 254         }
 255     }
 256
 257 void BoxSwitchEffect::tabBoxClosed()
 258     {
 259     if( mActivated )
 260         setInactive();
 261     }
 262
 263 void BoxSwitchEffect::tabBoxUpdated()
 264     {
 265     if( mActivated )
 266         {
 267         if( mMode == TabBoxWindowsMode )
 268             {
 269             if( selected_window != NULL )
 270                 {
 271                 if( windows.contains( selected_window ))
 272                     effects->addRepaint( windows.value( selected_window )->area );
 273                 selected_window->addRepaintFull();
 274                 }
 275             setSelectedWindow( effects->currentTabBoxWindow());
 276             if( windows.contains( selected_window ))
 277                 effects->addRepaint( windows.value( selected_window )->area );
 278             selected_window->addRepaintFull();
 279             effects->addRepaint( text_area );
 280             if( effects->currentTabBoxWindowList() == original_windows )
 281                 return;
 282             original_windows = effects->currentTabBoxWindowList();
 283             }
 284         else
 285             { // DesktopMode
 286             if( desktops.contains( selected_desktop ))
 287                 effects->addRepaint( desktops.value( selected_desktop )->area );
 288             selected_desktop = effects->currentTabBoxDesktop();
 289             if( desktops.contains( selected_desktop ))
 290                 effects->addRepaint( desktops.value( selected_desktop )->area );
 291             effects->addRepaint( text_area );
 292             if( effects->currentTabBoxDesktopList() == original_desktops )
 293                 return;
 294             original_desktops = effects->currentTabBoxDesktopList();
 295             }
 296         effects->addRepaint( frame_area );
 297         calculateFrameSize();
 298         calculateItemSizes();
 299         moveResizeInputWindow( frame_area.x(), frame_area.y(), frame_area.width(), frame_area.height());
 300         effects->addRepaint( frame_area );
 301         }
 302     }
 303
 304 void BoxSwitchEffect::setActive()
 305     {
 306     mActivated = true;
 307     if( mMode == TabBoxWindowsMode )
 308         {
 309         original_windows = effects->currentTabBoxWindowList();
 310         setSelectedWindow( effects->currentTabBoxWindow());
 311         }
 312     else
 313         {
 314         original_desktops = effects->currentTabBoxDesktopList();
 315         selected_desktop = effects->currentTabBoxDesktop();
 316         }
 317     calculateFrameSize();
 318     calculateItemSizes();
 319     mInput = effects->createInputWindow( this, frame_area.x(), frame_area.y(),
 320         frame_area.width(), frame_area.height(), Qt::ArrowCursor );
 321     effects->addRepaint( frame_area );
 322     if( mMode == TabBoxWindowsMode )
 323         {
 324         foreach( EffectWindow* w, windows.keys())
 325             {
 326             w->addRepaintFull();
 327             }
 328         }
 329     }
 330
 331 void BoxSwitchEffect::setInactive()
 332     {
 333     mActivated = false;
 334     effects->unrefTabBox();
 335     if( mInput != None )
 336         {
 337         effects->destroyInputWindow( mInput );
 338         mInput = None;
 339         }
 340     if( mMode == TabBoxWindowsMode )
 341         {
 342         foreach( EffectWindow* w, windows.keys())
 343             {
 344             if( w != selected_window )
 345                 w->addRepaintFull();
 346             }
 347         foreach( ItemInfo* i, windows )
 348             {
 349 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
 350         if( effects->compositingType() == XRenderCompositing )
 351                 {
 352                 if( i->iconPicture != None )
 353                     XRenderFreePicture( display(), i->iconPicture );
 354                 i->iconPicture = None;
 355                 }
 356 #endif
 357             delete i;
 358             }
 359         windows.clear();
 360         setSelectedWindow( 0 );
 361         }
 362     else
 363         { // DesktopMode
 364         foreach( ItemInfo* i, desktops )
 365             delete i;
 366         desktops.clear();
 367         }
 368     effects->addRepaint( frame_area );
 369     frame_area = QRect();
 370     }
 371
 372 void BoxSwitchEffect::setSelectedWindow( EffectWindow* w )
 373     {
 374     if( selected_window )
 375         {
 376         effects->setElevatedWindow( selected_window, false );
 377         }
 378     selected_window = w;
 379     if( w )
 380         {
 381         effects->setElevatedWindow( selected_window, true );
 382         }
 383     }
 384
 385 void BoxSwitchEffect::windowClosed( EffectWindow* w )
 386     {
 387     if( w == selected_window )
 388         {
 389         setSelectedWindow( 0 );
 390         }
 391     }
 392
 393 void BoxSwitchEffect::moveResizeInputWindow( int x, int y, int width, int height )
 394     {
 395     XMoveWindow( display(), mInput, x, y );
 396     XResizeWindow( display(), mInput, width, height );
 397     }
 398
 399 void BoxSwitchEffect::calculateFrameSize()
 400     {
 401     int itemcount;
 402
 403     if( mMode == TabBoxWindowsMode )
 404         {
 405         itemcount = original_windows.count();
 406         item_max_size.setWidth( 200 );
 407         item_max_size.setHeight( 200 );
 408         }
 409     else
 410         {
 411         itemcount = original_desktops.count();
 412         item_max_size.setWidth( 200 );
 413         item_max_size.setHeight( 200 );
 414         }
 415     // How much height to reserve for a one-line text label
 416     text_font.setBold( true );
 417     text_font.setPointSize( 12 );
 418     text_area.setHeight( QFontMetrics( text_font ).height() * 1.2 );
 419     // Separator space between items and text
 420     const int separator_height = 6;
 421     // Shrink the size until all windows/desktops can fit onscreen
 422     frame_area.setWidth( frame_margin * 2 + itemcount * item_max_size.width());
 423     QRect screenr = effects->clientArea( PlacementArea, effects->activeScreen(), effects->currentDesktop());
 424     while( frame_area.width() > screenr.width())
 425         {
 426         item_max_size /= 2;
 427         frame_area.setWidth( frame_margin * 2 + itemcount * item_max_size.width());
 428         }
 429     frame_area.setHeight( frame_margin * 2 + item_max_size.height() +
 430             separator_height + text_area.height());
 431     text_area.setWidth( frame_area.width() - frame_margin * 2 );
 432
 433     frame_area.moveTo( screenr.x() + ( screenr.width() - frame_area.width()) / 2,
 434         screenr.y() + ( screenr.height() - frame_area.height()) / 2 );
 435     text_area.moveTo( frame_area.x() + frame_margin,
 436                       frame_area.y() + frame_margin + item_max_size.height() + separator_height);
 437     }
 438
 439 void BoxSwitchEffect::calculateItemSizes()
 440     {
 441     if( mMode == TabBoxWindowsMode )
 442         {
 443         windows.clear();
 444         for( int i = 0; i < original_windows.count(); i++ )
 445             {
 446             EffectWindow* w = original_windows.at( i );
 447             windows[ w ] = new ItemInfo();
 448
 449             windows[ w ]->area = QRect( frame_area.x() + frame_margin
 450                 + i * item_max_size.width(),
 451                 frame_area.y() + frame_margin,
 452                 item_max_size.width(), item_max_size.height());
 453             windows[ w ]->clickable = windows[ w ]->area;
 454             }
 455         }
 456     else
 457         {
 458         desktops.clear();
 459         for( int i = 0; i < original_desktops.count(); i++ )
 460             {
 461             int it = original_desktops.at( i );
 462             desktops[ it ] = new ItemInfo();
 463
 464             desktops[ it ]->area = QRect( frame_area.x() + frame_margin
 465                 + i * item_max_size.width(),
 466                 frame_area.y() + frame_margin,
 467                 item_max_size.width(), item_max_size.height());
 468             desktops[ it ]->clickable = desktops[ it ]->area;
 469             }
 470         }
 471     }
 472
 473 void BoxSwitchEffect::paintFrame()
 474     {
 475 #ifdef KWIN_HAVE_OPENGL_COMPOSITING
 476     if( effects->compositingType() == OpenGLCompositing )
 477         {
 478         glPushAttrib( GL_CURRENT_BIT );
 479         glColor4f( color_frame.redF(), color_frame.greenF(), color_frame.blueF(), color_frame.alphaF());
 480         renderRoundBoxWithEdge( frame_area );
 481         glPopAttrib();
 482         }
 483 #endif
 484 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
 485     if( effects->compositingType() == XRenderCompositing )
 486         {
 487         Pixmap pixmap = XCreatePixmap( display(), rootWindow(),
 488             frame_area.width(), frame_area.height(), 32 );
 489         Picture pic = XRenderCreatePicture( display(), pixmap, alphaFormat, 0, NULL );
 490         XFreePixmap( display(), pixmap );
 491         XRenderColor col;
 492         col.alpha = int( color_frame.alphaF() * 0xffff );
 493         col.red = int( color_frame.redF() * color_frame.alphaF() * 0xffff );
 494         col.green = int( color_frame.greenF() * color_frame.alphaF() * 0xffff );
 495         col.blue = int( color_frame.blueF() * color_frame.alphaF() * 0xffff );
 496         XRenderFillRectangle( display(), PictOpSrc, pic, &col, 0, 0,
 497             frame_area.width(), frame_area.height());
 498         XRenderComposite( display(), color_frame.alphaF() != 1.0 ? PictOpOver : PictOpSrc,
 499             pic, None, effects->xrenderBufferPicture(),
 500             0, 0, 0, 0, frame_area.x(), frame_area.y(), frame_area.width(), frame_area.height());
 501         XRenderFreePicture( display(), pic );
 502         }
 503 #endif
 504     }
 505
 506 void BoxSwitchEffect::paintHighlight( QRect area )
 507     {
 508 #ifdef KWIN_HAVE_OPENGL_COMPOSITING
 509     if( effects->compositingType() == OpenGLCompositing )
 510         {
 511         glPushAttrib( GL_CURRENT_BIT );
 512         glColor4f( color_highlight.redF(), color_highlight.greenF(), color_highlight.blueF(), color_highlight.alphaF());
 513         renderRoundBox( area, 6 );
 514         glPopAttrib();
 515         }
 516 #endif
 517 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
 518     if( effects->compositingType() == XRenderCompositing )
 519         {
 520         Pixmap pixmap = XCreatePixmap( display(), rootWindow(),
 521             area.width(), area.height(), 32 );
 522         Picture pic = XRenderCreatePicture( display(), pixmap, alphaFormat, 0, NULL );
 523         XFreePixmap( display(), pixmap );
 524         XRenderColor col;
 525         col.alpha = int( color_highlight.alphaF() * 0xffff );
 526         col.red = int( color_highlight.redF() * color_highlight.alphaF() * 0xffff );
 527         col.green = int( color_highlight.greenF() * color_highlight.alphaF() * 0xffff );
 528         col.blue = int( color_highlight.blueF() * color_highlight.alphaF() * 0xffff );
 529         XRenderFillRectangle( display(), PictOpSrc, pic, &col, 0, 0,
 530             area.width(), area.height());
 531         XRenderComposite( display(), color_highlight.alphaF() != 1.0 ? PictOpOver : PictOpSrc,
 532             pic, None, effects->xrenderBufferPicture(),
 533             0, 0, 0, 0, area.x(), area.y(), area.width(), area.height());
 534         XRenderFreePicture( display(), pic );
 535         }
 536 #endif
 537     }
 538
 539 void BoxSwitchEffect::paintWindowThumbnail( EffectWindow* w )
 540     {
 541     if( !windows.contains( w ))
 542         return;
 543     WindowPaintData data( w );
 544
 545     setPositionTransformations( data,
 546         windows[ w ]->thumbnail, w,
 547         windows[ w ]->area.adjusted( highlight_margin, highlight_margin, -highlight_margin, -highlight_margin ),
 548         Qt::KeepAspectRatio );
 549
 550     effects->drawWindow( w,
 551         PAINT_WINDOW_OPAQUE | PAINT_WINDOW_TRANSFORMED,
 552         windows[ w ]->thumbnail, data );
 553     }
 554
 555 void BoxSwitchEffect::paintDesktopThumbnail( int iDesktop )
 556     {
 557     if( !desktops.contains( iDesktop ))
 558         return;
 559
 560     ScreenPaintData data;
 561     QRect region;
 562     QRect r = desktops[ iDesktop ]->area.adjusted( highlight_margin, highlight_margin,
 563         -highlight_margin, -highlight_margin );
 564     QSize size = QSize( displayWidth(), displayHeight());
 565
 566     size.scale( r.size(), Qt::KeepAspectRatio );
 567     data.xScale = size.width() / double( displayWidth());
 568     data.yScale = size.height() / double( displayHeight());
 569     int width = int( displayWidth() * data.xScale );
 570     int height = int( displayHeight() * data.yScale );
 571     int x = r.x() + ( r.width() - width ) / 2;
 572     int y = r.y() + ( r.height() - height ) / 2;
 573     region = QRect( x, y, width, height );
 574     data.xTranslate = x;
 575     data.yTranslate = y;
 576
 577     effects->paintScreen( PAINT_SCREEN_TRANSFORMED | PAINT_SCREEN_BACKGROUND_FIRST,
 578         region, data );
 579     }
 580
 581 void BoxSwitchEffect::paintWindowIcon( EffectWindow* w )
 582     {
 583     if( !windows.contains( w ))
 584         return;
 585     // Don't render null icons
 586     if( w->icon().isNull() )
 587         {
 588         return;
 589         }
 590
 591     if( windows[ w ]->icon.cacheKey() != w->icon().cacheKey())
 592         { // make sure windows[ w ]->icon is the right QPixmap, and rebind
 593         windows[ w ]->icon = w->icon();
 594 #ifdef KWIN_HAVE_OPENGL_COMPOSITING
 595         if( effects->compositingType() == OpenGLCompositing )
 596             {
 597             windows[ w ]->iconTexture.load( windows[ w ]->icon );
 598             windows[ w ]->iconTexture.setFilter( GL_LINEAR );
 599             }
 600 #endif
 601 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
 602         if( effects->compositingType() == XRenderCompositing )
 603             {
 604             if( windows[ w ]->iconPicture != None )
 605                 XRenderFreePicture( display(), windows[ w ]->iconPicture );
 606             windows[ w ]->iconPicture = XRenderCreatePicture( display(),
 607                 windows[ w ]->icon.handle(), alphaFormat, 0, NULL );
 608             }
 609 #endif
 610         }
 611     int width = windows[ w ]->icon.width();
 612     int height = windows[ w ]->icon.height();
 613     int x = windows[ w ]->area.x() + windows[ w ]->area.width() - width - highlight_margin;
 614     int y = windows[ w ]->area.y() + windows[ w ]->area.height() - height - highlight_margin;
 615 #ifdef KWIN_HAVE_OPENGL_COMPOSITING
 616     if( effects->compositingType() == OpenGLCompositing )
 617         {
 618         glPushAttrib( GL_CURRENT_BIT | GL_ENABLE_BIT );
 619         glEnable( GL_BLEND );
 620         glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 621         // Render some background
 622         glColor4f( 0, 0, 0, 0.5 );
 623         renderRoundBox( QRect( x-3, y-3, width+6, height+6 ), 3 );
 624         // Render the icon
 625         glColor4f( 1, 1, 1, 1 );
 626         windows[ w ]->iconTexture.bind();
 627         const float verts[ 4 * 2 ] =
 628             {
 629             x, y,
 630             x, y + height,
 631             x + width, y + height,
 632             x + width, y
 633             };
 634         const float texcoords[ 4 * 2 ] =
 635             {
 636             0, 1,
 637             0, 0,
 638             1, 0,
 639             1, 1
 640             };
 641         renderGLGeometry( 4, verts, texcoords );
 642         windows[ w ]->iconTexture.unbind();
 643         glPopAttrib();
 644         }
 645 #endif
 646 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
 647     if( effects->compositingType() == XRenderCompositing )
 648         {
 649         XRenderComposite( display(),
 650             windows[ w ]->icon.depth() == 32 ? PictOpOver : PictOpSrc,
 651             windows[ w ]->iconPicture, None,
 652             effects->xrenderBufferPicture(),
 653             0, 0, 0, 0, x, y, width, height );
 654         }
 655 #endif
 656     }
 657
 658 void BoxSwitchEffect::paintText( const QString& text )
 659 {
 660     int maxwidth = text_area.width();
 661     effects->paintText( text, text_area.center(), maxwidth, color_text, text_font );
 662 }
 663
 664 } // namespace