Theme window control buttons....

chrome/browser/views/tabs/tab_strip.h

 // Copyright (c) 2006-2008 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_VIEWS_TABS_TAB_STRIP_H_
 #define CHROME_BROWSER_VIEWS_TABS_TAB_STRIP_H_
 
 #include "base/gfx/point.h"
 #include "base/message_loop.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
@@ skipping 71 matching lines @@
 
   // Retrieve the ideal bounds for the Tab at the specified index.
   gfx::Rect GetIdealBounds(int index);
 
   // Updates loading animations for the TabStrip.
   void UpdateLoadingAnimations();
 
   // Set the background offset used by inactive tabs to match the frame image.
   void SetBackgroundOffset(gfx::Point offset);
 
+  // Create the new tab button.
+  void InitTabStripButtons();
+
   // views::View overrides:
   virtual void PaintChildren(gfx::Canvas* canvas);
   virtual views::View* GetViewByID(int id) const;
   virtual void Layout();
   virtual gfx::Size GetPreferredSize();
   // NOTE: the drag and drop methods are invoked from FrameView. This is done to
   // allow for a drop region that extends outside the bounds of the TabStrip.
   virtual void OnDragEntered(const views::DropTargetEvent& event);
   virtual int OnDragUpdated(const views::DropTargetEvent& event);
   virtual void OnDragExited();
   virtual int OnPerformDrop(const views::DropTargetEvent& event);
   virtual bool GetAccessibleRole(AccessibilityTypes::Role* role);
   virtual bool GetAccessibleName(std::wstring* name);
   virtual void SetAccessibleName(const std::wstring& name);
   virtual views::View* GetViewForPoint(const gfx::Point& point);
+  virtual void ThemeChanged();
 
  protected:
   // TabStripModelObserver implementation:
   virtual void TabInsertedAt(TabContents* contents,
                              int index,
                              bool foreground);
   virtual void TabDetachedAt(TabContents* contents, int index);
   virtual void TabSelectedAt(TabContents* old_contents,
                              TabContents* contents,
                              int index,
@@ skipping 42 matching lines @@
   friend class DraggedTabController;
   friend class InsertTabAnimation;
   friend class MoveTabAnimation;
   friend class RemoveTabAnimation;
   friend class ResizeLayoutAnimation;
   friend class TabAnimation;
 
   TabStrip();
   void Init();
 
+  // Set the images for the new tab button.
+  void LoadNewTabButtonImage();
+
   // Retrieves the Tab at the specified index. Take care in using this, you may
   // need to use GetTabAtAdjustForAnimation.
   Tab* GetTabAt(int index) const;
 
   // Returns the tab at the specified index. If a remove animation is on going
   // and the index is >= the index of the tab being removed, the index is
   // incremented. While a remove operation is on going the indices of the model
   // do not line up with the indices of the view. This method adjusts the index
   // accordingly.
   //
@@ skipping 117 matching lines @@
   bool added_as_message_loop_observer_;
 
   // True if a resize layout animation should be run a short delay after the
   // mouse exits the TabStrip.
   // TODO(beng): (Cleanup) this would be better named "needs_resize_layout_".
   bool resize_layout_scheduled_;
 
   // The "New Tab" button.
   views::ImageButton* newtab_button_;
   gfx::Size newtab_button_size_;
-  gfx::Size actual_newtab_button_size_;
 
   // The current widths of various types of tabs.  We save these so that, as
   // users close tabs while we're holding them at the same size, we can lay out
   // tabs exactly and eliminate the "pixel jitter" we'd get from just leaving
   // them all at their existing, rounded widths.
   double current_unselected_width_;
   double current_selected_width_;
 
   // If this value is nonnegative, it is used in GetDesiredTabWidths() to
   // calculate how much space in the tab strip to use for tabs.  Most of the
   // time this will be -1, but while we're handling closing a tab via the mouse,
   // we'll set this to the edge of the last tab before closing, so that if we
   // are closing the last tab and need to resize immediately, we'll resize only
   // back to this width, thus once again placing the last tab under the mouse
   // cursor.
   int available_width_for_tabs_;
 
   // Storage of strings needed for accessibility.
   std::wstring accessible_name_;
 
+  // The size of the new tab button must be hardcoded because we need to be
+  // able to lay it out before we are able to get its image from the
+  // ThemeProvider.  It also makes sense to do this, because the size of the
+  // new tab button should not need to be calculated dynamically.
+  static const int kNewTabButtonWidth = 28;
+  static const int kNewTabButtonHeight = 18;
+
   // Used during a drop session of a url. Tracks the position of the drop as
   // well as a window used to highlight where the drop occurs.
   struct DropInfo {
     DropInfo(int index, bool drop_before, bool paint_down);
     ~DropInfo();
 
     // Index of the tab to drop on. If drop_before is true, the drop should
     // occur between the tab at drop_index - 1 and drop_index.
     // WARNING: if drop_before is true it is possible this will == tab_count,
     // which indicates the drop should create a new tab at the end of the tabs.
@@ skipping 30 matching lines @@
   };
   std::vector<TabData> tab_data_;
 
   // The currently running animation.
   scoped_ptr<TabAnimation> active_animation_;
 
   DISALLOW_COPY_AND_ASSIGN(TabStrip);
 };
 
 #endif  // CHROME_BROWSER_VIEWS_TABS_TAB_STRIP_H_