#include "ash/system/tray/tray_background_view.h"
-#include "ash/ash_switches.h"
#include "ash/root_window_controller.h"
#include "ash/screen_util.h"
#include "ash/shelf/shelf_layout_manager.h"
#include "ash/system/tray/tray_constants.h"
#include "ash/system/tray/tray_event_filter.h"
#include "ash/wm/window_animations.h"
+#include "base/command_line.h"
#include "grit/ash_resources.h"
#include "ui/accessibility/ax_view_state.h"
#include "ui/aura/window.h"
#include "ui/aura/window_event_dispatcher.h"
#include "ui/base/resource/resource_bundle.h"
+#include "ui/base/ui_base_switches_util.h"
+#include "ui/compositor/layer.h"
+#include "ui/compositor/layer_animation_element.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
+#include "ui/events/event_constants.h"
+#include "ui/gfx/animation/tween.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/image/image_skia.h"
#include "ui/gfx/image/image_skia_operations.h"
#include "ui/gfx/rect.h"
#include "ui/gfx/screen.h"
#include "ui/gfx/skia_util.h"
+#include "ui/gfx/transform.h"
#include "ui/views/background.h"
#include "ui/views/layout/box_layout.h"
const int kTrayBackgroundHoverAlpha = 150;
const SkColor kTrayBackgroundPressedColor = SkColorSetRGB(66, 129, 244);
-const int kAnimationDurationForPopupMS = 200;
+const int kAnimationDurationForPopupMs = 200;
+
+// Duration of opacity animation for visibility changes.
+const int kAnimationDurationForVisibilityMs = 250;
+
+// When becoming visible delay the animation so that StatusAreaWidgetDelegate
+// can animate sibling views out of the position to be occuped by the
+// TrayBackgroundView.
+const int kShowAnimationDelayMs = 100;
} // namespace
: host_(host) {
}
- virtual void OnWidgetBoundsChanged(views::Widget* widget,
- const gfx::Rect& new_bounds) OVERRIDE {
+ void OnWidgetBoundsChanged(views::Widget* widget,
+ const gfx::Rect& new_bounds) override {
host_->AnchorUpdated();
}
- virtual void OnWidgetVisibilityChanged(views::Widget* widget,
- bool visible) OVERRIDE {
+ void OnWidgetVisibilityChanged(views::Widget* widget, bool visible) override {
host_->AnchorUpdated();
}
IDR_AURA_TRAY_BG_VERTICAL_BOTTOM_PRESSED).ToImageSkia();
}
- virtual ~TrayBackground() {}
+ ~TrayBackground() override {}
SkColor color() { return color_; }
void set_color(SkColor color) { color_ = color; }
}
// Overridden from views::Background.
- virtual void Paint(gfx::Canvas* canvas, views::View* view) const OVERRIDE {
+ void Paint(gfx::Canvas* canvas, views::View* view) const override {
int orientation = kImageHorizontal;
ShelfWidget* shelf_widget = GetShelfWidget();
if (shelf_widget &&
UpdateLayout();
}
-gfx::Size TrayBackgroundView::TrayContainer::GetPreferredSize() {
+gfx::Size TrayBackgroundView::TrayContainer::GetPreferredSize() const {
if (size_.IsEmpty())
return views::View::GetPreferredSize();
return size_;
views::BoxLayout* layout =
new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, 0);
- layout->set_spread_blank_space(true);
+ layout->SetDefaultFlex(1);
views::View::SetLayoutManager(layout);
} else {
SetBorder(views::Border::CreateEmptyBorder(
views::BoxLayout* layout =
new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0);
- layout->set_spread_blank_space(true);
+ layout->SetDefaultFlex(1);
views::View::SetLayoutManager(layout);
}
PreferredSizeChanged();
tray_container_ = new TrayContainer(shelf_alignment_);
SetContents(tray_container_);
tray_event_filter_.reset(new TrayEventFilter);
+
+ SetPaintToLayer(true);
+ SetFillsBoundsOpaquely(false);
+ // Start the tray items not visible, because visibility changes are animated.
+ views::View::SetVisible(false);
}
TrayBackgroundView::~TrayBackgroundView() {
SetTrayBorder();
}
+void TrayBackgroundView::SetVisible(bool visible) {
+ if (visible == layer()->GetTargetVisibility())
+ return;
+
+ if (visible) {
+ // The alignment of the shelf can change while the TrayBackgroundView is
+ // hidden. Reset the offscreen transform so that the animation to becoming
+ // visible reflects the current layout.
+ HideTransformation();
+ // SetVisible(false) is defered until the animation for hiding is done.
+ // Otherwise the view is immediately hidden and the animation does not
+ // render.
+ views::View::SetVisible(true);
+ // If SetVisible(true) is called while animating to not visible, then
+ // views::View::SetVisible(true) is a no-op. When the previous animation
+ // ends layer->SetVisible(false) is called. To prevent this
+ // layer->SetVisible(true) immediately interrupts the animation of this
+ // property, and keeps the layer visible.
+ layer()->SetVisible(true);
+ }
+
+ ui::ScopedLayerAnimationSettings animation(layer()->GetAnimator());
+ animation.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
+ kAnimationDurationForVisibilityMs));
+ animation.SetPreemptionStrategy(
+ ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+
+ if (visible) {
+ animation.SetTweenType(gfx::Tween::EASE_OUT);
+ // Show is delayed so as to allow time for other children of
+ // StatusAreaWidget to begin animating to their new positions.
+ layer()->GetAnimator()->SchedulePauseForProperties(
+ base::TimeDelta::FromMilliseconds(kShowAnimationDelayMs),
+ ui::LayerAnimationElement::OPACITY |
+ ui::LayerAnimationElement::TRANSFORM);
+ layer()->SetOpacity(1.0f);
+ gfx::Transform transform;
+ transform.Translate(0.0f, 0.0f);
+ layer()->SetTransform(transform);
+ } else {
+ // Listen only to the hide animation. As we cannot turn off visibility
+ // until the animation is over.
+ animation.AddObserver(this);
+ animation.SetTweenType(gfx::Tween::EASE_IN);
+ layer()->SetOpacity(0.0f);
+ layer()->SetVisible(false);
+ HideTransformation();
+ }
+}
+
const char* TrayBackgroundView::GetClassName() const {
return kViewClassName;
}
return GetContentsBounds();
}
+void TrayBackgroundView::OnGestureEvent(ui::GestureEvent* event) {
+ if (switches::IsTouchFeedbackEnabled()) {
+ if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
+ SetDrawBackgroundAsActive(true);
+ } else if (event->type() == ui::ET_GESTURE_SCROLL_BEGIN ||
+ event->type() == ui::ET_GESTURE_TAP_CANCEL) {
+ SetDrawBackgroundAsActive(false);
+ }
+ }
+ ActionableView::OnGestureEvent(event);
+}
+
void TrayBackgroundView::UpdateBackground(int alpha) {
// The animator should never fire when the alternate shelf layout is used.
if (!background_ || draw_background_as_active_)
top_edge, left_edge, bottom_edge, right_edge));
}
+void TrayBackgroundView::OnImplicitAnimationsCompleted() {
+ // If there is another animation in the queue, the reverse animation was
+ // triggered before the completion of animating to invisible. Do not turn off
+ // the visibility so that the next animation may render. The value of
+ // layer()->GetTargetVisibility() can be incorrect if the hide animation was
+ // aborted to schedule an animation to become visible. As the new animation
+ // is not yet added to the queue. crbug.com/374236
+ if(layer()->GetAnimator()->is_animating() ||
+ layer()->GetTargetVisibility())
+ return;
+ views::View::SetVisible(false);
+}
+
+void TrayBackgroundView::HideTransformation() {
+ gfx::Transform transform;
+ if (shelf_alignment_ == SHELF_ALIGNMENT_BOTTOM ||
+ shelf_alignment_ == SHELF_ALIGNMENT_TOP)
+ transform.Translate(width(), 0.0f);
+ else
+ transform.Translate(0.0f, height());
+ layer()->SetTransform(transform);
+}
+
void TrayBackgroundView::InitializeBubbleAnimations(
views::Widget* bubble_widget) {
wm::SetWindowVisibilityAnimationType(
wm::ANIMATE_HIDE);
wm::SetWindowVisibilityAnimationDuration(
bubble_widget->GetNativeWindow(),
- base::TimeDelta::FromMilliseconds(kAnimationDurationForPopupMS));
+ base::TimeDelta::FromMilliseconds(kAnimationDurationForPopupMs));
}
aura::Window* TrayBackgroundView::GetBubbleWindowContainer() const {
} else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_LEFT) {
rect.Inset(0, 0, kBubblePaddingVerticalSide + 4,
kBubblePaddingVerticalBottom);
- } else {
+ } else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT) {
rect.Inset(kBubblePaddingVerticalSide, 0, 0,
kBubblePaddingVerticalBottom);
+ } else {
+ // TODO(bruthig) May need to handle other ANCHOR_ALIGNMENT_ values.
+ // ie. ANCHOR_ALIGNMENT_TOP
+ DCHECK(false) << "Unhandled anchor alignment.";
}
} else if (anchor_type == TrayBubbleView::ANCHOR_TYPE_BUBBLE) {
// Invert the offsets to align with the bubble below.
rect.Inset(vertical_alignment, 0, 0, horizontal_alignment);
else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT)
rect.Inset(0, 0, vertical_alignment, horizontal_alignment);
+ } else {
+ DCHECK(false) << "Unhandled anchor type.";
}
- }
-
- // TODO(jennyz): May need to add left/right alignment in the following code.
- if (rect.IsEmpty()) {
+ } else {
aura::Window* target_root = anchor_widget ?
anchor_widget->GetNativeView()->GetRootWindow() :
Shell::GetPrimaryRootWindow();
rect = target_root->bounds();
- rect = gfx::Rect(
- base::i18n::IsRTL() ? kPaddingFromRightEdgeOfScreenBottomAlignment :
- rect.width() - kPaddingFromRightEdgeOfScreenBottomAlignment,
- rect.height() - kPaddingFromBottomOfScreenBottomAlignment,
- 0, 0);
- rect = ScreenUtil::ConvertRectToScreen(target_root, rect);
+ if (anchor_type == TrayBubbleView::ANCHOR_TYPE_TRAY) {
+ if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM) {
+ rect = gfx::Rect(
+ base::i18n::IsRTL() ?
+ kPaddingFromRightEdgeOfScreenBottomAlignment :
+ rect.width() - kPaddingFromRightEdgeOfScreenBottomAlignment,
+ rect.height() - kPaddingFromBottomOfScreenBottomAlignment,
+ 0, 0);
+ rect = ScreenUtil::ConvertRectToScreen(target_root, rect);
+ } else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_LEFT) {
+ rect = gfx::Rect(
+ kPaddingFromRightEdgeOfScreenBottomAlignment,
+ rect.height() - kPaddingFromBottomOfScreenBottomAlignment,
+ 1, 1);
+ rect = ScreenUtil::ConvertRectToScreen(target_root, rect);
+ } else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT) {
+ rect = gfx::Rect(
+ rect.width() - kPaddingFromRightEdgeOfScreenBottomAlignment,
+ rect.height() - kPaddingFromBottomOfScreenBottomAlignment,
+ 1, 1);
+ rect = ScreenUtil::ConvertRectToScreen(target_root, rect);
+ } else {
+ // TODO(bruthig) May need to handle other ANCHOR_ALIGNMENT_ values.
+ // ie. ANCHOR_ALIGNMENT_TOP
+ DCHECK(false) << "Unhandled anchor alignment.";
+ }
+ } else {
+ rect = gfx::Rect(
+ base::i18n::IsRTL() ?
+ kPaddingFromRightEdgeOfScreenBottomAlignment :
+ rect.width() - kPaddingFromRightEdgeOfScreenBottomAlignment,
+ rect.height() - kPaddingFromBottomOfScreenBottomAlignment,
+ 0, 0);
+ }
}
return rect;
}
}
void TrayBackgroundView::SetDrawBackgroundAsActive(bool visible) {
+ if (draw_background_as_active_ == visible)
+ return;
draw_background_as_active_ = visible;
if (!background_)
return;
projects / platform / framework / web / crosswalk.git / blobdiff