GTK: Step 1 of tab strip refresh.

chrome/browser/ui/gtk/tabs/tab_renderer_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 CHROME_BROWSER_UI_GTK_TABS_TAB_RENDERER_GTK_H_
 #define CHROME_BROWSER_UI_GTK_TABS_TAB_RENDERER_GTK_H_
 #pragma once
 
 #include <gtk/gtk.h>
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
+#include "chrome/browser/ui/gtk/cairo_cached_surface.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/animation/animation_delegate.h"
 #include "ui/base/gtk/gtk_signal.h"
 #include "ui/base/gtk/owned_widget_gtk.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/rect.h"
 
 namespace gfx {
 class Size;
 }  // namespace gfx
 
+class CairoCachedSurface;
 class CustomDrawButton;
 class TabContents;
-class ThemeService;
+class GtkThemeService;
 
 namespace ui {
 class SlideAnimation;
 class ThrobAnimation;
 }
 
-class TabRendererGtk : public ui::AnimationDelegate,
-                       public content::NotificationObserver {
+class TabRendererGtk : public ui::AnimationDelegate {
  public:
   // Possible animation states.
   enum AnimationState {
     ANIMATION_NONE,
     ANIMATION_WAITING,
     ANIMATION_LOADING
   };
 
   class LoadingAnimation : public content::NotificationObserver {
    public:
     struct Data {
-      explicit Data(ThemeService* theme_service);
+      explicit Data(GtkThemeService* theme_service);
       Data(int loading, int waiting, int waiting_to_loading);
 
-      SkBitmap* waiting_animation_frames;
-      SkBitmap* loading_animation_frames;
       int loading_animation_frame_count;
       int waiting_animation_frame_count;
       int waiting_to_loading_frame_count_ratio;
     };
 
-    explicit LoadingAnimation(ThemeService* theme_service);
+    explicit LoadingAnimation(GtkThemeService* theme_service);
 
     // Used in unit tests to inject specific data.
     explicit LoadingAnimation(const LoadingAnimation::Data& data);
 
     virtual ~LoadingAnimation();
 
     // Advance the loading animation to the next frame, or hide the animation if
     // the tab isn't loading. Returns |true| if the icon area needs to be
     // repainted.
     bool ValidateLoadingAnimation(AnimationState animation_state);
 
     AnimationState animation_state() const { return animation_state_; }
     int animation_frame() const { return animation_frame_; }
 
-    const SkBitmap* waiting_animation_frames() const {
-      return data_->waiting_animation_frames;
-    }
-    const SkBitmap* loading_animation_frames() const {
-      return data_->loading_animation_frames;
-    }
-
     // Provide content::NotificationObserver implementation.
     virtual void Observe(int type,
                          const content::NotificationSource& source,
                          const content::NotificationDetails& details);
 
    private:
     scoped_ptr<Data> data_;
 
     // Used to listen for theme change notifications.
     content::NotificationRegistrar registrar_;
 
     // Gives us our throbber images.
-    ThemeService* theme_service_;
+    GtkThemeService* theme_service_;
 
     // Current state of the animation.
     AnimationState animation_state_;
 
     // The current index into the Animation image strip.
     int animation_frame_;
 
     DISALLOW_COPY_AND_ASSIGN(LoadingAnimation);
   };
 
-  explicit TabRendererGtk(ThemeService* theme_service);
+  explicit TabRendererGtk(GtkThemeService* theme_service);
   virtual ~TabRendererGtk();
 
   // TabContents. If only the loading state was updated, the loading_only flag
   // should be specified. If other things change, set this flag to false to
   // update everything.
   virtual void UpdateData(TabContents* contents, bool app, bool loading_only);
 
   // Sets the blocked state of the tab.
   void SetBlocked(bool pinned);
   bool is_blocked() const;
@@ skipping 22 matching lines @@
 
   // Returns true if the Tab is selected, false otherwise.
   virtual bool IsSelected() const;
 
   // Returns true if the Tab is visible, false otherwise.
   virtual bool IsVisible() const;
 
   // Sets the visibility of the Tab.
   virtual void SetVisible(bool visible) const;
 
-  // Paints the tab into |canvas|.
-  virtual void Paint(gfx::Canvas* canvas);
+  // Paints the tab using resources from the display that |widget| is on,
+  // drawing into |cr|.
+  void Paint(GtkWidget* widget, cairo_t* cr);
 
   // Paints the tab, and keeps the result server-side. The returned surface must
   // be freed with cairo_surface_destroy().
-  virtual cairo_surface_t* PaintToSurface();
+  cairo_surface_t* PaintToSurface(GtkWidget* widget, cairo_t* cr);
 
   // There is no PaintNow available, so the fastest we can do is schedule a
   // paint with the windowing system.
-  virtual void SchedulePaint();
+  void SchedulePaint();
 
   // Notifies the Tab that the close button has been clicked.
   virtual void CloseButtonClicked();
 
   // Sets the bounds of the tab.
   virtual void SetBounds(const gfx::Rect& bounds);
 
-  // Provide NotificationObserver implementation.
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
-
   // Advance the loading animation to the next frame, or hide the animation if
   // the tab isn't loading.  Returns |true| if the icon area needs to be
   // repainted.
   bool ValidateLoadingAnimation(AnimationState animation_state);
 
   // Repaint only the area of the tab that contains the favicon.
-  void PaintFaviconArea(GdkEventExpose* event);
+  void PaintFaviconArea(GtkWidget* widget, cairo_t* cr);
 
   // Returns whether the Tab should display a favicon.
   bool ShouldShowIcon() const;
 
   // Returns the minimum possible size of a single unselected Tab.
   static gfx::Size GetMinimumUnselectedSize();
   // Returns the minimum possible size of a selected Tab. Selected tabs must
   // always show a close button and have a larger minimum size than unselected
   // tabs.
   static gfx::Size GetMinimumSelectedSize();
   // Returns the preferred size of a single Tab, assuming space is
   // available.
   static gfx::Size GetStandardSize();
 
   // Returns the width for mini-tabs. Mini-tabs always have this width.
   static int GetMiniWidth();
 
-  // Loads the images to be used for the tab background.
-  static void LoadTabImages();
-
   // Sets the colors used for painting text on the tabs.
   static void SetSelectedTitleColor(SkColor color);
   static void SetUnselectedTitleColor(SkColor color);
 
   static gfx::Font* title_font() { return title_font_; }
 
   // Returns the bounds of the Tab.
   int x() const { return bounds_.x(); }
   int y() const { return bounds_.y(); }
   int width() const { return bounds_.width(); }
@@ skipping 31 matching lines @@
   CHROMEGTK_CALLBACK_1(TabRendererGtk, gboolean, OnEnterNotifyEvent,
                        GdkEventCrossing*);
 
   // leave-notify-event handler that signals when the mouse enters the tab.
   CHROMEGTK_CALLBACK_1(TabRendererGtk, gboolean, OnLeaveNotifyEvent,
                        GdkEventCrossing*);
 
  private:
   class FaviconCrashAnimation;
 
-  // The data structure used to hold cached bitmaps.  We need to manually free
-  // the bitmap in CachedBitmap when we remove it from |cached_bitmaps_|.  We
-  // handle this when we replace images in the map and in the destructor.
-  struct CachedBitmap {
-    int bg_offset_x;
-    int bg_offset_y;
-    SkBitmap* bitmap;
-  };
-  typedef std::map<std::pair<const SkBitmap*, const SkBitmap*>, CachedBitmap>
-      BitmapCache;
-
   // Model data. We store this here so that we don't need to ask the underlying
   // model, which is tricky since instances of this object can outlive the
   // corresponding objects in the underlying model.
   struct TabData {
-    TabData()
-        : is_default_favicon(false),
-          loading(false),
-          crashed(false),
-          incognito(false),
-          show_icon(true),
-          mini(false),
-          blocked(false),
-          animating_mini_change(false),
-          app(false) {
-    }
+    TabData();
+    ~TabData();
 
     SkBitmap favicon;
+    CairoCachedSurface cairo_favicon;
     bool is_default_favicon;
     string16 title;
     bool loading;
     bool crashed;
     bool incognito;
     bool show_icon;
     bool mini;
     bool blocked;
     bool animating_mini_change;
     bool app;
   };
 
-  // TODO(jhawkins): Move into TabResources class.
-  struct TabImage {
-    SkBitmap* image_l;
-    SkBitmap* image_c;
-    SkBitmap* image_r;
-    int l_width;
-    int r_width;
-    int y_offset;
-  };
-
   // Overridden from ui::AnimationDelegate:
   virtual void AnimationProgressed(const ui::Animation* animation);
   virtual void AnimationCanceled(const ui::Animation* animation);
   virtual void AnimationEnded(const ui::Animation* animation);
 
   // Starts/Stops the crash animation.
   void StartCrashAnimation();
   void StopCrashAnimation();
 
   // Return true if the crash animation is currently running.
@@ skipping 11 matching lines @@
   // Returns the local bounds of the tab.  This returns the rect
   // {0, 0, width(), height()} for now, as we don't yet support borders.
   gfx::Rect GetLocalBounds();
 
   // Moves the close button widget within the GtkFixed container.
   void MoveCloseButtonWidget();
 
   // Returns the largest of the favicon, title text, and the close button.
   static int GetContentHeight();
 
-  // A helper method for generating the masked bitmaps used to draw the curved
-  // edges of tabs.  We cache the generated bitmaps because they can take a
-  // long time to compute.
-  SkBitmap* GetMaskedBitmap(const SkBitmap* mask,
-                            const SkBitmap* background,
-                            int bg_offset_x,
-                            int bg_offset_y);
-  BitmapCache cached_bitmaps_;
-
-  // Paints the tab, minus the close button.
-  void PaintTab(GdkEventExpose* event);
+  void PaintTab(GtkWidget* widget, GdkEventExpose* event);
 
   // Paint various portions of the Tab
-  void PaintTitle(gfx::Canvas* canvas);
-  void PaintIcon(gfx::Canvas* canvas);
-  void PaintTabBackground(gfx::Canvas* canvas);
-  void PaintInactiveTabBackground(gfx::Canvas* canvas);
-  void PaintActiveTabBackground(gfx::Canvas* canvas);
-  void PaintLoadingAnimation(gfx::Canvas* canvas);
+  void PaintTitle(GtkWidget* widget, cairo_t* cr);
+  void PaintIcon(GtkWidget* widget, cairo_t* cr);
+  void PaintTabBackground(GtkWidget* widget, cairo_t* cr);
+  void PaintInactiveTabBackground(GtkWidget* widget, cairo_t* cr);
+  void PaintActiveTabBackground(GtkWidget* widget, cairo_t* cr);
+  void PaintLoadingAnimation(GtkWidget* widget, cairo_t* cairo);
+
+  // Draws the given |tab_bg| onto |cr| using the tab shape masks along the
+  // sides for the rounded tab shape.
+  void DrawTabBackground(cairo_t* cr,
+                         GtkWidget* widget,
+                         CairoCachedSurface* tab_bg,
+                         int offset_x,
+                         int offset_y);
+
+  // Draws the tab shadow using the given idr resources onto |cr|.
+  void DrawTabShadow(cairo_t* cr,
+                     GtkWidget* widget,
+                     int left_idr,
+                     int center_idr,
+                     int right_idr);
 
   // Returns the number of favicon-size elements that can fit in the tab's
   // current size.
   int IconCapacity() const;
 
-
   // Returns whether the Tab should display a close button.
   bool ShouldShowCloseBox() const;
 
   CustomDrawButton* MakeCloseButton();
 
   // Gets the throb value for the tab. When a tab is not selected the
   // active background is drawn at |GetThrobValue()|%. This is used for hover
   // and mini-tab title change effects.
   double GetThrobValue();
 
@@ skipping 15 matching lines @@
   static void InitResources();
   static bool initialized_;
 
   // The bounds of various sections of the display.
   gfx::Rect favicon_bounds_;
   gfx::Rect title_bounds_;
   gfx::Rect close_button_bounds_;
 
   TabData data_;
 
-  static TabImage tab_active_;
-  static TabImage tab_inactive_;
-  static TabImage tab_alpha_;
+  static int tab_active_l_width_;

[Evan Stade, 2011/10/26 21:46:05]

I'm not sure if you saw my previous comment about making these gfx::Size and
adding docs? Also I had wondered aloud whether active_l and inactive_l were
different, not whether active_l and active_r were different (although l and r
being the same is another cool thing). Is it possible to simplify all these
types to something like

static gfx::Size tab_edge_size_;

[Elliot Glaysher, 2011/10/26 23:23:52]

gfx::Size would make a static initializer, no?

+  static int tab_active_l_height_;
+  static int tab_inactive_l_width_;
+  static int tab_inactive_l_height_;
 
   static gfx::Font* title_font_;
   static int title_font_height_;
 
   static int close_button_width_;
   static int close_button_height_;
 
   static SkColor selected_title_color_;
   static SkColor unselected_title_color_;
 
@@ skipping 34 matching lines @@
   LoadingAnimation loading_animation_;
 
   // The offset used to paint the tab theme images.
   int background_offset_x_;
 
   // The vertical offset used to paint the tab theme images. Controlled by the
   // tabstrip and plumbed here to offset the theme image by the size of the
   // alignment in the BrowserTitlebar.
   int background_offset_y_;
 
-  ThemeService* theme_service_;
+  GtkThemeService* theme_service_;
 
   // The close button.
   scoped_ptr<CustomDrawButton> close_button_;
 
   // The current color of the close button.
   SkColor close_button_color_;
 
   // Indicates whether this tab is the active one.
   bool is_active_;
 
-  // Used to listen for theme change notifications.
-  content::NotificationRegistrar registrar_;
-
   DISALLOW_COPY_AND_ASSIGN(TabRendererGtk);
 };
 
 #endif  // CHROME_BROWSER_UI_GTK_TABS_TAB_RENDERER_GTK_H_