Makes it so tab_strip can compile on linux. Most differences are due...

chrome/browser/views/tabs/tab_strip.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/tabs/tab_strip.h"
 
 #include "app/drag_drop_types.h"
 #include "app/gfx/canvas.h"
 #include "app/gfx/path.h"
 #include "app/l10n_util.h"
 #include "app/os_exchange_data.h"
 #include "app/resource_bundle.h"
 #include "app/slide_animation.h"
+#if defined(OS_WIN)
 #include "app/win_util.h"
+#endif
 #include "base/gfx/size.h"
 #include "base/stl_util-inl.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/view_ids.h"
 #include "chrome/browser/views/tabs/dragged_tab_controller.h"
 #include "chrome/browser/views/tabs/tab.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
@@ skipping 43 matching lines @@
   virtual ~NewTabButton() {}
 
  protected:
   // Overridden from views::View:
   virtual bool HasHitTestMask() const {
     return true;
   }
   virtual void GetHitTestMask(gfx::Path* path) const {
     DCHECK(path);
 
-    SkScalar h = SkIntToScalar(height());
     SkScalar w = SkIntToScalar(width());
 
     // These values are defined by the shape of the new tab bitmap. Should that
     // bitmap ever change, these values will need to be updated. They're so
     // custom it's not really worth defining constants for.
     path->moveTo(0, 1);
     path->lineTo(w - 7, 1);
     path->lineTo(w - 4, 4);
     path->lineTo(w, 16);
     path->lineTo(w - 1, 17);
@@ skipping 135 matching lines @@
   bool layout_on_completion_;
 
   const Type type_;
 
   DISALLOW_EVIL_CONSTRUCTORS(TabAnimation);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Handles insertion of a Tab at |index|.
-class InsertTabAnimation : public TabStrip::TabAnimation {
+class TabStrip::InsertTabAnimation : public TabStrip::TabAnimation {
  public:
   explicit InsertTabAnimation(TabStrip* tabstrip, int index)
       : TabAnimation(tabstrip, INSERT),
         index_(index) {
     int tab_count = tabstrip->GetTabCount();
     GenerateStartAndEndWidths(tab_count - 1, tab_count);
   }
   virtual ~InsertTabAnimation() {}
 
  protected:
@@ skipping 20 matching lines @@
 
  private:
   int index_;
 
   DISALLOW_EVIL_CONSTRUCTORS(InsertTabAnimation);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Handles removal of a Tab from |index|
-class RemoveTabAnimation : public TabStrip::TabAnimation {
+class TabStrip::RemoveTabAnimation : public TabStrip::TabAnimation {
  public:
   RemoveTabAnimation(TabStrip* tabstrip, int index, TabContents* contents)
       : TabAnimation(tabstrip, REMOVE),
         index_(index) {
     int tab_count = tabstrip->GetTabCount();
     GenerateStartAndEndWidths(tab_count, tab_count - 1);
   }
 
   // Returns the index of the tab being removed.
   int index() const { return index_; }
@@ skipping 43 matching lines @@
   // a mouse moved event at the current mouse position. This tickles the Tab
   // the mouse is currently over to show the "hot" state of the close button.
   void HighlightCloseButton() {
     if (tabstrip_->available_width_for_tabs_ == -1 ||
         tabstrip_->IsDragSessionActive()) {
       // This function is not required (and indeed may crash!) for removes
       // spawned by non-mouse closes and drag-detaches.
       return;
     }
 
+#if defined(OS_WIN)
     POINT pt;
     GetCursorPos(&pt);
     views::Widget* widget = tabstrip_->GetWidget();
     RECT wr;
     GetWindowRect(widget->GetNativeView(), &wr);
     pt.x -= wr.left;
     pt.y -= wr.top;
 
     // Return to message loop - otherwise we may disrupt some operation that's
     // in progress.
     PostMessage(widget->GetNativeView(), WM_MOUSEMOVE, 0,
                 MAKELPARAM(pt.x, pt.y));
+#else
+    NOTIMPLEMENTED();
+#endif
   }
 
   int index_;
 
   DISALLOW_EVIL_CONSTRUCTORS(RemoveTabAnimation);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Handles the movement of a Tab from one position to another.
-class MoveTabAnimation : public TabStrip::TabAnimation {
+class TabStrip::MoveTabAnimation : public TabStrip::TabAnimation {
  public:
   MoveTabAnimation(TabStrip* tabstrip, int tab_a_index, int tab_b_index)
       : TabAnimation(tabstrip, MOVE),
         start_tab_a_bounds_(tabstrip_->GetIdealBounds(tab_b_index)),
         start_tab_b_bounds_(tabstrip_->GetIdealBounds(tab_a_index)) {
     tab_a_ = tabstrip_->GetTabAt(tab_a_index);
     tab_b_ = tabstrip_->GetTabAt(tab_b_index);
 
     // Since we don't do a full TabStrip re-layout, we need to force a full
     // layout upon completion since we're not guaranteed to be in a good state
@@ skipping 34 matching lines @@
   gfx::Rect start_tab_a_bounds_;
   gfx::Rect start_tab_b_bounds_;
 
   DISALLOW_EVIL_CONSTRUCTORS(MoveTabAnimation);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Handles the animated resize layout of the entire TabStrip from one width
 // to another.
-class ResizeLayoutAnimation : public TabStrip::TabAnimation {
+class TabStrip::ResizeLayoutAnimation : public TabStrip::TabAnimation {
  public:
   explicit ResizeLayoutAnimation(TabStrip* tabstrip)
       : TabAnimation(tabstrip, RESIZE) {
     int tab_count = tabstrip->GetTabCount();
     GenerateStartAndEndWidths(tab_count, tab_count);
     InitStartState();
   }
   virtual ~ResizeLayoutAnimation() {
   }
 
@@ skipping 62 matching lines @@
   // crash in the case where the user closes the window after closing a tab
   // but before moving the mouse.
   RemoveMessageLoopObserver();
 }
 
 int TabStrip::GetPreferredHeight() {
   return GetPreferredSize().height();
 }
 
 bool TabStrip::CanProcessInputEvents() const {
-  return IsAnimating() == NULL;
+  return !IsAnimating();
 }
 
 bool TabStrip::PointIsWithinWindowCaption(const gfx::Point& point) {
   views::View* v = GetViewForPoint(point);
 
   // If there is no control at this location, claim the hit was in the title
   // bar to get a move action.
   if (v == this)
     return true;
 
@@ skipping 298 matching lines @@
     }
   }
 
   // We only add the tab to the child list if it's not already - an invisible
   // tab maintained by the DraggedTabController will already be parented.
   if (!tab->GetParent())
     AddChildView(tab);
 
   // Don't animate the first tab, it looks weird, and don't animate anything
   // if the containing window isn't visible yet.
-  if (GetTabCount() > 1 && GetWidget() &&
-      IsWindowVisible(GetWidget()->GetNativeView())) {
+  if (GetTabCount() > 1 && GetWindow() && GetWindow()->IsVisible()) {
     StartInsertTabAnimation(index);
   } else {
     Layout();
   }
 }
 
 void TabStrip::TabDetachedAt(TabContents* contents, int index) {
   if (CanUpdateDisplay()) {
     GenerateIdealBounds();
     StartRemoveTabAnimation(index, contents);
@@ skipping 16 matching lines @@
     if (!IsAnimating() && (!resize_layout_scheduled_ || tiny_tabs)) {
       Layout();
     } else {
       SchedulePaint();
     }
   }
 }
 
 void TabStrip::TabMoved(TabContents* contents, int from_index, int to_index) {
   Tab* tab = GetTabAt(from_index);
-  Tab* other_tab = GetTabAt(to_index);
   tab_data_.erase(tab_data_.begin() + from_index);
   TabData data = {tab, gfx::Rect()};
   tab_data_.insert(tab_data_.begin() + to_index, data);
   GenerateIdealBounds();
   StartMoveTabAnimation(from_index, to_index);
 }
 
 void TabStrip::TabChangedAt(TabContents* contents, int index,
                             bool loading_only) {
   // Index is in terms of the model. Need to make sure we adjust that index in
@@ skipping 132 matching lines @@
 void TabStrip::ButtonPressed(views::Button* sender) {
   if (sender == newtab_button_) {
     UserMetrics::RecordAction(L"NewTab_Button", model_->profile());
     model_->delegate()->AddBlankTab(true);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, MessageLoop::Observer implementation:
 
+#if defined(OS_WIN)
 void TabStrip::WillProcessMessage(const MSG& msg) {
 }
 
 void TabStrip::DidProcessMessage(const MSG& msg) {
   // We spy on three different Windows messages here to see if the mouse has
   // moved out of the bounds of the tabstrip, which we use as our cue to kick
   // of the resize animation. The messages are:
   //
   // WM_MOUSEMOVE:
   //   For when the mouse moves from the tabstrip over into the rest of the
@@ skipping 30 matching lines @@
         }
       } else {
         // Mouse moved quickly out of the tab strip and then into it again, so
         // cancel the timer so that the strip doesn't move when the mouse moves
         // back over it.
         resize_layout_factory_.RevokeAll();
       }
       break;
   }
 }
+#else
+void TabStrip::WillProcessEvent(GdkEvent* event) {
+  NOTIMPLEMENTED();
+}
+#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, private:
 
 void TabStrip::Init() {
   model_->AddObserver(this);
   newtab_button_ = new NewTabButton(this);
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   SkBitmap* bitmap;
 
@@ skipping 127 matching lines @@
     StartResizeLayoutAnimation();
 }
 
 bool TabStrip::IsCursorInTabStripZone() {
   gfx::Rect bounds = GetLocalBounds(true);
   gfx::Point tabstrip_topleft(bounds.origin());
   View::ConvertPointToScreen(this, &tabstrip_topleft);
   bounds.set_origin(tabstrip_topleft);
   bounds.set_height(bounds.height() + kTabStripAnimationVSlop);
 
-  CPoint cursor_point;
-  GetCursorPos(&cursor_point);
+#if defined(OS_WIN)
+  CPoint cursor_point_c;
+  GetCursorPos(&cursor_point_c);
+  gfx::Point cursor_point(cursor_point_c);
+#else
+  // TODO: make sure this is right with multiple monitors.
+  gint x, y;
+  gdk_display_get_pointer(NULL, NULL, &x, &y, NULL);
+  gfx::Point cursor_point(x, y);
+#endif
 
-  return bounds.Contains(cursor_point.x, cursor_point.y);
+  return bounds.Contains(cursor_point.x(), cursor_point.y());
 }
 
 void TabStrip::AddMessageLoopObserver() {
   if (!added_as_message_loop_observer_) {
     MessageLoopForUI::current()->AddObserver(this);
     added_as_message_loop_observer_ = true;
   }
 }
 
 void TabStrip::RemoveMessageLoopObserver() {
@@ skipping 23 matching lines @@
   center_x = MirroredXCoordinateInsideView(center_x);
 
   // Determine the screen bounds.
   gfx::Point drop_loc(center_x - drop_indicator_width / 2,
                       -drop_indicator_height);
   ConvertPointToScreen(this, &drop_loc);
   gfx::Rect drop_bounds(drop_loc.x(), drop_loc.y(), drop_indicator_width,
                         drop_indicator_height);
 
   // If the rect doesn't fit on the monitor, push the arrow to the bottom.
+#if defined(OS_WIN)
   gfx::Rect monitor_bounds = win_util::GetMonitorBoundsForRect(drop_bounds);
   *is_beneath = (monitor_bounds.IsEmpty() ||
                  !monitor_bounds.Contains(drop_bounds));
+#else
+  *is_beneath = false;
+  NOTIMPLEMENTED();
+#endif
   if (*is_beneath)
     drop_bounds.Offset(0, drop_bounds.height() + height());
 
   return drop_bounds;
 }
 
 void TabStrip::UpdateDropIndex(const DropTargetEvent& event) {
   // If the UI layout is right-to-left, we need to mirror the mouse
   // coordinates since we calculate the drop index based on the
   // original (and therefore non-mirrored) positions of the tabs.
@@ skipping 40 matching lines @@
     if (is_beneath == drop_info_->point_down) {
       drop_info_->point_down = !is_beneath;
       drop_info_->arrow_view->SetImage(
           GetDropArrowImage(drop_info_->point_down));
     }
   }
 
   // Reposition the window. Need to show it too as the window is initially
   // hidden.
 
+#if defined(OS_WIN)
   drop_info_->arrow_window->SetWindowPos(
       HWND_TOPMOST, drop_bounds.x(), drop_bounds.y(), drop_bounds.width(),
       drop_bounds.height(), SWP_NOACTIVATE | SWP_SHOWWINDOW);
+#else
+  NOTIMPLEMENTED();
+#endif
 }
 
 int TabStrip::GetDropEffect(const views::DropTargetEvent& event) {
   const int source_ops = event.GetSourceOperations();
   if (source_ops & DragDropTypes::DRAG_COPY)
     return DragDropTypes::DRAG_COPY;
   if (source_ops & DragDropTypes::DRAG_LINK)
     return DragDropTypes::DRAG_LINK;
   return DragDropTypes::DRAG_MOVE;
 }
 
 // static
 SkBitmap* TabStrip::GetDropArrowImage(bool is_down) {
   return ResourceBundle::GetSharedInstance().GetBitmapNamed(
       is_down ? IDR_TAB_DROP_DOWN : IDR_TAB_DROP_UP);
 }
 
 // TabStrip::DropInfo ----------------------------------------------------------
 
 TabStrip::DropInfo::DropInfo(int drop_index, bool drop_before, bool point_down)
     : drop_index(drop_index),
       drop_before(drop_before),
       point_down(point_down) {
+#if defined(OS_WIN)
   arrow_window = new views::WidgetWin;
   arrow_window->set_window_style(WS_POPUP);
   arrow_window->set_window_ex_style(WS_EX_TOPMOST | WS_EX_NOACTIVATE |
                                     WS_EX_LAYERED | WS_EX_TRANSPARENT);
 
   arrow_view = new views::ImageView;
   arrow_view->SetImage(GetDropArrowImage(point_down));
 
   arrow_window->Init(
       NULL,
       gfx::Rect(0, 0, drop_indicator_width, drop_indicator_height),
       true);
   arrow_window->SetContentsView(arrow_view);
+#else
+  NOTIMPLEMENTED();
+#endif
 }
 
 TabStrip::DropInfo::~DropInfo() {
   // Close eventually deletes the window, which deletes arrow_view too.
+#if defined(OS_WIN)
   arrow_window->Close();
+#endif
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Called from:
 // - BasicLayout
 // - Tab insertion/removal
 // - Tab reorder
 void TabStrip::GenerateIdealBounds() {
   int tab_count = GetTabCount();
@@ skipping 146 matching lines @@
   // If the TabContents being detached was removed as a result of a drag
   // gesture from its corresponding Tab, we don't want to remove the Tab from
   // the child list, because if we do so it'll stop receiving events and the
   // drag will stall. So we only remove if a drag isn't active, or the Tab
   // was for some other TabContents.
   if (!IsDragSessionActive() || !drag_controller_->IsDragSourceTab(removed)) {
     removed->GetParent()->RemoveChildView(removed);
     delete removed;
   }
 }