athena: Improve the overview mode support for split-view mode.

athena/wm/overview_toolbar.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 "athena/wm/overview_toolbar.h"
 
 #include "athena/resources/grit/athena_resources.h"
 #include "base/bind.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
@@ skipping 80 matching lines @@
 
   int resource_id_;
   base::string16 label_;
   scoped_ptr<ui::Layer> layer_;
 
   DISALLOW_COPY_AND_ASSIGN(ActionButton);
 };
 
 OverviewToolbar::OverviewToolbar(aura::Window* container)
     : shown_(false),
+      disabled_action_bitfields_(0),
       close_(new ActionButton(IDR_ATHENA_OVERVIEW_TRASH, "Close")),
       split_(new ActionButton(IDR_ATHENA_OVERVIEW_SPLIT, "Split")),
       current_action_(ACTION_TYPE_NONE),
       container_bounds_(container->bounds()) {
   const int kPaddingFromBottom = 200;
   const int kPaddingBetweenButtons = 200;
 
   int x = container_bounds_.right() -
           (kActionButtonPaddingFromRight + kActionButtonImageSize);
   int y = container_bounds_.bottom() -
@@ skipping 10 matching lines @@
   // If the buttons are visible, then fade them out, instead of destroying them
   // immediately.
   if (shown_) {
     ActionButton::DestroyAfterFadeout(split_.Pass());
     ActionButton::DestroyAfterFadeout(close_.Pass());
   }
 }
 
 OverviewToolbar::ActionType OverviewToolbar::GetHighlightAction(
     const ui::GestureEvent& event) const {
-  if (IsEventOverButton(split_.get(), event))
+  if (IsActionEnabled(ACTION_TYPE_SPLIT) &&
+      IsEventOverButton(split_.get(), event))
     return ACTION_TYPE_SPLIT;
-  if (IsEventOverButton(close_.get(), event))
+  if (IsActionEnabled(ACTION_TYPE_CLOSE) &&
+      IsEventOverButton(close_.get(), event))
     return ACTION_TYPE_CLOSE;
   return ACTION_TYPE_NONE;
 }
 
 void OverviewToolbar::SetHighlightAction(ActionType action) {
+  CHECK(IsActionEnabled(action));
   if (current_action_ == action)
     return;
   current_action_ = action;
   if (!shown_) {
     ShowActionButtons();
   } else {
     TransformButton(close_.get());
     TransformButton(split_.get());
   }
 }
 
 void OverviewToolbar::ShowActionButtons() {
   if (!shown_)
     ToggleActionButtonsVisibility();
 }
 
 void OverviewToolbar::HideActionButtons() {
   if (shown_)
     ToggleActionButtonsVisibility();
 }
 
+void OverviewToolbar::DisableAction(ActionType action) {
+  CHECK_NE(current_action_, action);
+  disabled_action_bitfields_ |= (1u << action);
+}
+
 void OverviewToolbar::ToggleActionButtonsVisibility() {
   shown_ = !shown_;
   TransformButton(close_.get());
   TransformButton(split_.get());
 }
 
+bool OverviewToolbar::IsActionEnabled(ActionType action) const {
+  return !(disabled_action_bitfields_ & (1u << action));
+}
+
 bool OverviewToolbar::IsEventOverButton(ActionButton* button,
                                         const ui::GestureEvent& event) const {
   const int kBoundsInsetForTarget = 30;
   gfx::RectF bounds = button->layer()->bounds();
   bounds.Inset(-kBoundsInsetForTarget, -kBoundsInsetForTarget);
   return bounds.Contains(event.location());
 }
 
 gfx::Transform OverviewToolbar::ComputeTransformFor(
     ActionButton* button) const {
@@ skipping 10 matching lines @@
     transform.Scale(kHighlightScale, kHighlightScale);
   }
   return transform;
 }
 
 void OverviewToolbar::TransformButton(ActionButton* button) {
   ui::ScopedLayerAnimationSettings split_settings(
       button->layer()->GetAnimator());
   split_settings.SetTweenType(gfx::Tween::SMOOTH_IN_OUT);
   button->layer()->SetTransform(ComputeTransformFor(button));
-  button->layer()->SetOpacity(shown_ ? 1 : 0);
+  bool button_is_enabled =
+      (button == close_.get() && IsActionEnabled(ACTION_TYPE_CLOSE)) ||
+      (button == split_.get() && IsActionEnabled(ACTION_TYPE_SPLIT));
+  button->layer()->SetOpacity((button_is_enabled && shown_) ? 1 : 0);
 }
 
 }  // namespace athena