Re-land:

views/widget/widget_gtk.h

 // 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.
 
 #ifndef VIEWS_WIDGET_WIDGET_GTK_H_
 #define VIEWS_WIDGET_WIDGET_GTK_H_
 #pragma once
 
 #include <gtk/gtk.h>
 
@@ skipping 23 matching lines @@
 class InputMethod;
 class TooltipManagerGtk;
 class View;
 class WindowGtk;
 
 namespace internal {
 class NativeWidgetDelegate;
 }
 
 // Widget implementation for GTK.
-class WidgetGtk : public Widget,
-                  public NativeWidget,
+class WidgetGtk : public NativeWidget,
                   public ui::ActiveWindowWatcherX::Observer,
                   public internal::InputMethodDelegate {
  public:
-  WidgetGtk();
+  explicit WidgetGtk(internal::NativeWidgetDelegate* delegate);
   virtual ~WidgetGtk();
 
-  // Marks this window as transient to its parent. A window that is transient
-  // to its parent results in the parent rendering active when the child is
-  // active.
-  // This must be invoked before Init. This is only used for types other than
-  // TYPE_CHILD. The default is false.
-  // See gtk_window_set_transient_for for details.
-  void make_transient_to_parent() {
-    DCHECK(!widget_);
-    transient_to_parent_ = true;
-  }
-
   // Returns the transient parent. See make_transient_to_parent for details on
   // what the transient parent is.
   GtkWindow* GetTransientParent() const;
 
   // Makes the background of the window totally transparent. This must be
   // invoked before Init. This does a couple of checks and returns true if
   // the window can be made transparent. The actual work of making the window
   // transparent is done by ConfigureWidgetForTransparentBackground.
   // This works for both child and window types.
   bool MakeTransparent();
@@ skipping 43 matching lines @@
   void ResetDropTarget();
 
   // Gets the requested size of the widget.  This can be the size
   // stored in properties for a GtkViewsFixed, or in the requisitioned
   // size of other kinds of widgets.
   void GetRequestedSize(gfx::Size* out) const;
 
   // Overridden from ui::ActiveWindowWatcherX::Observer.
   virtual void ActiveWindowChanged(GdkWindow* active_window);
 
-  // Overridden from Widget:
-  virtual gfx::NativeView GetNativeView() const;
-  virtual gfx::NativeWindow GetNativeWindow() const;
-  virtual bool GetAccelerator(int cmd_id, ui::Accelerator* accelerator);
-  virtual Window* GetWindow();
-  virtual const Window* GetWindow() const;
-  virtual void ViewHierarchyChanged(bool is_add, View *parent,
-                                    View *child);
-  virtual void NotifyAccessibilityEvent(
-      View* view,
-      ui::AccessibilityTypes::Event event_type,
-      bool send_native_event);
-
   // Clears the focus on the native widget having the focus.
   virtual void ClearNativeFocus();
 
   // Handles a keyboard event by sending it to our focus manager.
   // Returns true if it's handled by the focus manager.
   bool HandleKeyboardEvent(const KeyEvent& key);
 
   // Enables debug painting. See |debug_paint_enabled_| for details.
   static void EnableDebugPaint();
 
@@ skipping 12 matching lines @@
   // If you are adding a GtkWidget with its own GdkWindow that may
   // fill the entire area of the WidgetGtk to the view hierachy, you
   // need use this function to tell WM that when the widget is ready
   // to be shown.
   // Caller of this method do not need to disconnect this because the
   // handler will be removed upon the first invocation of the handler,
   // or when the widget is re-attached, and expose won't be emitted on
   // detached widget.
   static void RegisterChildExposeHandler(GtkWidget* widget);
 
+  void set_focus_on_creation(bool focus_on_creation) {
+    focus_on_creation_ = focus_on_creation;
+  }
+
   // Overridden from NativeWidget:
-  virtual void InitNativeWidget(const InitParams& params) OVERRIDE;
+  virtual void InitNativeWidget(const Widget::InitParams& params) OVERRIDE;
   virtual Widget* GetWidget() OVERRIDE;
+  virtual const Widget* GetWidget() const OVERRIDE;
+  virtual gfx::NativeView GetNativeView() const OVERRIDE;
+  virtual gfx::NativeWindow GetNativeWindow() const OVERRIDE;
+  virtual Window* GetContainingWindow() OVERRIDE;
+  virtual const Window* GetContainingWindow() const OVERRIDE;
+  virtual void ViewRemoved(View* view) OVERRIDE;
   virtual void SetNativeWindowProperty(const char* name, void* value) OVERRIDE;
   virtual void* GetNativeWindowProperty(const char* name) OVERRIDE;
   virtual TooltipManager* GetTooltipManager() const OVERRIDE;
   virtual bool IsScreenReaderActive() const OVERRIDE;
+  virtual void SendNativeAccessibilityEvent(
+      View* view,
+      ui::AccessibilityTypes::Event event_type) OVERRIDE;
   virtual void SetMouseCapture() OVERRIDE;
   virtual void ReleaseMouseCapture() OVERRIDE;
   virtual bool HasMouseCapture() const OVERRIDE;
+  virtual bool IsMouseButtonDown() const OVERRIDE;
   virtual InputMethod* GetInputMethodNative() OVERRIDE;
   virtual void ReplaceInputMethod(InputMethod* input_method) OVERRIDE;
   virtual gfx::Rect GetWindowScreenBounds() const OVERRIDE;
   virtual gfx::Rect GetClientAreaScreenBounds() const OVERRIDE;
   virtual void SetBounds(const gfx::Rect& bounds) OVERRIDE;
   virtual void SetSize(const gfx::Size& size) OVERRIDE;
   virtual void MoveAbove(gfx::NativeView native_view) OVERRIDE;
   virtual void SetShape(gfx::NativeRegion shape) OVERRIDE;
   virtual void Close() OVERRIDE;
   virtual void CloseNow() OVERRIDE;
@@ skipping 70 matching lines @@
   // when a window holding grab is closed without releasing grab.
   virtual void HandleXGrabBroke();
 
   // Are we a subclass of WindowGtk?
   bool is_window_;
 
  private:
   class DropObserver;
   friend class DropObserver;
 
-  // Overridden from Widget
-  virtual RootView* CreateRootView() OVERRIDE;
-
   // Overridden from NativeWidget
   virtual gfx::AcceleratedWidget GetAcceleratedWidget() OVERRIDE;
 
   // Overridden from internal::InputMethodDelegate
   virtual void DispatchKeyEventPostIME(const KeyEvent& key) OVERRIDE;
 
-  void SetInitParams(const InitParams& params);
+  void SetInitParams(const Widget::InitParams& params);
 
   // This is called only when the window is transparent.
   CHROMEGTK_CALLBACK_1(WidgetGtk, gboolean, OnWindowPaint, GdkEventExpose*);
 
   // Callbacks for expose event on child widgets. See the description of
   // RegisterChildChildExposeHandler.
   void OnChildExpose(GtkWidget* child);
   static gboolean ChildExposeHandler(GtkWidget* widget, GdkEventExpose* event);
 
   // Returns the first ancestor of |widget| that is a window.
   static Window* GetWindowImpl(GtkWidget* widget);
 
   // Creates the GtkWidget.
-  void CreateGtkWidget(const InitParams& params);
+  void CreateGtkWidget(const Widget::InitParams& params);
 
   // Invoked from create widget to enable the various bits needed for a
   // transparent background. This is only invoked if MakeTransparent has been
   // invoked.
   void ConfigureWidgetForTransparentBackground(GtkWidget* parent);
 
   // Invoked from create widget to enable the various bits needed for a
   // window which doesn't receive events.
   void ConfigureWidgetForIgnoreEvents();
 
   // A utility function to draw a transparent background onto the |widget|.
   static void DrawTransparentBackground(GtkWidget* widget,
                                         GdkEventExpose* event);
 
   // A delegate implementation that handles events received here.
+  // See class documentation for Widget in widget.h for a note about ownership.
   internal::NativeWidgetDelegate* delegate_;
 
   // Our native views. If we're a window/popup, then widget_ is the window and
   // window_contents_ is a GtkFixed. If we're not a window/popup, then widget_
   // and window_contents_ point to the same GtkFixed.
   GtkWidget* widget_;
   GtkWidget* window_contents_;
 
   // Child GtkWidgets created with no parent need to be parented to a valid top
   // level window otherwise Gtk throws a fit. |null_parent_| is an invisible
   // popup that such GtkWidgets are parented to.
   static GtkWidget* null_parent_;
 
   // True if the widget is a child of some other widget.
   bool child_;
 
   // The TooltipManager.
   // WARNING: RootView's destructor calls into the TooltipManager. As such, this
   // must be destroyed AFTER root_view_.
   scoped_ptr<TooltipManagerGtk> tooltip_manager_;
 
   scoped_ptr<DropTargetGtk> drop_target_;
 
   // The following factory is used to delay destruction.
   ScopedRunnableMethodFactory<WidgetGtk> close_widget_factory_;
 
-  // See description above setter.
+  // See class documentation for Widget in widget.h for a note about ownership.
   bool delete_on_destroy_;
 
   // See description above make_transparent for details.
   bool transparent_;
 
   // Makes the window pass all events through to any windows behind it.
   // Set during SetInitParams before the widget is created. The actual work of
   // making the window ignore events is done by ConfigureWidgetForIgnoreEvents.
   bool ignore_events_;
 
@@ skipping 31 matching lines @@
   // request focus on some widget. Because of async events on Gtk this becomes
   // show, request focus, get focus in event which ends up clearing focus
   // (first request to FocusManager::RestoreFocusedView ends up clearing focus).
   bool got_initial_focus_in_;
 
   // If true, we've received a focus-in event. If false we've received a
   // focus-out event. We can get multiple focus-out events in a row, we use
   // this to determine whether we should process the event.
   bool has_focus_;
 
+  // Whether we should SetFocus() on a newly created window after
+  // Init(). Defaults to true.
+  bool focus_on_creation_;
+
   // If true, the window stays on top of the screen. This is only used
   // for types other than TYPE_CHILD.
   bool always_on_top_;
 
   // If true, we enable the content widget's double buffering.
   // This is false by default.
   bool is_double_buffered_;
 
   // Indicates if we should handle the upcoming Alt key release event.
   bool should_handle_menu_key_release_;
 
   // Valid for the lifetime of StartDragForViewFromMouseEvent, indicates the
   // view the drag started from.
   View* dragged_view_;
 
   // If the widget has ever been painted. This is used to guarantee
   // that window manager shows the window only after the window is painted.
   bool painted_;
 
   scoped_ptr<InputMethod> input_method_;
 
   DISALLOW_COPY_AND_ASSIGN(WidgetGtk);
 };
 
 }  // namespace views
 
 #endif  // VIEWS_WIDGET_WIDGET_GTK_H_