Window cycle ui improvements

ash/common/wm/window_cycle_list.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/common/wm/window_cycle_list.h"
 
 #include <list>
 #include <map>
 
 #include "ash/common/ash_switches.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/forwarding_layer_delegate.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "base/command_line.h"
 #include "ui/views/background.h"
+#include "ui/views/border.h"
+#include "ui/views/controls/label.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/painter.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/visibility_controller.h"
 
 namespace ash {
 
 // Returns the window immediately below |window| in the current container.
 WmWindow* GetWindowBelow(WmWindow* window) {
@@ skipping 29 matching lines @@
 
   // The window immediately below where window_ belongs.
   WmWindow* stack_window_above_;
 
   // If true, minimize window_ on going out of scope.
   bool minimized_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedShowWindow);
 };
 
+// This view represents a single WmWindow by displaying a title and a thumbnail
+// of the window's contents.
+class WindowPreviewView : public views::View {
+ public:
+  explicit WindowPreviewView(WmWindow* window)
+      : window_title_(new views::Label),
+        preview_background_(new views::View),
+        mirror_view_(window->CreateViewWithRecreatedLayers().release()) {
+    window_title_->SetText(window->GetTitle());
+    window_title_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+    window_title_->SetEnabledColor(SK_ColorWHITE);
+    window_title_->SetAutoColorReadabilityEnabled(false);
+    // The base font is 12pt (for English) so this comes out to 14pt.
+    const int kLabelSizeDelta = 2;
+    window_title_->SetFontList(
+        window_title_->font_list().DeriveWithSizeDelta(kLabelSizeDelta));
+    const int kAboveLabelPadding = 5;
+    const int kBelowLabelPadding = 10;
+    window_title_->SetBorder(views::Border::CreateEmptyBorder(
+        kAboveLabelPadding, 0, kBelowLabelPadding, 0));
+    AddChildView(window_title_);
+
+    // Preview padding is black at 50% opacity.
+    preview_background_->set_background(
+        views::Background::CreateSolidBackground(
+            SkColorSetA(SK_ColorBLACK, 0xFF / 2)));
+    AddChildView(preview_background_);
+
+    AddChildView(mirror_view_);
+  }
+  ~WindowPreviewView() override {}
+
+  // views::View:
+  gfx::Size GetPreferredSize() const override {
+    gfx::Size size = GetSizeForPreviewArea();
+    size.Enlarge(0, window_title_->GetPreferredSize().height());
+    return size;
+  }
+
+  void Layout() override {
+    const gfx::Size preview_area_size = GetSizeForPreviewArea();
+    // The window title is positioned above the preview area.
+    window_title_->SetBounds(0, 0, width(),
+                             height() - preview_area_size.height());
+
+    gfx::Rect preview_area_bounds(preview_area_size);
+    preview_area_bounds.set_y(height() - preview_area_size.height());
+    mirror_view_->SetSize(GetMirrorViewScaledSize());
+    if (mirror_view_->size() == preview_area_size) {
+      // Padding is not needed, hide the background and set the mirror view
+      // to take up the entire preview area.
+      mirror_view_->SetPosition(preview_area_bounds.origin());
+      preview_background_->SetVisible(false);
+      return;
+    }
+
+    // Padding is needed, so show the background and set the mirror view to be
+    // centered within it.
+    preview_background_->SetBoundsRect(preview_area_bounds);
+    preview_background_->SetVisible(true);
+    preview_area_bounds.ClampToCenteredSize(mirror_view_->size());
+    mirror_view_->SetPosition(preview_area_bounds.origin());
+  }
+
+ private:
+  // The maximum width of a window preview.
+  static const int kMaxPreviewWidth = 512;
+  // All previews are the same height (this is achieved via a combination of
+  // scaling and padding).
+  static const int kFixedPreviewHeight = 256;
+
+  // Returns the size for the mirror view, scaled to fit within the max bounds.
+  // Scaling is always 1:1 and we only scale down, never up.
+  gfx::Size GetMirrorViewScaledSize() const {
+    gfx::Size mirror_pref_size = mirror_view_->GetPreferredSize();
+
+    if (mirror_pref_size.width() > kMaxPreviewWidth ||
+        mirror_pref_size.height() > kFixedPreviewHeight) {
+      float scale = std::min(
+          kMaxPreviewWidth / static_cast<float>(mirror_pref_size.width()),
+          kFixedPreviewHeight / static_cast<float>(mirror_pref_size.height()));
+      mirror_pref_size =
+          gfx::ScaleToFlooredSize(mirror_pref_size, scale, scale);
+    }
+
+    return mirror_pref_size;
+  }
+
+  // Returns the size for the entire preview area (mirror view and additional
+  // padding). All previews will be the same height, so if the mirror view isn't
+  // tall enough we will add top and bottom padding. Previews can range in width
+  // from kMaxPreviewWidth down to half that value. Again, padding will be added
+  // to the sides to achieve this if the preview is too narrow.
+  gfx::Size GetSizeForPreviewArea() const {
+    gfx::Size mirror_size = GetMirrorViewScaledSize();
+    float aspect_ratio =
+        static_cast<float>(mirror_size.width()) / mirror_size.height();
+    gfx::Size preview_size = mirror_size;
+    // Very narrow windows get vertical bars of padding on the sides.
+    if (aspect_ratio < 0.5f)
+      preview_size.set_width(mirror_size.height() / 2);
+
+    // All previews are the same height (this may add padding on top and
+    // bottom).
+    preview_size.set_height(kFixedPreviewHeight);
+    // Previews should never be narrower than half their max width (128dip).
+    preview_size.set_width(
+        std::max(preview_size.width(), kMaxPreviewWidth / 2));
+
+    return preview_size;
+  }
+
+  // Displays the title of the window above the preview.
+  views::Label* window_title_;
+  // When visible, shows a darkened background area behind |mirror_view_|
+  // (effectively padding the preview to fit the desired bounds).
+  views::View* preview_background_;
+  // The view that actually renders a thumbnail version of the window.
+  views::View* mirror_view_;
+
+  DISALLOW_COPY_AND_ASSIGN(WindowPreviewView);
+};
+
 // A view that shows a collection of windows the user can tab through.
 class WindowCycleView : public views::View {
  public:
   explicit WindowCycleView(const WindowCycleList::WindowList& windows)
       : mirror_container_(new views::View()),
         highlight_view_(new views::View()),
         target_window_(nullptr) {
     DCHECK(!windows.empty());
     SetPaintToLayer(true);
     layer()->SetFillsBoundsOpaquely(false);
 
     set_background(views::Background::CreateSolidBackground(
         SkColorSetA(SK_ColorBLACK, 0xCC)));
 
     const int kInsideBorderPaddingDip = 64;
     const int kBetweenChildPaddingDip = 10;
     views::BoxLayout* layout = new views::BoxLayout(
         views::BoxLayout::kHorizontal, kInsideBorderPaddingDip,
         kInsideBorderPaddingDip, kBetweenChildPaddingDip);
     layout->set_cross_axis_alignment(
         views::BoxLayout::CROSS_AXIS_ALIGNMENT_START);
     mirror_container_->SetLayoutManager(layout);
     mirror_container_->SetPaintToLayer(true);
     mirror_container_->layer()->SetFillsBoundsOpaquely(false);
     // The preview list animates bounds changes (other animatable properties
     // never change).
     mirror_container_->layer()->SetAnimator(
         ui::LayerAnimator::CreateImplicitAnimator());
 
     for (WmWindow* window : windows) {

[sky, 2016/07/20 19:48:45]

Not related to this change, but recreating layers isn't cheap. At some point
will you only recreate the layers of a subset of windows?

[Evan Stade, 2016/07/20 19:53:42]

Yes. It's an open question whether we want to be able to alt tab through all
windows or just the N MRU (N ~= 10). If we limit it to 10 that would naturally
limit this. But also we can/should defer creating these previews until they'd
actually be visible (given that some of them would start off the edge of the
screen).

       // |mirror_container_| owns |view|.
-      views::View* view = window->CreateViewWithRecreatedLayers().release();
+      views::View* view = new WindowPreviewView(window);
       window_view_map_[window] = view;
       mirror_container_->AddChildView(view);
     }
 
     const float kHighlightCornerRadius = 4;
     highlight_view_->set_background(views::Background::CreateBackgroundPainter(
         true, views::Painter::CreateRoundRectWith1PxBorderPainter(
                   SkColorSetA(SK_ColorWHITE, 0x4D),
                   SkColorSetA(SK_ColorWHITE, 0x33), kHighlightCornerRadius)));
     highlight_view_->SetPaintToLayer(true);
@@ skipping 226 matching lines @@
   }
 }
 
 bool WindowCycleList::ShouldShowUi() {
   return windows_.size() > 1 &&
          base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kAshEnableWindowCycleUi);
 }
 
 }  // namespace ash