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
|
// 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.
#ifndef CHROME_BROWSER_TAB_CONTENTS_INFOBAR_H_
#define CHROME_BROWSER_TAB_CONTENTS_INFOBAR_H_
#pragma once
#include "build/build_config.h"
#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "chrome/browser/tab_contents/infobar_delegate.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/base/animation/animation_delegate.h"
#include "ui/base/animation/slide_animation.h"
#include "ui/gfx/size.h"
// TODO(sail): These functions should be static methods in the InfoBar class
// below once all platforms use that class.
SkColor GetInfoBarTopColor(InfoBarDelegate::Type infobar_type);
SkColor GetInfoBarBottomColor(InfoBarDelegate::Type infobar_type);
// TODO(pkasting): Port Mac to use this.
#if defined(TOOLKIT_VIEWS) || defined(TOOLKIT_GTK)
class InfoBarContainer;
class TabContentsWrapper;
class InfoBar : public ui::AnimationDelegate {
public:
InfoBar(TabContentsWrapper* owner, InfoBarDelegate* delegate);
virtual ~InfoBar();
// Platforms must define these.
static const int kSeparatorLineHeight;
static const int kDefaultArrowTargetHeight;
static const int kMaximumArrowTargetHeight;
// The half-width (see comments on |arrow_half_width_| below) scales to its
// default and maximum values proportionally to how the height scales to its.
static const int kDefaultArrowTargetHalfWidth;
static const int kMaximumArrowTargetHalfWidth;
InfoBarDelegate* delegate() { return delegate_; }
void set_container(InfoBarContainer* container) { container_ = container; }
// Makes the infobar visible. If |animate| is true, the infobar is then
// animated to full size.
void Show(bool animate);
// Makes the infobar hidden. If |animate| is true, the infobar is first
// animated to zero size. Once the infobar is hidden, it is removed from its
// container (triggering its deletion), and its delegate is closed.
void Hide(bool animate);
// Changes the target height of the arrow portion of the infobar. This has no
// effect once the infobar is animating closed.
void SetArrowTargetHeight(int height);
const ui::SlideAnimation& animation() const { return animation_; }
int arrow_height() const { return arrow_height_; }
int arrow_target_height() const { return arrow_target_height_; }
int arrow_half_width() const { return arrow_half_width_; }
int total_height() const { return arrow_height_ + bar_height_; }
protected:
// Platforms must define this.
static const int kDefaultBarTargetHeight;
// ui::AnimationDelegate:
virtual void AnimationProgressed(const ui::Animation* animation) OVERRIDE;
// Called when the user closes the infobar, notifies the delegate we've been
// dismissed and forwards a removal request to our owner.
void RemoveInfoBar();
// Changes the target height of the main ("bar") portion of the infobar.
void SetBarTargetHeight(int height);
// Given a control with size |prefsize|, returns the centered y position
// within us, taking into account animation so the control "slides in" (or
// out) as we animate open and closed.
int OffsetY(const gfx::Size& prefsize) const;
const InfoBarContainer* container() const { return container_; }
InfoBarContainer* container() { return container_; }
ui::SlideAnimation* animation() { return &animation_; }
int bar_height() const { return bar_height_; }
int bar_target_height() const { return bar_target_height_; }
// Platforms may optionally override these if they need to do work during
// processing of the given calls.
virtual void PlatformSpecificShow(bool animate) {}
virtual void PlatformSpecificHide(bool animate) {}
virtual void PlatformSpecificOnHeightsRecalculated() {}
private:
// ui::AnimationDelegate:
virtual void AnimationEnded(const ui::Animation* animation) OVERRIDE;
// Finds the new desired arrow and bar heights, and if they differ from the
// current ones, calls PlatformSpecificOnHeightRecalculated(). Informs our
// container our state has changed if either the heights have changed or
// |force_notify| is set.
void RecalculateHeights(bool force_notify);
// Checks whether we're closed. If so, notifies the container that it should
// remove us (which will cause the platform-specific code to asynchronously
// delete us) and closes the delegate.
void MaybeDelete();
TabContentsWrapper* owner_;
InfoBarDelegate* delegate_;
InfoBarContainer* container_;
ui::SlideAnimation animation_;
// The current and target heights of the arrow and bar portions, and half the
// current arrow width. (It's easier to work in half-widths as we draw the
// arrow as two halves on either side of a center point.)
int arrow_height_; // Includes both fill and top stroke.
int arrow_target_height_;
int arrow_half_width_; // Includes only fill.
int bar_height_; // Includes both fill and bottom separator.
int bar_target_height_;
DISALLOW_COPY_AND_ASSIGN(InfoBar);
};
#elif defined(OS_MACOSX)
#include "chrome/browser/ui/cocoa/infobars/infobar.h"
#endif
#endif // CHROME_BROWSER_TAB_CONTENTS_INFOBAR_H_
|
