Implement touch selection menu.

views/touchui/touch_selection_controller_impl.cc

 // Copyright (c) 2011 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 "views/touchui/touch_selection_controller_impl.h"
 
+#include "base/time.h"
+#include "grit/ui_strings.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/rect.h"
+#include "ui/gfx/screen.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/transform.h"
+#include "views/background.h"
+#include "views/controls/button/button.h"
+#include "views/controls/button/text_button.h"
+#include "views/controls/label.h"
+#include "views/layout/box_layout.h"
 #include "views/widget/widget.h"
-#include "views/controls/label.h"
-#include "views/background.h"
 
 namespace {
 
 // Constants defining the visual attributes of selection handles
 const int kSelectionHandleRadius = 10;
 const int kSelectionHandleCursorHeight = 10;
 const int kSelectionHandleAlpha = 0x7F;
 const SkColor kSelectionHandleColor =
     SkColorSetA(SK_ColorBLUE, kSelectionHandleAlpha);
 
+const int kContextMenuCommands[] = {IDS_APP_CUT,
+                                    IDS_APP_COPY,
+// TODO(varunjain): PASTE is acting funny due to some gtk clipboard issue.
+// Uncomment the following when that is fixed.
+//                                    IDS_APP_PASTE,
+                                    IDS_APP_DELETE,
+                                    IDS_APP_SELECT_ALL};
+const int kContextMenuPadding = 2;
+const int kContextMenuTimoutMs = 1000;
+const int kContextMenuVerticalOffset = 10;
+
 // Convenience struct to represent a circle shape.
 struct Circle {
   int radius;
   gfx::Point center;
   SkColor color;
 };
 
 // Creates a widget to host SelectionHandleView.
-views::Widget* CreateSelectionHandleWidget() {
+views::Widget* CreateTouchSelectionPopupWidget() {
   views::Widget* widget = new views::Widget;
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP);
   params.can_activate = false;
   params.transparent = true;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   widget->Init(params);
   return widget;
 }
 
 void PaintCircle(const Circle& circle, gfx::Canvas* canvas) {
@@ skipping 16 matching lines @@
 
 }  // namespace
 
 namespace views {
 
 // A View that displays the text selection handle.
 class TouchSelectionControllerImpl::SelectionHandleView : public View {
  public:
   SelectionHandleView(TouchSelectionControllerImpl* controller)
       : controller_(controller) {
-    widget_.reset(CreateSelectionHandleWidget());
+    widget_.reset(CreateTouchSelectionPopupWidget());
     widget_->SetContentsView(this);
     widget_->SetAlwaysOnTop(true);
 
     // We are owned by the TouchSelectionController.
     set_parent_owned(false);
   }
 
   virtual ~SelectionHandleView() {
     widget_->Close();
   }
@@ skipping 52 matching lines @@
     return widget_->GetClientAreaScreenBounds().origin();
   }
 
  private:
   scoped_ptr<Widget> widget_;
   TouchSelectionControllerImpl* controller_;
 
   DISALLOW_COPY_AND_ASSIGN(SelectionHandleView);
 };
 
+// A View that displays the touch context menu.
+class TouchSelectionControllerImpl::TouchContextMenuView
+    : public ButtonListener,
+      public View {
+ public:
+  TouchContextMenuView(TouchSelectionControllerImpl* controller)
+      : controller_(controller) {
+    widget_.reset(CreateTouchSelectionPopupWidget());
+    widget_->SetContentsView(this);
+    widget_->SetAlwaysOnTop(true);
+
+    // We are owned by the TouchSelectionController.
+    set_parent_owned(false);
+    SetLayoutManager(new BoxLayout(BoxLayout::kHorizontal, kContextMenuPadding,
+        kContextMenuPadding, kContextMenuPadding));
+  }
+
+  virtual ~TouchContextMenuView() {
+    widget_->Close();
+  }
+
+  virtual void SetVisible(bool visible) OVERRIDE {
+    // We simply show/hide the container widget.
+    if (visible != widget_->IsVisible()) {
+      if (visible)
+        widget_->Show();
+      else
+        widget_->Hide();
+    }
+    View::SetVisible(visible);
+  }
+
+  void SetScreenPosition(const gfx::Point& position) {
+    RefreshButtonsAndLayout();
+    gfx::Rect widget_bounds(position.x() - width() / 2, position.y() - height(),
+                            width(), height());
+    gfx::Rect monitor_bounds =
+        gfx::Screen::GetMonitorAreaNearestPoint(position);
+    widget_->SetBounds(widget_bounds.AdjustToFit(monitor_bounds));

[sky, 2011/08/26 15:45:33]

Might you end up showing the context menu over the selection handles?

[varunjain, 2011/08/26 16:31:15]

This is possible in theory. But in practice, selection can only occur on a
webpage or omnibox. in both cases AdjustToFit is there to make sure that the
menu does not go off-screen on the x-axis. It should never need to adjust the y
position of the menu (hence never cover the selection handles)

+  }
+
+  gfx::Point GetScreenPosition() {
+    return widget_->GetClientAreaScreenBounds().origin();
+  }
+
+  // ButtonListener
+  virtual void ButtonPressed(Button* sender, const views::Event& event) {
+    controller_->ExecuteCommand(sender->tag());
+  }
+
+ private:
+  // Queries the client view for what elements to show in the menu and sizes
+  // the menu appropriately.
+  void RefreshButtonsAndLayout() {

[sky, 2011/08/26 15:45:33]

nit: this doesn't layout, so maybe just RefreshButtons?

[varunjain, 2011/08/26 16:31:15]

Done.

+    RemoveAllChildViews(true);
+    int total_width = 0;
+    int height = 0;
+    for (size_t i = 0; i < arraysize(kContextMenuCommands); i++) {
+      int command_id = kContextMenuCommands[i];
+      if (controller_->IsCommandIdEnabled(command_id)) {
+        TextButton* button = new TextButton(this,
+            UTF16ToWide(l10n_util::GetStringUTF16(command_id)));
+        button->set_focusable(true);

[sky, 2011/08/26 15:45:33]

Is there a reason why we aren't using a standard menu here?

+        button->set_request_focus_on_press(false);
+        button->set_prefix_type(TextButton::PREFIX_HIDE);
+        button->SetEnabledColor(SK_ColorWHITE);
+        button->SetHoverColor(SK_ColorWHITE);
+        button->set_background(
+            Background::CreateSolidBackground(SK_ColorBLACK));
+        button->set_alignment(TextButton::ALIGN_CENTER);
+        button->SetFont(ui::ResourceBundle::GetSharedInstance().GetFont(
+            ui::ResourceBundle::LargeFont));
+        button->set_tag(command_id);
+        AddChildView(button);
+        gfx::Size button_size = button->GetPreferredSize();
+        total_width += button_size.width() + kContextMenuPadding;
+        if (height < button_size.height())
+          height = button_size.height();
+      }
+    }
+    SetBounds(0, 0, total_width, height);

[sky, 2011/08/26 15:45:33]

I don't think this is necessary. What matters is the bounds of the widget
change. Once that happens, it'll update your views bounds.

[varunjain, 2011/08/26 16:31:15]

Done.

[varunjain, 2011/08/26 16:41:39]

This is not really working. What I am seeing is that if I do not SetBounds on
the view, it ends up having zero bounds while the widget has proper bounds. I am
adding SetBounds on the view back.

+  }
+
+  scoped_ptr<Widget> widget_;
+  TouchSelectionControllerImpl* controller_;
+
+  DISALLOW_COPY_AND_ASSIGN(TouchContextMenuView);
+};
+
 TouchSelectionControllerImpl::TouchSelectionControllerImpl(
     TouchSelectionClientView* client_view)
     : client_view_(client_view),
       selection_handle_1_(new SelectionHandleView(this)),
       selection_handle_2_(new SelectionHandleView(this)),
+      context_menu_(new TouchContextMenuView(this)),
       dragging_handle_(NULL) {
 }
 
 TouchSelectionControllerImpl::~TouchSelectionControllerImpl() {
 }
 
 void TouchSelectionControllerImpl::SelectionChanged(const gfx::Point& p1,
                                                     const gfx::Point& p2) {
   gfx::Point screen_pos_1(p1);
   View::ConvertPointToScreen(client_view_, &screen_pos_1);
   gfx::Point screen_pos_2(p2);
   View::ConvertPointToScreen(client_view_, &screen_pos_2);
 
   if (dragging_handle_) {
     // We need to reposition only the selection handle that is being dragged.
     // The other handle stays the same. Also, the selection handle being dragged
     // will always be at the end of selection, while the other handle will be at
     // the start.
     dragging_handle_->SetScreenPosition(screen_pos_2);
   } else {
+    UpdateContextMenu(p1, p2);
+
     // Check if there is any selection at all.
     if (screen_pos_1 == screen_pos_2) {
       selection_handle_1_->SetVisible(false);
       selection_handle_2_->SetVisible(false);
       return;
     }
 
     if (client_view_->bounds().Contains(p1)) {
       selection_handle_1_->SetScreenPosition(screen_pos_1);
       selection_handle_1_->SetVisible(true);
     } else {
       selection_handle_1_->SetVisible(false);
     }
 
     if (client_view_->bounds().Contains(p2)) {
       selection_handle_2_->SetScreenPosition(screen_pos_2);
       selection_handle_2_->SetVisible(true);
     } else {
       selection_handle_2_->SetVisible(false);
     }
   }
 }
 
 void TouchSelectionControllerImpl::ClientViewLostFocus() {
   selection_handle_1_->SetVisible(false);
   selection_handle_2_->SetVisible(false);
+  HideContextMenu();
 }
 
 void TouchSelectionControllerImpl::SelectionHandleDragged(
     const gfx::Point& drag_pos) {
+  // We do not want to show the context menu while dragging.
+  HideContextMenu();
+  context_menu_timer_.Start(
+      base::TimeDelta::FromMilliseconds(kContextMenuTimoutMs),
+      this,
+      &TouchSelectionControllerImpl::ContextMenuTimerFired);
+
   if (client_view_->GetWidget()) {
     DCHECK(dragging_handle_);
     // Find the stationary selection handle.
     SelectionHandleView* fixed_handle = selection_handle_1_.get();
     if (fixed_handle == dragging_handle_)
       fixed_handle = selection_handle_2_.get();
 
     // Find selection end points in client_view's coordinate system.
     gfx::Point p1(drag_pos.x() + kSelectionHandleRadius, drag_pos.y());
     ConvertPointToClientView(dragging_handle_, &p1);
 
     gfx::Point p2(kSelectionHandleRadius, 0);
     ConvertPointToClientView(fixed_handle, &p2);
 
     // Instruct client_view to select the region between p1 and p2. The position
     // of |fixed_handle| is the start and that of |dragging_handle| is the end
     // of selection.
     client_view_->SelectRect(p2, p1);
   }
 }
 
 void TouchSelectionControllerImpl::ConvertPointToClientView(
     SelectionHandleView* source, gfx::Point* point) {
   View::ConvertPointToScreen(source, point);
   gfx::Rect r = client_view_->GetWidget()->GetClientAreaScreenBounds();
   point->SetPoint(point->x() - r.x(), point->y() - r.y());
   View::ConvertPointFromWidget(client_view_, point);
 }
 
+bool TouchSelectionControllerImpl::IsCommandIdEnabled(int command_id) const {
+  return client_view_->IsCommandIdEnabled(command_id);
+}
+
+void TouchSelectionControllerImpl::ExecuteCommand(int command_id) {
+  HideContextMenu();
+  client_view_->ExecuteCommand(command_id);
+}
+
+void TouchSelectionControllerImpl::ContextMenuTimerFired() {
+  context_menu_->SetScreenPosition(context_menu_screen_pos_);
+  context_menu_->SetVisible(true);
+}
+
+void TouchSelectionControllerImpl::UpdateContextMenu(const gfx::Point& p1,
+                                                     const gfx::Point& p2) {
+
+  // No selection means no context menu.
+  if (p1 == p2) {
+    HideContextMenu();
+    return;
+  }
+
+  // if selection is completely inside the view, we display the context menu
+  // in the middle of the end points on the top. Else, we show the menu on the
+  // top border of the view in the center.
+  if (client_view_->bounds().Contains(p1) &&
+      client_view_->bounds().Contains(p2)) {
+    context_menu_screen_pos_.set_x((p1.x() + p2.x()) / 2);

[sky, 2011/08/26 15:45:33]

Why does this need to be cached here instead of calculating in MenuTimeFired
when you need it?

[varunjain, 2011/08/26 16:31:15]

It doesnt. Changed.

+    context_menu_screen_pos_.set_y(
+        std::min(p1.y(), p2.y()) - kContextMenuVerticalOffset);
+  } else {
+    context_menu_screen_pos_.set_x(
+        client_view_->x() + client_view_->width() / 2);
+    context_menu_screen_pos_.set_y(client_view_->y());
+  }
+
+  View::ConvertPointToScreen(client_view_, &context_menu_screen_pos_);
+
+  // If menu is already visible we hide it to be display after the timer fires.
+  if (context_menu_->IsVisible())
+    context_menu_->SetVisible(false);
+  if (context_menu_timer_.IsRunning()) {
+    context_menu_timer_.Reset();
+  } else {
+    context_menu_timer_.Start(
+        base::TimeDelta::FromMilliseconds(kContextMenuTimoutMs),
+        this,
+        &TouchSelectionControllerImpl::ContextMenuTimerFired);
+  }
+}
+
+void TouchSelectionControllerImpl::HideContextMenu() {
+  context_menu_->SetVisible(false);
+  if (context_menu_timer_.IsRunning())

[sky, 2011/08/26 15:45:33]

No need to check if running.

[varunjain, 2011/08/26 16:31:15]

Done.

+    context_menu_timer_.Stop();
+}
+
 gfx::Point TouchSelectionControllerImpl::GetSelectionHandle1Position() {
   return selection_handle_1_->GetScreenPosition();
 }
 
 gfx::Point TouchSelectionControllerImpl::GetSelectionHandle2Position() {
   return selection_handle_2_->GetScreenPosition();
 }
 
 bool TouchSelectionControllerImpl::IsSelectionHandle1Visible() {
   return selection_handle_1_->IsVisible();
 }
 
 bool TouchSelectionControllerImpl::IsSelectionHandle2Visible() {
   return selection_handle_2_->IsVisible();
 }
 
 TouchSelectionController* TouchSelectionController::create(
     TouchSelectionClientView* client_view) {
   return new TouchSelectionControllerImpl(client_view);
 }
 
 }  // namespace views