Remove TOUCH_UI.

ui/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 "ui/views/widget/native_widget_gtk.h"
 
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 #include <X11/extensions/shape.h>
 #include <gdk/gdk.h>
@@ skipping 24 matching lines @@
 #include "ui/gfx/screen.h"
 #include "ui/views/bubble/bubble_delegate.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/ime/input_method_gtk.h"
 #include "views/controls/textfield/native_textfield_views.h"
 #include "views/views_delegate.h"
 #include "ui/views/widget/drop_target_gtk.h"
 #include "ui/views/widget/gtk_views_fixed.h"
 #include "ui/views/widget/gtk_views_window.h"
 #include "ui/views/widget/root_view.h"
+#include "ui/views/widget/tooltip_manager_gtk.h"
 #include "ui/views/widget/widget_delegate.h"
 
-#if defined(TOUCH_UI)
-#include "ui/base/touch/touch_factory.h"
-#include "ui/views/widget/tooltip_manager_views.h"
-#else
-#include "ui/views/widget/tooltip_manager_gtk.h"
-#endif
-
 #if defined(HAVE_IBUS)
 #include "ui/views/ime/input_method_ibus.h"
 #endif
 
 using ui::OSExchangeData;
 using ui::OSExchangeDataProviderGtk;
 using ui::ActiveWindowWatcherX;
 
 namespace views {
 
@@ skipping 192 matching lines @@
 // 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() {}
 
   static DropObserver* GetInstance() {
     return Singleton<DropObserver>::get();
   }
-#if defined(TOUCH_UI)
-  virtual base::EventStatus WillProcessEvent(
-      const base::NativeEvent& event) OVERRIDE {
-    return base::EVENT_CONTINUE;
-  }
 
-  virtual void DidProcessEvent(const base::NativeEvent& event) OVERRIDE {
-  }
-#else
   virtual void WillProcessEvent(GdkEvent* event) {
     if (event->type == GDK_DROP_START) {
       NativeWidgetGtk* widget = GetNativeWidgetGtkForEvent(event);
       if (widget)
         widget->ignore_drag_leave_ = true;
     }
   }
 
   virtual void DidProcessEvent(GdkEvent* event) {
   }
-#endif
 
  private:
   NativeWidgetGtk* GetNativeWidgetGtkForEvent(GdkEvent* event) {
     GtkWidget* gtk_widget = gtk_get_event_widget(event);
     if (!gtk_widget)
       return NULL;
 
     return static_cast<NativeWidgetGtk*>(
         internal::NativeWidgetPrivate::GetNativeWidgetForNativeView(
             gtk_widget));
@@ skipping 87 matching lines @@
       always_on_top_(false),
       is_double_buffered_(false),
       should_handle_menu_key_release_(false),
       dragged_view_(NULL),
       painted_(false),
       has_pointer_grab_(false),
       has_keyboard_grab_(false),
       grab_notify_signal_id_(0),
       is_menu_(false),
       signal_registrar_(new ui::GtkSignalRegistrar) {
-#if defined(TOUCH_UI)
-  // Make sure the touch factory is initialized so that it can setup XInput2 for
-  // the widget.
-  ui::TouchFactory::GetInstance();
-#endif
   static bool installed_message_loop_observer = false;
   if (!installed_message_loop_observer) {
     installed_message_loop_observer = true;
     MessageLoopForUI* loop = MessageLoopForUI::current();
     if (loop)
       loop->AddObserver(DropObserver::GetInstance());
   }
 }
 
 NativeWidgetGtk::~NativeWidgetGtk() {
@@ skipping 388 matching lines @@
   signal_registrar_->Connect(window_contents_, "drag_end",
                              G_CALLBACK(&OnDragEndThunk), this);
   signal_registrar_->Connect(window_contents_, "drag_failed",
                              G_CALLBACK(&OnDragFailedThunk), this);
   signal_registrar_->Connect(G_OBJECT(widget_), "window-state-event",
                              G_CALLBACK(&OnWindowStateEventThunk), this);
 
   ui::GObjectDestructorFILO::GetInstance()->Connect(
       G_OBJECT(widget_), &OnDestroyedThunk, this);
 
-#if defined(TOUCH_UI)
-  if (params.type != Widget::InitParams::TYPE_TOOLTIP) {
-    views::TooltipManagerViews* manager = new views::TooltipManagerViews(
-        static_cast<internal::RootView*>(GetWidget()->GetRootView()));
-    tooltip_manager_.reset(manager);
-  }
-#else
   tooltip_manager_.reset(new TooltipManagerGtk(this));
-#endif
 
   // Register for tooltips.
   g_object_set(G_OBJECT(window_contents_), "has-tooltip", TRUE, NULL);
   signal_registrar_->Connect(window_contents_, "query_tooltip",
                              G_CALLBACK(&OnQueryTooltipThunk), this);
 
   if (child_) {
     if (modified_params.parent)
       SetBounds(params.bounds);
   } else {
@@ skipping 119 matching lines @@
     GdkGrabStatus pointer_grab_status =
         gdk_pointer_grab(window_contents()->window, FALSE,
                          static_cast<GdkEventMask>(
                              GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
                              GDK_POINTER_MOTION_MASK),
                          NULL, NULL, GDK_CURRENT_TIME);
     // NOTE: technically grab may fail. We may want to try and continue on in
     // that case.
     DCHECK_EQ(GDK_GRAB_SUCCESS, pointer_grab_status);
     has_pointer_grab_ = pointer_grab_status == GDK_GRAB_SUCCESS;
-
-#if defined(TOUCH_UI)
-    ::Window window = GDK_WINDOW_XID(window_contents()->window);
-    Display* display = GDK_WINDOW_XDISPLAY(window_contents()->window);
-    bool xi2grab =
-        ui::TouchFactory::GetInstance()->GrabTouchDevices(display, window);
-    // xi2grab should always succeed if has_pointer_grab_ succeeded.
-    DCHECK(xi2grab);
-    has_pointer_grab_ = has_pointer_grab_ && xi2grab;
-#endif
   }
 }
 
 void NativeWidgetGtk::ReleaseMouseCapture() {
   bool delegate_lost_capture = HasMouseCapture();
   if (GTK_WIDGET_HAS_GRAB(window_contents_))
     gtk_grab_remove(window_contents_);
   if (grab_notify_signal_id_) {
     g_signal_handler_disconnect(window_contents_, grab_notify_signal_id_);
     grab_notify_signal_id_ = 0;
   }
   if (has_pointer_grab_) {
     has_pointer_grab_ = false;
     gdk_pointer_ungrab(GDK_CURRENT_TIME);
-#if defined(TOUCH_UI)
-    ui::TouchFactory::GetInstance()->UngrabTouchDevices(
-        GDK_WINDOW_XDISPLAY(window_contents()->window));
-#endif
   }
   if (delegate_lost_capture)
     delegate_->OnMouseCaptureLost();
 }
 
 bool NativeWidgetGtk::HasMouseCapture() const {
   return GTK_WIDGET_HAS_GRAB(window_contents_) || has_pointer_grab_;
 }
 
 InputMethod* NativeWidgetGtk::CreateInputMethod() {
@@ skipping 237 matching lines @@
 }
 
 void NativeWidgetGtk::SetAlwaysOnTop(bool on_top) {
   DCHECK(!child_);
   always_on_top_ = on_top;
   if (widget_)
     gtk_window_set_keep_above(GTK_WINDOW(widget_), on_top);
 }
 
 void NativeWidgetGtk::Maximize() {
-#if defined(TOUCH_UI)
-  // There may not be a window manager. So maximize ourselves: move to the
-  // top-left corner and resize to the entire bounds of the screen.
-  gfx::Rect screen = gfx::Screen::GetMonitorAreaNearestWindow(GetNativeView());
-  gtk_window_move(GTK_WINDOW(GetNativeWindow()), screen.x(), screen.y());
-  // TODO(backer): Remove this driver bug workaround once it is fixed.
-  gtk_window_resize(GTK_WINDOW(GetNativeWindow()),
-                    screen.width() - 1, screen.height());
-#else
   gtk_window_maximize(GetNativeWindow());
-#endif
 }
 
 void NativeWidgetGtk::Minimize() {
   gtk_window_iconify(GetNativeWindow());
 }
 
 bool NativeWidgetGtk::IsMaximized() const {
   return window_state_ & GDK_WINDOW_STATE_MAXIMIZED;
 }
 
@@ skipping 53 matching lines @@
   // 2) widget_ is not drawable (mapped and visible)
   // 3) If it's never painted before. The first expose event will
   // paint the area that has to be painted.
   if (widget_ && GTK_WIDGET_DRAWABLE(widget_) && painted_) {
     gtk_widget_queue_draw_area(widget_, rect.x(), rect.y(), rect.width(),
                                rect.height());
   }
 }
 
 void NativeWidgetGtk::SetCursor(gfx::NativeCursor cursor) {
-#if defined(TOUCH_UI)
-  if (!ui::TouchFactory::GetInstance()->is_cursor_visible())
-    cursor = gfx::GetCursor(GDK_BLANK_CURSOR);
-#endif
   // |window_contents_| is placed on top of |widget_|. So the cursor needs to be
   // set on |window_contents_| instead of |widget_|.
   if (window_contents_)
     gdk_window_set_cursor(window_contents_->window, cursor);
 }
 
 void NativeWidgetGtk::ClearNativeFocus() {
   DCHECK(!child_);
   if (!GetNativeView()) {
     NOTREACHED();
@@ skipping 372 matching lines @@
 
   // Returns true to prevent GtkWindow's default key event handler.
   return true;
 }
 
 gboolean NativeWidgetGtk::OnQueryTooltip(GtkWidget* widget,
                                          gint x,
                                          gint y,
                                          gboolean keyboard_mode,
                                          GtkTooltip* tooltip) {
-#if defined(TOUCH_UI)
-  return false; // Tell GTK not to draw tooltips as we draw tooltips in views
-#else
   return static_cast<TooltipManagerGtk*>(tooltip_manager_.get())->
       ShowTooltip(x, y, keyboard_mode, tooltip);
-#endif
 }
 
 gboolean NativeWidgetGtk::OnVisibilityNotify(GtkWidget* widget,
                                              GdkEventVisibility* event) {
   return false;
 }
 
 gboolean NativeWidgetGtk::OnGrabBrokeEvent(GtkWidget* widget, GdkEvent* event) {
   if (!has_pointer_grab_ && !has_keyboard_grab_) {
     // We don't have any grabs; don't attempt to do anything.
@@ skipping 14 matching lines @@
     // Mouse grab was broke.
     has_pointer_grab_ = false;
     if (has_keyboard_grab_) {
       has_keyboard_grab_ = false;
       gdk_keyboard_ungrab(GDK_CURRENT_TIME);
     }
     delegate_->OnMouseCaptureLost();
   }
   ReleaseMouseCapture();
 
-#if defined(TOUCH_UI)
-  ui::TouchFactory::GetInstance()->UngrabTouchDevices(
-      GDK_WINDOW_XDISPLAY(window_contents()->window));
-#endif
   return false;  // To let other widgets get the event.
 }
 
 void NativeWidgetGtk::OnGrabNotify(GtkWidget* widget, gboolean was_grabbed) {
   // Sent when gtk_grab_add changes.
   if (!window_contents_)
     return;  // Grab broke after window destroyed, don't try processing it.
   if (!was_grabbed)  // Indicates we've been shadowed (lost grab).
     HandleGtkGrabBroke();
 }
@@ skipping 17 matching lines @@
   delegate_->OnNativeWidgetDestroyed();
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete this;
 }
 
 void NativeWidgetGtk::OnShow(GtkWidget* widget) {
   delegate_->OnNativeWidgetVisibilityChanged(true);
 }
 
 void NativeWidgetGtk::OnMap(GtkWidget* widget) {
-#if defined(TOUCH_UI)
-  // Force an expose event to trigger OnPaint for touch. This is
-  // a workaround for a bug that X Expose event does not trigger
-  // Gdk's expose signal. This happens when you try to open views menu
-  // while a virtual keyboard gets kicked in or out. This seems to be
-  // a bug in message_pump_x.cc as we do get X Expose event but
-  // it doesn't trigger gtk's expose signal. We're not going to fix this
-  // as we're removing gtk and migrating to new compositor.
-  gdk_window_process_all_updates();
-#endif
 }
 
 void NativeWidgetGtk::OnHide(GtkWidget* widget) {
   delegate_->OnNativeWidgetVisibilityChanged(false);
 }
 
 gboolean NativeWidgetGtk::OnWindowStateEvent(GtkWidget* widget,
                                              GdkEventWindowState* event) {
   if (GetWidget()->non_client_view() &&
       !(event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN)) {
@@ skipping 474 matching lines @@
     button_pressed = event->type == GDK_BUTTON_PRESS ||
         event->type == GDK_2BUTTON_PRESS ||
         event->type == GDK_3BUTTON_PRESS;
     gdk_event_free(event);
   }
   return button_pressed;
 }
 
 }  // namespace internal
 }  // namespace views