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
|
// Copyright (c) 2008 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_VIEWS_BLOCKED_POPUP_CONTAINER_H_
#define CHROME_BROWSER_VIEWS_BLOCKED_POPUP_CONTAINER_H_
#include <utility>
#include <vector>
#include "base/gfx/rect.h"
#include "chrome/browser/constrained_window.h"
#include "chrome/browser/tab_contents_delegate.h"
#include "chrome/common/animation.h"
#include "chrome/common/pref_member.h"
#include "chrome/views/widget_win.h"
class BlockedPopupContainerView;
class Profile;
class TabContents;
class TextButton;
///////////////////////////////////////////////////////////////////////////////
//
// BlockedPopupContainer
//
// This class takes ownership of TabContents that are unrequested popup
// windows and presents an interface to the user for launching them. (Or never
// showing them again)
//
class BlockedPopupContainer : public ConstrainedWindow,
public TabContentsDelegate,
public views::WidgetWin,
public Animation {
public:
virtual ~BlockedPopupContainer();
// Create a BlockedPopupContainer, anchoring the container to the lower right
// corner.
static BlockedPopupContainer* Create(
TabContents* owner, Profile* profile, const gfx::Point& initial_anchor);
// Toggles the preference to display this notification.
void ToggleBlockedPopupNotification();
// Gets the current state of the show blocked popup notification preference.
bool GetShowBlockedPopupNotification();
// Adds a Tabbed contents to this container. |bounds| are the window bounds
// requested by the popup window.
void AddTabContents(TabContents* blocked_contents, const gfx::Rect& bounds);
// Creates a window from blocked popup |index|.
void LaunchPopupIndex(int index);
// Return the number of blocked popups
int GetTabContentsCount() const;
// Returns the string to display to the user in the menu for item |index|.
std::wstring GetDisplayStringForItem(int index);
// Deletes all popups and hides the interface parts.
void CloseAllPopups();
// Called to force this container to never show itself again.
void set_dismissed() { has_been_dismissed_ = true; }
// Override from ConstrainedWindow:
virtual void CloseConstrainedWindow();
virtual void RepositionConstrainedWindowTo(const gfx::Point& anchor_point);
virtual void WasHidden() { }
virtual void DidBecomeSelected() { }
virtual std::wstring GetWindowTitle() const;
virtual const gfx::Rect& GetCurrentBounds() const;
// Override from TabContentsDelegate:
virtual void OpenURLFromTab(TabContents* source,
const GURL& url, const GURL& referrer,
WindowOpenDisposition disposition,
PageTransition::Type transition);
virtual void NavigationStateChanged(const TabContents* source,
unsigned changed_flags) { }
virtual void ReplaceContents(TabContents* source,
TabContents* new_contents);
virtual void AddNewContents(TabContents* source,
TabContents* new_contents,
WindowOpenDisposition disposition,
const gfx::Rect& initial_pos,
bool user_gesture);
virtual void ActivateContents(TabContents* contents) { }
virtual void LoadingStateChanged(TabContents* source) { }
virtual void CloseContents(TabContents* source);
virtual void MoveContents(TabContents* source, const gfx::Rect& pos);
virtual bool IsPopup(TabContents* source);
virtual TabContents* GetConstrainingContents(TabContents* source);
virtual void ToolbarSizeChanged(TabContents* source, bool is_animating) { }
virtual void URLStarredChanged(TabContents* source, bool starred) { }
virtual void UpdateTargetURL(TabContents* source, const GURL& url) { }
// Override from Animation:
virtual void AnimateToState(double state);
protected:
// Override from views::WidgetWin:
virtual void OnFinalMessage(HWND window);
virtual void OnSize(UINT param, const CSize& size);
private:
// Create a container for a certain TabContents.
BlockedPopupContainer(TabContents* owner, Profile* profile);
// Initialize our Views and positions us to the lower right corner of the
// browser window.
void Init(const gfx::Point& initial_anchor);
// Hides the UI portion of the container.
void HideSelf();
// Shows the UI portion of the container.
void ShowSelf();
// Sets our position, based on our |anchor_point_| and on our
// |visibility_percentage_|. This method is called whenever either of those
// change.
void SetPosition();
// Send a CloseContents() to each message in |blocked_popups_|.
void CloseEachTabContents();
// The TabContents that owns and constrains this BlockedPopupContainer.
TabContents* owner_;
// The TabContents and initial positions of all blocked popups.
std::vector<std::pair<TabContents*, gfx::Rect> > blocked_popups_;
// Our associated view object.
BlockedPopupContainerView* container_view_;
// Link to the block popups preference. Used to both determine whether we
// should show ourself to the user and to toggle whether we should show this
// notification to the user.
BooleanPrefMember block_popup_pref_;
// Once the container is hidden, this is set to prevent it from reappearing.
bool has_been_dismissed_;
// True while animation in; false while animating out.
bool in_show_animation_;
// Percentage of the window to show; used to animate in the notification.
double visibility_percentage_;
// The bounds to report to the automation system (may not equal our actual
// bounds while animating in or out).
gfx::Rect bounds_;
// The bottom right corner of where we should appear in our parent window.
gfx::Point anchor_point_;
DISALLOW_COPY_AND_ASSIGN(BlockedPopupContainer);
};
#endif
|
