~unity-team/unity/4.0

« back to all changes in this revision

Viewing changes to plugins/unityshell/src/unityshell.cpp

MergeĀ lp:~unity-team/unity/unity.minimized_windows_switcher

Show diffs side-by-side

added added

removed removed

Lines of Context:
500
500
              geo.height);
501
501
}
502
502
 
 
503
void UnityScreen::enterShowDesktopMode ()
 
504
{
 
505
  for (CompWindow *w : screen->windows ())
 
506
  {
 
507
    if (UnityShowdesktopHandler::shouldHide (w))
 
508
      UnityWindow::get (w)->enterShowDesktop ();
 
509
  }
 
510
 
 
511
  PluginAdapter::Default()->OnShowDesktop();
 
512
 
 
513
  screen->enterShowDesktopMode ();
 
514
}
 
515
 
 
516
void UnityScreen::leaveShowDesktopMode (CompWindow *w)
 
517
{
 
518
  for (CompWindow *cw : screen->windows ())
 
519
    UnityWindow::get (cw)->leaveShowDesktop ();
 
520
 
 
521
  PluginAdapter::Default()->OnLeaveDesktop();
 
522
 
 
523
  screen->leaveShowDesktopMode (w);
 
524
}
 
525
 
 
526
void UnityWindow::enterShowDesktop ()
 
527
{
 
528
  if (!mShowdesktopHandler)
 
529
    mShowdesktopHandler = new UnityShowdesktopHandler (window);
 
530
 
 
531
  window->setShowDesktopMode (true);
 
532
  mShowdesktopHandler->fadeOut ();
 
533
}
 
534
 
 
535
void UnityWindow::leaveShowDesktop ()
 
536
{
 
537
  if (mShowdesktopHandler)
 
538
  {
 
539
    mShowdesktopHandler->fadeIn ();
 
540
    window->setShowDesktopMode (false);
 
541
  }
 
542
}
 
543
 
 
544
bool UnityWindow::handleAnimations (unsigned int ms)
 
545
{
 
546
  if (mShowdesktopHandler)
 
547
    if (mShowdesktopHandler->animate (ms))
 
548
    { 
 
549
      delete mShowdesktopHandler;
 
550
      mShowdesktopHandler = NULL;
 
551
      return true;
 
552
    }
 
553
 
 
554
  return false;
 
555
}
 
556
 
 
557
/* 300 ms */
 
558
const unsigned int UnityShowdesktopHandler::fade_time = 300;
 
559
CompWindowList UnityShowdesktopHandler::animating_windows (0);
 
560
 
 
561
bool UnityShowdesktopHandler::shouldHide (CompWindow *w)
 
562
{
 
563
  if (!w->managed ())
 
564
    return false;
 
565
 
 
566
  if (w->grabbed ())
 
567
    return false;
 
568
 
 
569
  if (w->wmType () & (CompWindowTypeDesktopMask |
 
570
                      CompWindowTypeDockMask))
 
571
  return false;
 
572
 
 
573
  if (w->state () & CompWindowStateSkipPagerMask)
 
574
    return false;
 
575
 
 
576
  return true;
 
577
}
 
578
 
 
579
UnityShowdesktopHandler::UnityShowdesktopHandler (CompWindow *w) :
 
580
  mWindow (w),
 
581
  mRemover (new compiz::WindowInputRemover (screen->dpy (), ROOTPARENT (w))),
 
582
  mState (Visible),
 
583
  mProgress (0.0f)
 
584
{
 
585
}
 
586
 
 
587
UnityShowdesktopHandler::~UnityShowdesktopHandler ()
 
588
{
 
589
  if (mRemover)
 
590
    delete mRemover;
 
591
}
 
592
 
 
593
void UnityShowdesktopHandler::fadeOut ()
 
594
{
 
595
  mState = UnityShowdesktopHandler::FadeOut;
 
596
  mProgress = 1.0f;
 
597
 
 
598
  mRemover->save ();
 
599
  mRemover->remove ();
 
600
 
 
601
  CompositeWindow::get (mWindow)->addDamage ();
 
602
 
 
603
  if (std::find (animating_windows.begin(),
 
604
                 animating_windows.end(),
 
605
                 mWindow) == animating_windows.end())
 
606
    animating_windows.push_back(mWindow);
 
607
}
 
608
 
 
609
void UnityShowdesktopHandler::fadeIn ()
 
