OLD | NEW |
| (Empty) |
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "content/browser/web_contents/touch_editable_impl_aura.h" | |
6 | |
7 #include "content/browser/renderer_host/render_widget_host_impl.h" | |
8 #include "content/browser/renderer_host/render_widget_host_view_aura.h" | |
9 #include "content/browser/web_contents/web_contents_impl.h" | |
10 #include "content/common/view_messages.h" | |
11 #include "content/public/browser/render_view_host.h" | |
12 #include "content/public/browser/render_widget_host.h" | |
13 #include "ui/aura/client/screen_position_client.h" | |
14 #include "ui/aura/window.h" | |
15 #include "ui/aura/window_tree_host.h" | |
16 #include "ui/base/clipboard/clipboard.h" | |
17 #include "ui/base/touch/selection_bound.h" | |
18 #include "ui/base/ui_base_switches_util.h" | |
19 #include "ui/gfx/range/range.h" | |
20 #include "ui/strings/grit/ui_strings.h" | |
21 #include "ui/wm/public/activation_client.h" | |
22 | |
23 namespace content { | |
24 | |
25 //////////////////////////////////////////////////////////////////////////////// | |
26 // TouchEditableImplAura, public: | |
27 | |
28 TouchEditableImplAura::~TouchEditableImplAura() { | |
29 Cleanup(); | |
30 } | |
31 | |
32 // static | |
33 TouchEditableImplAura* TouchEditableImplAura::Create() { | |
34 if (switches::IsTouchEditingEnabled()) | |
35 return new TouchEditableImplAura(); | |
36 return NULL; | |
37 } | |
38 | |
39 void TouchEditableImplAura::AttachToView(RenderWidgetHostViewAura* view) { | |
40 if (rwhva_ == view) | |
41 return; | |
42 | |
43 Cleanup(); | |
44 if (!view) | |
45 return; | |
46 | |
47 rwhva_ = view; | |
48 rwhva_->set_touch_editing_client(this); | |
49 } | |
50 | |
51 void TouchEditableImplAura::UpdateEditingController() { | |
52 if (!rwhva_ || !rwhva_->HasFocus()) | |
53 return; | |
54 | |
55 if (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE || | |
56 selection_anchor_ != selection_focus_) { | |
57 if (touch_selection_controller_) | |
58 touch_selection_controller_->SelectionChanged(); | |
59 } else { | |
60 EndTouchEditing(false); | |
61 } | |
62 } | |
63 | |
64 void TouchEditableImplAura::OverscrollStarted() { | |
65 overscroll_in_progress_ = true; | |
66 } | |
67 | |
68 void TouchEditableImplAura::OverscrollCompleted() { | |
69 overscroll_in_progress_ = false; | |
70 StartTouchEditingIfNecessary(); | |
71 } | |
72 | |
73 //////////////////////////////////////////////////////////////////////////////// | |
74 // TouchEditableImplAura, RenderWidgetHostViewAura::TouchEditingClient | |
75 // implementation: | |
76 | |
77 void TouchEditableImplAura::StartTouchEditing() { | |
78 if (!rwhva_ || !rwhva_->HasFocus()) | |
79 return; | |
80 | |
81 if (!touch_selection_controller_) { | |
82 touch_selection_controller_.reset( | |
83 ui::TouchEditingControllerDeprecated::Create(this)); | |
84 } | |
85 if (touch_selection_controller_) | |
86 touch_selection_controller_->SelectionChanged(); | |
87 } | |
88 | |
89 void TouchEditableImplAura::EndTouchEditing(bool quick) { | |
90 if (touch_selection_controller_) { | |
91 if (touch_selection_controller_->IsHandleDragInProgress()) { | |
92 touch_selection_controller_->SelectionChanged(); | |
93 } else { | |
94 selection_gesture_in_process_ = false; | |
95 touch_selection_controller_->HideHandles(quick); | |
96 touch_selection_controller_.reset(); | |
97 } | |
98 } | |
99 } | |
100 | |
101 void TouchEditableImplAura::OnSelectionOrCursorChanged( | |
102 const ui::SelectionBound& anchor, | |
103 const ui::SelectionBound& focus) { | |
104 selection_anchor_ = anchor; | |
105 selection_focus_ = focus; | |
106 | |
107 // If touch editing handles were not visible, we bring them up only if the | |
108 // current event is a gesture event, no scroll/fling/overscoll is in progress, | |
109 // and there is non-zero selection on the page | |
110 if (selection_gesture_in_process_ && !scroll_in_progress_ && | |
111 !overscroll_in_progress_ && selection_anchor_ != selection_focus_) { | |
112 StartTouchEditing(); | |
113 selection_gesture_in_process_ = false; | |
114 } | |
115 | |
116 UpdateEditingController(); | |
117 } | |
118 | |
119 void TouchEditableImplAura::OnTextInputTypeChanged(ui::TextInputType type) { | |
120 text_input_type_ = type; | |
121 } | |
122 | |
123 bool TouchEditableImplAura::HandleInputEvent(const ui::Event* event) { | |
124 DCHECK(rwhva_); | |
125 if (!event->IsGestureEvent()) { | |
126 // Ignore all non-gesture events. Non-gesture events that can deactivate | |
127 // touch editing are handled in TouchSelectionControllerImpl. | |
128 return false; | |
129 } | |
130 | |
131 const ui::GestureEvent* gesture_event = | |
132 static_cast<const ui::GestureEvent*>(event); | |
133 switch (event->type()) { | |
134 case ui::ET_GESTURE_TAP: | |
135 // When the user taps, we want to show touch editing handles if user | |
136 // tapped on selected text. | |
137 if (gesture_event->details().tap_count() == 1 && | |
138 selection_anchor_ != selection_focus_) { | |
139 gfx::Rect selection_rect = | |
140 ui::RectBetweenSelectionBounds(selection_anchor_, selection_focus_); | |
141 // When tap is on selection, show handles and mark event as handled only | |
142 // if handles are not present or text is not editable. Otherwise, do not | |
143 // set event as handles so that event is forwarded to the renderer to | |
144 // update selection/cursor. | |
145 if (selection_rect.Contains(gesture_event->location()) && | |
146 (text_input_type_ == ui::TEXT_INPUT_TYPE_NONE || | |
147 !touch_selection_controller_)) { | |
148 StartTouchEditing(); | |
149 return true; | |
150 } | |
151 } | |
152 // For single taps, not inside selected region, we want to show handles | |
153 // only when the tap is on an already focused textfield. | |
154 textfield_was_focused_on_tap_ = | |
155 gesture_event->details().tap_count() == 1 && | |
156 text_input_type_ != ui::TEXT_INPUT_TYPE_NONE; | |
157 break; | |
158 case ui::ET_GESTURE_LONG_PRESS: | |
159 selection_gesture_in_process_ = true; | |
160 break; | |
161 case ui::ET_GESTURE_SCROLL_BEGIN: | |
162 scroll_in_progress_ = true;; | |
163 // We need to hide selection handles during scroll (including fling and | |
164 // overscroll), but they should be re-activated after scrolling if: | |
165 // - an existing scroll decided that handles should be shown after | |
166 // scrolling; or | |
167 // - the gesture in progress is going to end in selection; or | |
168 // - selection handles are currently active. | |
169 handles_hidden_due_to_scroll_ = handles_hidden_due_to_scroll_ || | |
170 selection_gesture_in_process_ || | |
171 touch_selection_controller_ != NULL; | |
172 selection_gesture_in_process_ = false; | |
173 EndTouchEditing(true); | |
174 break; | |
175 case ui::ET_GESTURE_SCROLL_END: | |
176 scroll_in_progress_ = false; | |
177 StartTouchEditingIfNecessary(); | |
178 break; | |
179 default: | |
180 break; | |
181 } | |
182 return false; | |
183 } | |
184 | |
185 void TouchEditableImplAura::GestureEventAck(int gesture_event_type) { | |
186 DCHECK(rwhva_); | |
187 if (gesture_event_type == blink::WebInputEvent::GestureTap && | |
188 text_input_type_ != ui::TEXT_INPUT_TYPE_NONE && | |
189 textfield_was_focused_on_tap_) { | |
190 StartTouchEditing(); | |
191 UpdateEditingController(); | |
192 } | |
193 } | |
194 | |
195 void TouchEditableImplAura::DidStopFlinging() { | |
196 scroll_in_progress_ = false; | |
197 StartTouchEditingIfNecessary(); | |
198 } | |
199 | |
200 void TouchEditableImplAura::OnViewDestroyed() { | |
201 Cleanup(); | |
202 } | |
203 | |
204 //////////////////////////////////////////////////////////////////////////////// | |
205 // TouchEditableImplAura, ui::TouchEditable implementation: | |
206 | |
207 void TouchEditableImplAura::SelectRect(const gfx::Point& start, | |
208 const gfx::Point& end) { | |
209 RenderWidgetHost* host = rwhva_->GetRenderWidgetHost(); | |
210 RenderViewHost* rvh = RenderViewHost::From(host); | |
211 WebContentsImpl* wc = | |
212 static_cast<WebContentsImpl*>(WebContents::FromRenderViewHost(rvh)); | |
213 wc->SelectRange(start, end); | |
214 } | |
215 | |
216 void TouchEditableImplAura::MoveCaretTo(const gfx::Point& point) { | |
217 if (!rwhva_) | |
218 return; | |
219 | |
220 RenderWidgetHostImpl* host = RenderWidgetHostImpl::From( | |
221 rwhva_->GetRenderWidgetHost()); | |
222 host->MoveCaret(point); | |
223 } | |
224 | |
225 void TouchEditableImplAura::GetSelectionEndPoints(ui::SelectionBound* anchor, | |
226 ui::SelectionBound* focus) { | |
227 *anchor = selection_anchor_; | |
228 *focus = selection_focus_; | |
229 } | |
230 | |
231 gfx::Rect TouchEditableImplAura::GetBounds() { | |
232 return rwhva_ ? gfx::Rect(rwhva_->GetNativeView()->bounds().size()) : | |
233 gfx::Rect(); | |
234 } | |
235 | |
236 gfx::NativeView TouchEditableImplAura::GetNativeView() const { | |
237 return rwhva_ ? rwhva_->GetNativeView()->GetToplevelWindow() : NULL; | |
238 } | |
239 | |
240 void TouchEditableImplAura::ConvertPointToScreen(gfx::Point* point) { | |
241 if (!rwhva_) | |
242 return; | |
243 aura::Window* window = rwhva_->GetNativeView(); | |
244 aura::client::ScreenPositionClient* screen_position_client = | |
245 aura::client::GetScreenPositionClient(window->GetRootWindow()); | |
246 if (screen_position_client) | |
247 screen_position_client->ConvertPointToScreen(window, point); | |
248 } | |
249 | |
250 void TouchEditableImplAura::ConvertPointFromScreen(gfx::Point* point) { | |
251 if (!rwhva_) | |
252 return; | |
253 aura::Window* window = rwhva_->GetNativeView(); | |
254 aura::client::ScreenPositionClient* screen_position_client = | |
255 aura::client::GetScreenPositionClient(window->GetRootWindow()); | |
256 if (screen_position_client) | |
257 screen_position_client->ConvertPointFromScreen(window, point); | |
258 } | |
259 | |
260 bool TouchEditableImplAura::DrawsHandles() { | |
261 return false; | |
262 } | |
263 | |
264 void TouchEditableImplAura::OpenContextMenu(const gfx::Point& anchor) { | |
265 if (!rwhva_) | |
266 return; | |
267 gfx::Point point = anchor; | |
268 ConvertPointFromScreen(&point); | |
269 RenderWidgetHost* host = rwhva_->GetRenderWidgetHost(); | |
270 host->Send(new ViewMsg_ShowContextMenu( | |
271 host->GetRoutingID(), ui::MENU_SOURCE_TOUCH_EDIT_MENU, point)); | |
272 EndTouchEditing(false); | |
273 } | |
274 | |
275 bool TouchEditableImplAura::IsCommandIdChecked(int command_id) const { | |
276 NOTREACHED(); | |
277 return false; | |
278 } | |
279 | |
280 bool TouchEditableImplAura::IsCommandIdEnabled(int command_id) const { | |
281 if (!rwhva_) | |
282 return false; | |
283 bool editable = rwhva_->GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE; | |
284 bool readable = rwhva_->GetTextInputType() != ui::TEXT_INPUT_TYPE_PASSWORD; | |
285 gfx::Range selection_range; | |
286 rwhva_->GetSelectionRange(&selection_range); | |
287 bool has_selection = !selection_range.is_empty(); | |
288 switch (command_id) { | |
289 case IDS_APP_CUT: | |
290 return editable && readable && has_selection; | |
291 case IDS_APP_COPY: | |
292 return readable && has_selection; | |
293 case IDS_APP_PASTE: { | |
294 base::string16 result; | |
295 ui::Clipboard::GetForCurrentThread()->ReadText( | |
296 ui::CLIPBOARD_TYPE_COPY_PASTE, &result); | |
297 return editable && !result.empty(); | |
298 } | |
299 case IDS_APP_DELETE: | |
300 return editable && has_selection; | |
301 case IDS_APP_SELECT_ALL: | |
302 return true; | |
303 default: | |
304 return false; | |
305 } | |
306 } | |
307 | |
308 bool TouchEditableImplAura::GetAcceleratorForCommandId( | |
309 int command_id, | |
310 ui::Accelerator* accelerator) { | |
311 return false; | |
312 } | |
313 | |
314 void TouchEditableImplAura::ExecuteCommand(int command_id, int event_flags) { | |
315 RenderWidgetHost* host = rwhva_->GetRenderWidgetHost(); | |
316 RenderViewHost* rvh = RenderViewHost::From(host); | |
317 WebContents* wc = WebContents::FromRenderViewHost(rvh); | |
318 | |
319 switch (command_id) { | |
320 case IDS_APP_CUT: | |
321 wc->Cut(); | |
322 break; | |
323 case IDS_APP_COPY: | |
324 wc->Copy(); | |
325 break; | |
326 case IDS_APP_PASTE: | |
327 wc->Paste(); | |
328 break; | |
329 case IDS_APP_DELETE: | |
330 wc->Delete(); | |
331 break; | |
332 case IDS_APP_SELECT_ALL: | |
333 wc->SelectAll(); | |
334 break; | |
335 default: | |
336 NOTREACHED(); | |
337 break; | |
338 } | |
339 EndTouchEditing(false); | |
340 } | |
341 | |
342 void TouchEditableImplAura::DestroyTouchSelection() { | |
343 EndTouchEditing(false); | |
344 } | |
345 | |
346 //////////////////////////////////////////////////////////////////////////////// | |
347 // TouchEditableImplAura, private: | |
348 | |
349 TouchEditableImplAura::TouchEditableImplAura() | |
350 : text_input_type_(ui::TEXT_INPUT_TYPE_NONE), | |
351 rwhva_(NULL), | |
352 selection_gesture_in_process_(false), | |
353 handles_hidden_due_to_scroll_(false), | |
354 scroll_in_progress_(false), | |
355 overscroll_in_progress_(false), | |
356 textfield_was_focused_on_tap_(false) { | |
357 } | |
358 | |
359 void TouchEditableImplAura::StartTouchEditingIfNecessary() { | |
360 // If there is no scrolling left in progress, show selection handles if they | |
361 // were hidden due to scroll and there is a selection. | |
362 if (!scroll_in_progress_ && !overscroll_in_progress_ && | |
363 handles_hidden_due_to_scroll_ && | |
364 (selection_anchor_ != selection_focus_ || | |
365 text_input_type_ != ui::TEXT_INPUT_TYPE_NONE)) { | |
366 StartTouchEditing(); | |
367 UpdateEditingController(); | |
368 handles_hidden_due_to_scroll_ = false; | |
369 } | |
370 } | |
371 | |
372 void TouchEditableImplAura::Cleanup() { | |
373 if (rwhva_) { | |
374 rwhva_->set_touch_editing_client(NULL); | |
375 rwhva_ = NULL; | |
376 } | |
377 text_input_type_ = ui::TEXT_INPUT_TYPE_NONE; | |
378 EndTouchEditing(true); | |
379 selection_gesture_in_process_ = false; | |
380 handles_hidden_due_to_scroll_ = false; | |
381 scroll_in_progress_ = false; | |
382 overscroll_in_progress_ = false; | |
383 } | |
384 | |
385 } // namespace content | |
OLD | NEW |