Move last of event handlers down to NativeWidgetWin/Gtk.

views/widget/native_widget_gtk.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "views/widget/native_widget_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #include <X11/extensions/shape.h>
 #include <X11/Xatom.h>
@@ skipping 18 matching lines @@
 #include "views/controls/textfield/native_textfield_views.h"
 #include "views/focus/view_storage.h"
 #include "views/ime/input_method_gtk.h"
 #include "views/screen.h"
 #include "views/views_delegate.h"
 #include "views/widget/drop_target_gtk.h"
 #include "views/widget/gtk_views_fixed.h"
 #include "views/widget/gtk_views_window.h"
 #include "views/widget/tooltip_manager_gtk.h"
 #include "views/widget/widget_delegate.h"
+#include "views/window/hit_test.h"
 #include "views/window/native_window_gtk.h"
 
 #if defined(TOUCH_UI)
 #if defined(HAVE_XINPUT2)
 #include <gdk/gdkx.h>
 
 #include "ui/gfx/gtk_util.h"
 #include "views/touchui/touch_factory.h"
 #endif
 #endif
@@ skipping 124 matching lines @@
 
 void RemoveExposeHandlerIfExists(GtkWidget* widget) {
   gulong id = reinterpret_cast<gulong>(g_object_get_data(G_OBJECT(widget),
                                                          kExposeHandlerIdKey));
   if (id) {
     g_signal_handler_disconnect(G_OBJECT(widget), id);
     g_object_set_data(G_OBJECT(widget), kExposeHandlerIdKey, 0);
   }
 }
 
