| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/ui/views/fullscreen_exit_bubble_views.h" | |
| 6 | |
| 7 #include "base/message_loop/message_loop.h" | |
| 8 #include "base/strings/utf_string_conversions.h" | |
| 9 #include "chrome/app/chrome_command_ids.h" | |
| 10 #include "chrome/browser/chrome_notification_types.h" | |
| 11 #include "chrome/browser/ui/fullscreen/fullscreen_controller.h" | |
| 12 #include "chrome/browser/ui/views/frame/browser_view.h" | |
| 13 #include "chrome/browser/ui/views/frame/immersive_mode_controller.h" | |
| 14 #include "chrome/browser/ui/views/frame/top_container_view.h" | |
| 15 #include "chrome/grit/generated_resources.h" | |
| 16 #include "content/public/browser/notification_service.h" | |
| 17 #include "ui/base/l10n/l10n_util.h" | |
| 18 #include "ui/base/resource/resource_bundle.h" | |
| 19 #include "ui/events/keycodes/keyboard_codes.h" | |
| 20 #include "ui/gfx/animation/slide_animation.h" | |
| 21 #include "ui/gfx/canvas.h" | |
| 22 #include "ui/gfx/screen.h" | |
| 23 #include "ui/strings/grit/ui_strings.h" | |
| 24 #include "ui/views/bubble/bubble_border.h" | |
| 25 #include "ui/views/controls/button/label_button.h" | |
| 26 #include "ui/views/controls/link.h" | |
| 27 #include "ui/views/controls/link_listener.h" | |
| 28 #include "ui/views/layout/box_layout.h" | |
| 29 #include "ui/views/layout/grid_layout.h" | |
| 30 #include "ui/views/view.h" | |
| 31 #include "ui/views/widget/widget.h" | |
| 32 #include "url/gurl.h" | |
| 33 | |
| 34 #if defined(OS_WIN) | |
| 35 #include "ui/base/l10n/l10n_util_win.h" | |
| 36 #endif | |
| 37 | |
| 38 // FullscreenExitView ---------------------------------------------------------- | |
| 39 | |
| 40 namespace { | |
| 41 | |
| 42 // Space between the site info label and the buttons / link. | |
| 43 const int kMiddlePaddingPx = 30; | |
| 44 | |
| 45 class ButtonView : public views::View { | |
| 46 public: | |
| 47 ButtonView(views::ButtonListener* listener, int between_button_spacing); | |
| 48 ~ButtonView() override; | |
| 49 | |
| 50 // Returns an empty size when the view is not visible. | |
| 51 gfx::Size GetPreferredSize() const override; | |
| 52 | |
| 53 views::LabelButton* accept_button() const { return accept_button_; } | |
| 54 views::LabelButton* deny_button() const { return deny_button_; } | |
| 55 | |
| 56 private: | |
| 57 views::LabelButton* accept_button_; | |
| 58 views::LabelButton* deny_button_; | |
| 59 | |
| 60 DISALLOW_COPY_AND_ASSIGN(ButtonView); | |
| 61 }; | |
| 62 | |
| 63 ButtonView::ButtonView(views::ButtonListener* listener, | |
| 64 int between_button_spacing) | |
| 65 : accept_button_(NULL), | |
| 66 deny_button_(NULL) { | |
| 67 accept_button_ = new views::LabelButton(listener, base::string16()); | |
| 68 accept_button_->SetStyle(views::Button::STYLE_BUTTON); | |
| 69 accept_button_->SetFocusable(false); | |
| 70 AddChildView(accept_button_); | |
| 71 | |
| 72 deny_button_ = new views::LabelButton(listener, base::string16()); | |
| 73 deny_button_->SetStyle(views::Button::STYLE_BUTTON); | |
| 74 deny_button_->SetFocusable(false); | |
| 75 AddChildView(deny_button_); | |
| 76 | |
| 77 SetLayoutManager(new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, | |
| 78 between_button_spacing)); | |
| 79 } | |
| 80 | |
| 81 ButtonView::~ButtonView() { | |
| 82 } | |
| 83 | |
| 84 gfx::Size ButtonView::GetPreferredSize() const { | |
| 85 return visible() ? views::View::GetPreferredSize() : gfx::Size(); | |
| 86 } | |
| 87 | |
| 88 } // namespace | |
| 89 | |
| 90 class FullscreenExitBubbleViews::FullscreenExitView | |
| 91 : public views::View, | |
| 92 public views::ButtonListener, | |
| 93 public views::LinkListener { | |
| 94 public: | |
| 95 FullscreenExitView(FullscreenExitBubbleViews* bubble, | |
| 96 const base::string16& accelerator, | |
| 97 const GURL& url, | |
| 98 FullscreenExitBubbleType bubble_type); | |
| 99 ~FullscreenExitView() override; | |
| 100 | |
| 101 // views::ButtonListener | |
| 102 void ButtonPressed(views::Button* sender, const ui::Event& event) override; | |
| 103 | |
| 104 // views::LinkListener | |
| 105 void LinkClicked(views::Link* source, int event_flags) override; | |
| 106 | |
| 107 void UpdateContent(const GURL& url, FullscreenExitBubbleType bubble_type); | |
| 108 | |
| 109 private: | |
| 110 FullscreenExitBubbleViews* bubble_; | |
| 111 | |
| 112 // Clickable hint text for exiting fullscreen mode. | |
| 113 views::Link* link_; | |
| 114 // Instruction for exiting mouse lock. | |
| 115 views::Label* mouse_lock_exit_instruction_; | |
| 116 // Informational label: 'www.foo.com has gone fullscreen'. | |
| 117 views::Label* message_label_; | |
| 118 ButtonView* button_view_; | |
| 119 const base::string16 browser_fullscreen_exit_accelerator_; | |
| 120 | |
| 121 DISALLOW_COPY_AND_ASSIGN(FullscreenExitView); | |
| 122 }; | |
| 123 | |
| 124 FullscreenExitBubbleViews::FullscreenExitView::FullscreenExitView( | |
| 125 FullscreenExitBubbleViews* bubble, | |
| 126 const base::string16& accelerator, | |
| 127 const GURL& url, | |
| 128 FullscreenExitBubbleType bubble_type) | |
| 129 : bubble_(bubble), | |
| 130 link_(NULL), | |
| 131 mouse_lock_exit_instruction_(NULL), | |
| 132 message_label_(NULL), | |
| 133 button_view_(NULL), | |
| 134 browser_fullscreen_exit_accelerator_(accelerator) { | |
| 135 scoped_ptr<views::BubbleBorder> bubble_border( | |
| 136 new views::BubbleBorder(views::BubbleBorder::NONE, | |
| 137 views::BubbleBorder::BIG_SHADOW, | |
| 138 SK_ColorWHITE)); | |
| 139 set_background(new views::BubbleBackground(bubble_border.get())); | |
| 140 SetBorder(bubble_border.Pass()); | |
| 141 SetFocusable(false); | |
| 142 | |
| 143 ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance(); | |
| 144 const gfx::FontList& medium_font_list = | |
| 145 rb.GetFontList(ui::ResourceBundle::MediumFont); | |
| 146 message_label_ = new views::Label(base::string16(), medium_font_list); | |
| 147 | |
| 148 mouse_lock_exit_instruction_ = | |
| 149 new views::Label(bubble_->GetInstructionText(), medium_font_list); | |
| 150 mouse_lock_exit_instruction_->set_collapse_when_hidden(true); | |
| 151 | |
| 152 link_ = new views::Link(); | |
| 153 link_->set_collapse_when_hidden(true); | |
| 154 link_->SetFocusable(false); | |
| 155 #if defined(OS_CHROMEOS) | |
| 156 // On CrOS, the link text doesn't change, since it doesn't show the shortcut. | |
| 157 link_->SetText(l10n_util::GetStringUTF16(IDS_EXIT_FULLSCREEN_MODE)); | |
| 158 #endif | |
| 159 link_->set_listener(this); | |
| 160 link_->SetFontList(medium_font_list); | |
| 161 link_->SetPressedColor(message_label_->enabled_color()); | |
| 162 link_->SetEnabledColor(message_label_->enabled_color()); | |
| 163 link_->SetVisible(false); | |
| 164 | |
| 165 link_->SetBackgroundColor(background()->get_color()); | |
| 166 message_label_->SetBackgroundColor(background()->get_color()); | |
| 167 mouse_lock_exit_instruction_->SetBackgroundColor(background()->get_color()); | |
| 168 | |
| 169 button_view_ = new ButtonView(this, kPaddingPx); | |
| 170 button_view_->accept_button()->SetText(bubble->GetAllowButtonText()); | |
| 171 | |
| 172 views::GridLayout* layout = new views::GridLayout(this); | |
| 173 views::ColumnSet* columns = layout->AddColumnSet(0); | |
| 174 columns->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER, 0, | |
| 175 views::GridLayout::USE_PREF, 0, 0); | |
| 176 columns->AddPaddingColumn(1, kMiddlePaddingPx); | |
| 177 columns->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER, 0, | |
| 178 views::GridLayout::USE_PREF, 0, 0); | |
| 179 columns->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER, 0, | |
| 180 views::GridLayout::USE_PREF, 0, 0); | |
| 181 columns->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER, 0, | |
| 182 views::GridLayout::USE_PREF, 0, 0); | |
| 183 | |
| 184 layout->StartRow(0, 0); | |
| 185 layout->AddView(message_label_); | |
| 186 layout->AddView(button_view_); | |
| 187 layout->AddView(mouse_lock_exit_instruction_); | |
| 188 layout->AddView(link_); | |
| 189 | |
| 190 gfx::Insets padding(kPaddingPx, kPaddingPx, kPaddingPx, kPaddingPx); | |
| 191 padding += GetInsets(); | |
| 192 layout->SetInsets(padding); | |
| 193 SetLayoutManager(layout); | |
| 194 | |
| 195 UpdateContent(url, bubble_type); | |
| 196 } | |
| 197 | |
| 198 FullscreenExitBubbleViews::FullscreenExitView::~FullscreenExitView() { | |
| 199 } | |
| 200 | |
| 201 void FullscreenExitBubbleViews::FullscreenExitView::ButtonPressed( | |
| 202 views::Button* sender, | |
| 203 const ui::Event& event) { | |
| 204 if (sender == button_view_->accept_button()) | |
| 205 bubble_->Accept(); | |
| 206 else | |
| 207 bubble_->Cancel(); | |
| 208 } | |
| 209 | |
| 210 void FullscreenExitBubbleViews::FullscreenExitView::LinkClicked( | |
| 211 views::Link* link, | |
| 212 int event_flags) { | |
| 213 bubble_->ToggleFullscreen(); | |
| 214 } | |
| 215 | |
| 216 void FullscreenExitBubbleViews::FullscreenExitView::UpdateContent( | |
| 217 const GURL& url, | |
| 218 FullscreenExitBubbleType bubble_type) { | |
| 219 DCHECK_NE(FEB_TYPE_NONE, bubble_type); | |
| 220 | |
| 221 message_label_->SetText(bubble_->GetCurrentMessageText()); | |
| 222 if (fullscreen_bubble::ShowButtonsForType(bubble_type)) { | |
| 223 link_->SetVisible(false); | |
| 224 mouse_lock_exit_instruction_->SetVisible(false); | |
| 225 button_view_->SetVisible(true); | |
| 226 button_view_->deny_button()->SetText(bubble_->GetCurrentDenyButtonText()); | |
| 227 button_view_->deny_button()->SetMinSize(gfx::Size()); | |
| 228 } else { | |
| 229 bool link_visible = true; | |
| 230 base::string16 accelerator; | |
| 231 if (bubble_type == FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION || | |
| 232 bubble_type == FEB_TYPE_BROWSER_EXTENSION_FULLSCREEN_EXIT_INSTRUCTION) { | |
| 233 accelerator = browser_fullscreen_exit_accelerator_; | |
| 234 } else if (bubble_type == FEB_TYPE_FULLSCREEN_EXIT_INSTRUCTION) { | |
| 235 accelerator = l10n_util::GetStringUTF16(IDS_APP_ESC_KEY); | |
| 236 } else { | |
| 237 link_visible = false; | |
| 238 } | |
| 239 #if !defined(OS_CHROMEOS) | |
| 240 if (link_visible) { | |
| 241 link_->SetText( | |
| 242 l10n_util::GetStringUTF16(IDS_EXIT_FULLSCREEN_MODE) + | |
| 243 base::UTF8ToUTF16(" ") + | |
| 244 l10n_util::GetStringFUTF16(IDS_EXIT_FULLSCREEN_MODE_ACCELERATOR, | |
| 245 accelerator)); | |
| 246 } | |
| 247 #endif | |
| 248 link_->SetVisible(link_visible); | |
| 249 mouse_lock_exit_instruction_->SetVisible(!link_visible); | |
| 250 button_view_->SetVisible(false); | |
| 251 } | |
| 252 } | |
| 253 | |
| 254 | |
| 255 // FullscreenExitBubbleViews --------------------------------------------------- | |
| 256 | |
| 257 FullscreenExitBubbleViews::FullscreenExitBubbleViews( | |
| 258 BrowserView* browser_view, | |
| 259 const GURL& url, | |
| 260 FullscreenExitBubbleType bubble_type) | |
| 261 : FullscreenExitBubble(browser_view->browser(), url, bubble_type), | |
| 262 browser_view_(browser_view), | |
| 263 popup_(NULL), | |
| 264 animation_(new gfx::SlideAnimation(this)), | |
| 265 animated_attribute_(ANIMATED_ATTRIBUTE_BOUNDS) { | |
| 266 animation_->Reset(1); | |
| 267 | |
| 268 // Create the contents view. | |
| 269 ui::Accelerator accelerator(ui::VKEY_UNKNOWN, ui::EF_NONE); | |
| 270 bool got_accelerator = browser_view_->GetWidget()->GetAccelerator( | |
| 271 IDC_FULLSCREEN, &accelerator); | |
| 272 DCHECK(got_accelerator); | |
| 273 view_ = new FullscreenExitView( | |
| 274 this, accelerator.GetShortcutText(), url, bubble_type_); | |
| 275 | |
| 276 // TODO(yzshen): Change to use the new views bubble, BubbleDelegateView. | |
| 277 // TODO(pkotwicz): When this becomes a views bubble, make sure that this | |
| 278 // bubble is ignored by ImmersiveModeControllerAsh::BubbleManager. | |
| 279 // Initialize the popup. | |
| 280 popup_ = new views::Widget; | |
| 281 views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP); | |
| 282 params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW; | |
| 283 params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; | |
| 284 params.parent = browser_view_->GetWidget()->GetNativeView(); | |
| 285 params.bounds = GetPopupRect(false); | |
| 286 popup_->Init(params); | |
| 287 gfx::Size size = GetPopupRect(true).size(); | |
| 288 popup_->SetContentsView(view_); | |
| 289 // We set layout manager to NULL to prevent the widget from sizing its | |
| 290 // contents to the same size as itself. This prevents the widget contents from | |
| 291 // shrinking while we animate the height of the popup to give the impression | |
| 292 // that it is sliding off the top of the screen. | |
| 293 popup_->GetRootView()->SetLayoutManager(NULL); | |
| 294 view_->SetBounds(0, 0, size.width(), size.height()); | |
| 295 popup_->ShowInactive(); // This does not activate the popup. | |
| 296 | |
| 297 popup_->AddObserver(this); | |
| 298 | |
| 299 registrar_.Add( | |
| 300 this, | |
| 301 chrome::NOTIFICATION_FULLSCREEN_CHANGED, | |
| 302 content::Source<FullscreenController>( | |
| 303 browser_view_->browser()->fullscreen_controller())); | |
| 304 | |
| 305 UpdateForImmersiveState(); | |
| 306 } | |
| 307 | |
| 308 FullscreenExitBubbleViews::~FullscreenExitBubbleViews() { | |
| 309 popup_->RemoveObserver(this); | |
| 310 | |
| 311 // This is tricky. We may be in an ATL message handler stack, in which case | |
| 312 // the popup cannot be deleted yet. We also can't set the popup's ownership | |
| 313 // model to NATIVE_WIDGET_OWNS_WIDGET because if the user closed the last tab | |
| 314 // while in fullscreen mode, Windows has already destroyed the popup HWND by | |
| 315 // the time we get here, and thus either the popup will already have been | |
| 316 // deleted (if we set this in our constructor) or the popup will never get | |
| 317 // another OnFinalMessage() call (if not, as currently). So instead, we tell | |
| 318 // the popup to synchronously hide, and then asynchronously close and delete | |
| 319 // itself. | |
| 320 popup_->Close(); | |
| 321 base::MessageLoop::current()->DeleteSoon(FROM_HERE, popup_); | |
| 322 } | |
| 323 | |
| 324 void FullscreenExitBubbleViews::UpdateContent( | |
| 325 const GURL& url, | |
| 326 FullscreenExitBubbleType bubble_type) { | |
| 327 DCHECK_NE(FEB_TYPE_NONE, bubble_type); | |
| 328 if (bubble_type_ == bubble_type && url_ == url) | |
| 329 return; | |
| 330 | |
| 331 url_ = url; | |
| 332 bubble_type_ = bubble_type; | |
| 333 view_->UpdateContent(url_, bubble_type_); | |
| 334 | |
| 335 gfx::Size size = GetPopupRect(true).size(); | |
| 336 view_->SetSize(size); | |
| 337 popup_->SetBounds(GetPopupRect(false)); | |
| 338 Show(); | |
| 339 | |
| 340 // Stop watching the mouse even if UpdateMouseWatcher() will start watching | |
| 341 // it again so that the popup with the new content is visible for at least | |
| 342 // |kInitialDelayMs|. | |
| 343 StopWatchingMouse(); | |
| 344 | |
| 345 UpdateMouseWatcher(); | |
| 346 } | |
| 347 | |
| 348 void FullscreenExitBubbleViews::RepositionIfVisible() { | |
| 349 if (popup_->IsVisible()) | |
| 350 UpdateBounds(); | |
| 351 } | |
| 352 | |
| 353 void FullscreenExitBubbleViews::UpdateMouseWatcher() { | |
| 354 bool should_watch_mouse = false; | |
| 355 if (popup_->IsVisible()) | |
| 356 should_watch_mouse = !fullscreen_bubble::ShowButtonsForType(bubble_type_); | |
| 357 else | |
| 358 should_watch_mouse = CanMouseTriggerSlideIn(); | |
| 359 | |
| 360 if (should_watch_mouse == IsWatchingMouse()) | |
| 361 return; | |
| 362 | |
| 363 if (should_watch_mouse) | |
| 364 StartWatchingMouse(); | |
| 365 else | |
| 366 StopWatchingMouse(); | |
| 367 } | |
| 368 | |
| 369 void FullscreenExitBubbleViews::UpdateForImmersiveState() { | |
| 370 AnimatedAttribute expected_animated_attribute = | |
| 371 browser_view_->immersive_mode_controller()->IsEnabled() ? | |
| 372 ANIMATED_ATTRIBUTE_OPACITY : ANIMATED_ATTRIBUTE_BOUNDS; | |
| 373 if (animated_attribute_ != expected_animated_attribute) { | |
| 374 // If an animation is currently in progress, skip to the end because | |
| 375 // switching the animated attribute midway through the animation looks | |
| 376 // weird. | |
| 377 animation_->End(); | |
| 378 | |
| 379 animated_attribute_ = expected_animated_attribute; | |
| 380 | |
| 381 // We may have finished hiding |popup_|. However, the bounds animation | |
| 382 // assumes |popup_| has the opacity when it is fully shown and the opacity | |
| 383 // animation assumes |popup_| has the bounds when |popup_| is fully shown. | |
| 384 if (animated_attribute_ == ANIMATED_ATTRIBUTE_BOUNDS) | |
| 385 popup_->SetOpacity(255); | |
| 386 else | |
| 387 UpdateBounds(); | |
| 388 } | |
| 389 | |
| 390 UpdateMouseWatcher(); | |
| 391 } | |
| 392 | |
| 393 void FullscreenExitBubbleViews::UpdateBounds() { | |
| 394 gfx::Rect popup_rect(GetPopupRect(false)); | |
| 395 if (!popup_rect.IsEmpty()) { | |
| 396 popup_->SetBounds(popup_rect); | |
| 397 view_->SetY(popup_rect.height() - view_->height()); | |
| 398 } | |
| 399 } | |
| 400 | |
| 401 views::View* FullscreenExitBubbleViews::GetBrowserRootView() const { | |
| 402 return browser_view_->GetWidget()->GetRootView(); | |
| 403 } | |
| 404 | |
| 405 void FullscreenExitBubbleViews::AnimationProgressed( | |
| 406 const gfx::Animation* animation) { | |
| 407 if (animated_attribute_ == ANIMATED_ATTRIBUTE_OPACITY) { | |
| 408 int opacity = animation_->CurrentValueBetween(0, 255); | |
| 409 if (opacity == 0) { | |
| 410 popup_->Hide(); | |
| 411 } else { | |
| 412 popup_->Show(); | |
| 413 popup_->SetOpacity(opacity); | |
| 414 } | |
| 415 } else { | |
| 416 if (GetPopupRect(false).IsEmpty()) { | |
| 417 popup_->Hide(); | |
| 418 } else { | |
| 419 UpdateBounds(); | |
| 420 popup_->Show(); | |
| 421 } | |
| 422 } | |
| 423 } | |
| 424 | |
| 425 void FullscreenExitBubbleViews::AnimationEnded( | |
| 426 const gfx::Animation* animation) { | |
| 427 AnimationProgressed(animation); | |
| 428 } | |
| 429 | |
| 430 gfx::Rect FullscreenExitBubbleViews::GetPopupRect( | |
| 431 bool ignore_animation_state) const { | |
| 432 gfx::Size size(view_->GetPreferredSize()); | |
| 433 // NOTE: don't use the bounds of the root_view_. On linux GTK changing window | |
| 434 // size is async. Instead we use the size of the screen. | |
| 435 gfx::Screen* screen = | |
| 436 gfx::Screen::GetScreenFor(browser_view_->GetWidget()->GetNativeView()); | |
| 437 gfx::Rect screen_bounds = screen->GetDisplayNearestWindow( | |
| 438 browser_view_->GetWidget()->GetNativeView()).bounds(); | |
| 439 int x = screen_bounds.x() + (screen_bounds.width() - size.width()) / 2; | |
| 440 | |
| 441 int top_container_bottom = screen_bounds.y(); | |
| 442 if (browser_view_->immersive_mode_controller()->IsEnabled()) { | |
| 443 // Skip querying the top container height in non-immersive fullscreen | |
| 444 // because: | |
| 445 // - The top container height is always zero in non-immersive fullscreen. | |
| 446 // - Querying the top container height may return the height before entering | |
| 447 // fullscreen because layout is disabled while entering fullscreen. | |
| 448 // A visual glitch due to the delayed layout is avoided in immersive | |
| 449 // fullscreen because entering fullscreen starts with the top container | |
| 450 // revealed. When revealed, the top container has the same height as before | |
| 451 // entering fullscreen. | |
| 452 top_container_bottom = | |
| 453 browser_view_->top_container()->GetBoundsInScreen().bottom(); | |
| 454 } | |
| 455 int y = top_container_bottom + kPopupTopPx; | |
| 456 | |
| 457 if (!ignore_animation_state && | |
| 458 animated_attribute_ == ANIMATED_ATTRIBUTE_BOUNDS) { | |
| 459 int total_height = size.height() + kPopupTopPx; | |
| 460 int popup_bottom = animation_->CurrentValueBetween(total_height, 0); | |
| 461 int y_offset = std::min(popup_bottom, kPopupTopPx); | |
| 462 size.set_height(size.height() - popup_bottom + y_offset); | |
| 463 y -= y_offset; | |
| 464 } | |
| 465 return gfx::Rect(gfx::Point(x, y), size); | |
| 466 } | |
| 467 | |
| 468 gfx::Point FullscreenExitBubbleViews::GetCursorScreenPoint() { | |
| 469 gfx::Point cursor_pos = gfx::Screen::GetScreenFor( | |
| 470 browser_view_->GetWidget()->GetNativeView())->GetCursorScreenPoint(); | |
| 471 views::View::ConvertPointFromScreen(GetBrowserRootView(), &cursor_pos); | |
| 472 return cursor_pos; | |
| 473 } | |
| 474 | |
| 475 bool FullscreenExitBubbleViews::WindowContainsPoint(gfx::Point pos) { | |
| 476 return GetBrowserRootView()->HitTestPoint(pos); | |
| 477 } | |
| 478 | |
| 479 bool FullscreenExitBubbleViews::IsWindowActive() { | |
| 480 return browser_view_->GetWidget()->IsActive(); | |
| 481 } | |
| 482 | |
| 483 void FullscreenExitBubbleViews::Hide() { | |
| 484 animation_->SetSlideDuration(kSlideOutDurationMs); | |
| 485 animation_->Hide(); | |
| 486 } | |
| 487 | |
| 488 void FullscreenExitBubbleViews::Show() { | |
| 489 animation_->SetSlideDuration(kSlideInDurationMs); | |
| 490 animation_->Show(); | |
| 491 } | |
| 492 | |
| 493 bool FullscreenExitBubbleViews::IsAnimating() { | |
| 494 return animation_->is_animating(); | |
| 495 } | |
| 496 | |
| 497 bool FullscreenExitBubbleViews::CanMouseTriggerSlideIn() const { | |
| 498 return !browser_view_->immersive_mode_controller()->IsEnabled(); | |
| 499 } | |
| 500 | |
| 501 void FullscreenExitBubbleViews::Observe( | |
| 502 int type, | |
| 503 const content::NotificationSource& source, | |
| 504 const content::NotificationDetails& details) { | |
| 505 DCHECK_EQ(chrome::NOTIFICATION_FULLSCREEN_CHANGED, type); | |
| 506 UpdateForImmersiveState(); | |
| 507 } | |
| 508 | |
| 509 void FullscreenExitBubbleViews::OnWidgetVisibilityChanged( | |
| 510 views::Widget* widget, | |
| 511 bool visible) { | |
| 512 UpdateMouseWatcher(); | |
| 513 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 789403002:
Rename fullscreen_exit_bubble_* to exclusive_access_bubble_* (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master