1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
|
// Copyright 2014 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/view_targeter_delegate.h"
#include "ui/gfx/geometry/rect_conversions.h"
#include "ui/views/rect_based_targeting_utils.h"
#include "ui/views/view.h"
namespace {
// The minimum percentage of a view's area that needs to be covered by a rect
// representing a touch region in order for that view to be considered by the
// rect-based targeting algorithm.
static const float kRectTargetOverlap = 0.6f;
} // namespace
namespace views {
// TODO(tdanderson): Move the contents of rect_based_targeting_utils.(h|cc)
// into here.
bool ViewTargeterDelegate::DoesIntersectRect(const View* target,
const gfx::Rect& rect) const {
return target->GetLocalBounds().Intersects(rect);
}
View* ViewTargeterDelegate::TargetForRect(View* root, const gfx::Rect& rect) {
// |rect_view| represents the current best candidate to return
// if rect-based targeting (i.e., fuzzing) is used.
// |rect_view_distance| is used to keep track of the distance
// between the center point of |rect_view| and the center
// point of |rect|.
View* rect_view = NULL;
int rect_view_distance = INT_MAX;
// |point_view| represents the view that would have been returned
// from this function call if point-based targeting were used.
View* point_view = NULL;
for (int i = root->child_count() - 1; i >= 0; --i) {
View* child = root->child_at(i);
if (!child->CanProcessEventsWithinSubtree())
continue;
// Ignore any children which are invisible or do not intersect |rect|.
if (!child->visible())
continue;
gfx::RectF rect_in_child_coords_f(rect);
View::ConvertRectToTarget(root, child, &rect_in_child_coords_f);
gfx::Rect rect_in_child_coords = gfx::ToEnclosingRect(
rect_in_child_coords_f);
if (!child->HitTestRect(rect_in_child_coords))
continue;
View* cur_view = child->GetEventHandlerForRect(rect_in_child_coords);
if (views::UsePointBasedTargeting(rect))
return cur_view;
gfx::RectF cur_view_bounds_f(cur_view->GetLocalBounds());
View::ConvertRectToTarget(cur_view, root, &cur_view_bounds_f);
gfx::Rect cur_view_bounds = gfx::ToEnclosingRect(
cur_view_bounds_f);
if (views::PercentCoveredBy(cur_view_bounds, rect) >= kRectTargetOverlap) {
// |cur_view| is a suitable candidate for rect-based targeting.
// Check to see if it is the closest suitable candidate so far.
gfx::Point touch_center(rect.CenterPoint());
int cur_dist = views::DistanceSquaredFromCenterToPoint(touch_center,
cur_view_bounds);
if (!rect_view || cur_dist < rect_view_distance) {
rect_view = cur_view;
rect_view_distance = cur_dist;
}
} else if (!rect_view && !point_view) {
// Rect-based targeting has not yielded any candidates so far. Check
// if point-based targeting would have selected |cur_view|.
gfx::Point point_in_child_coords(rect_in_child_coords.CenterPoint());
if (child->HitTestPoint(point_in_child_coords))
point_view = child->GetEventHandlerForPoint(point_in_child_coords);
}
}
if (views::UsePointBasedTargeting(rect) || (!rect_view && !point_view))
return root;
// If |root| is a suitable candidate for rect-based targeting, check to
// see if it is closer than the current best suitable candidate so far.
gfx::Rect local_bounds(root->GetLocalBounds());
if (views::PercentCoveredBy(local_bounds, rect) >= kRectTargetOverlap) {
gfx::Point touch_center(rect.CenterPoint());
int cur_dist = views::DistanceSquaredFromCenterToPoint(touch_center,
local_bounds);
if (!rect_view || cur_dist < rect_view_distance)
rect_view = root;
}
return rect_view ? rect_view : point_view;
}
} // namespace views
|