+// Converts a Windows-style hit test result code into a GDK window edge.
+GdkWindowEdge HitTestCodeToGDKWindowEdge(int hittest_code) {
+  switch (hittest_code) {
+    case HTBOTTOM:
+      return GDK_WINDOW_EDGE_SOUTH;
+    case HTBOTTOMLEFT:
+      return GDK_WINDOW_EDGE_SOUTH_WEST;
+    case HTBOTTOMRIGHT:
+    case HTGROWBOX:
+      return GDK_WINDOW_EDGE_SOUTH_EAST;
+    case HTLEFT:
+      return GDK_WINDOW_EDGE_WEST;
+    case HTRIGHT:
+      return GDK_WINDOW_EDGE_EAST;
+    case HTTOP:
+      return GDK_WINDOW_EDGE_NORTH;
+    case HTTOPLEFT:
+      return GDK_WINDOW_EDGE_NORTH_WEST;
+    case HTTOPRIGHT:
+      return GDK_WINDOW_EDGE_NORTH_EAST;
+    default:
+      NOTREACHED();
+      break;
+  }
+  // Default to something defaultish.
+  return HitTestCodeToGDKWindowEdge(HTGROWBOX);
+}
+
+// Converts a Windows-style hit test result code into a GDK cursor type.
+GdkCursorType HitTestCodeToGdkCursorType(int hittest_code) {
+  switch (hittest_code) {
+    case HTBOTTOM:
+      return GDK_BOTTOM_SIDE;
+    case HTBOTTOMLEFT:
+      return GDK_BOTTOM_LEFT_CORNER;
+    case HTBOTTOMRIGHT:
+    case HTGROWBOX:
+      return GDK_BOTTOM_RIGHT_CORNER;
+    case HTLEFT:
+      return GDK_LEFT_SIDE;
+    case HTRIGHT:
+      return GDK_RIGHT_SIDE;
+    case HTTOP:
+      return GDK_TOP_SIDE;
+    case HTTOPLEFT:
+      return GDK_TOP_LEFT_CORNER;
+    case HTTOPRIGHT:
+      return GDK_TOP_RIGHT_CORNER;
+    default:
+      break;
+  }
+  // Default to something defaultish.
+  return GDK_LEFT_PTR;
+}
+
 }  // namespace
 
 // During drag and drop GTK sends a drag-leave during a drop. This means we
 // have no way to tell the difference between a normal drag leave and a drop.
 // To work around that we listen for DROP_START, then ignore the subsequent
 // drag-leave that GTK generates.
 class NativeWidgetGtk::DropObserver : public MessageLoopForUI::Observer {
  public:
   DropObserver() {}
 
@@ skipping 490 matching lines @@
   g_signal_connect(widget_, "focus_out_event",
                    G_CALLBACK(&OnFocusOutThunk), this);
   g_signal_connect(widget_, "destroy",
                    G_CALLBACK(&OnDestroyThunk), this);
   g_signal_connect(widget_, "show",
                    G_CALLBACK(&OnShowThunk), this);
   g_signal_connect(widget_, "map",
                    G_CALLBACK(&OnMapThunk), this);
   g_signal_connect(widget_, "hide",
                    G_CALLBACK(&OnHideThunk), this);
+  g_signal_connect(G_OBJECT(widget_), "configure-event",
+                   G_CALLBACK(&OnConfigureEventThunk), this);
 
   // Views/FocusManager (re)sets the focus to the root window,
   // so we need to connect signal handlers to the gtk window.
   // See views::Views::Focus and views::FocusManager::ClearNativeFocus
   // for more details.
   g_signal_connect(widget_, "key_press_event",
                    G_CALLBACK(&OnEventKeyThunk), this);
   g_signal_connect(widget_, "key_release_event",
                    G_CALLBACK(&OnEventKeyThunk), this);
 
@@ skipping 192 matching lines @@
 
 void NativeWidgetGtk::SetAccessibleName(const std::wstring& name) {
 }
 
 void NativeWidgetGtk::SetAccessibleRole(ui::AccessibilityTypes::Role role) {
 }
 
 void NativeWidgetGtk::SetAccessibleState(ui::AccessibilityTypes::State state) {
 }
 
+void NativeWidgetGtk::BecomeModal() {
+  gtk_window_set_modal(GetNativeWindow(), true);
+}
+
 gfx::Rect NativeWidgetGtk::GetWindowScreenBounds() const {
   // Client == Window bounds on Gtk.
   return GetClientAreaScreenBounds();
 }
 
 gfx::Rect NativeWidgetGtk::GetClientAreaScreenBounds() const {
   // Due to timing we can get a request for bounds after Close().
   // TODO(beng): Figure out if this is bogus.
   if (!widget_)
     return gfx::Rect(size_);
@@ skipping 273 matching lines @@
                                      GtkAllocation* allocation) {
   // See comment next to size_ as to why we do this. Also note, it's tempting
   // to put this in the static method so subclasses don't need to worry about
   // it, but if a subclasses needs to set a shape then they need to always
   // reset the shape in this method regardless of whether the size changed.
   gfx::Size new_size(allocation->width, allocation->height);
   if (new_size == size_)
     return;
   size_ = new_size;
   delegate_->OnNativeWidgetSizeChanged(size_);
+
+  if (GetWidget()->non_client_view()) {
+    // The Window's NonClientView may provide a custom shape for the Window.
+    gfx::Path window_mask;
+    GetWidget()->non_client_view()->GetWindowMask(gfx::Size(allocation->width,
+                                                            allocation->height),
+                                                  &window_mask);
+    GdkRegion* mask_region = window_mask.CreateNativeRegion();
+    gdk_window_shape_combine_region(GetNativeView()->window, mask_region, 0, 0);
+    if (mask_region)
+      gdk_region_destroy(mask_region);
+
+    SaveWindowPosition();
+  }
 }
 
 gboolean NativeWidgetGtk::OnPaint(GtkWidget* widget, GdkEventExpose* event) {
   if (transparent_ && child_) {
     // Clear the background before drawing any view and native components.
     DrawTransparentBackground(widget, event);
     if (!CompositePainter::IsComposited(widget_) &&
         gdk_screen_is_composited(gdk_screen_get_default())) {
       // Let the parent draw the content only after something is drawn on
       // the widget.
@@ skipping 122 matching lines @@
     motion.state &= ~(GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK);
 
     MouseEvent mouse_event(TransformEvent(&motion));
     delegate_->OnMouseEvent(mouse_event);
   }
   return false;
 }
 
 gboolean NativeWidgetGtk::OnLeaveNotify(GtkWidget* widget,
                                         GdkEventCrossing* event) {
+  gdk_window_set_cursor(widget->window, gfx::GetCursor(GDK_LEFT_PTR));
+
   GetWidget()->ResetLastMouseMoveFlag();
 
   if (!HasMouseCapture() && !GetWidget()->is_mouse_button_pressed_) {
     MouseEvent mouse_event(TransformEvent(event));
     delegate_->OnMouseEvent(mouse_event);
   }
   return false;
 }
 
 gboolean NativeWidgetGtk::OnMotionNotify(GtkWidget* widget,
                                          GdkEventMotion* event) {
+  if (GetWidget()->non_client_view()) {
+    GdkEventMotion transformed_event = *event;
+    TransformEvent(&transformed_event);
+    gfx::Point translated_location(transformed_event.x, transformed_event.y);
+
+    // Update the cursor for the screen edge.
+    int hittest_code =
+        GetWindow()->non_client_view()->NonClientHitTest(translated_location);
+    if (hittest_code != HTCLIENT) {
+      GdkCursorType cursor_type = HitTestCodeToGdkCursorType(hittest_code);
+      gdk_window_set_cursor(widget->window, gfx::GetCursor(cursor_type));
+    }
+  }
+
   MouseEvent mouse_event(TransformEvent(event));
   delegate_->OnMouseEvent(mouse_event);
   return true;
 }
 
 gboolean NativeWidgetGtk::OnButtonPress(GtkWidget* widget,
                                         GdkEventButton* event) {
+  if (GetWidget()->non_client_view()) {
+    GdkEventButton transformed_event = *event;
+    MouseEvent mouse_event(TransformEvent(&transformed_event));
+
+    int hittest_code = GetWidget()->non_client_view()->NonClientHitTest(
+        mouse_event.location());
+    switch (hittest_code) {
+      case HTCAPTION: {
+        // Start dragging if the mouse event is a single click and *not* a right
+        // click. If it is a right click, then pass it through to
+        // NativeWidgetGtk::OnButtonPress so that View class can show
+        // ContextMenu upon a mouse release event. We only start drag on single
+        // clicks as we get a crash in Gtk on double/triple clicks.
+        if (event->type == GDK_BUTTON_PRESS &&
+            !mouse_event.IsOnlyRightMouseButton()) {
+          gfx::Point screen_point(event->x, event->y);
+          View::ConvertPointToScreen(GetWidget()->GetRootView(), &screen_point);
+          gtk_window_begin_move_drag(GetNativeWindow(), event->button,
+                                     screen_point.x(), screen_point.y(),
+                                     event->time);
+          return TRUE;
+        }
+        break;
+      }
+      case HTBOTTOM:
+      case HTBOTTOMLEFT:
+      case HTBOTTOMRIGHT:
+      case HTGROWBOX:
+      case HTLEFT:
+      case HTRIGHT:
+      case HTTOP:
+      case HTTOPLEFT:
+      case HTTOPRIGHT: {
+        gfx::Point screen_point(event->x, event->y);
+        View::ConvertPointToScreen(GetWidget()->GetRootView(), &screen_point);
+        // TODO(beng): figure out how to get a good minimum size.
+        gtk_widget_set_size_request(GetNativeView(), 100, 100);
+        gtk_window_begin_resize_drag(GetNativeWindow(),
+                                     HitTestCodeToGDKWindowEdge(hittest_code),
+                                     event->button, screen_point.x(),
+                                     screen_point.y(), event->time);
+        return TRUE;
+      }
+      default:
+        // Everything else falls into standard client event handling...
+        break;
+    }
+  }
+
   if (event->type == GDK_2BUTTON_PRESS || event->type == GDK_3BUTTON_PRESS) {
     // The sequence for double clicks is press, release, press, 2press, release.
     // This means that at the time we get the second 'press' we don't know
     // whether it corresponds to a double click or not. For now we're completely
     // ignoring the 2press/3press events as they are duplicate. To make this
     // work right we need to write our own code that detects if the press is a
     // double/triple. For now we're completely punting, which means we always
     // get single clicks.
     // TODO: fix this.
     return true;
@@ skipping 121 matching lines @@
   // as we're removing gtk and migrating to new compositor.
   gdk_window_process_all_updates();
 #endif
 }
 
 void NativeWidgetGtk::OnHide(GtkWidget* widget) {
 }
 
 gboolean NativeWidgetGtk::OnWindowStateEvent(GtkWidget* widget,
                                              GdkEventWindowState* event) {
+  if (GetWidget()->non_client_view() &&
+      !(event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN)) {
+    SaveWindowPosition();
+  }
   window_state_ = event->new_window_state;
   return FALSE;
 }
 
+gboolean NativeWidgetGtk::OnConfigureEvent(GtkWidget* widget) {
+  SaveWindowPosition();
+  return FALSE;
+}
+
 void NativeWidgetGtk::HandleXGrabBroke() {
 }
 
 void NativeWidgetGtk::HandleGtkGrabBroke() {
   delegate_->OnMouseCaptureLost();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetGtk, private:
 
@@ skipping 277 matching lines @@
 
 void NativeWidgetGtk::DrawTransparentBackground(GtkWidget* widget,
                                                 GdkEventExpose* event) {
   cairo_t* cr = gdk_cairo_create(widget->window);
   cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
   gdk_cairo_region(cr, event->region);
   cairo_fill(cr);
   cairo_destroy(cr);
 }
 
+void NativeWindowGtk::SaveWindowPosition() {
+  // The delegate may have gone away on us.
+  if (!GetWidget()->widget_delegate())
+    return;
+
+  bool maximized = window_state_ & GDK_WINDOW_STATE_MAXIMIZED;
+  GetWidget()->widget_delegate()->SaveWindowPlacement(
+      GetWidget()->GetWindowScreenBounds(),
+      maximized);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, public:
 
 // static
 void Widget::NotifyLocaleChanged() {
   GList *window_list = gtk_window_list_toplevels();
   for (GList* element = window_list; element; element = g_list_next(element)) {
     NativeWidget* native_widget =
         NativeWidget::GetNativeWidgetForNativeWindow(GTK_WINDOW(element->data));
     if (native_widget)
@@ skipping 135 matching lines @@
 
   // And now, notify them that they have a brand new parent.
   for (NativeWidgets::iterator it = widgets.begin();
        it != widgets.end(); ++it) {
     (*it)->GetWidget()->NotifyNativeViewHierarchyChanged(true,
                                                          new_parent);
   }
 }
 
 }  // namespace views