610
{
 
611
  mState = UnityShowdesktopHandler::FadeIn;
 
612
 
 
613
  mRemover->restore ();
 
614
 
 
615
  CompositeWindow::get (mWindow)->addDamage ();
 
616
}
 
617
 
 
618
bool UnityShowdesktopHandler::animate (unsigned int ms)
 
619
{
 
620
  float inc = fade_time / (float) ms;
 
621
 
 
622
  if (mState == UnityShowdesktopHandler::FadeOut)
 
623
  {
 
624
    mProgress -= inc;
 
625
    if (mProgress <= 0.0f)
 
626
    {
 
627
      mProgress = 0.0f;
 
628
      mState = Invisible;
 
629
    }
 
630
    else
 
631
      CompositeWindow::get (mWindow)->addDamage ();
 
632
  }
 
633
  else if (mState == FadeIn)
 
634
  {
 
635
    mProgress += inc;
 
636
    if (mProgress >= 1.0f)
 
637
    {
 
638
      mProgress = 1.0f;
 
639
      mState = Visible;
 
640
 
 
641
      return true;
 
642
    }
 
643
    else
 
644
      CompositeWindow::get (mWindow)->addDamage ();
 
645
  }
 
646
 
 
647
  return false;
 
648
}
 
649
 
 
650
void UnityShowdesktopHandler::paintAttrib (GLWindowPaintAttrib &attrib)
 
651
{
 
652
  attrib.opacity = attrib.opacity * mProgress;
 
653
}
 
654
 
