chrome/browser/ui/gtk/panels/panel_gtk.cc

   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/gtk/panels/panel_gtk.h"
   6
   7 #include <gdk/gdk.h>
   8 #include <gdk/gdkkeysyms.h>
   9 #include <X11/XF86keysym.h>
  10
  11 #include "base/bind.h"
  12 #include "base/debug/trace_event.h"
  13 #include "base/logging.h"
  14 #include "base/message_loop/message_loop.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "chrome/app/chrome_command_ids.h"
  17 #include "chrome/browser/chrome_notification_types.h"
  18 #include "chrome/browser/ui/app_modal_dialogs/app_modal_dialog_queue.h"
  19 #include "chrome/browser/ui/gtk/custom_button.h"
  20 #include "chrome/browser/ui/gtk/gtk_util.h"
  21 #include "chrome/browser/ui/gtk/gtk_window_util.h"
  22 #include "chrome/browser/ui/gtk/panels/panel_drag_gtk.h"
  23 #include "chrome/browser/ui/gtk/panels/panel_titlebar_gtk.h"
  24 #include "chrome/browser/ui/panels/display_settings_provider.h"
  25 #include "chrome/browser/ui/panels/panel.h"
  26 #include "chrome/browser/ui/panels/panel_constants.h"
  27 #include "chrome/browser/ui/panels/panel_manager.h"
  28 #include "chrome/browser/ui/panels/stacked_panel_collection.h"
  29 #include "chrome/browser/web_applications/web_app.h"
  30 #include "content/public/browser/native_web_keyboard_event.h"
  31 #include "content/public/browser/notification_service.h"
  32 #include "content/public/browser/web_contents.h"
  33 #include "content/public/browser/web_contents_view.h"
  34 #include "grit/ui_resources.h"
  35 #include "ui/base/accelerators/platform_accelerator_gtk.h"
  36 #include "ui/base/gtk/gtk_expanded_container.h"
  37 #include "ui/base/gtk/gtk_hig_constants.h"
  38 #include "ui/base/x/active_window_watcher_x.h"
  39 #include "ui/base/x/x11_util.h"
  40 #include "ui/gfx/canvas.h"
  41 #include "ui/gfx/gtk_compat.h"
  42 #include "ui/gfx/image/cairo_cached_surface.h"
  43 #include "ui/gfx/image/image.h"
  44
  45 using content::NativeWebKeyboardEvent;
  46 using content::WebContents;
  47
  48 namespace {
  49
  50 const char* kPanelWindowKey = "__PANEL_GTK__";
  51
  52 // The number of milliseconds between loading animation frames.
  53 const int kLoadingAnimationFrameTimeMs = 30;
  54
  55 // The frame border is only visible in restored mode and is hardcoded to 4 px
  56 // on each side regardless of the system window border size.
  57 const int kFrameBorderThickness = 4;
  58 // While resize areas on Windows are normally the same size as the window
  59 // borders, our top area is shrunk by 1 px to make it easier to move the window
  60 // around with our thinner top grabbable strip.  (Incidentally, our side and
  61 // bottom resize areas don't match the frame border thickness either -- they
  62 // span the whole nonclient area, so there's no "dead zone" for the mouse.)
  63 const int kTopResizeAdjust = 1;
  64 // In the window corners, the resize areas don't actually expand bigger, but
  65 // the 16 px at the end of each edge triggers diagonal resizing.
  66 const int kResizeAreaCornerSize = 16;
  67
  68 // Colors used to draw frame background under default theme.
  69 const SkColor kActiveBackgroundDefaultColor = SkColorSetRGB(0x3a, 0x3d, 0x3d);
  70 const SkColor kInactiveBackgroundDefaultColor = SkColorSetRGB(0x7a, 0x7c, 0x7c);
  71 const SkColor kAttentionBackgroundDefaultColor =
  72     SkColorSetRGB(0x53, 0xa9, 0x3f);
  73 const SkColor kMinimizeBackgroundDefaultColor = SkColorSetRGB(0xf5, 0xf4, 0xf0);
  74 const SkColor kMinimizeBorderDefaultColor = SkColorSetRGB(0xc9, 0xc9, 0xc9);
  75
  76 // Set minimium width for window really small.
  77 const int kMinWindowWidth = 26;
  78
  79 // Table of supported accelerators in Panels.
  80 const struct AcceleratorMapping {
  81   guint keyval;
  82   int command_id;
  83   GdkModifierType modifier_type;
  84 } kAcceleratorMap[] = {
  85   // Window controls.
  86   { GDK_w, IDC_CLOSE_WINDOW, GDK_CONTROL_MASK },
  87   { GDK_w, IDC_CLOSE_WINDOW,
  88     GdkModifierType(GDK_CONTROL_MASK | GDK_SHIFT_MASK) },
  89   { GDK_q, IDC_EXIT, GdkModifierType(GDK_CONTROL_MASK | GDK_SHIFT_MASK) },
  90
  91   // Zoom level.
  92   { GDK_KP_Add, IDC_ZOOM_PLUS, GDK_CONTROL_MASK },
  93   { GDK_plus, IDC_ZOOM_PLUS,
  94     GdkModifierType(GDK_CONTROL_MASK | GDK_SHIFT_MASK) },
  95   { GDK_equal, IDC_ZOOM_PLUS, GDK_CONTROL_MASK },
  96   { XF86XK_ZoomIn, IDC_ZOOM_PLUS, GdkModifierType(0) },
  97   { GDK_KP_0, IDC_ZOOM_NORMAL, GDK_CONTROL_MASK },
  98   { GDK_0, IDC_ZOOM_NORMAL, GDK_CONTROL_MASK },
  99   { GDK_KP_Subtract, IDC_ZOOM_MINUS, GDK_CONTROL_MASK },
 100   { GDK_minus, IDC_ZOOM_MINUS, GDK_CONTROL_MASK },
 101   { GDK_underscore, IDC_ZOOM_MINUS,
 102     GdkModifierType(GDK_CONTROL_MASK | GDK_SHIFT_MASK) },
 103   { XF86XK_ZoomOut, IDC_ZOOM_MINUS, GdkModifierType(0) },
 104
 105   // Navigation.
 106   { GDK_Escape, IDC_STOP, GdkModifierType(0) },
 107   { XF86XK_Stop, IDC_STOP, GdkModifierType(0) },
 108   { GDK_r, IDC_RELOAD, GDK_CONTROL_MASK },
 109   { GDK_r, IDC_RELOAD_IGNORING_CACHE,
 110     GdkModifierType(GDK_CONTROL_MASK|GDK_SHIFT_MASK) },
 111   { GDK_F5, IDC_RELOAD, GdkModifierType(0) },
 112   { GDK_F5, IDC_RELOAD_IGNORING_CACHE, GDK_CONTROL_MASK },
 113   { GDK_F5, IDC_RELOAD_IGNORING_CACHE, GDK_SHIFT_MASK },
 114   { XF86XK_Reload, IDC_RELOAD, GdkModifierType(0) },
 115   { XF86XK_Refresh, IDC_RELOAD, GdkModifierType(0) },
 116
 117   // Editing.
 118   { GDK_c, IDC_COPY, GDK_CONTROL_MASK },
 119   { GDK_x, IDC_CUT, GDK_CONTROL_MASK },
 120   { GDK_v, IDC_PASTE, GDK_CONTROL_MASK },
 121
 122   // Dev tools.
 123   { GDK_i, IDC_DEV_TOOLS,
 124     GdkModifierType(GDK_CONTROL_MASK | GDK_SHIFT_MASK) },
 125   { GDK_j, IDC_DEV_TOOLS_CONSOLE,
 126     GdkModifierType(GDK_CONTROL_MASK | GDK_SHIFT_MASK) },
 127
 128 };
 129
 130 // Table of accelerator mappings to command ids.
 131 typedef std::map<ui::Accelerator, int> AcceleratorMap;
 132
 133 const AcceleratorMap& GetAcceleratorTable() {
 134   CR_DEFINE_STATIC_LOCAL(AcceleratorMap, accelerator_table, ());
 135   if (accelerator_table.empty()) {
 136     for (size_t i = 0; i < arraysize(kAcceleratorMap); ++i) {
 137       const AcceleratorMapping& entry = kAcceleratorMap[i];
 138       ui::Accelerator accelerator = ui::AcceleratorForGdkKeyCodeAndModifier(
 139           entry.keyval, entry.modifier_type);
 140       accelerator_table[accelerator] = entry.command_id;
 141     }
 142   }
 143   return accelerator_table;
 144 }
 145
 146 gfx::Image CreateImageForColor(SkColor color) {
 147   gfx::Canvas canvas(gfx::Size(1, 1), 1.0f, true);
 148   canvas.DrawColor(color);
 149   return gfx::Image(gfx::ImageSkia(canvas.ExtractImageRep()));
 150 }
 151
 152 const gfx::Image GetActiveBackgroundDefaultImage() {
 153   CR_DEFINE_STATIC_LOCAL(gfx::Image, image, ());
 154   if (image.IsEmpty())
 155     image = CreateImageForColor(kActiveBackgroundDefaultColor);
 156   return image;
 157 }
 158
 159 gfx::Image GetInactiveBackgroundDefaultImage() {
 160   CR_DEFINE_STATIC_LOCAL(gfx::Image, image, ());
 161   if (image.IsEmpty())
 162     image = CreateImageForColor(kInactiveBackgroundDefaultColor);
 163   return image;
 164 }
 165
 166 gfx::Image GetAttentionBackgroundDefaultImage() {
 167   CR_DEFINE_STATIC_LOCAL(gfx::Image, image, ());
 168   if (image.IsEmpty())
 169     image = CreateImageForColor(kAttentionBackgroundDefaultColor);
 170   return image;
 171 }
 172
 173 gfx::Image GetMinimizeBackgroundDefaultImage() {
 174   CR_DEFINE_STATIC_LOCAL(gfx::Image, image, ());
 175   if (image.IsEmpty())
 176     image = CreateImageForColor(kMinimizeBackgroundDefaultColor);
 177   return image;
 178 }
 179
 180 // Used to stash a pointer to the Panel window inside the native
 181 // Gtk window for retrieval in static callbacks.
 182 GQuark GetPanelWindowQuarkKey() {
 183   static GQuark quark = g_quark_from_static_string(kPanelWindowKey);
 184   return quark;
 185 }
 186
 187 // Size of window frame. Empty until first panel has been allocated
 188 // and sized. Frame size won't change for other panels so it can be
 189 // computed once for all panels.
 190 gfx::Size& GetFrameSize() {
 191   CR_DEFINE_STATIC_LOCAL(gfx::Size, frame_size, ());
 192   return frame_size;
 193 }
 194
 195 void SetFrameSize(const gfx::Size& new_size) {
 196   gfx::Size& frame_size = GetFrameSize();
 197   frame_size.SetSize(new_size.width(), new_size.height());
 198 }
 199
 200 }  // namespace
 201
 202 // static
 203 NativePanel* Panel::CreateNativePanel(Panel* panel,
 204                                       const gfx::Rect& bounds,
 205                                       bool always_on_top) {
 206   PanelGtk* panel_gtk = new PanelGtk(panel, bounds, always_on_top);
 207   panel_gtk->Init();
 208   return panel_gtk;
 209 }
 210
 211 PanelGtk::PanelGtk(Panel* panel, const gfx::Rect& bounds, bool always_on_top)
 212     : panel_(panel),
 213       bounds_(bounds),
 214       always_on_top_(always_on_top),
 215       is_shown_(false),
 216       paint_state_(PAINT_AS_INACTIVE),
 217       is_drawing_attention_(false),
 218       frame_cursor_(NULL),
 219       is_active_(!ui::ActiveWindowWatcherX::WMSupportsActivation()),
 220       is_minimized_(false),
 221       window_(NULL),
 222       window_container_(NULL),
 223       window_vbox_(NULL),
 224       render_area_event_box_(NULL),
 225       contents_expanded_(NULL),
 226       accel_group_(NULL),
 227       corner_style_(panel::ALL_ROUNDED) {
 228 }
 229
 230 PanelGtk::~PanelGtk() {
 231   ui::ActiveWindowWatcherX::RemoveObserver(this);
 232 }
 233
 234 void PanelGtk::Init() {
 235   ui::ActiveWindowWatcherX::AddObserver(this);
 236
 237   window_ = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
 238   g_object_set_qdata(G_OBJECT(window_), GetPanelWindowQuarkKey(), this);
 239   gtk_widget_add_events(GTK_WIDGET(window_), GDK_BUTTON_PRESS_MASK |
 240                                              GDK_POINTER_MOTION_MASK);
 241   gtk_window_set_decorated(window_, false);
 242
 243   // Disable the resize gripper on Ubuntu.
 244   gtk_window_util::DisableResizeGrip(window_);
 245
 246   // Add this window to its own unique window group to allow for
 247   // window-to-parent modality.
 248   gtk_window_group_add_window(gtk_window_group_new(), window_);
 249   g_object_unref(gtk_window_get_group(window_));
 250
 251   // Set minimum height for the window.
 252   GdkGeometry hints;
 253   hints.min_height = panel::kMinimizedPanelHeight;
 254   hints.min_width = kMinWindowWidth;
 255   gtk_window_set_geometry_hints(
 256       window_, GTK_WIDGET(window_), &hints, GDK_HINT_MIN_SIZE);
 257
 258   // Connect signal handlers to the window.
 259   g_signal_connect(window_, "delete-event",
 260                    G_CALLBACK(OnMainWindowDeleteEventThunk), this);
 261   g_signal_connect(window_, "destroy",
 262                    G_CALLBACK(OnMainWindowDestroyThunk), this);
 263   g_signal_connect(window_, "configure-event",
 264                    G_CALLBACK(OnConfigureThunk), this);
 265   g_signal_connect(window_, "window-state-event",
 266                    G_CALLBACK(OnWindowStateThunk), this);
 267   g_signal_connect(window_, "key-press-event",
 268                    G_CALLBACK(OnKeyPressThunk), this);
 269   g_signal_connect(window_, "motion-notify-event",
 270                    G_CALLBACK(OnMouseMoveEventThunk), this);
 271   g_signal_connect(window_, "button-press-event",
 272                    G_CALLBACK(OnButtonPressEventThunk), this);
 273
 274   // This vbox contains the titlebar and the render area, but not
 275   // the custom frame border.
 276   window_vbox_ = gtk_vbox_new(FALSE, 0);
 277   gtk_widget_show(window_vbox_);
 278
 279   // TODO(jennb): add GlobalMenuBar after refactoring out Browser.
 280
 281   // The window container draws the custom window frame.
 282   window_container_ = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
 283   gtk_widget_set_name(window_container_, "chrome-custom-frame-border");
 284   gtk_widget_set_app_paintable(window_container_, TRUE);
 285   gtk_widget_set_double_buffered(window_container_, FALSE);
 286   gtk_widget_set_redraw_on_allocate(window_container_, TRUE);
 287   gtk_alignment_set_padding(GTK_ALIGNMENT(window_container_), 0,
 288       kFrameBorderThickness, kFrameBorderThickness, kFrameBorderThickness);
 289   g_signal_connect(window_container_, "expose-event",
 290                    G_CALLBACK(OnCustomFrameExposeThunk), this);
 291   gtk_container_add(GTK_CONTAINER(window_container_), window_vbox_);
 292
 293   // Build the titlebar.
 294   titlebar_.reset(new PanelTitlebarGtk(this));
 295   titlebar_->Init();
 296   gtk_box_pack_start(GTK_BOX(window_vbox_), titlebar_->widget(), FALSE, FALSE,
 297                      0);
 298   g_signal_connect(titlebar_->widget(), "button-press-event",
 299                    G_CALLBACK(OnTitlebarButtonPressEventThunk), this);
 300   g_signal_connect(titlebar_->widget(), "button-release-event",
 301                    G_CALLBACK(OnTitlebarButtonReleaseEventThunk), this);
 302
 303   contents_expanded_ = gtk_expanded_container_new();
 304   gtk_widget_show(contents_expanded_);
 305
 306   render_area_event_box_ = gtk_event_box_new();
 307   // Set a white background so during startup the user sees white in the
 308   // content area before we get a WebContents in place.
 309   gtk_widget_modify_bg(render_area_event_box_, GTK_STATE_NORMAL,
 310                        &ui::kGdkWhite);
 311   gtk_container_add(GTK_CONTAINER(render_area_event_box_),
 312                     contents_expanded_);
 313   gtk_widget_show(render_area_event_box_);
 314   gtk_box_pack_end(GTK_BOX(window_vbox_), render_area_event_box_,
 315                    TRUE, TRUE, 0);
 316
 317   gtk_container_add(GTK_CONTAINER(window_), window_container_);
 318   gtk_widget_show(window_container_);
 319
 320   ConnectAccelerators();
 321   SetPanelAlwaysOnTop(always_on_top_);
 322 }
 323
 324 void PanelGtk::SetWindowCornerStyle(panel::CornerStyle corner_style) {
 325   corner_style_ = corner_style;
 326   UpdateWindowShape();
 327 }
 328
 329 void PanelGtk::MinimizePanelBySystem() {
 330   gtk_window_iconify(window_);
 331 }
 332
 333 bool PanelGtk::IsPanelMinimizedBySystem() const {
 334   return is_minimized_;
 335 }
 336
 337 bool PanelGtk::IsPanelShownOnActiveDesktop() const {
 338   // IsWindowVisible checks _NET_WM_DESKTOP.
 339   if (!ui::IsWindowVisible(ui::GetX11WindowFromGtkWidget(GTK_WIDGET(window_))))
 340     return false;
 341
 342   // Certain window manager, like Unity, does not update _NET_WM_DESKTOP when a
 343   // window is moved to other workspace. However, it treats all workspaces as
 344   // concatenated together in one big coordinate space. When the user switches
 345   // to another workspace, the window manager will update the origins of all
 346   // windows in previous active workspace to move by the size of display
 347   // area.
 348   gfx::Rect display_area = PanelManager::GetInstance()->
 349       display_settings_provider()->GetDisplayAreaMatching(bounds_);
 350   int win_x = 0, win_y = 0;
 351   gdk_window_get_origin(gtk_widget_get_window(GTK_WIDGET(window_)),
 352                                               &win_x, &win_y);
 353   return abs(win_x - bounds_.x()) < display_area.width() &&
 354          abs(win_y - bounds_.y()) < display_area.height();
 355 }
 356
 357 void PanelGtk::ShowShadow(bool show) {
 358   // Shadow is not supported for GTK panel.
 359 }
 360
 361 void PanelGtk::UpdateWindowShape() {
 362   int width = configure_size_.width();
 363   int height = configure_size_.height();
 364   if (!width || !height)
 365     return;
 366
 367   GdkRegion* mask;
 368   if (corner_style_ & panel::TOP_ROUNDED) {
 369     GdkRectangle top_top_rect = { 3, 0, width - 6, 1 };
 370     GdkRectangle top_mid_rect = { 1, 1, width - 2, 2 };
 371     mask = gdk_region_rectangle(&top_top_rect);
 372     gdk_region_union_with_rect(mask, &top_mid_rect);
 373   } else {
 374     GdkRectangle top_rect = { 0, 0, width, 3 };
 375     mask = gdk_region_rectangle(&top_rect);
 376   }
 377
 378   if (corner_style_ & panel::BOTTOM_ROUNDED) {
 379     GdkRectangle mid_rect = { 0, 3, width, height - 6 };
 380     GdkRectangle bottom_mid_rect = { 1, height - 3, width - 2, 2 };
 381     GdkRectangle bottom_bottom_rect = { 3, height - 1, width - 6, 1 };
 382     gdk_region_union_with_rect(mask, &mid_rect);
 383     gdk_region_union_with_rect(mask, &bottom_mid_rect);
 384     gdk_region_union_with_rect(mask, &bottom_bottom_rect);
 385   } else {
 386     GdkRectangle mid_rect = { 0, 3, width, height - 3 };
 387     gdk_region_union_with_rect(mask, &mid_rect);
 388   }
 389
 390   gdk_window_shape_combine_region(
 391       gtk_widget_get_window(GTK_WIDGET(window_)), mask, 0, 0);
 392   if (mask)
 393     gdk_region_destroy(mask);
 394 }
 395
 396 gboolean PanelGtk::OnConfigure(GtkWidget* widget,
 397                                GdkEventConfigure* event) {
 398   // When the window moves, we'll get multiple configure-event signals. We can
 399   // also get events when the bounds haven't changed, but the window's stacking
 400   // has, which we aren't interested in. http://crbug.com/70125
 401   gfx::Size new_size(event->width, event->height);
 402   if (new_size == configure_size_)
 403     return FALSE;
 404   configure_size_ = new_size;
 405
 406   UpdateWindowShape();
 407
 408   if (!GetFrameSize().IsEmpty())
 409     return FALSE;
 410
 411   // Save the frame size allocated by the system as the
 412   // frame size will be affected when we shrink the panel smaller
 413   // than the frame (e.g. when the panel is minimized).
 414   SetFrameSize(GetNonClientFrameSize());
 415   panel_->OnWindowSizeAvailable();
 416
 417   content::NotificationService::current()->Notify(
 418       chrome::NOTIFICATION_PANEL_WINDOW_SIZE_KNOWN,
 419       content::Source<Panel>(panel_.get()),
 420       content::NotificationService::NoDetails());
 421
 422   return FALSE;
 423 }
 424
 425 gboolean PanelGtk::OnWindowState(GtkWidget* widget,
 426                                  GdkEventWindowState* event) {
 427   is_minimized_ = event->new_window_state & GDK_WINDOW_STATE_ICONIFIED;
 428   return FALSE;
 429 }
 430
 431 void PanelGtk::ConnectAccelerators() {
 432   accel_group_ = gtk_accel_group_new();
 433   gtk_window_add_accel_group(window_, accel_group_);
 434
 435   const AcceleratorMap& accelerator_table = GetAcceleratorTable();
 436   for (AcceleratorMap::const_iterator iter = accelerator_table.begin();
 437        iter != accelerator_table.end(); ++iter) {
 438     gtk_accel_group_connect(
 439         accel_group_,
 440         ui::GetGdkKeyCodeForAccelerator(iter->first),
 441         ui::GetGdkModifierForAccelerator(iter->first),
 442         GtkAccelFlags(0),
 443         g_cclosure_new(G_CALLBACK(OnGtkAccelerator),
 444                        GINT_TO_POINTER(iter->second), NULL));
 445   }
 446 }
 447
 448 void PanelGtk::DisconnectAccelerators() {
 449   // Disconnecting the keys we connected to our accelerator group frees the
 450   // closures allocated in ConnectAccelerators.
 451   const AcceleratorMap& accelerator_table = GetAcceleratorTable();
 452   for (AcceleratorMap::const_iterator iter = accelerator_table.begin();
 453        iter != accelerator_table.end(); ++iter) {
 454     gtk_accel_group_disconnect_key(
 455         accel_group_,
 456         ui::GetGdkKeyCodeForAccelerator(iter->first),
 457         ui::GetGdkModifierForAccelerator(iter->first));
 458   }
 459   gtk_window_remove_accel_group(window_, accel_group_);
 460   g_object_unref(accel_group_);
 461   accel_group_ = NULL;
 462 }
 463
 464 // static
 465 gboolean PanelGtk::OnGtkAccelerator(GtkAccelGroup* accel_group,
 466                                     GObject* acceleratable,
 467                                     guint keyval,
 468                                     GdkModifierType modifier,
 469                                     void* user_data) {
 470   DCHECK(acceleratable);
 471   int command_id = GPOINTER_TO_INT(user_data);
 472   PanelGtk* panel_gtk = static_cast<PanelGtk*>(
 473       g_object_get_qdata(acceleratable, GetPanelWindowQuarkKey()));
 474   return panel_gtk->panel()->ExecuteCommandIfEnabled(command_id);
 475 }
 476
 477 gboolean PanelGtk::OnKeyPress(GtkWidget* widget, GdkEventKey* event) {
 478   // No way to deactivate a window in GTK, so ignore input if window
 479   // is supposed to be 'inactive'. See comments in DeactivatePanel().
 480   if (!is_active_)
 481     return TRUE;
 482
 483   // Propagate the key event to child widget first, so we don't override
 484   // their accelerators.
 485   if (!gtk_window_propagate_key_event(GTK_WINDOW(widget), event)) {
 486     if (!gtk_window_activate_key(GTK_WINDOW(widget), event)) {
 487       gtk_bindings_activate_event(GTK_OBJECT(widget), event);
 488     }
 489   }
 490   return TRUE;
 491 }
 492
 493 bool PanelGtk::GetWindowEdge(int x, int y, GdkWindowEdge* edge) const {
 494   // Only detect the window edge when panels can be resized by the user.
 495   // This method is used by the base class to detect when the cursor has
 496   // hit the window edge in order to change the cursor to a resize cursor
 497   // and to detect when to initiate a resize drag.
 498   panel::Resizability resizability = panel_->CanResizeByMouse();
 499   if (panel::NOT_RESIZABLE == resizability)
 500     return false;
 501
 502   int width = bounds_.width();
 503   int height = bounds_.height();
 504   if (x < kFrameBorderThickness) {
 505     if (y < kResizeAreaCornerSize - kTopResizeAdjust &&
 506         (resizability & panel::RESIZABLE_TOP_LEFT)) {
 507       *edge = GDK_WINDOW_EDGE_NORTH_WEST;
 508       return true;
 509     } else if (y >= height - kResizeAreaCornerSize &&
 510               (resizability & panel::RESIZABLE_BOTTOM_LEFT)) {
 511       *edge = GDK_WINDOW_EDGE_SOUTH_WEST;
 512       return true;
 513     }
 514   } else if (x >= width - kFrameBorderThickness) {
 515     if (y < kResizeAreaCornerSize - kTopResizeAdjust &&
 516         (resizability & panel::RESIZABLE_TOP_RIGHT)) {
 517       *edge = GDK_WINDOW_EDGE_NORTH_EAST;
 518       return true;
 519     } else if (y >= height - kResizeAreaCornerSize &&
 520               (resizability & panel::RESIZABLE_BOTTOM_RIGHT)) {
 521       *edge = GDK_WINDOW_EDGE_SOUTH_EAST;
 522       return true;
 523     }
 524   }
 525
 526   if (x < kFrameBorderThickness && (resizability & panel::RESIZABLE_LEFT)) {
 527     *edge = GDK_WINDOW_EDGE_WEST;
 528     return true;
 529   } else if (x >= width - kFrameBorderThickness &&
 530             (resizability & panel::RESIZABLE_RIGHT)) {
 531     *edge = GDK_WINDOW_EDGE_EAST;
 532     return true;
 533   }
 534
 535   if (y < kFrameBorderThickness && (resizability & panel::RESIZABLE_TOP)) {
 536     *edge = GDK_WINDOW_EDGE_NORTH;
 537     return true;
 538   } else if (y >= height - kFrameBorderThickness &&
 539             (resizability & panel::RESIZABLE_BOTTOM)) {
 540     *edge = GDK_WINDOW_EDGE_SOUTH;
 541     return true;
 542   }
 543
 544   return false;
 545 }
 546
 547 gfx::Image PanelGtk::GetFrameBackground() const {
 548   switch (paint_state_) {
 549     case PAINT_AS_INACTIVE:
 550       return GetInactiveBackgroundDefaultImage();
 551     case PAINT_AS_ACTIVE:
 552       return GetActiveBackgroundDefaultImage();
 553     case PAINT_AS_MINIMIZED:
 554       return GetMinimizeBackgroundDefaultImage();
 555     case PAINT_FOR_ATTENTION:
 556       return GetAttentionBackgroundDefaultImage();
 557     default:
 558       NOTREACHED();
 559       return GetInactiveBackgroundDefaultImage();
 560   }
 561 }
 562
 563 gboolean PanelGtk::OnCustomFrameExpose(GtkWidget* widget,
 564                                        GdkEventExpose* event) {
 565   TRACE_EVENT0("ui::gtk", "PanelGtk::OnCustomFrameExpose");
 566   cairo_t* cr = gdk_cairo_create(gtk_widget_get_window(widget));
 567   gdk_cairo_rectangle(cr, &event->area);
 568   cairo_clip(cr);
 569
 570   // Update the painting state.
 571   int window_height = gdk_window_get_height(gtk_widget_get_window(widget));
 572   if (is_drawing_attention_)
 573     paint_state_ = PAINT_FOR_ATTENTION;
 574   else if (window_height <= panel::kMinimizedPanelHeight)
 575     paint_state_ = PAINT_AS_MINIMIZED;
 576   else if (is_active_)
 577     paint_state_ = PAINT_AS_ACTIVE;
 578   else
 579     paint_state_ = PAINT_AS_INACTIVE;
 580
 581   // Draw the background.
 582   gfx::CairoCachedSurface* surface = GetFrameBackground().ToCairo();
 583   surface->SetSource(cr, widget, 0, 0);
 584   cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT);
 585   cairo_rectangle(cr, event->area.x, event->area.y,
 586                   event->area.width, event->area.height);
 587   cairo_fill(cr);
 588
 589   // Draw the border for the minimized panel only.
 590   if (paint_state_ == PAINT_AS_MINIMIZED) {
 591     cairo_move_to(cr, 0, 3);
 592     cairo_line_to(cr, 1, 2);
 593     cairo_line_to(cr, 1, 1);
 594     cairo_line_to(cr, 2, 1);
 595     cairo_line_to(cr, 3, 0);
 596     cairo_line_to(cr, event->area.width - 3, 0);
 597     cairo_line_to(cr, event->area.width - 2, 1);
 598     cairo_line_to(cr, event->area.width - 1, 1);
 599     cairo_line_to(cr, event->area.width - 1, 2);
 600     cairo_line_to(cr, event->area.width - 1, 3);
 601     cairo_line_to(cr, event->area.width - 1, event->area.height - 1);
 602     cairo_line_to(cr, 0, event->area.height - 1);
 603     cairo_close_path(cr);
 604     cairo_set_source_rgb(cr,
 605                          SkColorGetR(kMinimizeBorderDefaultColor) / 255.0,
 606                          SkColorGetG(kMinimizeBorderDefaultColor) / 255.0,
 607                          SkColorGetB(kMinimizeBorderDefaultColor) / 255.0);
 608     cairo_set_line_width(cr, 1.0);
 609     cairo_stroke(cr);
 610   }
 611
 612   cairo_destroy(cr);
 613
 614   return FALSE;  // Allow subwidgets to paint.
 615 }
 616
 617 void PanelGtk::EnsureDragHelperCreated() {
 618   if (drag_helper_.get())
 619     return;
 620
 621   drag_helper_.reset(new PanelDragGtk(panel_.get()));
 622   gtk_box_pack_end(GTK_BOX(window_vbox_), drag_helper_->widget(),
 623                    FALSE, FALSE, 0);
 624 }
 625
 626 gboolean PanelGtk::OnTitlebarButtonPressEvent(
 627     GtkWidget* widget, GdkEventButton* event) {
 628   if (event->button != 1)
 629     return TRUE;
 630   if (event->type != GDK_BUTTON_PRESS)
 631     return TRUE;
 632
 633   // If the panel is in a stack, bring all other panels in the stack to the
 634   // top.
 635   StackedPanelCollection* stack = panel_->stack();
 636   if (stack) {
 637     for (StackedPanelCollection::Panels::const_iterator iter =
 638              stack->panels().begin();
 639          iter != stack->panels().end(); ++iter) {
 640       Panel* panel = *iter;
 641       GtkWindow* gtk_window = panel->GetNativeWindow();
 642       // If a panel is collapsed, we make it not to take focus. For such window,
 643       // it cannot be brought to the top by calling gdk_window_raise. To work
 644       // around this issue, we make it always-on-top first and then put it back
 645       // to normal. Note that this trick has been done for all panels in the
 646       // stack, regardless of whether it is collapsed or not.
 647       // There is one side-effect to this approach: if the panel being pressed
 648       // on is collapsed, clicking on the client area of the last active
 649       // window will not raise it above these panels.
 650       gtk_window_set_keep_above(gtk_window, true);
 651       gtk_window_set_keep_above(gtk_window, false);
 652     }
 653   } else {
 654     gdk_window_raise(gtk_widget_get_window(GTK_WIDGET(window_)));
 655   }
 656
 657   EnsureDragHelperCreated();
 658   drag_helper_->InitialTitlebarMousePress(event, titlebar_->widget());
 659   return TRUE;
 660 }
 661
 662 gboolean PanelGtk::OnTitlebarButtonReleaseEvent(
 663     GtkWidget* widget, GdkEventButton* event) {
 664   if (event->button != 1)
 665     return TRUE;
 666
 667   panel_->OnTitlebarClicked((event->state & GDK_CONTROL_MASK) ?
 668                             panel::APPLY_TO_ALL : panel::NO_MODIFIER);
 669   return TRUE;
 670 }
 671
 672 gboolean PanelGtk::OnMouseMoveEvent(GtkWidget* widget,
 673                                     GdkEventMotion* event) {
 674   // This method is used to update the mouse cursor when over the edge of the
 675   // custom frame.  If we're over some other widget, do nothing.
 676   if (event->window != gtk_widget_get_window(widget)) {
 677     // Reset the cursor.
 678     if (frame_cursor_) {
 679       frame_cursor_ = NULL;
 680       gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(window_)), NULL);
 681     }
 682     return FALSE;
 683   }
 684
 685   // Update the cursor if we're on the custom frame border.
 686   GdkWindowEdge edge;
 687   bool has_hit_edge = GetWindowEdge(static_cast<int>(event->x),
 688                                     static_cast<int>(event->y), &edge);
 689   GdkCursorType new_cursor = has_hit_edge ?
 690       gtk_window_util::GdkWindowEdgeToGdkCursorType(edge) : GDK_LAST_CURSOR;
 691   GdkCursorType last_cursor =
 692       frame_cursor_ ? frame_cursor_->type : GDK_LAST_CURSOR;
 693
 694   if (last_cursor != new_cursor) {
 695     frame_cursor_ = has_hit_edge ? gfx::GetCursor(new_cursor) : NULL;
 696     gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(window_)),
 697                           frame_cursor_);
 698   }
 699   return FALSE;
 700 }
 701
 702 gboolean PanelGtk::OnButtonPressEvent(GtkWidget* widget,
 703                                       GdkEventButton* event) {
 704   if (event->button != 1 || event->type != GDK_BUTTON_PRESS)
 705     return FALSE;
 706
 707   // No way to deactivate a window in GTK, so we pretended it is deactivated.
 708   // See comments in DeactivatePanel().
 709   // Mouse click anywhere in window should re-activate window so do it now.
 710   if (!is_active_)
 711     panel_->Activate();
 712
 713   // Make the button press coordinate relative to the panel window.
 714   int win_x, win_y;
 715   GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window_));
 716   gdk_window_get_origin(gdk_window, &win_x, &win_y);
 717
 718   GdkWindowEdge edge;
 719   gfx::Point point(static_cast<int>(event->x_root - win_x),
 720                    static_cast<int>(event->y_root - win_y));
 721   bool has_hit_edge = GetWindowEdge(point.x(), point.y(), &edge);
 722   if (has_hit_edge) {
 723     gdk_window_raise(gdk_window);
 724     EnsureDragHelperCreated();
 725     // Resize cursor was set by PanelGtk when mouse moved over window edge.
 726     GdkCursor* cursor =
 727         gdk_window_get_cursor(gtk_widget_get_window(GTK_WIDGET(window_)));
 728     drag_helper_->InitialWindowEdgeMousePress(event, cursor, edge);
 729     return TRUE;
 730   }
 731
 732   return FALSE;  // Continue to propagate the event.
 733 }
 734
 735 void PanelGtk::ActiveWindowChanged(GdkWindow* active_window) {
 736   // Do nothing if we're in the process of closing the panel window.
 737   if (!window_)
 738     return;
 739
 740   bool is_active = gtk_widget_get_window(GTK_WIDGET(window_)) == active_window;
 741   if (is_active == is_active_)
 742     return;  // State did not change.
 743
 744   if (is_active) {
 745     // If there's an app modal dialog (e.g., JS alert), try to redirect
 746     // the user's attention to the window owning the dialog.
 747     if (AppModalDialogQueue::GetInstance()->HasActiveDialog()) {
 748       AppModalDialogQueue::GetInstance()->ActivateModalDialog();
 749       return;
 750     }
 751   }
 752
 753   is_active_ = is_active;
 754   titlebar_->UpdateTextColor();
 755   InvalidateWindow();
 756   panel_->OnActiveStateChanged(is_active_);
 757 }
 758
 759 // Callback for the delete event.  This event is fired when the user tries to
 760 // close the window.
 761 gboolean PanelGtk::OnMainWindowDeleteEvent(GtkWidget* widget,
 762                                            GdkEvent* event) {
 763   ClosePanel();
 764
 765   // Return true to prevent the gtk window from being destroyed.  Close will
 766   // destroy it for us.
 767   return TRUE;
 768 }
 769
 770 void PanelGtk::OnMainWindowDestroy(GtkWidget* widget) {
 771   // BUG 8712. When we gtk_widget_destroy() in ClosePanel(), this will emit the
 772   // signal right away, and we will be here (while ClosePanel() is still in the
 773   // call stack). Let stack unwind before deleting the panel.
 774   //
 775   // We don't want to use DeleteSoon() here since it won't work on a nested pump
 776   // (like in UI tests).
 777   base::MessageLoop::current()->PostTask(
 778       FROM_HERE, base::Bind(&base::DeletePointer<PanelGtk>, this));
 779 }
 780
 781 void PanelGtk::ShowPanel() {
 782   gtk_window_present(window_);
 783   RevealPanel();
 784 }
 785
 786 void PanelGtk::ShowPanelInactive() {
 787   gtk_window_set_focus_on_map(window_, false);
 788   gtk_widget_show(GTK_WIDGET(window_));
 789   RevealPanel();
 790 }
 791
 792 void PanelGtk::RevealPanel() {
 793   DCHECK(!is_shown_);
 794   is_shown_ = true;
 795   SetBoundsInternal(bounds_);
 796 }
 797
 798 gfx::Rect PanelGtk::GetPanelBounds() const {
 799   return bounds_;
 800 }
 801
 802 void PanelGtk::SetPanelBounds(const gfx::Rect& bounds) {
 803   SetBoundsInternal(bounds);
 804 }
 805
 806 void PanelGtk::SetPanelBoundsInstantly(const gfx::Rect& bounds) {
 807   SetBoundsInternal(bounds);
 808 }
 809
 810 void PanelGtk::SetBoundsInternal(const gfx::Rect& bounds) {
 811   if (is_shown_) {
 812     gdk_window_move_resize(gtk_widget_get_window(GTK_WIDGET(window_)),
 813                            bounds.x(), bounds.y(),
 814                            bounds.width(), bounds.height());
 815   }
 816
 817   bounds_ = bounds;
 818
 819   titlebar_->SendEnterNotifyToCloseButtonIfUnderMouse();
 820   panel_->manager()->OnPanelAnimationEnded(panel_.get());
 821 }
 822
 823 void PanelGtk::ClosePanel() {
 824   // We're already closing.  Do nothing.
 825   if (!window_)
 826     return;
 827
 828   if (!panel_->ShouldCloseWindow())
 829     return;
 830
 831   if (drag_helper_.get())
 832     drag_helper_.reset();
 833
 834   if (accel_group_)
 835     DisconnectAccelerators();
 836
 837   // Cancel any pending callback from the loading animation timer.
 838   loading_animation_timer_.Stop();
 839
 840   if (panel_->GetWebContents()) {
 841     // Hide the window (so it appears to have closed immediately).
 842     // When web contents are destroyed, we will be called back again.
 843     gtk_widget_hide(GTK_WIDGET(window_));
 844     panel_->OnWindowClosing();
 845     return;
 846   }
 847
 848   GtkWidget* window = GTK_WIDGET(window_);
 849   // To help catch bugs in any event handlers that might get fired during the
 850   // destruction, set window_ to NULL before any handlers will run.
 851   window_ = NULL;
 852
 853   panel_->OnNativePanelClosed();
 854
 855   // We don't want GlobalMenuBar handling any notifications or commands after
 856   // the window is destroyed.
 857   // TODO(jennb):  global_menu_bar_->Disable();
 858   gtk_widget_destroy(window);
 859 }
 860
 861 void PanelGtk::ActivatePanel() {
 862   gtk_window_present(window_);
 863
 864   // When the user clicks to expand the minimized panel, the panel has already
 865   // become an active window before gtk_window_present is called. Thus the
 866   // active window change event, fired by ActiveWindowWatcherXObserver, is not
 867   // triggered. We need to call ActiveWindowChanged manually to update panel's
 868   // active status. It is OK to call ActiveWindowChanged with the same active
 869   // window twice since the 2nd call is just a no-op.
 870   ActiveWindowChanged(gtk_widget_get_window(GTK_WIDGET(window_)));
 871 }
 872
 873 void PanelGtk::DeactivatePanel() {
 874   // When a panel is deactivated, it should not be lowered to the bottom of the
 875   // z-order. We could put it behind other panel window.
 876   Panel* other_panel = NULL;
 877   // First, try to pick the sibling panel in the same stack.
 878   StackedPanelCollection* stack = panel_->stack();
 879   if (stack && stack->num_panels()) {
 880     other_panel = panel_ != stack->top_panel() ? stack->top_panel()
 881                                                : stack->bottom_panel();
 882   }
 883   // Then, try to pick other detached or stacked panel.
 884   if (!other_panel) {
 885     std::vector<Panel*> panels =
 886         panel_->manager()->GetDetachedAndStackedPanels();
 887     if (!panels.empty())
 888       other_panel = panel_ != panels.front() ? panels.front() : panels.back();
 889   }
 890
 891   gdk_window_restack(
 892       gtk_widget_get_window(GTK_WIDGET(window_)),
 893       other_panel ? gtk_widget_get_window(
 894           GTK_WIDGET(other_panel->GetNativeWindow())) : NULL,
 895       false);
 896
 897   // Per ICCCM: http://tronche.com/gui/x/icccm/sec-4.html#s-4.1.7
 898   // A convention is also required for clients that want to give up the
 899   // input focus. There is no safe value set for them to set the input
 900   // focus to; therefore, they should ignore input material.
 901   //
 902   // No way to deactive a GTK window. Pretend panel is deactivated
 903   // and ignore input.
 904   ActiveWindowChanged(NULL);
 905 }
 906
 907 bool PanelGtk::IsPanelActive() const {
 908   return is_active_;
 909 }
 910
 911 void PanelGtk::PreventActivationByOS(bool prevent_activation) {
 912   gtk_window_set_accept_focus(window_, !prevent_activation);
 913 }
 914
 915 gfx::NativeWindow PanelGtk::GetNativePanelWindow() {
 916   return window_;
 917 }
 918
 919 void PanelGtk::UpdatePanelTitleBar() {
 920   TRACE_EVENT0("ui::gtk", "PanelGtk::UpdatePanelTitleBar");
 921   base::string16 title = panel_->GetWindowTitle();
 922   gtk_window_set_title(window_, base::UTF16ToUTF8(title).c_str());
 923   titlebar_->UpdateTitleAndIcon();
 924
 925   gfx::Image app_icon = panel_->app_icon();
 926   if (!app_icon.IsEmpty())
 927     gtk_util::SetWindowIcon(window_, panel_->profile(), app_icon.ToGdkPixbuf());
 928 }
 929
 930 void PanelGtk::UpdatePanelLoadingAnimations(bool should_animate) {
 931   if (should_animate) {
 932     if (!loading_animation_timer_.IsRunning()) {
 933       // Loads are happening, and the timer isn't running, so start it.
 934       loading_animation_timer_.Start(FROM_HERE,
 935           base::TimeDelta::FromMilliseconds(kLoadingAnimationFrameTimeMs),
 936           this,
 937           &PanelGtk::LoadingAnimationCallback);
 938     }
 939   } else {
 940     if (loading_animation_timer_.IsRunning()) {
 941       loading_animation_timer_.Stop();
 942       // Loads are now complete, update the state if a task was scheduled.
 943       LoadingAnimationCallback();
 944     }
 945   }
 946 }
 947
 948 void PanelGtk::LoadingAnimationCallback() {
 949   titlebar_->UpdateThrobber(panel_->GetWebContents());
 950 }
 951
 952 void PanelGtk::PanelWebContentsFocused(content::WebContents* contents) {
 953   // Nothing to do.
 954 }
 955
 956 void PanelGtk::PanelCut() {
 957   gtk_window_util::DoCut(window_, panel_->GetWebContents());
 958 }
 959
 960 void PanelGtk::PanelCopy() {
 961   gtk_window_util::DoCopy(window_, panel_->GetWebContents());
 962 }
 963
 964 void PanelGtk::PanelPaste() {
 965   gtk_window_util::DoPaste(window_, panel_->GetWebContents());
 966 }
 967
 968 void PanelGtk::DrawAttention(bool draw_attention) {
 969   DCHECK((panel_->attention_mode() & Panel::USE_PANEL_ATTENTION) != 0);
 970
 971   if (is_drawing_attention_ == draw_attention)
 972     return;
 973
 974   is_drawing_attention_ = draw_attention;
 975
 976   titlebar_->UpdateTextColor();
 977   InvalidateWindow();
 978
 979   if ((panel_->attention_mode() & Panel::USE_SYSTEM_ATTENTION) != 0) {
 980     // May not be respected by all window managers.
 981     gtk_window_set_urgency_hint(window_, draw_attention);
 982   }
 983 }
 984
 985 bool PanelGtk::IsDrawingAttention() const {
 986   return is_drawing_attention_;
 987 }
 988
 989 void PanelGtk::HandlePanelKeyboardEvent(
 990     const NativeWebKeyboardEvent& event) {
 991   GdkEventKey* os_event = &event.os_event->key;
 992   if (os_event && event.type == blink::WebInputEvent::RawKeyDown)
 993     gtk_window_activate_key(window_, os_event);
 994 }
 995
 996 void PanelGtk::FullScreenModeChanged(bool is_full_screen) {
 997   // No need to hide panels when entering the full-screen mode because the
 998   // full-screen window will automatically be placed above all other windows.
 999   if (is_full_screen)
1000     return;
1001
1002   // Show the panel if not yet when leaving the full-screen mode. This is
1003   // because the panel is not shown when it is being created under full-screen
1004   // mode.
1005   GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window_));
1006   if (!GDK_IS_WINDOW(gdk_window) || !gdk_window_is_visible(gdk_window))
1007     ShowPanelInactive();
1008 }
1009
1010 void PanelGtk::PanelExpansionStateChanging(
1011     Panel::ExpansionState old_state, Panel::ExpansionState new_state) {
1012 }
1013
1014 void PanelGtk::AttachWebContents(content::WebContents* contents) {
1015   if (!contents)
1016     return;
1017   gfx::NativeView widget = contents->GetView()->GetNativeView();
1018   if (widget) {
1019     gtk_container_add(GTK_CONTAINER(contents_expanded_), widget);
1020     gtk_widget_show(widget);
1021     contents->WasShown();
1022   }
1023 }
1024
1025 void PanelGtk::DetachWebContents(content::WebContents* contents) {
1026   gfx::NativeView widget = contents->GetView()->GetNativeView();
1027   if (widget) {
1028     GtkWidget* parent = gtk_widget_get_parent(widget);
1029     if (parent) {
1030       DCHECK_EQ(parent, contents_expanded_);
1031       gtk_container_remove(GTK_CONTAINER(contents_expanded_), widget);
1032     }
1033   }
1034 }
1035
1036 gfx::Size PanelGtk::WindowSizeFromContentSize(
1037     const gfx::Size& content_size) const {
1038   gfx::Size& frame_size = GetFrameSize();
1039   return gfx::Size(content_size.width() + frame_size.width(),
1040                    content_size.height() + frame_size.height());
1041 }
1042
1043 gfx::Size PanelGtk::ContentSizeFromWindowSize(
1044     const gfx::Size& window_size) const {
1045   gfx::Size& frame_size = GetFrameSize();
1046   return gfx::Size(window_size.width() - frame_size.width(),
1047                    window_size.height() - frame_size.height());
1048 }
1049
1050 int PanelGtk::TitleOnlyHeight() const {
1051   gfx::Size& frame_size = GetFrameSize();
1052   if (!frame_size.IsEmpty())
1053     return panel::kTitlebarHeight;
1054
1055   NOTREACHED() << "Checking title height before window allocated";
1056   return 0;
1057 }
1058
1059 bool PanelGtk::IsPanelAlwaysOnTop() const {
1060   return always_on_top_;
1061 }
1062
1063 void PanelGtk::SetPanelAlwaysOnTop(bool on_top) {
1064   always_on_top_ = on_top;
1065
1066   gtk_window_set_keep_above(window_, on_top);
1067
1068   // Do not show an icon in the task bar for always-on-top windows.
1069   // Window operations such as close, minimize etc. can only be done
1070   // from the panel UI.
1071   gtk_window_set_skip_taskbar_hint(window_, on_top);
1072
1073   // Show always-on-top windows on all the virtual desktops.
1074   if (on_top)
1075     gtk_window_stick(window_);
1076   else
1077     gtk_window_unstick(window_);
1078 }
1079
1080 void PanelGtk::UpdatePanelMinimizeRestoreButtonVisibility() {
1081   titlebar_->UpdateMinimizeRestoreButtonVisibility();
1082 }
1083
1084 gfx::Size PanelGtk::GetNonClientFrameSize() const {
1085   GtkAllocation window_allocation;
1086   gtk_widget_get_allocation(window_container_, &window_allocation);
1087   GtkAllocation contents_allocation;
1088   gtk_widget_get_allocation(contents_expanded_, &contents_allocation);
1089   return gfx::Size(window_allocation.width - contents_allocation.width,
1090                    window_allocation.height - contents_allocation.height);
1091 }
1092
1093 void PanelGtk::InvalidateWindow() {
1094   GtkAllocation allocation;
1095   gtk_widget_get_allocation(GTK_WIDGET(window_), &allocation);
1096   gdk_window_invalidate_rect(gtk_widget_get_window(GTK_WIDGET(window_)),
1097                              &allocation, TRUE);
1098 }
1099
1100 // NativePanelTesting implementation.
1101 class GtkNativePanelTesting : public NativePanelTesting {
1102  public:
1103   explicit GtkNativePanelTesting(PanelGtk* panel_gtk);
1104
1105  private:
1106   virtual void PressLeftMouseButtonTitlebar(
1107       const gfx::Point& mouse_location, panel::ClickModifier modifier) OVERRIDE;
1108   virtual void ReleaseMouseButtonTitlebar(
1109       panel::ClickModifier modifier) OVERRIDE;
1110   virtual void DragTitlebar(const gfx::Point& mouse_location) OVERRIDE;
1111   virtual void CancelDragTitlebar() OVERRIDE;
1112   virtual void FinishDragTitlebar() OVERRIDE;
1113   virtual bool VerifyDrawingAttention() const OVERRIDE;
1114   virtual bool VerifyActiveState(bool is_active) OVERRIDE;
1115   virtual bool VerifyAppIcon() const OVERRIDE;
1116   virtual bool VerifySystemMinimizeState() const OVERRIDE;
1117   virtual bool IsWindowVisible() const OVERRIDE;
1118   virtual bool IsWindowSizeKnown() const OVERRIDE;
1119   virtual bool IsAnimatingBounds() const OVERRIDE;
1120   virtual bool IsButtonVisible(
1121       panel::TitlebarButtonType button_type) const OVERRIDE;
1122   virtual panel::CornerStyle GetWindowCornerStyle() const OVERRIDE;
1123   virtual bool EnsureApplicationRunOnForeground() OVERRIDE;
1124
1125   PanelGtk* panel_gtk_;
1126 };
1127
1128 NativePanelTesting* PanelGtk::CreateNativePanelTesting() {
1129   return new GtkNativePanelTesting(this);
1130 }
1131
1132 GtkNativePanelTesting::GtkNativePanelTesting(PanelGtk* panel_gtk)
1133     : panel_gtk_(panel_gtk) {
1134 }
1135
1136 void GtkNativePanelTesting::PressLeftMouseButtonTitlebar(
1137     const gfx::Point& mouse_location, panel::ClickModifier modifier) {
1138
1139   GdkEvent* event = gdk_event_new(GDK_BUTTON_PRESS);
1140   event->button.button = 1;
1141   event->button.x_root = mouse_location.x();
1142   event->button.y_root = mouse_location.y();
1143   if (modifier == panel::APPLY_TO_ALL)
1144     event->button.state |= GDK_CONTROL_MASK;
1145   panel_gtk_->OnTitlebarButtonPressEvent(
1146       NULL, reinterpret_cast<GdkEventButton*>(event));
1147   gdk_event_free(event);
1148   base::MessageLoopForUI::current()->RunUntilIdle();
1149 }
1150
1151 void GtkNativePanelTesting::ReleaseMouseButtonTitlebar(
1152     panel::ClickModifier modifier) {
1153   GdkEvent* event = gdk_event_new(GDK_BUTTON_RELEASE);
1154   event->button.button = 1;
1155   if (modifier == panel::APPLY_TO_ALL)
1156     event->button.state |= GDK_CONTROL_MASK;
1157   if (panel_gtk_->drag_helper_.get()) {
1158     panel_gtk_->drag_helper_->OnButtonReleaseEvent(
1159         NULL, reinterpret_cast<GdkEventButton*>(event));
1160   } else {
1161     panel_gtk_->OnTitlebarButtonReleaseEvent(
1162         NULL, reinterpret_cast<GdkEventButton*>(event));
1163   }
1164   gdk_event_free(event);
1165   base::MessageLoopForUI::current()->RunUntilIdle();
1166 }
1167
1168 void GtkNativePanelTesting::DragTitlebar(const gfx::Point& mouse_location) {
1169   if (!panel_gtk_->drag_helper_.get())
1170     return;
1171   GdkEvent* event = gdk_event_new(GDK_MOTION_NOTIFY);
1172   event->motion.x_root = mouse_location.x();
1173   event->motion.y_root = mouse_location.y();
1174   panel_gtk_->drag_helper_->OnMouseMoveEvent(
1175       NULL, reinterpret_cast<GdkEventMotion*>(event));
1176   gdk_event_free(event);
1177   base::MessageLoopForUI::current()->RunUntilIdle();
1178 }
1179
1180 void GtkNativePanelTesting::CancelDragTitlebar() {
1181   if (!panel_gtk_->drag_helper_.get())
1182     return;
1183   panel_gtk_->drag_helper_->OnGrabBrokenEvent(NULL, NULL);
1184   base::MessageLoopForUI::current()->RunUntilIdle();
1185 }
1186
1187 void GtkNativePanelTesting::FinishDragTitlebar() {
1188   if (!panel_gtk_->drag_helper_.get())
1189     return;
1190   ReleaseMouseButtonTitlebar(panel::NO_MODIFIER);
1191 }
1192
1193 bool GtkNativePanelTesting::VerifyDrawingAttention() const {
1194   return panel_gtk_->IsDrawingAttention();
1195 }
1196
1197 bool GtkNativePanelTesting::VerifyActiveState(bool is_active) {
1198   return gtk_window_is_active(panel_gtk_->GetNativePanelWindow()) == is_active;
1199 }
1200
1201 bool GtkNativePanelTesting::VerifyAppIcon() const {
1202   GdkPixbuf* icon = gtk_window_get_icon(panel_gtk_->GetNativePanelWindow());
1203   return icon &&
1204          gdk_pixbuf_get_width(icon) == panel::kPanelAppIconSize &&
1205          gdk_pixbuf_get_height(icon) == panel::kPanelAppIconSize;
1206 }
1207
1208 bool GtkNativePanelTesting::VerifySystemMinimizeState() const {
1209   // TODO(jianli): to be implemented.
1210   return true;
1211 }
1212
1213 bool GtkNativePanelTesting::IsWindowVisible() const {
1214   GdkWindow* gdk_window =
1215       gtk_widget_get_window(GTK_WIDGET(panel_gtk_->GetNativePanelWindow()));
1216   return GDK_IS_WINDOW(gdk_window) && gdk_window_is_visible(gdk_window);
1217 }
1218
1219 bool GtkNativePanelTesting::IsWindowSizeKnown() const {
1220   return !GetFrameSize().IsEmpty();
1221 }
1222
1223 bool GtkNativePanelTesting::IsAnimatingBounds() const {
1224   return false;
1225 }
1226
1227 bool GtkNativePanelTesting::IsButtonVisible(
1228     panel::TitlebarButtonType button_type) const {
1229   PanelTitlebarGtk* titlebar = panel_gtk_->titlebar();
1230   CustomDrawButton* button;
1231   switch (button_type) {
1232     case panel::CLOSE_BUTTON:
1233       button = titlebar->close_button();
1234       break;
1235     case panel::MINIMIZE_BUTTON:
1236       button = titlebar->minimize_button();
1237       break;
1238     case panel::RESTORE_BUTTON:
1239       button = titlebar->restore_button();
1240       break;
1241     default:
1242       NOTREACHED();
1243       return false;
1244   }
1245   return gtk_widget_get_visible(button->widget());
1246 }
1247
1248 panel::CornerStyle GtkNativePanelTesting::GetWindowCornerStyle() const {
1249   return panel_gtk_->corner_style_;
1250 }
1251
1252 bool GtkNativePanelTesting::EnsureApplicationRunOnForeground() {
1253   // Not needed on GTK.
1254   return true;
1255 }