Consistent fading behavior for touch editing handles

ui/views/touchui/touch_selection_controller_impl.cc

 // Copyright (c) 2013 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 "ui/views/touchui/touch_selection_controller_impl.h"
 
 #include "base/time/time.h"
 #include "grit/ui_resources.h"
 #include "grit/ui_strings.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_switches_util.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size.h"
 #include "ui/views/corewm/shadow_types.h"
+#include "ui/views/corewm/window_animations.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/public/masked_window_targeter.h"
 
 namespace {
 
 // Constants defining the visual attributes of selection handles
 const int kSelectionHandleLineWidth = 1;
 const SkColor kSelectionHandleLineColor =
     SkColorSetRGB(0x42, 0x81, 0xf4);
 
@@ skipping 21 matching lines @@
 //
 const int kSelectionHandleVerticalDragOffset = 5;
 
 // Padding around the selection handle defining the area that will be included
 // in the touch target to make dragging the handle easier (see pic above).
 const int kSelectionHandleHorizPadding = 10;
 const int kSelectionHandleVertPadding = 20;
 
 const int kContextMenuTimoutMs = 200;
 
+const int kSelectionHandleQuickFadeDurationMs = 50;
+
 // Creates a widget to host SelectionHandleView.
 views::Widget* CreateTouchSelectionPopupWidget(
     gfx::NativeView context,
     views::WidgetDelegate* widget_delegate) {
   views::Widget* widget = new views::Widget;
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_TOOLTIP);
   params.can_activate = false;
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.context = context;
@@ skipping 77 matching lines @@
 
     aura::Window* window = widget_->GetNativeWindow();
     window->set_event_targeter(scoped_ptr<ui::EventTargeter>(
         new TouchHandleWindowTargeter(window, this)));
 
     // We are owned by the TouchSelectionController.
     set_owned_by_client();
   }
 
   virtual ~EditingHandleView() {
+    SetWidgetVisible(false, false);
   }
 
   // Overridden from views::WidgetDelegateView:
   virtual bool WidgetHasHitTestMask() const OVERRIDE {
     return true;
   }
 
   virtual void GetWidgetHitTestMask(gfx::Path* mask) const OVERRIDE {
     gfx::Size image_size = GetHandleImageSize();
     mask->addRect(SkIntToScalar(0), SkIntToScalar(selection_rect_.height()),
@@ skipping 54 matching lines @@
     gfx::Size image_size = GetHandleImageSize();
     return gfx::Size(image_size.width() + 2 * kSelectionHandleHorizPadding,
                      image_size.height() + selection_rect_.height() +
                          kSelectionHandleVertPadding);
   }
 
   bool IsWidgetVisible() const {
     return widget_->IsVisible();
   }
 
-  void SetWidgetVisible(bool visible) {
+  void SetWidgetVisible(bool visible, bool quick) {
     if (widget_->IsVisible() == visible)
       return;
-    if (visible)
+    if (visible) {
+      corewm::SetWindowShowAnimationDuration(
+          widget_->GetNativeView(),
+          base::TimeDelta::FromMilliseconds(
+              quick ? kSelectionHandleQuickFadeDurationMs : 0));
       widget_->Show();
-    else
+    } else {
+      corewm::SetWindowHideAnimationDuration(
+          widget_->GetNativeView(),
+          base::TimeDelta::FromMilliseconds(
+              quick ? kSelectionHandleQuickFadeDurationMs : 0));
       widget_->Hide();
+    }
   }
 
   void SetSelectionRectInScreen(const gfx::Rect& rect) {
     gfx::Size image_size = GetHandleImageSize();
     selection_rect_ = rect;
     gfx::Rect widget_bounds(
         rect.x() - image_size.width() / 2 - kSelectionHandleHorizPadding,
         rect.y(),
         image_size.width() + 2 * kSelectionHandleHorizPadding,
         rect.height() + image_size.height() + kSelectionHandleVertPadding);
@@ skipping 120 matching lines @@
         selection_end_point_1_ = screen_rect_2;
         selection_end_point_2_ = screen_rect_1;
       }
       SetHandleSelectionRect(non_dragging_handle, r1, screen_rect_1);
     }
   } else {
     UpdateContextMenu(r1.origin(), r2.origin());
 
     // Check if there is any selection at all.
     if (screen_pos_1 == screen_pos_2) {
-      selection_handle_1_->SetWidgetVisible(false);
-      selection_handle_2_->SetWidgetVisible(false);
+      selection_handle_1_->SetWidgetVisible(false, false);
+      selection_handle_2_->SetWidgetVisible(false, false);
       SetHandleSelectionRect(cursor_handle_.get(), r1, screen_rect_1);
       return;
     }
 
-    cursor_handle_->SetWidgetVisible(false);
+    cursor_handle_->SetWidgetVisible(false, false);
     SetHandleSelectionRect(selection_handle_1_.get(), r1, screen_rect_1);
     SetHandleSelectionRect(selection_handle_2_.get(), r2, screen_rect_2);
   }
 }
 
 bool TouchSelectionControllerImpl::IsHandleDragInProgress() {
   return !!dragging_handle_;
 }
 
+void TouchSelectionControllerImpl::HideHandles(bool quick) {
+  selection_handle_1_->SetWidgetVisible(false, quick);
+  selection_handle_2_->SetWidgetVisible(false, quick);
+  cursor_handle_->SetWidgetVisible(false, quick);
+}
+
 void TouchSelectionControllerImpl::SetDraggingHandle(
     EditingHandleView* handle) {
   dragging_handle_ = handle;
   if (dragging_handle_)
     HideContextMenu();
   else
     StartContextMenuTimer();
 }
 
 void TouchSelectionControllerImpl::SelectionHandleDragged(
@@ skipping 29 matching lines @@
 void TouchSelectionControllerImpl::ConvertPointToClientView(
     EditingHandleView* source, gfx::Point* point) {
   View::ConvertPointToScreen(source, point);
   client_view_->ConvertPointFromScreen(point);
 }
 
 void TouchSelectionControllerImpl::SetHandleSelectionRect(
     EditingHandleView* handle,
     const gfx::Rect& rect,
     const gfx::Rect& rect_in_screen) {
-  handle->SetWidgetVisible(client_view_->GetBounds().Contains(rect));
+  handle->SetWidgetVisible(client_view_->GetBounds().Contains(rect), false);
   if (handle->IsWidgetVisible())
     handle->SetSelectionRectInScreen(rect_in_screen);
 }
 
 bool TouchSelectionControllerImpl::IsCommandIdEnabled(int command_id) const {
   return client_view_->IsCommandIdEnabled(command_id);
 }
 
 void TouchSelectionControllerImpl::ExecuteCommand(int command_id,
                                                   int event_flags) {
@@ skipping 115 matching lines @@
 }
 
 ui::TouchSelectionController* ViewsTouchSelectionControllerFactory::create(
     ui::TouchEditable* client_view) {
   if (switches::IsTouchEditingEnabled())
     return new views::TouchSelectionControllerImpl(client_view);
   return NULL;
 }
 
 }  // namespace views