Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(576)

Side by Side Diff: components/view_manager/gesture_manager.cc

Issue 1344573002: Mandoline: Rename components/view_manager to components/mus (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Rebased Created 5 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
1 // Copyright 2015 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 "components/view_manager/gesture_manager.h"
6
7 #include <algorithm>
8
9 #include "components/view_manager/gesture_manager_delegate.h"
10 #include "components/view_manager/public/cpp/keys.h"
11 #include "components/view_manager/server_view.h"
12 #include "components/view_manager/view_coordinate_conversions.h"
13 #include "components/view_manager/view_locator.h"
14 #include "ui/gfx/geometry/point_f.h"
15 #include "ui/mojo/events/input_events.mojom.h"
16
17 namespace view_manager {
18
19 using Views = std::vector<const ServerView*>;
20
21 namespace {
22
23 GestureManager::GestureAndConnectionId MakeGestureAndConnectionId(
24 const ServerView* view,
25 uint32_t gesture_id) {
26 return (static_cast<GestureManager::GestureAndConnectionId>(
27 view->id().connection_id)
28 << 32) |
29 gesture_id;
30 }
31
32 // Returns the views (deepest first) that should receive touch events. This only
33 // returns one view per connection. If multiple views from the same connection
34 // are interested in touch events the shallowest view is returned.
35 Views GetTouchTargets(const ServerView* deepest) {
36 Views result;
37 const ServerView* view = deepest;
38 while (view) {
39 if (view->properties().count(mojo::kViewManagerKeyWantsTouchEvents)) {
40 if (!result.empty() &&
41 result.back()->id().connection_id == view->id().connection_id) {
42 result.pop_back();
43 }
44 result.push_back(view);
45 }
46 view = view->parent();
47 }
48 // TODO(sky): I'm doing this until things are converted. Seems as though we
49 // shouldn't do this long term.
50 if (result.empty())
51 result.push_back(deepest);
52 return result;
53 }
54
55 mojo::EventPtr CloneEventForView(const mojo::Event& event,
56 const ServerView* view) {
57 mojo::EventPtr result(event.Clone());
58 const gfx::PointF location(event.pointer_data->x, event.pointer_data->y);
59 const gfx::PointF target_location(
60 ConvertPointFBetweenViews(view->GetRoot(), view, location));
61 result->pointer_data->x = target_location.x();
62 result->pointer_data->y = target_location.y();
63 return result.Pass();
64 }
65
66 } // namespace
67
68 // GestureStateChange ----------------------------------------------------------
69
70 GestureStateChange::GestureStateChange()
71 : chosen_gesture(GestureManager::kInvalidGestureId) {
72 }
73
74 GestureStateChange::~GestureStateChange() {
75 }
76
77 // ViewIterator ----------------------------------------------------------------
78
79 // Used to iterate over a set of views.
80 class ViewIterator {
81 public:
82 explicit ViewIterator(const Views& views)
83 : views_(views), current_(views_.begin()) {}
84
85 // Advances to the next view. Returns true if there are no more views (at
86 // the end).
87 bool advance() { return ++current_ != views_.end(); }
88
89 bool at_end() const { return current_ == views_.end(); }
90
91 bool empty() const { return views_.empty(); }
92
93 const ServerView* current() const { return *current_; }
94
95 void reset_to_beginning() { current_ = views_.begin(); }
96
97 void remove(const ServerView* view) {
98 Views::iterator iter = std::find(views_.begin(), views_.end(), view);
99 DCHECK(iter != views_.end());
100 if (iter == current_) {
101 current_ = views_.erase(current_);
102 } else if (!at_end()) {
103 size_t index = current_ - views_.begin();
104 if (current_ > iter)
105 index--;
106 views_.erase(iter);
107 current_ = views_.begin() + index;
108 } else {
109 views_.erase(iter);
110 current_ = views_.end();
111 }
112 }
113
114 bool contains(const ServerView* view) const {
115 return std::find(views_.begin(), views_.end(), view) != views_.end();
116 }
117
118 private:
119 Views views_;
120 Views::iterator current_;
121
122 DISALLOW_COPY_AND_ASSIGN(ViewIterator);
123 };
124
125 // PointerAndView --------------------------------------------------------------
126
127 struct GestureManager::PointerAndView {
128 PointerAndView();
129 PointerAndView(Pointer* pointer, const ServerView* view);
130
131 // Compares two PointerAndView instances based on pointer id, then view id.
132 // This is really only interesting for unit tests so that they get a known
133 // order of events.
134 bool operator<(const PointerAndView& other) const;
135
136 Pointer* pointer;
137 const ServerView* view;
138 };
139
140 // Gesture ---------------------------------------------------------------------
141
142 // Gesture maintains the set of pointers and views it is attached to.
143 class GestureManager::Gesture {
144 public:
145 enum State { STATE_INITIAL, STATE_CANCELED, STATE_CHOSEN };
146
147 explicit Gesture(uint32_t id);
148 ~Gesture();
149
150 uint32_t id() const { return id_; }
151
152 void Attach(Pointer* pointer, const ServerView* view);
153 void Detach(Pointer* pointer, const ServerView* view);
154
155 void set_state(State state) { state_ = state; }
156 State state() const { return state_; }
157
158 const std::set<PointerAndView>& pointers_and_views() const {
159 return pointers_and_views_;
160 }
161
162 private:
163 const uint32_t id_;
164 State state_;
165 std::set<PointerAndView> pointers_and_views_;
166
167 DISALLOW_COPY_AND_ASSIGN(Gesture);
168 };
169
170 GestureManager::Gesture::Gesture(uint32_t id) : id_(id), state_(STATE_INITIAL) {
171 }
172
173 GestureManager::Gesture::~Gesture() {
174 }
175
176 void GestureManager::Gesture::Attach(Pointer* pointer, const ServerView* view) {
177 pointers_and_views_.insert(PointerAndView(pointer, view));
178 }
179
180 void GestureManager::Gesture::Detach(Pointer* pointer, const ServerView* view) {
181 pointers_and_views_.erase(PointerAndView(pointer, view));
182 }
183
184 // Pointer ---------------------------------------------------------------------
185
186 // Pointer manages the state associated with a particular pointer from the time
187 // of the POINTER_DOWN to the time of the POINTER_UP (or POINTER_CANCEL). This
188 // state includes a mapping from view to the set of gestures the view is
189 // interested in. It also manages choosing gestures at the appropriate point as
190 // well as which view to dispatch to and the events to dispatch.
191 // See description in GestureManager for more.
192 class GestureManager::Pointer {
193 public:
194 Pointer(GestureManager* gesture_manager,
195 int32_t pointer_id,
196 const mojo::Event& event,
197 const Views& views);
198 ~Pointer();
199
200 int32_t pointer_id() const { return pointer_id_; }
201 bool was_chosen_or_canceled() const { return was_chosen_or_canceled_; }
202
203 // Sets the set of gestures for this pointer.
204 void SetGestures(const ServerView* view,
205 uint32_t chosen_gesture_id,
206 const std::set<uint32_t>& possible_gesture_ids,
207 const std::set<uint32_t>& canceled_ids);
208
209 // Called when a Gesture we contain has been canceled.
210 void GestureCanceled(Gesture* gesture);
211
212 // Called when a Gesture we contain has been chosen.
213 void GestureChosen(Gesture* gesture, const ServerView* view);
214
215 // Process a move or up event. This may delay processing if we're waiting for
216 // previous results.
217 void ProcessEvent(const mojo::Event& event);
218
219 private:
220 // Corresponds to the type of event we're dispatching.
221 enum Phase {
222 // We're dispatching the initial down.
223 PHASE_DOWN,
224
225 // We're dispatching a move.
226 PHASE_MOVE,
227 };
228
229 // Sends the event for the current phase to the delegate.
230 void ForwardCurrentEvent();
231
232 // Moves |pending_event_| to |current_event_| and notifies the delegate.
233 void MovePendingToCurrentAndProcess();
234
235 // If |was_chosen_or_canceled_| is false and there is only one possible
236 // gesture and it is in the initial state, choose it. Otherwise do nothing.
237 void ChooseGestureIfPossible();
238
239 bool ScheduleDeleteIfNecessary();
240
241 GestureManager* gesture_manager_;
242 const int32_t pointer_id_;
243 Phase phase_;
244
245 // Used to iterate over the set of views that potentially have gestures.
246 ViewIterator view_iter_;
247
248 // Maps from the view to the set of possible gestures for the view.
249 std::map<const ServerView*, std::set<Gesture*>> view_to_gestures_;
250
251 Gesture* chosen_gesture_;
252
253 bool was_chosen_or_canceled_;
254
255 // The event we're processing. When initially created this is the supplied
256 // down event. When in PHASE_MOVE this is a move event.
257 mojo::EventPtr current_event_;
258
259 // Incoming events (move or up) are added here while while waiting for
260 // responses.
261 mojo::EventPtr pending_event_;
262
263 DISALLOW_COPY_AND_ASSIGN(Pointer);
264 };
265
266 GestureManager::Pointer::Pointer(GestureManager* gesture_manager,
267 int32_t pointer_id,
268 const mojo::Event& event,
269 const Views& views)
270 : gesture_manager_(gesture_manager),
271 pointer_id_(pointer_id),
272 phase_(PHASE_DOWN),
273 view_iter_(views),
274 chosen_gesture_(nullptr),
275 was_chosen_or_canceled_(false),
276 current_event_(event.Clone()) {
277 ForwardCurrentEvent();
278 }
279
280 GestureManager::Pointer::~Pointer() {
281 for (auto& pair : view_to_gestures_) {
282 for (Gesture* gesture : pair.second)
283 gesture_manager_->DetachGesture(gesture, this, pair.first);
284 }
285 }
286
287 void GestureManager::Pointer::SetGestures(
288 const ServerView* view,
289 uint32_t chosen_gesture_id,
290 const std::set<uint32_t>& possible_gesture_ids,
291 const std::set<uint32_t>& canceled_gesture_ids) {
292 if (!view_iter_.contains(view)) {
293 // We don't know about this view.
294 return;
295 }
296
297 // True if this is the view we're waiting for a response from.
298 const bool was_waiting_on =
299 (!was_chosen_or_canceled_ &&
300 (!view_iter_.at_end() && view_iter_.current() == view));
301
302 if (possible_gesture_ids.empty()) {
303 // The view no longer wants to be notified.
304 for (Gesture* gesture : view_to_gestures_[view])
305 gesture_manager_->DetachGesture(gesture, this, view);
306 view_to_gestures_.erase(view);
307 view_iter_.remove(view);
308 if (view_iter_.empty()) {
309 gesture_manager_->PointerHasNoGestures(this);
310 // WARNING: we've been deleted.
311 return;
312 }
313 } else {
314 if (was_waiting_on)
315 view_iter_.advance();
316
317 Gesture* to_choose = nullptr;
318 std::set<Gesture*> gestures;
319 for (auto gesture_id : possible_gesture_ids) {
320 Gesture* gesture = gesture_manager_->GetGesture(view, gesture_id);
321 gesture_manager_->AttachGesture(gesture, this, view);
322 gestures.insert(gesture);
323 if (gesture->state() == Gesture::STATE_CHOSEN &&
324 !was_chosen_or_canceled_) {
325 to_choose = gesture;
326 }
327 }
328
329 // Give preference to the supplied |chosen_gesture_id|.
330 if (!was_chosen_or_canceled_ && chosen_gesture_id != kInvalidGestureId) {
331 Gesture* gesture = gesture_manager_->GetGesture(view, chosen_gesture_id);
332 if (gesture->state() != Gesture::STATE_CANCELED)
333 to_choose = gesture;
334
335 DCHECK(possible_gesture_ids.count(gesture->id()));
336 gesture_manager_->AttachGesture(gesture, this, view);
337 }
338
339 // Tell GestureManager of any Gestures we're no longer associated with.
340 std::set<Gesture*> removed_gestures;
341 std::set_difference(
342 view_to_gestures_[view].begin(), view_to_gestures_[view].end(),
343 gestures.begin(), gestures.end(),
344 std::inserter(removed_gestures, removed_gestures.begin()));
345 view_to_gestures_[view].swap(gestures);
346 for (Gesture* gesture : removed_gestures)
347 gesture_manager_->DetachGesture(gesture, this, view);
348
349 if (chosen_gesture_ && removed_gestures.count(chosen_gesture_))
350 chosen_gesture_ = nullptr;
351
352 if (to_choose) {
353 gesture_manager_->ChooseGesture(to_choose, this, view);
354 } else {
355 // Choosing a gesture implicitly cancels all other gestures. If we didn't
356 // choose a gesture we need to update the state of any newly added
357 // gestures.
358 for (Gesture* gesture : gestures) {
359 if (gesture != chosen_gesture_ &&
360 (was_chosen_or_canceled_ ||
361 canceled_gesture_ids.count(gesture->id()))) {
362 gesture_manager_->CancelGesture(gesture, this, view);
363 }
364 }
365 }
366 }
367
368 if (was_waiting_on && !was_chosen_or_canceled_) {
369 if (view_iter_.at_end()) {
370 if (ScheduleDeleteIfNecessary())
371 return;
372 // If we're got all the responses, check if there is only one valid
373 // gesture.
374 ChooseGestureIfPossible();
375 if (!was_chosen_or_canceled_) {
376 // There is more than one valid gesture and none chosen. Continue
377 // synchronous dispatch of move events.
378 phase_ = PHASE_MOVE;
379 MovePendingToCurrentAndProcess();
380 }
381 } else {
382 ForwardCurrentEvent();
383 }
384 } else if (!was_chosen_or_canceled_ && phase_ != PHASE_DOWN) {
385 // We weren't waiting on this view but we're in the move phase. The set of
386 // gestures may have changed such that we only have one valid gesture. Check
387 // for that.
388 ChooseGestureIfPossible();
389 }
390 }
391
392 void GestureManager::Pointer::GestureCanceled(Gesture* gesture) {
393 if (was_chosen_or_canceled_ && gesture == chosen_gesture_) {
394 chosen_gesture_ = nullptr;
395 // No need to cancel other gestures as they are already canceled by virtue
396 // of us having been chosen.
397 } else if (!was_chosen_or_canceled_ && phase_ == PHASE_MOVE) {
398 ChooseGestureIfPossible();
399 }
400 }
401
402 void GestureManager::Pointer::GestureChosen(Gesture* gesture,
403 const ServerView* view) {
404 DCHECK(!was_chosen_or_canceled_);
405 was_chosen_or_canceled_ = true;
406 chosen_gesture_ = gesture;
407 for (auto& pair : view_to_gestures_) {
408 for (Gesture* g : pair.second) {
409 if (g != gesture)
410 gesture_manager_->CancelGesture(g, this, pair.first);
411 }
412 }
413
414 while (!view_iter_.at_end()) {
415 ForwardCurrentEvent();
416 view_iter_.advance();
417 }
418 if (ScheduleDeleteIfNecessary())
419 return;
420 phase_ = PHASE_MOVE;
421 MovePendingToCurrentAndProcess();
422 }
423
424 void GestureManager::Pointer::ProcessEvent(const mojo::Event& event) {
425 // |event| is either a move or up. In either case it has the new coordinates
426 // and is safe to replace the existing one with.
427 pending_event_ = event.Clone();
428 if (was_chosen_or_canceled_) {
429 MovePendingToCurrentAndProcess();
430 } else if (view_iter_.at_end()) {
431 view_iter_.reset_to_beginning();
432 MovePendingToCurrentAndProcess();
433 }
434 // The else case is we are waiting on a response from a view before we
435 // continue dispatching. When we get the response for the last view in the
436 // stack we'll move pending to current and start dispatching it.
437 }
438
439 void GestureManager::Pointer::ForwardCurrentEvent() {
440 DCHECK(!view_iter_.at_end());
441 const ServerView* view = view_iter_.current();
442 gesture_manager_->delegate_->ProcessEvent(
443 view, CloneEventForView(*current_event_, view), was_chosen_or_canceled_);
444 }
445
446 void GestureManager::Pointer::MovePendingToCurrentAndProcess() {
447 if (!pending_event_.get()) {
448 current_event_ = nullptr;
449 return;
450 }
451 current_event_ = pending_event_.Pass();
452 view_iter_.reset_to_beginning();
453 ForwardCurrentEvent();
454 if (was_chosen_or_canceled_) {
455 while (view_iter_.advance())
456 ForwardCurrentEvent();
457 if (ScheduleDeleteIfNecessary())
458 return;
459 current_event_ = nullptr;
460 }
461 }
462
463 void GestureManager::Pointer::ChooseGestureIfPossible() {
464 if (was_chosen_or_canceled_)
465 return;
466
467 Gesture* gesture_to_choose = nullptr;
468 const ServerView* view = nullptr;
469 for (auto& pair : view_to_gestures_) {
470 for (Gesture* gesture : pair.second) {
471 if (gesture->state() == Gesture::STATE_INITIAL) {
472 if (gesture_to_choose)
473 return;
474 view = pair.first;
475 gesture_to_choose = gesture;
476 }
477 }
478 }
479 if (view)
480 gesture_manager_->ChooseGesture(gesture_to_choose, this, view);
481 }
482
483 bool GestureManager::Pointer::ScheduleDeleteIfNecessary() {
484 if (current_event_ &&
485 (current_event_->action == mojo::EVENT_TYPE_POINTER_UP ||
486 current_event_->action == mojo::EVENT_TYPE_POINTER_CANCEL)) {
487 gesture_manager_->ScheduleDelete(this);
488 return true;
489 }
490 return false;
491 }
492
493 // ScheduledDeleteProcessor ---------------------------------------------------
494
495 class GestureManager::ScheduledDeleteProcessor {
496 public:
497 explicit ScheduledDeleteProcessor(GestureManager* manager)
498 : manager_(manager) {}
499
500 ~ScheduledDeleteProcessor() { manager_->pointers_to_delete_.clear(); }
501
502 private:
503 GestureManager* manager_;
504
505 DISALLOW_COPY_AND_ASSIGN(ScheduledDeleteProcessor);
506 };
507
508 // PointerAndView --------------------------------------------------------------
509
510 GestureManager::PointerAndView::PointerAndView()
511 : pointer(nullptr), view(nullptr) {
512 }
513
514 GestureManager::PointerAndView::PointerAndView(Pointer* pointer,
515 const ServerView* view)
516 : pointer(pointer), view(view) {
517 }
518
519 bool GestureManager::PointerAndView::operator<(
520 const PointerAndView& other) const {
521 if (other.pointer->pointer_id() == pointer->pointer_id())
522 return view->id().connection_id < other.view->id().connection_id;
523 return pointer->pointer_id() < other.pointer->pointer_id();
524 }
525
526 // GestureManager --------------------------------------------------------------
527
528 // static
529 const uint32_t GestureManager::kInvalidGestureId = 0u;
530
531 GestureManager::GestureManager(GestureManagerDelegate* delegate,
532 const ServerView* root)
533 : delegate_(delegate), root_view_(root) {
534 }
535
536 GestureManager::~GestureManager() {
537 // Explicitly delete the pointers first as this may result in calling back to
538 // us to cleanup and delete gestures.
539 active_pointers_.clear();
540 }
541
542 bool GestureManager::ProcessEvent(const mojo::Event& event) {
543 if (!event.pointer_data)
544 return false;
545
546 ScheduledDeleteProcessor delete_processor(this);
547 const gfx::Point location(static_cast<int>(event.pointer_data->x),
548 static_cast<int>(event.pointer_data->y));
549 switch (event.action) {
550 case mojo::EVENT_TYPE_POINTER_DOWN: {
551 if (GetPointerById(event.pointer_data->pointer_id)) {
552 DVLOG(1) << "received more than one down for a pointer without a "
553 << "corresponding up, id=" << event.pointer_data->pointer_id;
554 NOTREACHED();
555 return true;
556 }
557
558 const ServerView* deepest = FindDeepestVisibleView(root_view_, location);
559 Views targets(GetTouchTargets(deepest));
560 if (targets.empty())
561 return true;
562
563 scoped_ptr<Pointer> pointer(
564 new Pointer(this, event.pointer_data->pointer_id, event, targets));
565 active_pointers_.push_back(pointer.Pass());
566 return true;
567 }
568
569 case mojo::EVENT_TYPE_POINTER_CANCEL:
570 case mojo::EVENT_TYPE_POINTER_MOVE:
571 case mojo::EVENT_TYPE_POINTER_UP: {
572 Pointer* pointer = GetPointerById(event.pointer_data->pointer_id);
573 // We delete a pointer when it has no gestures, so it's possible to get
574 // here with no gestures. Additionally there is no need to explicitly
575 // delete |pointer| as it'll tell us when it's ready to be deleted.
576 if (pointer)
577 pointer->ProcessEvent(event);
578 return true;
579 }
580
581 default:
582 break;
583 }
584 return false;
585 }
586
587 scoped_ptr<ChangeMap> GestureManager::SetGestures(
588 const ServerView* view,
589 int32_t pointer_id,
590 uint32_t chosen_gesture_id,
591 const std::set<uint32_t>& possible_gesture_ids,
592 const std::set<uint32_t>& canceled_gesture_ids) {
593 // TODO(sky): caller should validate ids and make sure possible contains
594 // canceled and chosen.
595 DCHECK(!canceled_gesture_ids.count(kInvalidGestureId));
596 DCHECK(!possible_gesture_ids.count(kInvalidGestureId));
597 DCHECK(chosen_gesture_id == kInvalidGestureId ||
598 possible_gesture_ids.count(chosen_gesture_id));
599 DCHECK(chosen_gesture_id == kInvalidGestureId ||
600 !canceled_gesture_ids.count(chosen_gesture_id));
601 ScheduledDeleteProcessor delete_processor(this);
602 Pointer* pointer = GetPointerById(pointer_id);
603 current_change_.reset(new ChangeMap);
604 if (pointer) {
605 pointer->SetGestures(view, chosen_gesture_id, possible_gesture_ids,
606 canceled_gesture_ids);
607 }
608 return current_change_.Pass();
609 }
610
611 GestureManager::Pointer* GestureManager::GetPointerById(int32_t pointer_id) {
612 for (Pointer* pointer : active_pointers_) {
613 if (pointer->pointer_id() == pointer_id)
614 return pointer;
615 }
616 return nullptr;
617 }
618
619 void GestureManager::PointerHasNoGestures(Pointer* pointer) {
620 auto iter =
621 std::find(active_pointers_.begin(), active_pointers_.end(), pointer);
622 CHECK(iter != active_pointers_.end());
623 active_pointers_.erase(iter);
624 }
625
626 GestureManager::Gesture* GestureManager::GetGesture(const ServerView* view,
627 uint32_t gesture_id) {
628 GestureAndConnectionId gesture_and_connection_id =
629 MakeGestureAndConnectionId(view, gesture_id);
630 Gesture* gesture = gesture_map_[gesture_and_connection_id];
631 if (!gesture) {
632 gesture = new Gesture(gesture_id);
633 gesture_map_[gesture_and_connection_id] = gesture;
634 }
635 return gesture;
636 }
637
638 void GestureManager::AttachGesture(Gesture* gesture,
639 Pointer* pointer,
640 const ServerView* view) {
641 gesture->Attach(pointer, view);
642 }
643
644 void GestureManager::DetachGesture(Gesture* gesture,
645 Pointer* pointer,
646 const ServerView* view) {
647 gesture->Detach(pointer, view);
648 if (gesture->pointers_and_views().empty()) {
649 gesture_map_.erase(MakeGestureAndConnectionId(view, gesture->id()));
650 delete gesture;
651 }
652 }
653
654 void GestureManager::CancelGesture(Gesture* gesture,
655 Pointer* pointer,
656 const ServerView* view) {
657 if (gesture->state() == Gesture::STATE_CANCELED)
658 return;
659
660 gesture->set_state(Gesture::STATE_CANCELED);
661 for (auto& pointer_and_view : gesture->pointers_and_views()) {
662 (*current_change_)[pointer_and_view.view].canceled_gestures.insert(
663 gesture->id());
664 if (pointer_and_view.pointer != pointer)
665 pointer_and_view.pointer->GestureCanceled(gesture);
666 }
667 }
668
669 void GestureManager::ChooseGesture(Gesture* gesture,
670 Pointer* pointer,
671 const ServerView* view) {
672 if (gesture->state() == Gesture::STATE_CHOSEN) {
673 // This happens when |pointer| is supplied a gesture that is already
674 // chosen.
675 DCHECK((*current_change_)[view].chosen_gesture == kInvalidGestureId ||
676 (*current_change_)[view].chosen_gesture == gesture->id());
677 (*current_change_)[view].chosen_gesture = gesture->id();
678 pointer->GestureChosen(gesture, view);
679 } else {
680 gesture->set_state(Gesture::STATE_CHOSEN);
681 for (auto& pointer_and_view : gesture->pointers_and_views()) {
682 DCHECK((*current_change_)[pointer_and_view.view].chosen_gesture ==
683 kInvalidGestureId ||
684 (*current_change_)[pointer_and_view.view].chosen_gesture ==
685 gesture->id());
686 (*current_change_)[pointer_and_view.view].chosen_gesture = gesture->id();
687 pointer_and_view.pointer->GestureChosen(gesture, view);
688 }
689 }
690 }
691
692 void GestureManager::ScheduleDelete(Pointer* pointer) {
693 auto iter =
694 std::find(active_pointers_.begin(), active_pointers_.end(), pointer);
695 if (iter != active_pointers_.end()) {
696 active_pointers_.weak_erase(iter);
697 pointers_to_delete_.push_back(pointer);
698 }
699 }
700
701 } // namespace view_manager
OLDNEW
« no previous file with comments | « components/view_manager/gesture_manager.h ('k') | components/view_manager/gesture_manager_delegate.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698