503
655
/* called whenever we need to repaint parts of the screen */
504
656
bool UnityScreen::glPaintOutput(const GLScreenPaintAttrib& attrib,
505
657
                                const GLMatrix& transform,
543
695
 
544
696
void UnityScreen::preparePaint(int ms)
545
697
{
 
698
  CompWindowList remove_windows;
 
699
 
546
700
  if (BackgroundEffectHelper::blur_type == unity::BLUR_ACTIVE)
547
701
  {
548
702
    if (cScreen->damageMask() & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
568
722
 
569
723
  cScreen->preparePaint(ms);
570
724
 
 
725
  for (CompWindow *w : UnityShowdesktopHandler::animating_windows)
 
726
    if (UnityWindow::get (w)->handleAnimations (ms))
 
727
      remove_windows.push_back(w);
 
728
 
 
729
  for (CompWindow *w : remove_windows)
 
730
    UnityShowdesktopHandler::animating_windows.remove (w);
 
731
 
571
732
  if (damaged)
572
733
  {
573
734
    damaged = false;
669
830
    launcher->EnableCheckWindowOverLauncher(true);
670
831
    launcher->CheckWindowOverLauncher();
671
832
  }
 
833
 
 
834
  compiz::CompizMinimizedWindowHandler<UnityScreen, UnityWindow>::handleCompizEvent (plugin, event, option);
 
835
 
672
836
  screen->handleCompizEvent(plugin, event, option);
673
837
}
674
838
 
1101
1265
                          const CompRegion& region,
1102
1266
                          unsigned int mask)
1103
1267
{
 
1268
  GLWindowPaintAttrib wAttrib = attrib;
 
1269
 
 
1270
  if (mMinimizeHandler)
 
1271
  {
 
1272
    typedef compiz::CompizMinimizedWindowHandler<UnityScreen, UnityWindow> minimized_window_handler_unity;
 
1273
 
 
1274
    compiz::CompizMinimizedWindowHandler<UnityScreen, UnityWindow>::Ptr compizMinimizeHandler =
 
1275
        boost::dynamic_pointer_cast <minimized_window_handler_unity> (mMinimizeHandler);
 
1276
    mask |= compizMinimizeHandler->getPaintMask ();
 
1277
  }
 
1278
  else if (mShowdesktopHandler)
 
1279
    mShowdesktopHandler->paintAttrib (wAttrib);
 
1280
  
 
1281
 
1104
1282
  /* Don't bother detecting occlusions if we're not doing updates
1105
1283
   * or we don't want to repaint the shell this pass. We also
1106
1284
   * have a global flag detecting_occlusions which is set to false
1113
1291
      !uScreen->doShellRepaint ||
1114
1292
      !uScreen->allowWindowPaint)
1115
1293
  {
1116
 
    return gWindow->glPaint(attrib, matrix, region, mask);
 
1294
    return gWindow->glPaint(wAttrib, matrix, region, mask);
1117
1295
  }
1118
1296
 
1119
1297
  /* Compiz paints windows top to bottom during
1154
1332
        return false;
1155
1333
    }
1156
1334
    else
1157
 
      return gWindow->glPaint(attrib, matrix, region, mask);
 
1335
      return gWindow->glPaint(wAttrib, matrix, region, mask);
1158
1336
  }
1159
1337
 
1160
1338
  /* Should never be reached */
1161
 
  return gWindow->glPaint(attrib, matrix, region, mask);
 
1339
  return gWindow->glPaint(wAttrib, matrix, region, mask);
1162
1340
}
1163
1341
 
1164
1342
/* handle window painting in an opengl context
1202
1380
  return ret;
1203
1381
}
1204
1382
 
 
1383
void
 
1384
UnityWindow::minimize ()
 
1385
{
 
1386
  if (!window->managed ())
 
1387
    return;
 
1388
 
 
1389
  if (!mMinimizeHandler)
 
1390
  {
 
1391
    mMinimizeHandler = compiz::MinimizedWindowHandler::Ptr (new compiz::CompizMinimizedWindowHandler<UnityScreen, UnityWindow> (window));
 
1392
    mMinimizeHandler->minimize ();
 
1393
  }
 
1394
}
 
1395
 
 
1396
void
 
1397
UnityWindow::unminimize ()
 
1398
{
 
1399
  if (mMinimizeHandler)
 
1400
  {
 
1401
    mMinimizeHandler->unminimize ();
 
1402
    mMinimizeHandler.reset ();
 
1403
  }
 
1404
}
 
1405
 
 
1406
bool
 
1407
UnityWindow::minimized ()
 
1408
{
 
1409
  return mMinimizeHandler.get () != NULL;
 
1410
}
 
1411
 
1205
1412
/* Called whenever a window is mapped, unmapped, minimized etc */
1206
1413
void UnityWindow::windowNotify(CompWindowNotify n)
1207
1414
{
1336
1543
    case UnityshellOptions::AltTabTimeout:
1337
1544
      switcherController->detail_on_timeout = optionGetAltTabTimeout();
1338
1545
      break;
 
1546
    case UnityshellOptions::ShowMinimizedWindows:
 
1547
      compiz::CompizMinimizedWindowHandler<UnityScreen, UnityWindow>::setFunctions (optionGetShowMinimizedWindows ());
 
1548
      break;
1339
1549
    default:
1340
1550
      break;
1341
1551
  }
1706
1916
  , PluginClassHandler<UnityWindow, CompWindow>(window)
1707
1917
  , window(window)
1708
1918
  , gWindow(GLWindow::get(window))
 
1919
  , mShowdesktopHandler(nullptr)
1709
1920
{
1710
1921
  WindowInterface::setHandler(window);
1711
1922
  GLWindowInterface::setHandler(gWindow);
 
1923
 
 
1924
  if (UnityScreen::get (screen)->optionGetShowMinimizedWindows ())
 
1925
  {
 
1926
    bool wasMinimized = window->minimized ();
 
1927
    if (wasMinimized)
 
1928
      window->unminimize ();
 
1929
    window->minimizeSetEnabled (this, true);
 
1930
    window->unminimizeSetEnabled (this, true);
 
1931
    window->minimizedSetEnabled (this, true);
 
1932
 
 
1933
    if (wasMinimized)
 
1934
      window->minimize ();
 
1935
  }
 
1936
  else
 
1937
  {
 
1938
    window->minimizeSetEnabled (this, false);
 
1939
    window->unminimizeSetEnabled (this, false);
 
1940
    window->minimizedSetEnabled (this, false);
 
1941
  }
1712
1942
}
1713
1943
 
1714
1944
UnityWindow::~UnityWindow()
1718
1948
    us->newFocusedWindow = NULL;
1719
1949
  if (us->lastFocusedWindow && (UnityWindow::get(us->lastFocusedWindow) == this))
1720
1950
    us->lastFocusedWindow = NULL;
 
1951
 
 
1952
  UnityShowdesktopHandler::animating_windows.remove (window);
 
1953
 
 
1954
  if (mMinimizeHandler)
 
1955
  {
 
1956
    unminimize ();
 
1957
    window->minimizeSetEnabled (this, false);
 
1958
    window->unminimizeSetEnabled (this, false);
 
1959
    window->minimizedSetEnabled (this, false);
 
1960
    window->minimize ();
 
1961
 
 
1962
    mMinimizeHandler.reset ();
 
1963
  }
 
1964
  if (mShowdesktopHandler)
 
1965
    delete mShowdesktopHandler;
1721
1966
}
1722
1967
 
1723
1968
/* vtable init */