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