Support DWM switching....

chrome/browser/views/frame/glass_browser_frame_view.cc

 // 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.
 
-#include "chrome/browser/views/frame/aero_glass_non_client_view.h"
+#include "chrome/browser/views/frame/glass_browser_frame_view.h"
 
 #include "chrome/browser/views/frame/browser_view.h"
 #include "chrome/browser/views/tabs/tab_strip.h"
 #include "chrome/common/resource_bundle.h"
 #include "chrome/views/client_view.h"
 #include "chrome/views/window_resources.h"
 #include "grit/theme_resources.h"
 
 // An enumeration of bitmap resources used by this window.
 enum {
   // Client Edge Border.
   FRAME_CLIENT_EDGE_TOP_LEFT,
   FRAME_CLIENT_EDGE_TOP,
   FRAME_CLIENT_EDGE_TOP_RIGHT,
   FRAME_CLIENT_EDGE_RIGHT,
   FRAME_CLIENT_EDGE_BOTTOM_RIGHT,
   FRAME_CLIENT_EDGE_BOTTOM,
   FRAME_CLIENT_EDGE_BOTTOM_LEFT,
   FRAME_CLIENT_EDGE_LEFT,
 
   FRAME_PART_BITMAP_COUNT  // Must be last.
 };
 
-class AeroGlassWindowResources {
+class GlassBrowserWindowResources {
  public:
-  AeroGlassWindowResources() {
+  GlassBrowserWindowResources() {
     InitClass();
   }
-  virtual ~AeroGlassWindowResources() { }
+  virtual ~GlassBrowserWindowResources() { }
 
   virtual SkBitmap* GetPartBitmap(views::FramePartBitmap part) const {
     return standard_frame_bitmaps_[part];
   }
 
  private:
   static void InitClass() {
     static bool initialized = false;
     if (!initialized) {
       static const int kFramePartBitmapIds[] = {
         IDR_CONTENT_TOP_LEFT_CORNER, IDR_CONTENT_TOP_CENTER,
             IDR_CONTENT_TOP_RIGHT_CORNER, IDR_CONTENT_RIGHT_SIDE,
             IDR_CONTENT_BOTTOM_RIGHT_CORNER, IDR_CONTENT_BOTTOM_CENTER,
             IDR_CONTENT_BOTTOM_LEFT_CORNER, IDR_CONTENT_LEFT_SIDE,
       };
 
       ResourceBundle& rb = ResourceBundle::GetSharedInstance();
       for (int i = 0; i < FRAME_PART_BITMAP_COUNT; ++i)
         standard_frame_bitmaps_[i] = rb.GetBitmapNamed(kFramePartBitmapIds[i]);
 
       initialized = true;
     }
   }
 
   static SkBitmap* standard_frame_bitmaps_[FRAME_PART_BITMAP_COUNT];
 
-  DISALLOW_EVIL_CONSTRUCTORS(AeroGlassWindowResources);
+  DISALLOW_EVIL_CONSTRUCTORS(GlassBrowserWindowResources);
 };
 
 // static
-SkBitmap* AeroGlassWindowResources::standard_frame_bitmaps_[];
+SkBitmap* GlassBrowserWindowResources::standard_frame_bitmaps_[];
 
-AeroGlassWindowResources* AeroGlassNonClientView::resources_ = NULL;
-SkBitmap* AeroGlassNonClientView::distributor_logo_ = NULL;
+GlassBrowserWindowResources* GlassBrowserFrameView::resources_ = NULL;
+SkBitmap* GlassBrowserFrameView::distributor_logo_ = NULL;
+HICON GlassBrowserFrameView::throbber_icons_[GlassBrowserFrameView::kThrobberIconCount];
 
 namespace {
 // There are 3 px of client edge drawn inside the outer frame borders.
 const int kNonClientBorderThickness = 3;
 // Besides the frame border, there's another 11 px of empty space atop the
 // window in restored mode, to use to drag the window around.
 const int kNonClientRestoredExtraThickness = 11;
 // In the window corners, the resize areas don't actually expand bigger, but the
 // 16 px at the end of the top and bottom edges triggers diagonal resizing.
 const int kResizeAreaCornerSize = 16;
@@ skipping 16 matching lines @@
 // In maximized mode, where the New Tab button and the caption buttons are at
 // similar vertical coordinates, we need to reserve a larger, 16 px gap to avoid
 // looking too cluttered.
 const int kNewTabCaptionMaximizedSpacing = 16;
 // When there's a distributor logo, we leave a 7 px gap between it and the
 // caption buttons.
 const int kLogoCaptionSpacing = 7;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// AeroGlassNonClientView, public:
+// GlassBrowserFrameView, public:
 
-AeroGlassNonClientView::AeroGlassNonClientView(AeroGlassFrame* frame,
-                                               BrowserView* browser_view)
-    : frame_(frame),
-      browser_view_(browser_view) {
+GlassBrowserFrameView::GlassBrowserFrameView(BrowserFrame* frame,
+                                             BrowserView* browser_view)
+    : BrowserNonClientFrameView(),
+      frame_(frame),
+      browser_view_(browser_view),
+      throbber_running_(false),
+      throbber_frame_(0) {
   InitClass();
+  if (frame_->window_delegate()->ShouldShowWindowIcon())
+    InitThrobberIcons();
 }
 
-AeroGlassNonClientView::~AeroGlassNonClientView() {
+GlassBrowserFrameView::~GlassBrowserFrameView() {
 }
 
-gfx::Rect AeroGlassNonClientView::GetBoundsForTabStrip(TabStrip* tabstrip) {
+///////////////////////////////////////////////////////////////////////////////
+// GlassBrowserFrameView, BrowserNonClientFrameView implementation:
+
+gfx::Rect GlassBrowserFrameView::GetBoundsForTabStrip(
+    TabStrip* tabstrip) const {
   int tabstrip_x = browser_view_->ShouldShowOffTheRecordAvatar() ?
       (otr_avatar_bounds_.right() + kOTRSideSpacing) :
       NonClientBorderThickness();
   int tabstrip_width = frame_->GetMinimizeButtonOffset() - tabstrip_x -
       (frame_->IsMaximized() ?
       kNewTabCaptionMaximizedSpacing : kNewTabCaptionRestoredSpacing);
   return gfx::Rect(tabstrip_x, NonClientTopBorderHeight(),
                    std::max(0, tabstrip_width), tabstrip->GetPreferredHeight());
 }
 
+void GlassBrowserFrameView::UpdateThrobber(bool running) {
+  if (throbber_running_) {
+    if (running) {
+      DisplayNextThrobberFrame();
+    } else {
+      StopThrobber();
+    }
+  } else if (running) {
+    StartThrobber();
+  }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
-// AeroGlassNonClientView, views::NonClientView implementation:
+// GlassBrowserFrameView, views::NonClientFrameView implementation:
 
-gfx::Rect AeroGlassNonClientView::CalculateClientAreaBounds(int width,
-                                                            int height) const {
-  if (!browser_view_->IsTabStripVisible())
-    return gfx::Rect(0, 0, this->width(), this->height());
+gfx::Rect GlassBrowserFrameView::GetBoundsForClientView() const {
+  return client_view_bounds_;
+}
+
+gfx::Rect GlassBrowserFrameView::GetWindowBoundsForClientBounds(
+    const gfx::Rect& client_bounds) const {
+  if (!browser_view_->IsTabStripVisible()) {
+    // If we don't have a tabstrip, we're either a popup or an app window, in
+    // which case we have a standard size non-client area and can just use
+    // AdjustWindowRectEx to obtain it.
+    RECT rect = client_bounds.ToRECT();
+    AdjustWindowRectEx(&rect, frame_->window_style(), FALSE,
+                       frame_->window_ex_style());
+    return gfx::Rect(rect);    
+  }
 
   int top_height = NonClientTopBorderHeight();
   int border_thickness = NonClientBorderThickness();
-  return gfx::Rect(border_thickness, top_height,
-                   std::max(0, width - (2 * border_thickness)),
-                   std::max(0, height - top_height - border_thickness));
+  return gfx::Rect(std::max(0, client_bounds.x() - border_thickness),
+                   std::max(0, client_bounds.y() - top_height),
+                   client_bounds.width() + (2 * border_thickness),
+                   client_bounds.height() + top_height + border_thickness);
 }
 
-gfx::Size AeroGlassNonClientView::CalculateWindowSizeForClientSize(
-    int width,
-    int height) const {
-  int border_thickness = NonClientBorderThickness();
-  return gfx::Size(width + (2 * border_thickness),
-                   height + NonClientTopBorderHeight() + border_thickness);
-}
-
-gfx::Point AeroGlassNonClientView::GetSystemMenuPoint() const {
+gfx::Point GlassBrowserFrameView::GetSystemMenuPoint() const {
   gfx::Point system_menu_point;
   if (browser_view_->IsBrowserTypeNormal()) {
     // The maximized mode bit here is because in maximized mode the frame edge
     // and the client edge are both offscreen, whereas in the opaque frame
     // (where we don't do this trick) maximized windows have no client edge and
     // only the frame edge is offscreen.
     system_menu_point.SetPoint(NonClientBorderThickness() -
         (frame_->IsMaximized() ? 0 : kClientEdgeThickness),
         NonClientTopBorderHeight() + browser_view_->GetTabStripHeight() -
         kClientEdgeThickness);
   } else {
     system_menu_point.SetPoint(0, -kFrameShadowThickness);
   }
   ConvertPointToScreen(this, &system_menu_point);
   return system_menu_point;
 }
 
-int AeroGlassNonClientView::NonClientHitTest(const gfx::Point& point) {
+int GlassBrowserFrameView::NonClientHitTest(const gfx::Point& point) {
   // If the browser isn't in normal mode, we haven't customized the frame, so
   // Windows can figure this out.  If the point isn't within our bounds, then
   // it's in the native portion of the frame, so again Windows can figure it
   // out.
   if (!browser_view_->IsBrowserTypeNormal() || !bounds().Contains(point))
     return HTNOWHERE;
 
   int frame_component = frame_->client_view()->NonClientHitTest(point);
   if (frame_component != HTNOWHERE)
     return frame_component;
 
   int border_thickness = FrameBorderThickness();
   int window_component = GetHTComponentForFrame(point, border_thickness,
       NonClientBorderThickness(), border_thickness,
       kResizeAreaCornerSize - border_thickness,
       frame_->window_delegate()->CanResize());
   // Fall back to the caption if no other component matches.
   return (window_component == HTNOWHERE) ? HTCAPTION : window_component;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// AeroGlassNonClientView, views::View overrides:
+// GlassBrowserFrameView, views::View overrides:
 
-void AeroGlassNonClientView::Paint(ChromeCanvas* canvas) {
+void GlassBrowserFrameView::Paint(ChromeCanvas* canvas) {
   if (!browser_view_->IsTabStripVisible())
     return;  // Nothing is visible, so don't bother to paint.
 
   PaintDistributorLogo(canvas);
   PaintToolbarBackground(canvas);
   PaintOTRAvatar(canvas);
   PaintClientEdge(canvas);
 }
 
-void AeroGlassNonClientView::Layout() {
+void GlassBrowserFrameView::Layout() {
   LayoutDistributorLogo();
   LayoutOTRAvatar();
   LayoutClientView();
 }
 
-void AeroGlassNonClientView::ViewHierarchyChanged(bool is_add,
-                                                  views::View* parent,
-                                                  views::View* child) {
-  if (is_add && child == this) {
-    DCHECK(GetWidget());
-    DCHECK(frame_->client_view()->GetParent() != this);
-    AddChildView(frame_->client_view());
-  }
-}
+///////////////////////////////////////////////////////////////////////////////
+// GlassBrowserFrameView, private:
 
-///////////////////////////////////////////////////////////////////////////////
-// AeroGlassNonClientView, private:
-
-int AeroGlassNonClientView::FrameBorderThickness() const {
+int GlassBrowserFrameView::FrameBorderThickness() const {
   return GetSystemMetrics(SM_CXSIZEFRAME);
 }
 
-int AeroGlassNonClientView::NonClientBorderThickness() const {
+int GlassBrowserFrameView::NonClientBorderThickness() const {
   return kNonClientBorderThickness;
 }
 
-int AeroGlassNonClientView::NonClientTopBorderHeight() const {
+int GlassBrowserFrameView::NonClientTopBorderHeight() const {
   return FrameBorderThickness() +
       (frame_->IsMaximized() ? 0 : kNonClientRestoredExtraThickness);
 }
 
-void AeroGlassNonClientView::PaintDistributorLogo(ChromeCanvas* canvas) {
+void GlassBrowserFrameView::PaintDistributorLogo(ChromeCanvas* canvas) {
   // The distributor logo is only painted when the frame is not maximized and
   // when we actually have a logo.
   if (!frame_->IsMaximized() && distributor_logo_) {
     // NOTE: We don't mirror the logo placement here because the outer frame
     // itself isn't mirrored in RTL.  This is a bug; if it is fixed, this should
     // be mirrored as in opaque_non_client_view.cc.
     canvas->DrawBitmapInt(*distributor_logo_, logo_bounds_.x(),
                           logo_bounds_.y());
   }
 }
 
-void AeroGlassNonClientView::PaintToolbarBackground(ChromeCanvas* canvas) {
+void GlassBrowserFrameView::PaintToolbarBackground(ChromeCanvas* canvas) {
   gfx::Rect toolbar_bounds(browser_view_->GetToolbarBounds());
   gfx::Point toolbar_origin(toolbar_bounds.origin());
   View::ConvertPointToView(frame_->client_view(), this, &toolbar_origin);
   toolbar_bounds.set_origin(toolbar_origin);
 
   SkBitmap* toolbar_left =
       resources_->GetPartBitmap(FRAME_CLIENT_EDGE_TOP_LEFT);
   canvas->DrawBitmapInt(*toolbar_left,
                         toolbar_bounds.x() - toolbar_left->width(),
                         toolbar_bounds.y());
 
   SkBitmap* toolbar_center =
       resources_->GetPartBitmap(FRAME_CLIENT_EDGE_TOP);
   canvas->TileImageInt(*toolbar_center, toolbar_bounds.x(), toolbar_bounds.y(),
                        toolbar_bounds.width(), toolbar_center->height());
 
   canvas->DrawBitmapInt(*resources_->GetPartBitmap(FRAME_CLIENT_EDGE_TOP_RIGHT),
       toolbar_bounds.right(), toolbar_bounds.y());
 }
 
-void AeroGlassNonClientView::PaintOTRAvatar(ChromeCanvas* canvas) {
+void GlassBrowserFrameView::PaintOTRAvatar(ChromeCanvas* canvas) {
   if (!browser_view_->ShouldShowOffTheRecordAvatar())
     return;
 
   SkBitmap otr_avatar_icon = browser_view_->GetOTRAvatarIcon();
   canvas->DrawBitmapInt(otr_avatar_icon, 0,
       (otr_avatar_icon.height() - otr_avatar_bounds_.height()) / 2,
       otr_avatar_bounds_.width(), otr_avatar_bounds_.height(), 
       MirroredLeftPointForRect(otr_avatar_bounds_), otr_avatar_bounds_.y(),
       otr_avatar_bounds_.width(), otr_avatar_bounds_.height(), false);
 }
 
-void AeroGlassNonClientView::PaintClientEdge(ChromeCanvas* canvas) {
+void GlassBrowserFrameView::PaintClientEdge(ChromeCanvas* canvas) {
   // The client edges start below the toolbar upper corner images regardless
   // of how tall the toolbar itself is.
   int client_area_top =
       frame_->client_view()->y() + browser_view_->GetToolbarBounds().y() +
       resources_->GetPartBitmap(FRAME_CLIENT_EDGE_TOP_LEFT)->height();
 
   gfx::Rect client_area_bounds = CalculateClientAreaBounds(width(), height());
   int client_area_bottom =
       std::max(client_area_top, height() - NonClientBorderThickness());
   int client_area_height = client_area_bottom - client_area_top;
@@ skipping 13 matching lines @@
   SkBitmap* bottom_left =
       resources_->GetPartBitmap(FRAME_CLIENT_EDGE_BOTTOM_LEFT);
   canvas->DrawBitmapInt(*bottom_left,
       client_area_bounds.x() - bottom_left->width(), client_area_bottom);
 
   SkBitmap* left = resources_->GetPartBitmap(FRAME_CLIENT_EDGE_LEFT);
   canvas->TileImageInt(*left, client_area_bounds.x() - left->width(),
       client_area_top, left->width(), client_area_height);
 }
 
-void AeroGlassNonClientView::LayoutDistributorLogo() {
+void GlassBrowserFrameView::LayoutDistributorLogo() {
   if (distributor_logo_) {
     logo_bounds_.SetRect(frame_->GetMinimizeButtonOffset() -
         distributor_logo_->width() - kLogoCaptionSpacing, kLogoTopSpacing,
         distributor_logo_->width(), distributor_logo_->height());
   } else {
     logo_bounds_.SetRect(frame_->GetMinimizeButtonOffset(), kLogoTopSpacing, 0,
                          0);
   }
 }
 
-void AeroGlassNonClientView::LayoutOTRAvatar() {
+void GlassBrowserFrameView::LayoutOTRAvatar() {
   SkBitmap otr_avatar_icon = browser_view_->GetOTRAvatarIcon();
   int top_height = NonClientTopBorderHeight();
   int tabstrip_height, otr_height;
   if (browser_view_->IsTabStripVisible()) {
     tabstrip_height = browser_view_->GetTabStripHeight() - kOTRBottomSpacing;
     otr_height = frame_->IsMaximized() ?
         (tabstrip_height - kOTRMaximizedTopSpacing) :
         otr_avatar_icon.height();
   } else {
     tabstrip_height = otr_height = 0;
   }
   otr_avatar_bounds_.SetRect(NonClientBorderThickness() + kOTRSideSpacing,
                              top_height + tabstrip_height - otr_height,
                              otr_avatar_icon.width(), otr_height);
 }
 
-void AeroGlassNonClientView::LayoutClientView() {
-  frame_->client_view()->SetBounds(CalculateClientAreaBounds(width(),
-                                                             height()));
+void GlassBrowserFrameView::LayoutClientView() {
+  client_view_bounds_ = CalculateClientAreaBounds(width(), height());
+}
+
+gfx::Rect GlassBrowserFrameView::CalculateClientAreaBounds(int width,
+                                                           int height) const {
+  if (!browser_view_->IsTabStripVisible())
+    return gfx::Rect(0, 0, this->width(), this->height());
+
+  int top_height = NonClientTopBorderHeight();
+  int border_thickness = NonClientBorderThickness();
+  return gfx::Rect(border_thickness, top_height,
+                   std::max(0, width - (2 * border_thickness)),
+                   std::max(0, height - top_height - border_thickness));
+}
+
+void GlassBrowserFrameView::StartThrobber() {
+  if (!throbber_running_) {
+    throbber_running_ = true;
+    throbber_frame_ = 0;
+    InitThrobberIcons();
+    SendMessage(frame_->GetHWND(), WM_SETICON, static_cast<WPARAM>(ICON_SMALL),
+                reinterpret_cast<LPARAM>(throbber_icons_[throbber_frame_]));
+  }
+}
+
+void GlassBrowserFrameView::StopThrobber() {
+  if (throbber_running_)
+    throbber_running_ = false;
+}
+
+void GlassBrowserFrameView::DisplayNextThrobberFrame() {
+  throbber_frame_ = (throbber_frame_ + 1) % kThrobberIconCount;
+  SendMessage(frame_->GetHWND(), WM_SETICON, static_cast<WPARAM>(ICON_SMALL),
+              reinterpret_cast<LPARAM>(throbber_icons_[throbber_frame_]));
 }
 
 // static
-void AeroGlassNonClientView::InitClass() {
+void GlassBrowserFrameView::InitThrobberIcons() {
   static bool initialized = false;
   if (!initialized) {
-    resources_ = new AeroGlassWindowResources;
+    ResourceBundle &rb = ResourceBundle::GetSharedInstance();
+    for (int i = 0; i < kThrobberIconCount; ++i) {
+      throbber_icons_[i] = rb.LoadThemeIcon(IDR_THROBBER_01 + i);
+      DCHECK(throbber_icons_[i]);
+    }
+    initialized = true;
+  }
+}
+
+// static
+void GlassBrowserFrameView::InitClass() {
+  static bool initialized = false;
+  if (!initialized) {
+    resources_ = new GlassBrowserWindowResources;
 
 #if defined(GOOGLE_CHROME_BUILD)
     distributor_logo_ = ResourceBundle::GetSharedInstance().
         GetBitmapNamed(IDR_DISTRIBUTOR_LOGO);
 #endif
 
     initialized = true;
   }
 }