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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
// Copyright (c) 2009 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 "chrome/browser/find_bar_controller.h"
#include "base/i18n/rtl.h"
#include "build/build_config.h"
#include "chrome/browser/find_bar.h"
#include "chrome/browser/tab_contents/navigation_entry.h"
#include "chrome/common/notification_service.h"
#include "chrome/browser/tab_contents/tab_contents.h"
// The minimum space between the FindInPage window and the search result.
static const int kMinFindWndDistanceFromSelection = 5;
FindBarController::FindBarController(FindBar* find_bar)
: find_bar_(find_bar),
tab_contents_(NULL),
last_reported_matchcount_(0) {
}
FindBarController::~FindBarController() {
DCHECK(!tab_contents_);
}
void FindBarController::Show() {
// Only show the animation if we're not already showing a find bar for the
// selected TabContents.
if (!tab_contents_->find_ui_active()) {
tab_contents_->set_find_ui_active(true);
find_bar_->Show(true);
}
find_bar_->SetFocusAndSelection();
}
void FindBarController::EndFindSession(SelectionAction action) {
find_bar_->Hide(true);
// |tab_contents_| can be NULL for a number of reasons, for example when the
// tab is closing. We must guard against that case. See issue 8030.
if (tab_contents_) {
// When we hide the window, we need to notify the renderer that we are done
// for now, so that we can abort the scoping effort and clear all the
// tickmarks and highlighting.
tab_contents_->StopFinding(action);
find_bar_->ClearResults(tab_contents_->find_result());
// When we get dismissed we restore the focus to where it belongs.
find_bar_->RestoreSavedFocus();
}
}
void FindBarController::ChangeTabContents(TabContents* contents) {
if (tab_contents_) {
registrar_.RemoveAll();
find_bar_->StopAnimation();
}
tab_contents_ = contents;
// Hide any visible find window from the previous tab if NULL |tab_contents|
// is passed in or if the find UI is not active in the new tab.
if (find_bar_->IsFindBarVisible() &&
(!tab_contents_ || !tab_contents_->find_ui_active())) {
find_bar_->Hide(false);
}
if (!tab_contents_)
return;
registrar_.Add(this, NotificationType::FIND_RESULT_AVAILABLE,
Source<TabContents>(tab_contents_));
registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
Source<NavigationController>(&tab_contents_->controller()));
#if !defined(OS_MACOSX)
// Find out what we should show in the find text box. Usually, this will be
// the last search in this tab, but if no search has been issued in this tab
// we use the last search string (from any tab).
string16 find_string = tab_contents_->find_text();
if (find_string.empty())
find_string = tab_contents_->find_prepopulate_text();
// Update the find bar with existing results and search text, regardless of
// whether or not the find bar is visible, so that if it's subsequently
// shown it is showing the right state for this tab. We update the find text
// _first_ since the FindBarView checks its emptiness to see if it should
// clear the result count display when there's nothing in the box.
find_bar_->SetFindText(find_string);
#else
// Having a per-tab find_string is not compatible with OS X's find pasteboard,
// so we always have the same find text in all find bars. This is done through
// the find pasteboard mechanism, so don't set the text here.
#endif
if (tab_contents_->find_ui_active()) {
// A tab with a visible find bar just got selected and we need to show the
// find bar but without animation since it was already animated into its
// visible state. We also want to reset the window location so that
// we don't surprise the user by popping up to the left for no apparent
// reason.
find_bar_->Show(false);
}
UpdateFindBarForCurrentResult();
}
////////////////////////////////////////////////////////////////////////////////
// FindBarHost, NotificationObserver implementation:
void FindBarController::Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details) {
if (type == NotificationType::FIND_RESULT_AVAILABLE) {
// Don't update for notifications from TabContentses other than the one we
// are actively tracking.
if (Source<TabContents>(source).ptr() == tab_contents_) {
UpdateFindBarForCurrentResult();
if (tab_contents_->find_result().final_update() &&
tab_contents_->find_result().number_of_matches() == 0) {
const string16& last_search = tab_contents_->previous_find_text();
const string16& current_search = tab_contents_->find_text();
if (last_search.find(current_search) != 0)
find_bar_->AudibleAlert();
}
}
} else if (type == NotificationType::NAV_ENTRY_COMMITTED) {
NavigationController* source_controller =
Source<NavigationController>(source).ptr();
if (source_controller == &tab_contents_->controller()) {
NavigationController::LoadCommittedDetails* commit_details =
Details<NavigationController::LoadCommittedDetails>(details).ptr();
PageTransition::Type transition_type =
commit_details->entry->transition_type();
// We hide the FindInPage window when the user navigates away, except on
// reload.
if (find_bar_->IsFindBarVisible()) {
if (PageTransition::StripQualifier(transition_type) !=
PageTransition::RELOAD) {
EndFindSession(kKeepSelection);
} else {
// On Reload we want to make sure FindNext is converted to a full Find
// to make sure highlights for inactive matches are repainted.
tab_contents_->set_find_op_aborted(true);
}
}
}
}
}
// static
gfx::Rect FindBarController::GetLocationForFindbarView(
gfx::Rect view_location,
const gfx::Rect& dialog_bounds,
const gfx::Rect& avoid_overlapping_rect) {
if (base::i18n::IsRTL()) {
int boundary = dialog_bounds.width() - view_location.width();
view_location.set_x(std::min(view_location.x(), boundary));
} else {
view_location.set_x(std::max(view_location.x(), dialog_bounds.x()));
}
gfx::Rect new_pos = view_location;
// If the selection rectangle intersects the current position on screen then
// we try to move our dialog to the left (right for RTL) of the selection
// rectangle.
if (!avoid_overlapping_rect.IsEmpty() &&
avoid_overlapping_rect.Intersects(new_pos)) {
if (base::i18n::IsRTL()) {
new_pos.set_x(avoid_overlapping_rect.x() +
avoid_overlapping_rect.width() +
(2 * kMinFindWndDistanceFromSelection));
// If we moved it off-screen to the right, we won't move it at all.
if (new_pos.x() + new_pos.width() > dialog_bounds.width())
new_pos = view_location; // Reset.
} else {
new_pos.set_x(avoid_overlapping_rect.x() - new_pos.width() -
kMinFindWndDistanceFromSelection);
// If we moved it off-screen to the left, we won't move it at all.
if (new_pos.x() < 0)
new_pos = view_location; // Reset.
}
}
return new_pos;
}
void FindBarController::UpdateFindBarForCurrentResult() {
const FindNotificationDetails& find_result = tab_contents_->find_result();
// Avoid bug 894389: When a new search starts (and finds something) it reports
// an interim match count result of 1 before the scoping effort starts. This
// is to provide feedback as early as possible that we will find something.
// As you add letters to the search term, this creates a flashing effect when
// we briefly show "1 of 1" matches because there is a slight delay until
// the scoping effort starts updating the match count. We avoid this flash by
// ignoring interim results of 1 if we already have a positive number.
if (find_result.number_of_matches() > -1) {
if (last_reported_matchcount_ > 0 &&
find_result.number_of_matches() == 1 &&
!find_result.final_update())
return; // Don't let interim result override match count.
last_reported_matchcount_ = find_result.number_of_matches();
}
find_bar_->UpdateUIForFindResult(find_result, tab_contents_->find_text());
}
|
