Change the visual appearance of panel on GTK per new UI design.

chrome/browser/ui/gtk/browser_window_gtk.h

 // Copyright (c) 2012 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_BROWSER_WINDOW_GTK_H_
 #define CHROME_BROWSER_UI_GTK_BROWSER_WINDOW_GTK_H_
 #pragma once
 
 #include <gtk/gtk.h>
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/timer.h"
 #include "build/build_config.h"
 #include "chrome/browser/infobars/infobar_container.h"
 #include "chrome/browser/prefs/pref_member.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
 #include "ui/base/gtk/gtk_signal.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/base/x/active_window_watcher_x_observer.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/rect.h"
 
 class BookmarkBarGtk;
 class Browser;
-class BrowserTitlebar;
+class BrowserTitlebarBase;
 class BrowserToolbarGtk;
 class DownloadShelfGtk;
 class ExtensionKeybindingRegistryGtk;
 class FindBarGtk;
 class FullscreenExitBubbleGtk;
 class GlobalMenuBar;
 class InfoBarContainerGtk;
 class LocationBar;
 class StatusBubbleGtk;
 class TabContentsContainerGtk;
@@ skipping 13 matching lines @@
                          public ui::ActiveWindowWatcherXObserver,
                          public InfoBarContainer::Delegate {
  public:
   explicit BrowserWindowGtk(Browser* browser);
   virtual ~BrowserWindowGtk();
 
   // Separating initialization from constructor allows invocation of virtual
   // functions during initialization.
   virtual void Init();
 
-  // Returns whether to draw the content drop shadow on the sides and bottom
-  // of the browser window. When false, we still draw a shadow on the top of
-  // the toolbar (under the tab strip), but do not round the top corners.
-  virtual bool ShouldDrawContentDropShadow() const;
-
   // Overridden from BrowserWindow:
   virtual void Show() OVERRIDE;
   virtual void ShowInactive() OVERRIDE;
   virtual void SetBounds(const gfx::Rect& bounds) OVERRIDE;
   virtual void Close() OVERRIDE;
   virtual void Activate() OVERRIDE;
   virtual void Deactivate() OVERRIDE;
   virtual bool IsActive() const OVERRIDE;
   virtual void FlashFrame(bool flash) OVERRIDE;
   virtual bool IsAlwaysOnTop() const OVERRIDE;
@@ skipping 131 matching lines @@
   void OnDebouncedBoundsChanged();
 
   // Request the underlying window to unmaximize.  Also tries to work around
   // a window manager "feature" that can prevent this in some edge cases.
   void UnMaximize();
 
   // Returns false if we're not ready to close yet.  E.g., a tab may have an
   // onbeforeunload handler that prevents us from closing.
   bool CanClose() const;
 
+  // Returns whether to draw the content drop shadow on the sides and bottom
+  // of the browser window. When false, we still draw a shadow on the top of
+  // the toolbar (under the tab strip), but do not round the top corners.
+  bool ShouldDrawContentDropShadow() const;
+
   bool ShouldShowWindowIcon() const;
 
   // Add the find bar widget to the window hierarchy.
   void AddFindBar(FindBarGtk* findbar);
 
   // Reset the mouse cursor to the default cursor if it was set to something
   // else for the custom frame.
   void ResetCustomFrameCursor();
 
   // Returns the BrowserWindowGtk registered with |window|.
   static BrowserWindowGtk* GetBrowserWindowForNativeWindow(
       gfx::NativeWindow window);
 
   // Retrieves the GtkWindow associated with |xid|, which is the X Window
   // ID of the top-level X window of this object.
   static GtkWindow* GetBrowserWindowForXID(XID xid);
 
   Browser* browser() const { return browser_.get(); }
 
   GtkWindow* window() const { return window_; }
 
-  BrowserTitlebar* titlebar() const { return titlebar_.get(); }
+  BrowserTitlebarBase* titlebar() const { return titlebar_.get(); }
 
   GtkWidget* titlebar_widget() const;
 
   BrowserToolbarGtk* GetToolbar() { return toolbar_.get(); }
 
   gfx::Rect bounds() const { return bounds_; }
 
   // Returns the tab we're currently displaying in the tab contents container.
   TabContentsWrapper* GetDisplayedTab();
 
   static void RegisterUserPrefs(PrefService* prefs);
 
   // Tells GTK that the toolbar area is invalidated and needs redrawing. We
   // have this method as a hack because GTK doesn't queue the toolbar area for
   // redraw when it should.
   void QueueToolbarRedraw();
 
   // Get the position where the infobar arrow should be anchored in
   // |relative_to| coordinates. This is the middle of the omnibox location icon.
   int GetXPositionOfLocationIcon(GtkWidget* relative_to);
 
  protected:
   virtual void DestroyBrowser() OVERRIDE;
 
-  // Returns an instance of |BrowserTitlebar| to be used for this window.
-  virtual BrowserTitlebar* CreateBrowserTitlebar();
+  // Returns an instance of |BrowserTitlebarBase| to be used for this window.
+  virtual BrowserTitlebarBase* CreateBrowserTitlebar();
 
   // Checks to see if the mouse pointer at |x|, |y| is over the border of the
   // custom frame (a spot that should trigger a window resize). Returns true if
   // it should and sets |edge|.
   virtual bool GetWindowEdge(int x, int y, GdkWindowEdge* edge);
 
   // Returns the window shape for the window with |width| and |height|.
   // The caller is responsible for destroying the region if non-null region is
   // returned.
   virtual GdkRegion* GetWindowShape(int width, int height) const;
 
-  // Draws the border, including resizable corners, for the custom frame.
-  virtual void DrawCustomFrameBorder(GtkWidget* widget);
+  // Draws the frame, including background, border and drop shadow.
+  virtual void DrawFrame(GtkWidget* widget, GdkEventExpose* event);
 
   virtual bool HandleTitleBarLeftMousePress(GdkEventButton* event,
                                             guint32 last_click_time,
                                             gfx::Point last_click_position);
 
   // Returns true if handled.
   virtual bool HandleWindowEdgeLeftMousePress(GtkWindow* window,
                                               GdkWindowEdge edge,
                                               GdkEventButton* event);
 
   // Save the window position in the prefs.
   virtual void SaveWindowPosition();
 
   // Sets the default size for the window and the way the user is allowed to
   // resize it.
   virtual void SetGeometryHints();
 
   // Returns |true| if we should use the custom frame.
   virtual bool UseCustomFrame() const;
 
-  // Whether we should draw the tab background instead of the theme_frame
-  // background because this window is a popup.
-  virtual bool UsingCustomPopupFrame() const;
-
   // Called when the window size changed.
   virtual void OnSizeChanged(int width, int height);
 
-  // Draws the normal custom frame using theme_frame.
-  virtual void DrawCustomFrame(cairo_t* cr, GtkWidget* widget,
-                               GdkEventExpose* event);
-
-  // Draws the tab image as the frame so we can write legible text.
-  virtual void DrawPopupFrame(cairo_t* cr, GtkWidget* widget,
-                              GdkEventExpose* event);
-
   // 'focus-in-event' handler.
   virtual void HandleFocusIn(GtkWidget* widget, GdkEventFocus* event);
 
   // Returns the size of the window frame around the client content area.
   gfx::Size GetNonClientFrameSize() const;
 
   // Invalidate window to force repaint.
   void InvalidateWindow();
 
   // Top level window.
@@ skipping 29 matching lines @@
   // not).
   void SetBackgroundColor();
 
   // Applies the window shape to if we're in custom drawing mode.
   void UpdateWindowShape(int width, int height);
 
   // Connect accelerators that aren't connected to menu items (like ctrl-o,
   // ctrl-l, etc.).
   void ConnectAccelerators();
 
+  // Whether we should draw the tab background instead of the theme_frame
+  // background because this window is a popup.
+  bool UsingCustomPopupFrame() const;
+
+  // Draws the normal custom frame using theme_frame.
+  void DrawCustomFrame(cairo_t* cr, GtkWidget* widget, GdkEventExpose* event);
+
+  // Draws the tab image as the frame so we can write legible text.
+  void DrawPopupFrame(cairo_t* cr, GtkWidget* widget, GdkEventExpose* event);
+
+  // Draws the border, including resizable corners, for the custom frame.
+  void DrawCustomFrameBorder(GtkWidget* widget);
+
   // Change whether we're showing the custom blue frame.
   // Must be called once at startup.
   // Triggers relayout of the content.
   void UpdateCustomFrame();
 
   // Set the bounds of the current window. If |exterior| is true, set the size
   // of the window itself, otherwise set the bounds of the web contents.
   // If |move| is true, set the position of the window, otherwise leave the
   // position to the WM.
   void SetBoundsImpl(const gfx::Rect& bounds, bool exterior, bool move);
@@ skipping 106 matching lines @@
   // The position and size of the non-maximized, non-fullscreen window.
   gfx::Rect restored_bounds_;
 
   GdkWindowState state_;
 
   // Controls a hidden GtkMenuBar that we keep updated so GNOME can take a look
   // inside "our menu bar" and present it in the top panel, akin to Mac OS.
   scoped_ptr<GlobalMenuBar> global_menu_bar_;
 
   // The container for the titlebar + tab strip.
-  scoped_ptr<BrowserTitlebar> titlebar_;
+  scoped_ptr<BrowserTitlebarBase> titlebar_;
 
   // The object that manages all of the widgets in the toolbar.
   scoped_ptr<BrowserToolbarGtk> toolbar_;
 
   // The object that manages the bookmark bar. This will be NULL if the
   // bookmark bar is not supported.
   scoped_ptr<BookmarkBarGtk> bookmark_bar_;
 
   // The download shelf view (view at the bottom of the page).
   scoped_ptr<DownloadShelfGtk> download_shelf_;
@@ skipping 69 matching lines @@
   scoped_ptr<FullscreenExitBubbleGtk> fullscreen_exit_bubble_;
 
   FullscreenExitBubbleType fullscreen_exit_bubble_type_;
 
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserWindowGtk);
 };
 
 #endif  // CHROME_BROWSER_UI_GTK_BROWSER_WINDOW_GTK_H_