chrome/browser/ui/gtk/location_bar_view_gtk.h

   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 #ifndef CHROME_BROWSER_UI_GTK_LOCATION_BAR_VIEW_GTK_H_
   6 #define CHROME_BROWSER_UI_GTK_LOCATION_BAR_VIEW_GTK_H_
   7
   8 #include <gtk/gtk.h>
   9
  10 #include <map>
  11 #include <string>
  12
  13 #include "base/basictypes.h"
  14 #include "base/callback.h"
  15 #include "base/compiler_specific.h"
  16 #include "base/memory/scoped_ptr.h"
  17 #include "base/memory/scoped_vector.h"
  18 #include "base/memory/weak_ptr.h"
  19 #include "base/prefs/pref_member.h"
  20 #include "chrome/browser/extensions/extension_action.h"
  21 #include "chrome/browser/extensions/extension_action_icon_factory.h"
  22 #include "chrome/browser/extensions/extension_context_menu_model.h"
  23 #include "chrome/browser/ui/gtk/bubble/bubble_gtk.h"
  24 #include "chrome/browser/ui/gtk/menu_gtk.h"
  25 #include "chrome/browser/ui/omnibox/location_bar.h"
  26 #include "chrome/browser/ui/omnibox/omnibox_edit_controller.h"
  27 #include "chrome/browser/ui/view_ids.h"
  28 #include "chrome/common/content_settings_types.h"
  29 #include "content/public/browser/notification_observer.h"
  30 #include "content/public/browser/notification_registrar.h"
  31 #include "content/public/common/page_transition_types.h"
  32 #include "ui/base/gtk/gtk_signal.h"
  33 #include "ui/base/gtk/owned_widget_gtk.h"
  34 #include "ui/base/window_open_disposition.h"
  35 #include "ui/gfx/animation/animation_delegate.h"
  36 #include "ui/gfx/animation/slide_animation.h"
  37 #include "url/gurl.h"
  38
  39 class Browser;
  40 class CommandUpdater;
  41 class ContentSettingImageModel;
  42 class ContentSettingBubbleGtk;
  43 class ExtensionAction;
  44 class GtkThemeService;
  45 class OmniboxViewGtk;
  46
  47 namespace content {
  48 class WebContents;
  49 }
  50
  51 namespace gfx {
  52 class Image;
  53 }
  54
  55 namespace ui {
  56 class Accelerator;
  57 }
  58
  59 class LocationBarViewGtk : public OmniboxEditController,
  60                            public LocationBar,
  61                            public LocationBarTesting,
  62                            public content::NotificationObserver {
  63  public:
  64   explicit LocationBarViewGtk(Browser* browser);
  65   virtual ~LocationBarViewGtk();
  66
  67   void Init(bool popup_window_mode);
  68
  69   // Returns the widget the caller should host.  You must call Init() first.
  70   GtkWidget* widget() { return hbox_.get(); }
  71
  72   // Returns the widget the page info bubble should point to.
  73   GtkWidget* location_icon_widget() const { return location_icon_image_; }
  74
  75   // Returns the widget the extension installed bubble should point to.
  76   GtkWidget* location_entry_widget() const { return entry_box_; }
  77
  78   Browser* browser() const { return browser_; }
  79
  80   // Sets |preview_enabled| for the PageActionViewGtk associated with this
  81   // |page_action|. If |preview_enabled| is true, the view will display the
  82   // page action's icon even though it has not been activated by the extension.
  83   // This is used by the ExtensionInstalledBubbleGtk to preview what the icon
  84   // will look like for the user upon installation of the extension.
  85   void SetPreviewEnabledPageAction(ExtensionAction *page_action,
  86                                    bool preview_enabled);
  87
  88   // Retrieves the GtkWidget which is associated with PageActionView
  89   // corresponding to |page_action|.
  90   GtkWidget* GetPageActionWidget(ExtensionAction* page_action);
  91
  92   // Show the bookmark bubble.
  93   void ShowStarBubble(const GURL& url, bool newly_boomkarked);
  94
  95   // Happens when the zoom changes for the active tab. |can_show_bubble| will be
  96   // true if it was a user action and a bubble could be shown.
  97   void ZoomChangedForActiveTab(bool can_show_bubble);
  98
  99   // Returns the zoom widget. Used by the zoom bubble for an anchor.
 100   GtkWidget* zoom_widget() { return zoom_.get(); }
 101
 102   // Returns the manage passwords widget. Used by the manage passwords bubble
 103   // for an anchor.
 104   GtkWidget* manage_passwords_icon_widget() {
 105     return manage_passwords_icon_.get();
 106   }
 107
 108   // Set the starred state of the bookmark star.
 109   void SetStarred(bool starred);
 110
 111   // OmniboxEditController:
 112   virtual void Update(const content::WebContents* contents) OVERRIDE;
 113   virtual void OnChanged() OVERRIDE;
 114   virtual void OnSetFocus() OVERRIDE;
 115   virtual InstantController* GetInstant() OVERRIDE;
 116   virtual content::WebContents* GetWebContents() OVERRIDE;
 117   virtual ToolbarModel* GetToolbarModel() OVERRIDE;
 118   virtual const ToolbarModel* GetToolbarModel() const OVERRIDE;
 119
 120   // LocationBar:
 121   virtual void ShowFirstRunBubble() OVERRIDE;
 122   virtual GURL GetDestinationURL() const OVERRIDE;
 123   virtual WindowOpenDisposition GetWindowOpenDisposition() const OVERRIDE;
 124   virtual content::PageTransition GetPageTransition() const OVERRIDE;
 125   virtual void AcceptInput() OVERRIDE;
 126   virtual void FocusLocation(bool select_all) OVERRIDE;
 127   virtual void FocusSearch() OVERRIDE;
 128   virtual void UpdateContentSettingsIcons() OVERRIDE;
 129   virtual void UpdateManagePasswordsIconAndBubble() OVERRIDE;
 130   virtual void UpdatePageActions() OVERRIDE;
 131   virtual void InvalidatePageActions() OVERRIDE;
 132   virtual void UpdateOpenPDFInReaderPrompt() OVERRIDE;
 133   virtual void UpdateGeneratedCreditCardView() OVERRIDE;
 134   virtual void SaveStateToContents(content::WebContents* contents) OVERRIDE;
 135   virtual void Revert() OVERRIDE;
 136   virtual const OmniboxView* GetOmniboxView() const OVERRIDE;
 137   virtual OmniboxView* GetOmniboxView() OVERRIDE;
 138   virtual LocationBarTesting* GetLocationBarForTesting() OVERRIDE;
 139
 140   // LocationBarTesting:
 141   virtual int PageActionCount() OVERRIDE;
 142   virtual int PageActionVisibleCount() OVERRIDE;
 143   virtual ExtensionAction* GetPageAction(size_t index) OVERRIDE;
 144   virtual ExtensionAction* GetVisiblePageAction(size_t index) OVERRIDE;
 145   virtual void TestPageActionPressed(size_t index) OVERRIDE;
 146   virtual bool GetBookmarkStarVisibility() OVERRIDE;
 147
 148   // content::NotificationObserver:
 149   virtual void Observe(int type,
 150                        const content::NotificationSource& source,
 151                        const content::NotificationDetails& details) OVERRIDE;
 152
 153   // Edit background color.
 154   static const GdkColor kBackgroundColor;
 155
 156   // Superclass for content settings icons shown at the left side of the
 157   // location bar.
 158   class PageToolViewGtk : public gfx::AnimationDelegate {
 159    public:
 160     PageToolViewGtk();
 161     virtual ~PageToolViewGtk();
 162
 163     GtkWidget* widget() { return alignment_.get(); }
 164
 165     bool IsVisible();
 166
 167     virtual void Update(content::WebContents* web_contents) = 0;
 168
 169     // Overridden from gfx::AnimationDelegate:
 170     virtual void AnimationProgressed(const gfx::Animation* animation) OVERRIDE;
 171     virtual void AnimationEnded(const gfx::Animation* animation) OVERRIDE;
 172     virtual void AnimationCanceled(const gfx::Animation* animation) OVERRIDE;
 173
 174    protected:
 175     // Theme constants for solid background elements.
 176     virtual GdkColor GetButtonBorderColor() const = 0;
 177     virtual GdkColor GetGradientTopColor() const = 0;
 178     virtual GdkColor GetGradientBottomColor() const = 0;
 179
 180     // Delegate for ButtonPressed message.
 181     virtual void OnClick(GtkWidget* sender) = 0;
 182
 183     // Start the process of showing the label.
 184     void StartAnimating();
 185
 186     // Slide the label shut.
 187     void CloseAnimation();
 188
 189     CHROMEGTK_CALLBACK_1(PageToolViewGtk, gboolean, OnButtonPressed, GdkEvent*);
 190     CHROMEGTK_CALLBACK_1(PageToolViewGtk, gboolean, OnExpose, GdkEventExpose*);
 191
 192     // The widgets for this view.
 193     ui::OwnedWidgetGtk alignment_;
 194     ui::OwnedWidgetGtk event_box_;
 195     GtkWidget* hbox_;
 196     ui::OwnedWidgetGtk image_;
 197
 198     // Explanatory text (e.g. "popup blocked").
 199     ui::OwnedWidgetGtk label_;
 200
 201     // When we show explanatory text, we slide it in/out.
 202     gfx::SlideAnimation animation_;
 203
 204     // The label's default requisition (cached so we can animate accordingly).
 205     GtkRequisition label_req_;
 206
 207     base::WeakPtrFactory<PageToolViewGtk> weak_factory_;
 208
 209    private:
 210     DISALLOW_COPY_AND_ASSIGN(PageToolViewGtk);
 211   };
 212
 213  private:
 214   class PageActionViewGtk :
 215        public ExtensionActionIconFactory::Observer,
 216        public content::NotificationObserver,
 217        public ExtensionContextMenuModel::PopupDelegate,
 218        public ExtensionAction::IconAnimation::Observer {
 219    public:
 220     PageActionViewGtk(LocationBarViewGtk* owner, ExtensionAction* page_action);
 221     virtual ~PageActionViewGtk();
 222
 223     GtkWidget* widget() { return event_box_.get(); }
 224
 225     ExtensionAction* page_action() { return page_action_; }
 226
 227     void set_preview_enabled(bool preview_enabled) {
 228       preview_enabled_ = preview_enabled;
 229     }
 230
 231     bool IsVisible();
 232
 233     // Called to notify the PageAction that it should determine whether to be
 234     // visible or hidden. |contents| is the WebContents that is active, |url|
 235     // is the current page URL.
 236     void UpdateVisibility(content::WebContents* contents, const GURL& url);
 237
 238     // Overriden from ExtensionActionIconFactory::Observer.
 239     virtual void OnIconUpdated() OVERRIDE;
 240
 241     // Simulate left mouse click on the page action button.
 242     void TestActivatePageAction();
 243
 244     // Implement the content::NotificationObserver interface.
 245     virtual void Observe(int type,
 246                          const content::NotificationSource& source,
 247                          const content::NotificationDetails& details) OVERRIDE;
 248
 249     // Overridden from ExtensionContextMenuModel::PopupDelegate:
 250     virtual void InspectPopup(ExtensionAction* action) OVERRIDE;
 251
 252    private:
 253     // Connect the accelerator for the page action popup.
 254     void ConnectPageActionAccelerator();
 255
 256     // Disconnect the accelerator for the page action popup.
 257     void DisconnectPageActionAccelerator();
 258
 259     CHROMEGTK_CALLBACK_1(PageActionViewGtk, gboolean, OnButtonPressed,
 260                          GdkEventButton*);
 261     CHROMEGTK_CALLBACK_1(PageActionViewGtk, gboolean, OnExposeEvent,
 262                          GdkEventExpose*);
 263     CHROMEGTK_CALLBACK_0(PageActionViewGtk, void, OnRealize);
 264
 265     // The accelerator handler for when the shortcuts to open the popup is
 266     // struck.
 267     static gboolean OnGtkAccelerator(GtkAccelGroup* accel_group,
 268                                      GObject* acceleratable,
 269                                      guint keyval,
 270                                      GdkModifierType modifier,
 271                                      void* user_data);
 272
 273     // ExtensionAction::IconAnimationDelegate implementation.
 274     virtual void OnIconChanged() OVERRIDE;
 275
 276     // The location bar view that owns us.
 277     LocationBarViewGtk* owner_;
 278
 279     // The PageAction that this view represents. The PageAction is not owned by
 280     // us, it resides in the extension of this particular profile.
 281     ExtensionAction* page_action_;
 282
 283     // The object that will be used to get the extension action icon for us.
 284     // It may load the icon asynchronously (in which case the initial icon
 285     // returned by the factory will be transparent), so we have to observe it
 286     // for updates to the icon.
 287     scoped_ptr<ExtensionActionIconFactory> icon_factory_;
 288
 289     // The widgets for this page action.
 290     ui::OwnedWidgetGtk event_box_;
 291     ui::OwnedWidgetGtk image_;
 292
 293     // The tab id we are currently showing the icon for.
 294     int current_tab_id_;
 295
 296     // The URL we are currently showing the icon for.
 297     GURL current_url_;
 298
 299     // The native browser window of the location bar that owns us.
 300     gfx::NativeWindow window_;
 301
 302     // The Notification registrar.
 303     content::NotificationRegistrar registrar_;
 304
 305     // The accelerator group used to handle accelerators, owned by this object.
 306     GtkAccelGroup* accel_group_;
 307
 308     // The keybinding accelerator registered to show the page action popup.
 309     scoped_ptr<ui::Accelerator> page_action_keybinding_;
 310     // The keybinding accelerator registered to show the script badge popup.
 311     scoped_ptr<ui::Accelerator> script_badge_keybinding_;
 312
 313     // This is used for post-install visual feedback. The page_action icon
 314     // is briefly shown even if it hasn't been enabled by its extension.
 315     bool preview_enabled_;
 316
 317     // The context menu view and model for this extension action.
 318     scoped_ptr<MenuGtk> context_menu_;
 319     scoped_refptr<ExtensionContextMenuModel> context_menu_model_;
 320
 321     // Fade-in animation for the icon with observer scoped to this.
 322     ExtensionAction::IconAnimation::ScopedObserver
 323         scoped_icon_animation_observer_;
 324
 325     DISALLOW_COPY_AND_ASSIGN(PageActionViewGtk);
 326   };
 327   friend class PageActionViewGtk;
 328
 329   // Creates, initializes, and packs the location icon, EV certificate name,
 330   // and optional border.
 331   void BuildSiteTypeArea();
 332
 333   // Enable or disable the location icon/EV certificate as a drag source for
 334   // the URL.
 335   void SetSiteTypeDragSource();
 336
 337   GtkWidget* site_type_area() { return site_type_alignment_; }
 338
 339   CHROMEGTK_CALLBACK_1(LocationBarViewGtk, gboolean, HandleExpose,
 340                        GdkEventExpose*);
 341   CHROMEGTK_CALLBACK_1(LocationBarViewGtk, gboolean, OnIconReleased,
 342                        GdkEventButton*);
 343   CHROMEGTK_CALLBACK_4(LocationBarViewGtk, void, OnIconDragData,
 344                        GdkDragContext*, GtkSelectionData*, guint, guint);
 345   CHROMEGTK_CALLBACK_1(LocationBarViewGtk, void, OnIconDragBegin,
 346                        GdkDragContext*);
 347   CHROMEGTK_CALLBACK_1(LocationBarViewGtk, void, OnIconDragEnd,
 348                        GdkDragContext*);
 349   CHROMEGTK_CALLBACK_1(LocationBarViewGtk, void, OnHboxSizeAllocate,
 350                        GtkAllocation*);
 351   CHROMEGTK_CALLBACK_1(LocationBarViewGtk, void, OnEntryBoxSizeAllocate,
 352                        GtkAllocation*);
 353   CHROMEGTK_CALLBACK_1(LocationBarViewGtk, gboolean, OnZoomButtonPress,
 354                        GdkEventButton*);
 355   CHROMEGTK_CALLBACK_1(LocationBarViewGtk, gboolean,
 356                        OnManagePasswordsIconButtonPress, GdkEventButton*);
 357   CHROMEGTK_CALLBACK_1(LocationBarViewGtk, gboolean, OnScriptBubbleButtonPress,
 358                        GdkEventButton*);
 359   CHROMEGTK_CALLBACK_1(LocationBarViewGtk, void, OnStarButtonSizeAllocate,
 360                        GtkAllocation*);
 361   CHROMEGTK_CALLBACK_1(LocationBarViewGtk, gboolean, OnStarButtonPress,
 362                        GdkEventButton*);
 363   CHROMEGTK_CALLBACK_1(LocationBarViewGtk, gboolean,
 364                        OnScriptBubbleButtonExpose, GdkEventExpose*);
 365
 366   // Updates the site type area: changes the icon and shows/hides the EV
 367   // certificate information.
 368   void UpdateSiteTypeArea();
 369
 370   // Updates the maximum size of the EV certificate label.
 371   void UpdateEVCertificateLabelSize();
 372
 373   // Set the keyword text for the Search BLAH: keyword box.
 374   void SetKeywordLabel(const base::string16& keyword);
 375
 376   // Set the keyword text for the "Press tab to search BLAH" hint box.
 377   void SetKeywordHintLabel(const base::string16& keyword);
 378
 379   void ShowFirstRunBubbleInternal();
 380
 381   // Shows the zoom bubble.
 382   void ShowZoomBubble();
 383
 384   // Shows the manage password bubble.
 385   void ShowManagePasswordsBubble();
 386
 387   // Show or hide |tab_to_search_box_| and |tab_to_search_hint_| according to
 388   // the value of |show_selected_keyword_|, |show_keyword_hint_|, and the
 389   // available horizontal space in the location bar.
 390   void AdjustChildrenVisibility();
 391
 392   // Helpers to build create the various buttons that show up in the location
 393   // bar.
 394   GtkWidget* CreateIconButton(
 395       GtkWidget** image,
 396       int image_id,
 397       ViewID debug_id,
 398       int tooltip_id,
 399       gboolean (click_callback)(GtkWidget*, GdkEventButton*, gpointer));
 400   void CreateZoomButton();
 401   void CreateManagePasswordsIconButton();
 402   void CreateScriptBubbleButton();
 403   void CreateStarButton();
 404
 405   // Helpers to update state of the various buttons that show up in the
 406   // location bar.
 407   void UpdateZoomIcon();
 408   void UpdateManagePasswordsIcon();
 409   void UpdateScriptBubbleIcon();
 410   void UpdateStarIcon();
 411
 412   // Shows the managepassword bubble in case there is a password to be saved.
 413   void ShowManagePasswordsBubbleIfNeeded();
 414
 415   // Returns true if we should only show the URL and none of the extras like
 416   // the star button or page actions.
 417   bool ShouldOnlyShowLocation();
 418
 419   // The outermost widget we want to be hosted.
 420   ui::OwnedWidgetGtk hbox_;
 421
 422   // Zoom button.
 423   ui::OwnedWidgetGtk zoom_;
 424   GtkWidget* zoom_image_;
 425
 426   // Manage passwords button.
 427   ui::OwnedWidgetGtk manage_passwords_icon_;
 428   GtkWidget* manage_passwords_icon_image_;
 429
 430   ui::OwnedWidgetGtk script_bubble_button_;
 431   GtkWidget* script_bubble_button_image_;
 432   size_t num_running_scripts_;
 433
 434   // Star button.
 435   ui::OwnedWidgetGtk star_;
 436   GtkWidget* star_image_;
 437   bool starred_;
 438   bool star_sized_;  // True after a size-allocate signal to the star widget.
 439
 440   // Action to execute after the star icon has been sized, can refer to a NULL
 441   // function to indicate no such action should be taken.
 442   base::Closure on_star_sized_;
 443
 444   // An icon to the left of the address bar.
 445   GtkWidget* site_type_alignment_;
 446   GtkWidget* site_type_event_box_;
 447   GtkWidget* location_icon_image_;
 448   GtkWidget* drag_icon_;
 449   bool enable_location_drag_;
 450   // TODO(pkasting): Split this label off and move the rest of the items to the
 451   // left of the address bar.
 452   GtkWidget* security_info_label_;
 453
 454   // Content setting icons.
 455   ui::OwnedWidgetGtk content_setting_hbox_;
 456   ScopedVector<PageToolViewGtk> content_setting_views_;
 457
 458   // Extension page actions.
 459   std::vector<ExtensionAction*> page_actions_;
 460
 461   // Extension page action icons.
 462   ui::OwnedWidgetGtk page_action_hbox_;
 463   ScopedVector<PageActionViewGtk> page_action_views_;
 464
 465   // The widget that contains our tab hints and the location bar.
 466   GtkWidget* entry_box_;
 467
 468   // Area on the left shown when in tab to search mode.
 469   GtkWidget* tab_to_search_alignment_;
 470   GtkWidget* tab_to_search_box_;
 471   GtkWidget* tab_to_search_magnifier_;
 472   GtkWidget* tab_to_search_full_label_;
 473   GtkWidget* tab_to_search_partial_label_;
 474
 475   // Hint to user that they can tab-to-search by hitting tab.
 476   GtkWidget* tab_to_search_hint_;
 477   GtkWidget* tab_to_search_hint_leading_label_;
 478   GtkWidget* tab_to_search_hint_icon_;
 479   GtkWidget* tab_to_search_hint_trailing_label_;
 480
 481   scoped_ptr<OmniboxViewGtk> omnibox_view_;
 482
 483   // Alignment used to wrap |omnibox_view_|.
 484   GtkWidget* omnibox_view_alignment_;
 485
 486   Browser* browser_;
 487
 488   // When true, the location bar view is read only and also is has a slightly
 489   // different presentation (font size / color). This is used for popups.
 490   bool popup_window_mode_;
 491
 492   // Provides colors and rendering mode.
 493   GtkThemeService* theme_service_;
 494
 495   content::NotificationRegistrar registrar_;
 496
 497   // Width of the main |hbox_|. Used to properly elide the EV certificate.
 498   int hbox_width_;
 499
 500   // Width of the hbox that holds |tab_to_search_box_|, |omnibox_view_| and
 501   // |tab_to_search_hint_|.
 502   int entry_box_width_;
 503
 504   // Indicate if |tab_to_search_box_| should be shown.
 505   bool show_selected_keyword_;
 506
 507   // Indicate if |tab_to_search_hint_| should be shown.
 508   bool show_keyword_hint_;
 509
 510   // The last search keyword that was shown via the |tab_to_search_box_|.
 511   base::string16 last_keyword_;
 512
 513   // Used to change the visibility of the star decoration.
 514   BooleanPrefMember edit_bookmarks_enabled_;
 515
 516   // Used to remember the URL and title text when drag&drop has begun.
 517   GURL drag_url_;
 518   base::string16 drag_title_;
 519
 520   // Used to schedule a task for the first run bubble.
 521   base::WeakPtrFactory<LocationBarViewGtk> weak_ptr_factory_;
 522
 523   DISALLOW_COPY_AND_ASSIGN(LocationBarViewGtk);
 524 };
 525
 526 #endif  // CHROME_BROWSER_UI_GTK_LOCATION_BAR_VIEW_GTK_H_