[Metrics] Make MetricsStateManager take a callback param to check if UMA is enabled.
[chromium-blink-merge.git] / chrome / browser / ui / views / panels / panel_view.cc
bloba52c2767e1ac46fba20bf08e4c5ec3e9d849fe8f
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.
5 #include "chrome/browser/ui/views/panels/panel_view.h"
7 #include <map>
8 #include "base/logging.h"
9 #include "base/message_loop/message_loop.h"
10 #include "base/strings/utf_string_conversions.h"
11 #include "chrome/app/chrome_command_ids.h"
12 #include "chrome/browser/profiles/profile.h"
13 #include "chrome/browser/ui/host_desktop.h"
14 #include "chrome/browser/ui/panels/panel.h"
15 #include "chrome/browser/ui/panels/panel_bounds_animation.h"
16 #include "chrome/browser/ui/panels/panel_manager.h"
17 #include "chrome/browser/ui/panels/stacked_panel_collection.h"
18 #include "chrome/browser/ui/views/auto_keep_alive.h"
19 #include "chrome/browser/ui/views/panels/panel_frame_view.h"
20 #include "content/public/browser/render_view_host.h"
21 #include "content/public/browser/render_widget_host_view.h"
22 #include "content/public/browser/web_contents.h"
23 #include "ui/gfx/image/image.h"
24 #include "ui/gfx/path.h"
25 #include "ui/gfx/screen.h"
26 #include "ui/views/controls/button/image_button.h"
27 #include "ui/views/controls/webview/webview.h"
28 #include "ui/views/widget/widget.h"
30 #if defined(OS_WIN)
31 #include "base/win/windows_version.h"
32 #include "chrome/browser/shell_integration.h"
33 #include "chrome/browser/ui/views/panels/taskbar_window_thumbnailer_win.h"
34 #include "ui/base/win/shell.h"
35 #include "ui/gfx/icon_util.h"
36 #include "ui/views/win/hwnd_util.h"
37 #endif
39 namespace {
41 #if defined(OS_WIN)
42 // If the height of a stacked panel shrinks below this threshold during the
43 // user resizing, it will be treated as minimized.
44 const int kStackedPanelHeightShrinkThresholdToBecomeMinimized =
45 panel::kTitlebarHeight + 20;
46 #endif
48 // Supported accelerators.
49 // Note: We can't use the acclerator table defined in chrome/browser/ui/views
50 // due to checkdeps violation.
51 struct AcceleratorMapping {
52 ui::KeyboardCode keycode;
53 int modifiers;
54 int command_id;
56 const AcceleratorMapping kPanelAcceleratorMap[] = {
57 { ui::VKEY_W, ui::EF_CONTROL_DOWN, IDC_CLOSE_WINDOW },
58 { ui::VKEY_W, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN, IDC_CLOSE_WINDOW },
59 { ui::VKEY_F4, ui::EF_ALT_DOWN, IDC_CLOSE_WINDOW },
60 { ui::VKEY_R, ui::EF_CONTROL_DOWN, IDC_RELOAD },
61 { ui::VKEY_F5, ui::EF_NONE, IDC_RELOAD },
62 { ui::VKEY_R, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
63 IDC_RELOAD_IGNORING_CACHE },
64 { ui::VKEY_F5, ui::EF_CONTROL_DOWN, IDC_RELOAD_IGNORING_CACHE },
65 { ui::VKEY_F5, ui::EF_SHIFT_DOWN, IDC_RELOAD_IGNORING_CACHE },
66 { ui::VKEY_ESCAPE, ui::EF_NONE, IDC_STOP },
67 { ui::VKEY_OEM_MINUS, ui::EF_CONTROL_DOWN, IDC_ZOOM_MINUS },
68 { ui::VKEY_SUBTRACT, ui::EF_CONTROL_DOWN, IDC_ZOOM_MINUS },
69 { ui::VKEY_0, ui::EF_CONTROL_DOWN, IDC_ZOOM_NORMAL },
70 { ui::VKEY_NUMPAD0, ui::EF_CONTROL_DOWN, IDC_ZOOM_NORMAL },
71 { ui::VKEY_OEM_PLUS, ui::EF_CONTROL_DOWN, IDC_ZOOM_PLUS },
72 { ui::VKEY_ADD, ui::EF_CONTROL_DOWN, IDC_ZOOM_PLUS },
73 { ui::VKEY_I, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN, IDC_DEV_TOOLS },
74 { ui::VKEY_J, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
75 IDC_DEV_TOOLS_CONSOLE },
78 const std::map<ui::Accelerator, int>& GetAcceleratorTable() {
79 static std::map<ui::Accelerator, int>* accelerators = NULL;
80 if (!accelerators) {
81 accelerators = new std::map<ui::Accelerator, int>();
82 for (size_t i = 0; i < arraysize(kPanelAcceleratorMap); ++i) {
83 ui::Accelerator accelerator(kPanelAcceleratorMap[i].keycode,
84 kPanelAcceleratorMap[i].modifiers);
85 (*accelerators)[accelerator] = kPanelAcceleratorMap[i].command_id;
88 return *accelerators;
91 // NativePanelTesting implementation.
92 class NativePanelTestingWin : public NativePanelTesting {
93 public:
94 explicit NativePanelTestingWin(PanelView* panel_view);
96 private:
97 virtual void PressLeftMouseButtonTitlebar(
98 const gfx::Point& mouse_location, panel::ClickModifier modifier) OVERRIDE;
99 virtual void ReleaseMouseButtonTitlebar(
100 panel::ClickModifier modifier) OVERRIDE;
101 virtual void DragTitlebar(const gfx::Point& mouse_location) OVERRIDE;
102 virtual void CancelDragTitlebar() OVERRIDE;
103 virtual void FinishDragTitlebar() OVERRIDE;
104 virtual bool VerifyDrawingAttention() const OVERRIDE;
105 virtual bool VerifyActiveState(bool is_active) OVERRIDE;
106 virtual bool VerifyAppIcon() const OVERRIDE;
107 virtual bool VerifySystemMinimizeState() const OVERRIDE;
108 virtual bool IsWindowVisible() const OVERRIDE;
109 virtual bool IsWindowSizeKnown() const OVERRIDE;
110 virtual bool IsAnimatingBounds() const OVERRIDE;
111 virtual bool IsButtonVisible(
112 panel::TitlebarButtonType button_type) const OVERRIDE;
113 virtual panel::CornerStyle GetWindowCornerStyle() const OVERRIDE;
114 virtual bool EnsureApplicationRunOnForeground() OVERRIDE;
116 PanelView* panel_view_;
119 NativePanelTestingWin::NativePanelTestingWin(PanelView* panel_view)
120 : panel_view_(panel_view) {
123 void NativePanelTestingWin::PressLeftMouseButtonTitlebar(
124 const gfx::Point& mouse_location, panel::ClickModifier modifier) {
125 panel_view_->OnTitlebarMousePressed(mouse_location);
128 void NativePanelTestingWin::ReleaseMouseButtonTitlebar(
129 panel::ClickModifier modifier) {
130 panel_view_->OnTitlebarMouseReleased(modifier);
133 void NativePanelTestingWin::DragTitlebar(const gfx::Point& mouse_location) {
134 panel_view_->OnTitlebarMouseDragged(mouse_location);
137 void NativePanelTestingWin::CancelDragTitlebar() {
138 panel_view_->OnTitlebarMouseCaptureLost();
141 void NativePanelTestingWin::FinishDragTitlebar() {
142 panel_view_->OnTitlebarMouseReleased(panel::NO_MODIFIER);
145 bool NativePanelTestingWin::VerifyDrawingAttention() const {
146 base::MessageLoop::current()->RunUntilIdle();
147 return panel_view_->GetFrameView()->GetPaintState() ==
148 PanelFrameView::PAINT_FOR_ATTENTION;
151 bool NativePanelTestingWin::VerifyActiveState(bool is_active) {
152 return panel_view_->GetFrameView()->GetPaintState() ==
153 (is_active ? PanelFrameView::PAINT_AS_ACTIVE
154 : PanelFrameView::PAINT_AS_INACTIVE);
157 bool NativePanelTestingWin::VerifyAppIcon() const {
158 #if defined(OS_WIN)
159 // We only care about Windows 7 and later.
160 if (base::win::GetVersion() < base::win::VERSION_WIN7)
161 return true;
163 HWND native_window = views::HWNDForWidget(panel_view_->window());
164 HICON app_icon = reinterpret_cast<HICON>(
165 ::SendMessage(native_window, WM_GETICON, ICON_BIG, 0L));
166 if (!app_icon)
167 return false;
168 scoped_ptr<SkBitmap> bitmap(IconUtil::CreateSkBitmapFromHICON(app_icon));
169 return bitmap.get() &&
170 bitmap->width() == panel::kPanelAppIconSize &&
171 bitmap->height() == panel::kPanelAppIconSize;
172 #else
173 return true;
174 #endif
177 bool NativePanelTestingWin::VerifySystemMinimizeState() const {
178 #if defined(OS_WIN)
179 HWND native_window = views::HWNDForWidget(panel_view_->window());
180 WINDOWPLACEMENT placement;
181 if (!::GetWindowPlacement(native_window, &placement))
182 return false;
183 if (placement.showCmd == SW_MINIMIZE || placement.showCmd == SW_SHOWMINIMIZED)
184 return true;
186 // If the panel window has owner window, as in stacked mode, check its owner
187 // window. Note that owner window, instead of parent window, is returned
188 // though GWL_HWNDPARENT contains 'parent'.
189 HWND owner_window =
190 reinterpret_cast<HWND>(::GetWindowLongPtr(native_window,
191 GWLP_HWNDPARENT));
192 if (!owner_window || !::GetWindowPlacement(owner_window, &placement))
193 return false;
194 return placement.showCmd == SW_MINIMIZE ||
195 placement.showCmd == SW_SHOWMINIMIZED;
196 #else
197 return true;
198 #endif
201 bool NativePanelTestingWin::IsWindowVisible() const {
202 #if defined(OS_WIN)
203 HWND native_window = views::HWNDForWidget(panel_view_->window());
204 return ::IsWindowVisible(native_window) == TRUE;
205 #else
206 return panel_view_->visible();
207 #endif
210 bool NativePanelTestingWin::IsWindowSizeKnown() const {
211 return true;
214 bool NativePanelTestingWin::IsAnimatingBounds() const {
215 return panel_view_->IsAnimatingBounds();
218 bool NativePanelTestingWin::IsButtonVisible(
219 panel::TitlebarButtonType button_type) const {
220 PanelFrameView* frame_view = panel_view_->GetFrameView();
222 switch (button_type) {
223 case panel::CLOSE_BUTTON:
224 return frame_view->close_button()->visible();
225 case panel::MINIMIZE_BUTTON:
226 return frame_view->minimize_button()->visible();
227 case panel::RESTORE_BUTTON:
228 return frame_view->restore_button()->visible();
229 default:
230 NOTREACHED();
232 return false;
235 panel::CornerStyle NativePanelTestingWin::GetWindowCornerStyle() const {
236 return panel_view_->GetFrameView()->corner_style();
239 bool NativePanelTestingWin::EnsureApplicationRunOnForeground() {
240 // Not needed on views.
241 return true;
244 } // namespace
246 // static
247 NativePanel* Panel::CreateNativePanel(Panel* panel,
248 const gfx::Rect& bounds,
249 bool always_on_top) {
250 return new PanelView(panel, bounds, always_on_top);
253 // The panel window has to be created as always-on-top. We cannot create it
254 // as non-always-on-top and then change it to always-on-top because Windows
255 // system might deny making a window always-on-top if the application is not
256 // a foreground application.
257 PanelView::PanelView(Panel* panel, const gfx::Rect& bounds, bool always_on_top)
258 : panel_(panel),
259 bounds_(bounds),
260 window_(NULL),
261 window_closed_(false),
262 web_view_(NULL),
263 always_on_top_(always_on_top),
264 focused_(false),
265 user_resizing_(false),
266 #if defined(OS_WIN)
267 user_resizing_interior_stacked_panel_edge_(false),
268 #endif
269 mouse_pressed_(false),
270 mouse_dragging_state_(NO_DRAGGING),
271 is_drawing_attention_(false),
272 force_to_paint_as_inactive_(false),
273 old_focused_view_(NULL) {
274 window_ = new views::Widget;
275 views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
276 params.delegate = this;
277 params.remove_standard_frame = true;
278 params.keep_on_top = always_on_top;
279 params.visible_on_all_workspaces = always_on_top;
280 params.bounds = bounds;
281 window_->Init(params);
282 window_->set_frame_type(views::Widget::FRAME_TYPE_FORCE_CUSTOM);
283 window_->set_focus_on_creation(false);
284 window_->AddObserver(this);
286 // Prevent the browser process from shutting down while this window is open.
287 keep_alive_.reset(new AutoKeepAlive(GetNativePanelWindow()));
289 web_view_ = new views::WebView(NULL);
290 AddChildView(web_view_);
292 // Register accelarators supported by panels.
293 views::FocusManager* focus_manager = GetFocusManager();
294 const std::map<ui::Accelerator, int>& accelerator_table =
295 GetAcceleratorTable();
296 for (std::map<ui::Accelerator, int>::const_iterator iter =
297 accelerator_table.begin();
298 iter != accelerator_table.end(); ++iter) {
299 focus_manager->RegisterAccelerator(
300 iter->first, ui::AcceleratorManager::kNormalPriority, this);
303 #if defined(OS_WIN)
304 ui::win::SetAppIdForWindow(
305 ShellIntegration::GetAppModelIdForProfile(
306 base::UTF8ToWide(panel->app_name()), panel->profile()->GetPath()),
307 views::HWNDForWidget(window_));
308 ui::win::PreventWindowFromPinning(views::HWNDForWidget(window_));
309 #endif
312 PanelView::~PanelView() {
315 void PanelView::ShowPanel() {
316 ShowPanelInactive();
317 ActivatePanel();
320 void PanelView::ShowPanelInactive() {
321 if (window_->IsVisible())
322 return;
323 window_->ShowInactive();
324 // No animation is used for initial creation of a panel on Win.
325 // Signal immediately that pending actions can be performed.
326 panel_->manager()->OnPanelAnimationEnded(panel_.get());
329 gfx::Rect PanelView::GetPanelBounds() const {
330 return bounds_;
333 void PanelView::SetPanelBounds(const gfx::Rect& bounds) {
334 SetBoundsInternal(bounds, true);
337 void PanelView::SetPanelBoundsInstantly(const gfx::Rect& bounds) {
338 SetBoundsInternal(bounds, false);
341 void PanelView::SetBoundsInternal(const gfx::Rect& new_bounds, bool animate) {
342 if (bounds_ == new_bounds)
343 return;
345 bounds_ = new_bounds;
347 if (!animate) {
348 // If no animation is in progress, apply bounds change instantly. Otherwise,
349 // continue the animation with new target bounds.
350 if (!IsAnimatingBounds())
351 SetWidgetBounds(bounds_);
352 return;
355 animation_start_bounds_ = window_->GetWindowBoundsInScreen();
357 bounds_animator_.reset(new PanelBoundsAnimation(
358 this, panel_.get(), animation_start_bounds_, new_bounds));
359 bounds_animator_->Start();
362 #if defined(OS_WIN)
363 bool PanelView::FilterMessage(HWND hwnd,
364 UINT message,
365 WPARAM w_param,
366 LPARAM l_param,
367 LRESULT* l_result) {
368 switch (message) {
369 case WM_SIZING:
370 if (w_param == WMSZ_BOTTOM)
371 user_resizing_interior_stacked_panel_edge_ = true;
372 break;
374 return false;
376 #endif
378 void PanelView::AnimationEnded(const gfx::Animation* animation) {
379 panel_->manager()->OnPanelAnimationEnded(panel_.get());
382 void PanelView::AnimationProgressed(const gfx::Animation* animation) {
383 gfx::Rect new_bounds = bounds_animator_->CurrentValueBetween(
384 animation_start_bounds_, bounds_);
385 SetWidgetBounds(new_bounds);
388 void PanelView::SetWidgetBounds(const gfx::Rect& new_bounds) {
389 #if defined(OS_WIN)
390 // An overlapped window is a top-level window that has a titlebar, border,
391 // and client area. The Windows system will automatically put the shadow
392 // around the whole window. Also the system will enforce the minimum height
393 // (38 pixels based on observation) for the overlapped window such that it
394 // will always has the space for the titlebar.
396 // On contrast, a popup window is a bare minimum window without border and
397 // titlebar by default. It is often used for the popup menu and the window
398 // with short life. The Windows system does not add the shadow around the
399 // whole window though CS_DROPSHADOW class style could be passed to add the
400 // drop shadow which is only around the right and bottom edges.
402 // The height of the title-only or minimized panel is smaller than the minimum
403 // overlapped window height. If the panel still uses the overlapped window
404 // style, Windows system will automatically increase the window height. To
405 // work around this limitation, we temporarily change the window style to
406 // popup when the height to set is smaller than the minimum overlapped window
407 // height and then restore the window style to overlapped when the height
408 // grows.
409 static const int kMinimumOverlappedWindowHeight = 38;
410 gfx::Rect old_bounds = GetWidget()->GetRestoredBounds();
411 if (old_bounds.height() > kMinimumOverlappedWindowHeight &&
412 new_bounds.height() <= kMinimumOverlappedWindowHeight) {
413 // When the panel height shrinks below the minimum overlapped window height,
414 // change the window style to popup such that we can show the title-only
415 // and minimized panel without additional height being added by the system.
416 UpdateWindowAttribute(GWL_STYLE,
417 WS_POPUP,
418 WS_OVERLAPPED | WS_THICKFRAME | WS_SYSMENU,
419 true);
420 } else if (old_bounds.height() <= kMinimumOverlappedWindowHeight &&
421 new_bounds.height() > kMinimumOverlappedWindowHeight) {
422 // Change the window style back to overlappped when the panel height grow
423 // taller than the minimum overlapped window height.
424 UpdateWindowAttribute(GWL_STYLE,
425 WS_OVERLAPPED | WS_THICKFRAME | WS_SYSMENU,
426 WS_POPUP,
427 true);
429 #endif
431 GetWidget()->SetBounds(new_bounds);
434 void PanelView::ClosePanel() {
435 // We're already closing. Do nothing.
436 if (window_closed_)
437 return;
439 if (!panel_->ShouldCloseWindow())
440 return;
442 // Cancel any currently running animation since we're closing down.
443 if (bounds_animator_.get())
444 bounds_animator_.reset();
446 if (panel_->GetWebContents()) {
447 // Still have web contents. Allow renderer to shut down.
448 // When web contents are destroyed, we will be called back again.
449 panel_->OnWindowClosing();
450 return;
453 panel_->OnNativePanelClosed();
454 if (window_)
455 window_->Close();
456 window_closed_ = true;
459 void PanelView::ActivatePanel() {
460 window_->Activate();
463 void PanelView::DeactivatePanel() {
464 if (!focused_)
465 return;
467 #if defined(OS_WIN)
468 // Need custom behavior for always-on-top panels to avoid
469 // the OS activating a minimized panel when this one is
470 // deactivated.
471 if (always_on_top_) {
472 ::SetForegroundWindow(::GetDesktopWindow());
473 return;
475 #endif
477 window_->Deactivate();
480 bool PanelView::IsPanelActive() const {
481 return focused_;
484 void PanelView::PreventActivationByOS(bool prevent_activation) {
485 #if defined(OS_WIN)
486 // Set the flags "NoActivate" to make sure the minimized panels do not get
487 // activated by the OS. In addition, set "AppWindow" to make sure the
488 // minimized panels do appear in the taskbar and Alt-Tab menu if it is not
489 // in a stack.
490 int value_to_change = WS_EX_NOACTIVATE;
491 if (!panel_->stack())
492 value_to_change |= WS_EX_APPWINDOW;
493 if (prevent_activation)
494 UpdateWindowAttribute(GWL_EXSTYLE, value_to_change, 0, false);
495 else
496 UpdateWindowAttribute(GWL_EXSTYLE, 0, value_to_change, false);
497 #endif
500 gfx::NativeWindow PanelView::GetNativePanelWindow() {
501 return window_->GetNativeWindow();
504 void PanelView::UpdatePanelTitleBar() {
505 UpdateWindowTitle();
506 UpdateWindowIcon();
509 void PanelView::UpdatePanelLoadingAnimations(bool should_animate) {
510 GetFrameView()->UpdateThrobber();
513 void PanelView::PanelWebContentsFocused(content::WebContents* contents) {
514 web_view_->OnWebContentsFocused(contents);
517 void PanelView::PanelCut() {
518 // Nothing to do since we do not have panel-specific system menu.
519 NOTREACHED();
522 void PanelView::PanelCopy() {
523 // Nothing to do since we do not have panel-specific system menu.
524 NOTREACHED();
527 void PanelView::PanelPaste() {
528 // Nothing to do since we do not have panel-specific system menu.
529 NOTREACHED();
532 void PanelView::DrawAttention(bool draw_attention) {
533 DCHECK((panel_->attention_mode() & Panel::USE_PANEL_ATTENTION) != 0);
535 if (is_drawing_attention_ == draw_attention)
536 return;
537 is_drawing_attention_ = draw_attention;
538 GetFrameView()->SchedulePaint();
540 if ((panel_->attention_mode() & Panel::USE_SYSTEM_ATTENTION) != 0) {
541 #if defined(OS_WIN)
542 // The default implementation of Widget::FlashFrame only flashes 5 times.
543 // We need more than that.
544 FLASHWINFO fwi;
545 fwi.cbSize = sizeof(fwi);
546 fwi.hwnd = views::HWNDForWidget(window_);
547 if (draw_attention) {
548 fwi.dwFlags = FLASHW_ALL;
549 fwi.uCount = panel::kNumberOfTimesToFlashPanelForAttention;
550 fwi.dwTimeout = 0;
551 } else {
552 // TODO(jianli): calling FlashWindowEx with FLASHW_STOP flag for the
553 // panel window has the same problem as the stack window. However,
554 // we cannot take the similar fix since there is no background window
555 // to replace for the regular panel window. More investigation is needed.
556 fwi.dwFlags = FLASHW_STOP;
558 ::FlashWindowEx(&fwi);
559 #else
560 window_->FlashFrame(draw_attention);
561 #endif
565 bool PanelView::IsDrawingAttention() const {
566 return is_drawing_attention_;
569 void PanelView::HandlePanelKeyboardEvent(
570 const content::NativeWebKeyboardEvent& event) {
571 views::FocusManager* focus_manager = GetFocusManager();
572 if (focus_manager->shortcut_handling_suspended())
573 return;
575 ui::Accelerator accelerator(
576 static_cast<ui::KeyboardCode>(event.windowsKeyCode),
577 content::GetModifiersFromNativeWebKeyboardEvent(event));
578 if (event.type == blink::WebInputEvent::KeyUp)
579 accelerator.set_type(ui::ET_KEY_RELEASED);
580 focus_manager->ProcessAccelerator(accelerator);
583 void PanelView::FullScreenModeChanged(bool is_full_screen) {
584 if (is_full_screen) {
585 if (window_->IsVisible() && always_on_top_)
586 window_->Hide();
587 } else {
588 if (!window_->IsVisible()) {
589 ShowPanelInactive();
591 #if defined(OS_WIN)
592 // When hiding and showing again a top-most window that belongs to a
593 // background application (i.e. the application is not a foreground one),
594 // the window may loose top-most placement even though its WS_EX_TOPMOST
595 // bit is still set. Re-issuing SetWindowsPos() returns the window to its
596 // top-most placement.
597 if (always_on_top_)
598 window_->SetAlwaysOnTop(true);
599 #endif
604 bool PanelView::IsPanelAlwaysOnTop() const {
605 return always_on_top_;
608 void PanelView::SetPanelAlwaysOnTop(bool on_top) {
609 if (always_on_top_ == on_top)
610 return;
611 always_on_top_ = on_top;
613 window_->SetAlwaysOnTop(on_top);
614 window_->SetVisibleOnAllWorkspaces(on_top);
615 window_->non_client_view()->Layout();
616 window_->client_view()->Layout();
619 void PanelView::UpdatePanelMinimizeRestoreButtonVisibility() {
620 GetFrameView()->UpdateTitlebarMinimizeRestoreButtonVisibility();
623 void PanelView::SetWindowCornerStyle(panel::CornerStyle corner_style) {
624 GetFrameView()->SetWindowCornerStyle(corner_style);
627 void PanelView::PanelExpansionStateChanging(Panel::ExpansionState old_state,
628 Panel::ExpansionState new_state) {
629 #if defined(OS_WIN)
630 // Live preview is only available since Windows 7.
631 if (base::win::GetVersion() < base::win::VERSION_WIN7)
632 return;
634 if (panel_->collection()->type() != PanelCollection::DOCKED)
635 return;
637 bool is_minimized = old_state != Panel::EXPANDED;
638 bool will_be_minimized = new_state != Panel::EXPANDED;
639 if (is_minimized == will_be_minimized)
640 return;
642 HWND native_window = views::HWNDForWidget(window_);
644 if (!thumbnailer_.get()) {
645 DCHECK(native_window);
646 thumbnailer_.reset(new TaskbarWindowThumbnailerWin(native_window, NULL));
649 // Cache the image at this point.
650 if (will_be_minimized) {
651 // If the panel is still active (we will deactivate the minimizd panel at
652 // later time), we need to paint it immediately as inactive so that we can
653 // take a snapshot of inactive panel.
654 if (focused_) {
655 force_to_paint_as_inactive_ = true;
656 ::RedrawWindow(native_window, NULL, NULL,
657 RDW_NOCHILDREN | RDW_INVALIDATE | RDW_UPDATENOW);
660 // Start the thumbnailer and capture the snapshot now.
661 thumbnailer_->Start();
662 thumbnailer_->CaptureSnapshot();
663 } else {
664 force_to_paint_as_inactive_ = false;
665 thumbnailer_->Stop();
668 #endif
671 gfx::Size PanelView::WindowSizeFromContentSize(
672 const gfx::Size& content_size) const {
673 gfx::Size frame = GetFrameView()->NonClientAreaSize();
674 return gfx::Size(content_size.width() + frame.width(),
675 content_size.height() + frame.height());
678 gfx::Size PanelView::ContentSizeFromWindowSize(
679 const gfx::Size& window_size) const {
680 gfx::Size frame = GetFrameView()->NonClientAreaSize();
681 return gfx::Size(window_size.width() - frame.width(),
682 window_size.height() - frame.height());
685 int PanelView::TitleOnlyHeight() const {
686 return panel::kTitlebarHeight;
689 void PanelView::MinimizePanelBySystem() {
690 window_->Minimize();
693 bool PanelView::IsPanelMinimizedBySystem() const {
694 return window_->IsMinimized();
697 bool PanelView::IsPanelShownOnActiveDesktop() const {
698 #if defined(OS_WIN)
699 // Virtual desktop is not supported by the native Windows system.
700 return true;
701 #else
702 NOTIMPLEMENTED();
703 return true;
704 #endif
707 void PanelView::ShowShadow(bool show) {
708 #if defined(OS_WIN)
709 // The overlapped window has the shadow while the popup window does not have
710 // the shadow.
711 int overlap_style = WS_OVERLAPPED | WS_THICKFRAME | WS_SYSMENU;
712 int popup_style = WS_POPUP;
713 UpdateWindowAttribute(GWL_STYLE,
714 show ? overlap_style : popup_style,
715 show ? popup_style : overlap_style,
716 true);
717 #endif
720 void PanelView::AttachWebContents(content::WebContents* contents) {
721 web_view_->SetWebContents(contents);
724 void PanelView::DetachWebContents(content::WebContents* contents) {
725 web_view_->SetWebContents(NULL);
728 NativePanelTesting* PanelView::CreateNativePanelTesting() {
729 return new NativePanelTestingWin(this);
732 void PanelView::OnDisplayChanged() {
733 panel_->manager()->display_settings_provider()->OnDisplaySettingsChanged();
736 void PanelView::OnWorkAreaChanged() {
737 panel_->manager()->display_settings_provider()->OnDisplaySettingsChanged();
740 bool PanelView::WillProcessWorkAreaChange() const {
741 return true;
744 views::View* PanelView::GetContentsView() {
745 return this;
748 views::NonClientFrameView* PanelView::CreateNonClientFrameView(
749 views::Widget* widget) {
750 PanelFrameView* frame_view = new PanelFrameView(this);
751 frame_view->Init();
752 return frame_view;
755 bool PanelView::CanResize() const {
756 return true;
759 bool PanelView::CanMaximize() const {
760 return false;
763 base::string16 PanelView::GetWindowTitle() const {
764 return panel_->GetWindowTitle();
767 gfx::ImageSkia PanelView::GetWindowAppIcon() {
768 gfx::Image app_icon = panel_->app_icon();
769 if (app_icon.IsEmpty())
770 return GetWindowIcon();
771 else
772 return *app_icon.ToImageSkia();
775 gfx::ImageSkia PanelView::GetWindowIcon() {
776 gfx::Image icon = panel_->GetCurrentPageIcon();
777 return icon.IsEmpty() ? gfx::ImageSkia() : *icon.ToImageSkia();
780 void PanelView::WindowClosing() {
781 // When closing a panel via window.close, API or the close button,
782 // ClosePanel() is called first, destroying the native |window_|
783 // which results in this method being called. ClosePanel() sets
784 // |window_closed_| to NULL.
785 // If we still have a |window_closed_| here, the close was triggered by the
786 // OS, (e.g. clicking on taskbar menu), which destroys the native |window_|
787 // without invoking ClosePanel() beforehand.
788 if (!window_closed_) {
789 panel_->OnWindowClosing();
790 ClosePanel();
791 DCHECK(window_closed_);
795 void PanelView::DeleteDelegate() {
796 delete this;
799 void PanelView::OnWindowBeginUserBoundsChange() {
800 user_resizing_ = true;
801 panel_->OnPanelStartUserResizing();
803 #if defined(OS_WIN)
804 StackedPanelCollection* stack = panel_->stack();
805 if (stack) {
806 // Listen to WM_SIZING message in order to find out whether the interior
807 // edge is being resized such that the specific maximum size could be
808 // passed to the system.
809 if (panel_->stack()->GetPanelBelow(panel_.get())) {
810 ui::HWNDSubclass::AddFilterToTarget(views::HWNDForWidget(window_), this);
811 user_resizing_interior_stacked_panel_edge_ = false;
814 // Keep track of the original full size of the resizing panel such that it
815 // can be restored to this size once it is shrunk to minimized state.
816 original_full_size_of_resizing_panel_ = panel_->full_size();
818 // Keep track of the original full size of the panel below the resizing
819 // panel such that it can be restored to this size once it is shrunk to
820 // minimized state.
821 Panel* below_panel = stack->GetPanelBelow(panel_.get());
822 if (below_panel && !below_panel->IsMinimized()) {
823 original_full_size_of_panel_below_resizing_panel_ =
824 below_panel->full_size();
827 #endif
830 void PanelView::OnWindowEndUserBoundsChange() {
831 user_resizing_ = false;
832 panel_->OnPanelEndUserResizing();
834 // No need to proceed with post-resizing update when there is no size change.
835 gfx::Rect new_bounds = window_->GetWindowBoundsInScreen();
836 if (bounds_ == new_bounds)
837 return;
838 bounds_ = new_bounds;
840 panel_->IncreaseMaxSize(bounds_.size());
841 panel_->set_full_size(bounds_.size());
843 #if defined(OS_WIN)
844 StackedPanelCollection* stack = panel_->stack();
845 if (stack) {
846 // No need to listen to WM_SIZING message any more.
847 ui::HWNDSubclass::RemoveFilterFromAllTargets(this);
849 // If the height of resizing panel shrinks close to the titlebar height,
850 // treate it as minimized. This could occur when the user is dragging
851 // 1) the top edge of the top panel downward to shrink it; or
852 // 2) the bottom edge of any panel upward to shrink it.
853 if (panel_->GetBounds().height() <
854 kStackedPanelHeightShrinkThresholdToBecomeMinimized) {
855 stack->MinimizePanel(panel_.get());
856 panel_->set_full_size(original_full_size_of_resizing_panel_);
859 // If the height of panel below the resizing panel shrinks close to the
860 // titlebar height, treat it as minimized. This could occur when the user
861 // is dragging the bottom edge of non-bottom panel downward to expand it
862 // and also shrink the panel below.
863 Panel* below_panel = stack->GetPanelBelow(panel_.get());
864 if (below_panel && !below_panel->IsMinimized() &&
865 below_panel->GetBounds().height() <
866 kStackedPanelHeightShrinkThresholdToBecomeMinimized) {
867 stack->MinimizePanel(below_panel);
868 below_panel->set_full_size(
869 original_full_size_of_panel_below_resizing_panel_);
872 #endif
874 panel_->collection()->RefreshLayout();
877 views::Widget* PanelView::GetWidget() {
878 return window_;
881 const views::Widget* PanelView::GetWidget() const {
882 return window_;
885 void PanelView::UpdateLoadingAnimations(bool should_animate) {
886 GetFrameView()->UpdateThrobber();
889 void PanelView::UpdateWindowTitle() {
890 window_->UpdateWindowTitle();
891 GetFrameView()->UpdateTitle();
894 void PanelView::UpdateWindowIcon() {
895 window_->UpdateWindowIcon();
896 GetFrameView()->UpdateIcon();
899 void PanelView::Layout() {
900 // |web_view_| might not be created yet when the window is first created.
901 if (web_view_)
902 web_view_->SetBounds(0, 0, width(), height());
905 gfx::Size PanelView::GetMinimumSize() const {
906 // If the panel is minimized, it can be rendered to very small size, like
907 // 4-pixel lines when it is docked. Otherwise, its size should not be less
908 // than its minimum size.
909 return panel_->IsMinimized() ? gfx::Size() :
910 gfx::Size(panel::kPanelMinWidth, panel::kPanelMinHeight);
913 gfx::Size PanelView::GetMaximumSize() {
914 // If the user is resizing a stacked panel by its bottom edge, make sure its
915 // height cannot grow more than what the panel below it could offer. This is
916 // because growing a stacked panel by y amount will shrink the panel below it
917 // by same amount and we do not want the panel below it being shrunk to be
918 // smaller than the titlebar.
919 #if defined(OS_WIN)
920 if (panel_->stack() && user_resizing_interior_stacked_panel_edge_) {
921 Panel* below_panel = panel_->stack()->GetPanelBelow(panel_.get());
922 if (below_panel && !below_panel->IsMinimized()) {
923 return gfx::Size(0, below_panel->GetBounds().bottom() -
924 panel_->GetBounds().y() - panel::kTitlebarHeight);
927 #endif
928 return gfx::Size();
931 bool PanelView::AcceleratorPressed(const ui::Accelerator& accelerator) {
932 if (mouse_pressed_ && accelerator.key_code() == ui::VKEY_ESCAPE) {
933 OnTitlebarMouseCaptureLost();
934 return true;
937 // No other accelerator is allowed when the drag begins.
938 if (mouse_dragging_state_ == DRAGGING_STARTED)
939 return true;
941 const std::map<ui::Accelerator, int>& accelerator_table =
942 GetAcceleratorTable();
943 std::map<ui::Accelerator, int>::const_iterator iter =
944 accelerator_table.find(accelerator);
945 DCHECK(iter != accelerator_table.end());
946 return panel_->ExecuteCommandIfEnabled(iter->second);
949 void PanelView::OnWidgetDestroying(views::Widget* widget) {
950 window_ = NULL;
953 void PanelView::OnWidgetActivationChanged(views::Widget* widget, bool active) {
954 #if defined(OS_WIN)
955 // WM_NCACTIVATED could be sent when an active window is being destroyed on
956 // Windows. We need to guard against this.
957 if (window_closed_)
958 return;
960 bool focused = active;
961 if (chrome::GetActiveDesktop() == chrome::HOST_DESKTOP_TYPE_NATIVE) {
962 // The panel window is in focus (actually accepting keystrokes) if it is
963 // active and belongs to a foreground application.
964 focused = active &&
965 views::HWNDForWidget(widget) == ::GetForegroundWindow();
967 #else
968 NOTIMPLEMENTED();
969 bool focused = active;
970 #endif
972 if (focused_ == focused)
973 return;
974 focused_ = focused;
976 // Expand the panel if the minimized panel is activated by means other than
977 // clicking on its titlebar. This is the workaround to support restoring the
978 // minimized panel by other means, like alt-tabbing, win-tabbing, or clicking
979 // the taskbar icon. Note that this workaround does not work for one edge
980 // case: the mouse happens to be at the minimized panel when the user tries to
981 // bring up the panel with the above alternatives.
982 // When the user clicks on the minimized panel, the panel expansion will be
983 // done when we process the mouse button pressed message.
984 #if defined(OS_WIN)
985 if (focused_ && panel_->IsMinimized() &&
986 panel_->collection()->type() == PanelCollection::DOCKED &&
987 gfx::Screen::GetScreenFor(widget->GetNativeWindow())->
988 GetWindowUnderCursor() != widget->GetNativeWindow()) {
989 panel_->Restore();
991 #endif
993 panel()->OnActiveStateChanged(focused);
995 // Give web contents view a chance to set focus to the appropriate element.
996 if (focused_) {
997 content::WebContents* web_contents = panel_->GetWebContents();
998 if (web_contents)
999 web_contents->RestoreFocus();
1003 void PanelView::OnWidgetBoundsChanged(views::Widget* widget,
1004 const gfx::Rect& new_bounds) {
1005 if (user_resizing_)
1006 panel()->collection()->OnPanelResizedByMouse(panel(), new_bounds);
1009 bool PanelView::OnTitlebarMousePressed(const gfx::Point& mouse_location) {
1010 mouse_pressed_ = true;
1011 mouse_dragging_state_ = NO_DRAGGING;
1012 last_mouse_location_ = mouse_location;
1013 return true;
1016 bool PanelView::OnTitlebarMouseDragged(const gfx::Point& mouse_location) {
1017 if (!mouse_pressed_)
1018 return false;
1020 if (mouse_dragging_state_ == NO_DRAGGING &&
1021 ExceededDragThreshold(mouse_location - last_mouse_location_)) {
1022 // When a drag begins, we do not want to the client area to still receive
1023 // the focus. We do not need to do this for the unfocused minimized panel.
1024 if (!panel_->IsMinimized()) {
1025 old_focused_view_ = GetFocusManager()->GetFocusedView();
1026 GetFocusManager()->SetFocusedView(GetFrameView());
1029 panel_->manager()->StartDragging(panel_.get(), last_mouse_location_);
1030 mouse_dragging_state_ = DRAGGING_STARTED;
1032 if (mouse_dragging_state_ == DRAGGING_STARTED) {
1033 panel_->manager()->Drag(mouse_location);
1035 // Once in drag, update |last_mouse_location_| on each drag fragment, since
1036 // we already dragged the panel up to the current mouse location.
1037 last_mouse_location_ = mouse_location;
1039 return true;
1042 bool PanelView::OnTitlebarMouseReleased(panel::ClickModifier modifier) {
1043 if (mouse_dragging_state_ != NO_DRAGGING) {
1044 // Ensure dragging a minimized panel does not leave it activated.
1045 // Windows activates a panel on mouse-down, regardless of our attempts
1046 // to prevent activation of a minimized panel. Now that we know mouse-down
1047 // resulted in a mouse-drag, we need to ensure the minimized panel is
1048 // deactivated.
1049 if (panel_->IsMinimized() && focused_)
1050 panel_->Deactivate();
1052 if (mouse_dragging_state_ == DRAGGING_STARTED) {
1053 // When a drag ends, restore the focus.
1054 if (old_focused_view_) {
1055 GetFocusManager()->SetFocusedView(old_focused_view_);
1056 old_focused_view_ = NULL;
1058 return EndDragging(false);
1061 // The panel drag was cancelled before the mouse is released. Do not
1062 // treat this as a click.
1063 return true;
1066 panel_->OnTitlebarClicked(modifier);
1067 return true;
1070 bool PanelView::OnTitlebarMouseCaptureLost() {
1071 if (mouse_dragging_state_ == DRAGGING_STARTED)
1072 return EndDragging(true);
1073 return true;
1076 bool PanelView::EndDragging(bool cancelled) {
1077 // Only handle clicks that started in our window.
1078 if (!mouse_pressed_)
1079 return false;
1080 mouse_pressed_ = false;
1082 mouse_dragging_state_ = DRAGGING_ENDED;
1083 panel_->manager()->EndDragging(cancelled);
1084 return true;
1087 PanelFrameView* PanelView::GetFrameView() const {
1088 return static_cast<PanelFrameView*>(window_->non_client_view()->frame_view());
1091 bool PanelView::IsAnimatingBounds() const {
1092 if (bounds_animator_.get() && bounds_animator_->is_animating())
1093 return true;
1094 StackedPanelCollection* stack = panel_->stack();
1095 if (!stack)
1096 return false;
1097 return stack->IsAnimatingPanelBounds(panel_.get());
1100 bool PanelView::IsWithinResizingArea(const gfx::Point& mouse_location) const {
1101 gfx::Rect bounds = window_->GetWindowBoundsInScreen();
1102 DCHECK(bounds.Contains(mouse_location));
1103 return mouse_location.x() < bounds.x() + kResizeInsideBoundsSize ||
1104 mouse_location.x() >= bounds.right() - kResizeInsideBoundsSize ||
1105 mouse_location.y() < bounds.y() + kResizeInsideBoundsSize ||
1106 mouse_location.y() >= bounds.bottom() - kResizeInsideBoundsSize;
1109 #if defined(OS_WIN)
1110 void PanelView::UpdateWindowAttribute(int attribute_index,
1111 int attribute_value_to_set,
1112 int attribute_value_to_reset,
1113 bool update_frame) {
1114 HWND native_window = views::HWNDForWidget(window_);
1115 int value = ::GetWindowLong(native_window, attribute_index);
1116 int expected_value = value;
1117 if (attribute_value_to_set)
1118 expected_value |= attribute_value_to_set;
1119 if (attribute_value_to_reset)
1120 expected_value &= ~attribute_value_to_reset;
1121 if (value != expected_value)
1122 ::SetWindowLong(native_window, attribute_index, expected_value);
1124 // Per MSDN, if any of the frame styles is changed, SetWindowPos with the
1125 // SWP_FRAMECHANGED flag must be called in order for the cached window data
1126 // to be updated properly.
1127 // http://msdn.microsoft.com/en-us/library/windows/desktop/ms633591(v=vs.85).aspx
1128 if (update_frame) {
1129 ::SetWindowPos(native_window, NULL, 0, 0, 0, 0,
1130 SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE |
1131 SWP_NOZORDER | SWP_NOACTIVATE);
1134 #endif