Home | History | Annotate | Download | only in renderer_host 
      1 // Copyright (c) 2011 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 #ifndef CHROME_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_GTK_H_
      6 #define CHROME_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_GTK_H_
      7 #pragma once
      8 
      9 #include <gdk/gdk.h>
     10 
     11 #include <string>
     12 #include <vector>
     13 
     14 #include "base/memory/scoped_ptr.h"
     15 #include "base/time.h"
     16 #include "chrome/browser/ui/gtk/owned_widget_gtk.h"
     17 #include "content/browser/renderer_host/render_widget_host_view.h"
     18 #include "ui/base/animation/animation_delegate.h"
     19 #include "ui/base/animation/slide_animation.h"
     20 #include "ui/base/gtk/gtk_signal.h"
     21 #include "ui/gfx/native_widget_types.h"
     22 #include "ui/gfx/rect.h"
     23 #include "webkit/glue/webcursor.h"
     24 #include "webkit/plugins/npapi/gtk_plugin_container_manager.h"
     25 
     26 class RenderWidgetHost;
     27 class GtkIMContextWrapper;
     28 class GtkKeyBindingsHandler;
     29 #if !defined(TOOLKIT_VIEWS)
     30 class MenuGtk;
     31 #endif
     32 struct NativeWebKeyboardEvent;
     33 
     34 #if defined(OS_CHROMEOS)
     35 namespace views {
     36 class TooltipWindowGtk;
     37 }
     38 #endif  // defined(OS_CHROMEOS)
     39 
     40 typedef struct _GtkClipboard GtkClipboard;
     41 typedef struct _GtkSelectionData GtkSelectionData;
     42 
     43 // -----------------------------------------------------------------------------
     44 // See comments in render_widget_host_view.h about this class and its members.
     45 // -----------------------------------------------------------------------------
     46 class RenderWidgetHostViewGtk : public RenderWidgetHostView,
     47                                 public ui::AnimationDelegate {
     48  public:
     49   explicit RenderWidgetHostViewGtk(RenderWidgetHost* widget);
     50   ~RenderWidgetHostViewGtk();
     51 
     52   // Initialize this object for use as a drawing area.
     53   void InitAsChild();
     54 
     55   // RenderWidgetHostView implementation.
     56   virtual void InitAsPopup(RenderWidgetHostView* parent_host_view,
     57                            const gfx::Rect& pos);
     58   virtual void InitAsFullscreen();
     59   virtual RenderWidgetHost* GetRenderWidgetHost() const;
     60   virtual void DidBecomeSelected();
     61   virtual void WasHidden();
     62   virtual void SetSize(const gfx::Size& size);
     63   virtual void SetBounds(const gfx::Rect& rect);
     64   virtual gfx::NativeView GetNativeView();
     65   virtual void MovePluginWindows(
     66       const std::vector<webkit::npapi::WebPluginGeometry>& moves);
     67   virtual void Focus();
     68   virtual void Blur();
     69   virtual bool HasFocus();
     70   virtual void Show();
     71   virtual void Hide();
     72   virtual bool IsShowing();
     73   virtual gfx::Rect GetViewBounds() const;
     74   virtual void UpdateCursor(const WebCursor& cursor);
     75   virtual void SetIsLoading(bool is_loading);
     76   virtual void ImeUpdateTextInputState(WebKit::WebTextInputType type,
     77                                        const gfx::Rect& caret_rect);
     78   virtual void ImeCancelComposition();
     79   virtual void DidUpdateBackingStore(
     80       const gfx::Rect& scroll_rect, int scroll_dx, int scroll_dy,
     81       const std::vector<gfx::Rect>& copy_rects);
     82   virtual void RenderViewGone(base::TerminationStatus status,
     83                               int error_code);
     84   virtual void Destroy();
     85   virtual void WillDestroyRenderWidget(RenderWidgetHost* rwh) {}
     86   virtual void SetTooltipText(const std::wstring& tooltip_text);
     87   virtual void SelectionChanged(const std::string& text);
     88   virtual void ShowingContextMenu(bool showing);
     89   virtual BackingStore* AllocBackingStore(const gfx::Size& size);
     90   virtual void SetBackground(const SkBitmap& background);
     91   virtual void CreatePluginContainer(gfx::PluginWindowHandle id);
     92   virtual void DestroyPluginContainer(gfx::PluginWindowHandle id);
     93   virtual void SetVisuallyDeemphasized(const SkColor* color, bool animate);
     94   virtual bool ContainsNativeView(gfx::NativeView native_view) const;
     95 
     96   virtual void AcceleratedCompositingActivated(bool activated);
     97   virtual gfx::PluginWindowHandle GetCompositingSurface();
     98 
     99   // ui::AnimationDelegate implementation.
    100   virtual void AnimationEnded(const ui::Animation* animation);
    101   virtual void AnimationProgressed(const ui::Animation* animation);
    102   virtual void AnimationCanceled(const ui::Animation* animation);
    103 
    104   gfx::NativeView native_view() const { return view_.get(); }
    105 
    106   // If the widget is aligned with an edge of the monitor its on and the user
    107   // attempts to drag past that edge we track the number of times it has
    108   // occurred, so that we can force the widget to scroll when it otherwise
    109   // would be unable to.
    110   void ModifyEventForEdgeDragging(GtkWidget* widget, GdkEventMotion* event);
    111   void Paint(const gfx::Rect&);
    112 
    113   // Called by GtkIMContextWrapper to forward a keyboard event to renderer.
    114   // Before calling RenderWidgetHost::ForwardKeyboardEvent(), this method
    115   // calls GtkKeyBindingsHandler::Match() against the event and send matched
    116   // edit commands to renderer by calling
    117   // RenderWidgetHost::ForwardEditCommandsForNextKeyEvent().
    118   void ForwardKeyboardEvent(const NativeWebKeyboardEvent& event);
    119 
    120   GdkEventButton* last_mouse_down() const {
    121     return last_mouse_down_;
    122   }
    123 
    124 #if !defined(TOOLKIT_VIEWS)
    125   // Appends the input methods context menu to the specified |menu| object as a
    126   // submenu.
    127   void AppendInputMethodsContextMenu(MenuGtk* menu);
    128 #endif
    129 
    130  private:
    131   friend class RenderWidgetHostViewGtkWidget;
    132 
    133   CHROMEGTK_CALLBACK_1(RenderWidgetHostViewGtk,
    134                        gboolean,
    135                        OnWindowStateEvent,
    136                        GdkEventWindowState*);
    137 
    138   CHROMEGTK_CALLBACK_0(RenderWidgetHostViewGtk,
    139                        void,
    140                        OnDestroy);
    141 
    142   // Returns whether the widget needs an input grab (GTK+ and X) to work
    143   // properly.
    144   bool NeedsInputGrab();
    145 
    146   // Returns whether this render view is a popup (<select> dropdown or
    147   // autocomplete window).
    148   bool IsPopup() const;
    149 
    150   // Do initialization needed by all InitAs*() methods.
    151   void DoSharedInit();
    152 
    153   // Do initialization needed just by InitAsPopup() and InitAsFullscreen().
    154   // We move and resize |window| to |bounds| and show it and its contents.
    155   void DoPopupOrFullscreenInit(GtkWindow* window, const gfx::Rect& bounds);
    156 
    157   // Update the display cursor for the render view.
    158   void ShowCurrentCursor();
    159 
    160   void set_last_mouse_down(GdkEventButton* event);
    161 
    162   // The model object.
    163   RenderWidgetHost* host_;
    164 
    165   // The native UI widget.
    166   OwnedWidgetGtk view_;
    167 
    168   // This is true when we are currently painting and thus should handle extra
    169   // paint requests by expanding the invalid rect rather than actually
    170   // painting.
    171   bool about_to_validate_and_paint_;
    172 
    173   // This is the rectangle which we'll paint.
    174   gfx::Rect invalid_rect_;
    175 
    176   // Whether or not this widget is hidden.
    177   bool is_hidden_;
    178 
    179   // Whether we are currently loading.
    180   bool is_loading_;
    181 
    182   // The cursor for the page. This is passed up from the renderer.
    183   WebCursor current_cursor_;
    184 
    185   // Whether we are showing a context menu.
    186   bool is_showing_context_menu_;
    187 
    188   // The time at which this view started displaying white pixels as a result of
    189   // not having anything to paint (empty backing store from renderer). This
    190   // value returns true for is_null() if we are not recording whiteout times.
    191   base::TimeTicks whiteout_start_time_;
    192 
    193   // The time it took after this view was selected for it to be fully painted.
    194   base::TimeTicks tab_switch_paint_time_;
    195 
    196   // A color we use to shade the entire render view. If 100% transparent, we do
    197   // not shade the render view.
    198   SkColor overlay_color_;
    199 
    200   // The animation used for the abovementioned shade effect. The animation's
    201   // value affects the alpha we use for |overlay_color_|.
    202   ui::SlideAnimation overlay_animation_;
    203 
    204   // The native view of our parent widget.  Used only for popups.
    205   GtkWidget* parent_;
    206 
    207   // We ignore the first mouse release on popups so the popup will remain open.
    208   bool is_popup_first_mouse_release_;
    209 
    210   // Whether or not this widget was focused before shadowed by another widget.
    211   // Used in OnGrabNotify() handler to track the focused state correctly.
    212   bool was_focused_before_grab_;
    213 
    214   // True if we are responsible for creating an X grab. This will only be used
    215   // for <select> dropdowns. It should be true for most such cases, but false
    216   // for extension popups.
    217   bool do_x_grab_;
    218 
    219   // Is the widget fullscreen?
    220   bool is_fullscreen_;
    221 
    222   // For full-screen windows we have a OnDestroy handler that we need to remove,
    223   // so we keep it ID here.
    224   unsigned long destroy_handler_id_;
    225 
    226   // A convenience wrapper object for GtkIMContext;
    227   scoped_ptr<GtkIMContextWrapper> im_context_;
    228 
    229   // A convenience object for handling editor key bindings defined in gtk
    230   // keyboard theme.
    231   scoped_ptr<GtkKeyBindingsHandler> key_bindings_handler_;
    232 
    233   // Helper class that lets us allocate plugin containers and move them.
    234   webkit::npapi::GtkPluginContainerManager plugin_container_manager_;
    235 
    236   // The size that we want the renderer to be.  We keep this in a separate
    237   // variable because resizing in GTK+ is async.
    238   gfx::Size requested_size_;
    239 
    240   // The number of times the user has dragged against horizontal edge  of the
    241   // monitor (if the widget is aligned with that edge). Negative values
    242   // indicate the left edge, positive the right.
    243   int dragged_at_horizontal_edge_;
    244 
    245   // The number of times the user has dragged against vertical edge  of the
    246   // monitor (if the widget is aligned with that edge). Negative values
    247   // indicate the top edge, positive the bottom.
    248   int dragged_at_vertical_edge_;
    249 
    250   gfx::PluginWindowHandle compositing_surface_;
    251 
    252   // The event for the last mouse down we handled. We need this for context
    253   // menus and drags.
    254   GdkEventButton* last_mouse_down_;
    255 
    256 #if defined(OS_CHROMEOS)
    257   // Custimized tooltip window.
    258   scoped_ptr<views::TooltipWindowGtk> tooltip_window_;
    259 #endif  // defined(OS_CHROMEOS)
    260 };
    261 
    262 #endif  // CHROME_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_GTK_H_
    263