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
|
// 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.
#if defined(TOOLKIT_VIEWS) // TODO(pkasting): Port non-views to use this.
#include "chrome/browser/tab_contents/infobar.h"
#include <cmath>
#include "chrome/browser/tab_contents/infobar_container.h"
#include "chrome/browser/tab_contents/infobar_delegate.h"
#include "ui/base/animation/slide_animation.h"
InfoBar::InfoBar(TabContentsWrapper* owner, InfoBarDelegate* delegate)
: owner_(owner),
delegate_(delegate),
container_(NULL),
ALLOW_THIS_IN_INITIALIZER_LIST(animation_(new ui::SlideAnimation(this))),
arrow_height_(0),
arrow_target_height_(kDefaultArrowTargetHeight),
arrow_half_width_(0),
bar_height_(0),
bar_target_height_(kDefaultBarTargetHeight) {
DCHECK(owner != NULL);
DCHECK(delegate != NULL);
animation_->SetTweenType(ui::Tween::LINEAR);
}
InfoBar::~InfoBar() {
}
void InfoBar::Show(bool animate) {
if (animate) {
animation_->Show();
} else {
animation_->Reset(1.0);
AnimationEnded(NULL);
}
}
void InfoBar::Hide(bool animate) {
PlatformSpecificHide(animate);
if (animate) {
animation_->Hide();
} else {
animation_->Reset(0.0);
AnimationEnded(NULL);
}
}
void InfoBar::SetArrowTargetHeight(int height) {
DCHECK_LE(height, kMaximumArrowTargetHeight);
// Once the closing animation starts, we ignore further requests to change the
// target height.
if ((arrow_target_height_ != height) && !animation()->IsClosing()) {
arrow_target_height_ = height;
RecalculateHeights(false);
}
}
void InfoBar::AnimationProgressed(const ui::Animation* animation) {
RecalculateHeights(false);
}
void InfoBar::RemoveInfoBar() {
if (container_)
container_->RemoveDelegate(delegate_);
}
void InfoBar::SetBarTargetHeight(int height) {
if (bar_target_height_ != height) {
bar_target_height_ = height;
RecalculateHeights(false);
}
}
int InfoBar::OffsetY(const gfx::Size& prefsize) const {
return arrow_height_ +
std::max((bar_target_height_ - prefsize.height()) / 2, 0) -
(bar_target_height_ - bar_height_);
}
void InfoBar::AnimationEnded(const ui::Animation* animation) {
// When the animation ends, we must ensure the container is notified even if
// the heights haven't changed, lest it never get an "animation finished"
// notification. (If the browser doesn't get this notification, it will not
// bother to re-layout the content area for the new infobar size.)
RecalculateHeights(true);
MaybeDelete();
}
void InfoBar::RecalculateHeights(bool force_notify) {
int old_arrow_height = arrow_height_;
int old_bar_height = bar_height_;
// Find the desired arrow height/half-width. The arrow area is
// |arrow_height_| * |arrow_half_width_|. When the bar is opening or closing,
// scaling each of these with the square root of the animation value causes a
// linear animation of the area, which matches the perception of the animation
// of the bar portion.
double scale_factor = sqrt(animation_->GetCurrentValue());
arrow_height_ = static_cast<int>(arrow_target_height_ * scale_factor);
if (animation_->is_animating()) {
arrow_half_width_ = static_cast<int>(std::min(arrow_target_height_,
kMaximumArrowTargetHalfWidth) * scale_factor);
} else {
// When the infobar is not animating (i.e. fully open), we set the
// half-width to be proportionally the same distance between its default and
// maximum values as the height is between its.
arrow_half_width_ = kDefaultArrowTargetHalfWidth +
((kMaximumArrowTargetHalfWidth - kDefaultArrowTargetHalfWidth) *
((arrow_height_ - kDefaultArrowTargetHeight) /
(kMaximumArrowTargetHeight - kDefaultArrowTargetHeight)));
}
// Add pixels for the stroke, if the arrow is to be visible at all. Without
// this, changing the arrow height from 0 to kSeparatorLineHeight would
// produce no visible effect, because the stroke would paint atop the divider
// line above the infobar.
if (arrow_height_)
arrow_height_ += kSeparatorLineHeight;
bar_height_ = animation_->CurrentValueBetween(0, bar_target_height_);
// Don't re-layout if nothing has changed, e.g. because the animation step was
// not large enough to actually change the heights by at least a pixel.
bool heights_differ =
(old_arrow_height != arrow_height_) || (old_bar_height != bar_height_);
if (heights_differ)
PlatformSpecificOnHeightsRecalculated();
if (container_ && (heights_differ || force_notify))
container_->OnInfoBarStateChanged(animation_->is_animating());
}
void InfoBar::MaybeDelete() {
if (delegate_ && (animation_->GetCurrentValue() == 0.0)) {
if (container_)
container_->RemoveInfoBar(this);
// Note that we only tell the delegate we're closed here, and not when we're
// simply destroyed (by virtue of a tab switch or being moved from window to
// window), since this action can cause the delegate to destroy itself.
delegate_->InfoBarClosed();
delegate_ = NULL;
}
}
#endif // TOOLKIT_VIEWS
|
