Use RECT instead of CRect to reduce dependencies on ATL.

views/controls/table/table_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 "views/controls/table/table_view.h"
 
+#include <commctrl.h>
 #include <windowsx.h>
-#include <atlbase.h>
-#include <atlapp.h>
-#include <atlmisc.h>
 
 #include <algorithm>
 
 #include "app/gfx/canvas.h"
 #include "app/gfx/favicon_size.h"
 #include "app/gfx/icon_util.h"
 #include "app/l10n_util_win.h"
 #include "app/resource_bundle.h"
 #include "app/table_model.h"
 #include "base/string_util.h"
@@ skipping 206 matching lines @@
 
 TableView::iterator TableView::SelectionEnd() {
   return TableView::iterator(this, -1);
 }
 
 void TableView::OnItemsChanged(int start, int length) {
   if (!list_view_)
     return;
 
   if (length == -1) {
-    DCHECK(start >= 0);
+    DCHECK_GE(start, 0);
     length = model_->RowCount() - start;
   }
   int row_count = RowCount();
   DCHECK(start >= 0 && length > 0 && start + length <= row_count);
   SendMessage(list_view_, WM_SETREDRAW, static_cast<WPARAM>(FALSE), 0);
   if (table_type_ == ICON_AND_TEXT) {
     // The redraw event does not include the icon in the clip rect, preventing
     // our icon from being repainted. So far the only way I could find around
     // this is to change the image for the item. Even if the image does not
     // exist, it causes the clip rect to include the icon's bounds so we can
@@ skipping 103 matching lines @@
   //
   // When the model is set to NULL all the rows are removed. We don't notify
   // the delegate in this case as setting the model to NULL is usually done as
   // the last step before being deleted and callers shouldn't have to deal with
   // getting a selection change when the model is being reset.
   if (model_ && table_view_observer_ && had_selection && RowCount() == 0)
     table_view_observer_->OnSelectionChanged();
 }
 
 void TableView::AddColumn(const TableColumn& col) {
-  DCHECK(all_columns_.count(col.id) == 0);
+  DCHECK_EQ(0, all_columns_.count(col.id));
   all_columns_[col.id] = col;
 }
 
 void TableView::SetColumns(const std::vector<TableColumn>& columns) {
   // Remove the currently visible columns.
   while (!visible_columns_.empty())
     SetColumnVisibility(visible_columns_.front(), false);
 
   all_columns_.clear();
   for (std::vector<TableColumn>::const_iterator i = columns.begin();
@@ skipping 161 matching lines @@
       //    list-view twice in a row.
       // 2. Right clicking on the icon would show the scrollbar menu.
       //
       // As a work around this uses the position of the cursor and ignores
       // the position supplied in the l_param.
       if (table_view->UILayoutIsRightToLeft() &&
           (GET_X_LPARAM(l_param) != -1 || GET_Y_LPARAM(l_param) != -1)) {
         POINT screen_point;
         GetCursorPos(&screen_point);
         POINT table_point = screen_point;
-        WTL::CRect client_rect;
+        RECT client_rect;
         if (ScreenToClient(window, &table_point) &&
             GetClientRect(window, &client_rect) &&
-            client_rect.PtInRect(table_point)) {
+            PtInRect(&client_rect, table_point)) {
           // The point is over the client area of the table, handle it ourself.
           // But first select the row if it isn't already selected.
           LVHITTESTINFO hit_info = {0};
           hit_info.pt.x = table_point.x;
           hit_info.pt.y = table_point.y;
           int view_index = ListView_HitTest(window, &hit_info);
           if (view_index != -1) {
             int model_index = table_view->view_to_model(view_index);
             if (!table_view->IsItemSelected(model_index))
               table_view->Select(model_index);
@@ skipping 639 matching lines @@
       // We get notifications for empty items, just ignore them.
       if (view_index >= model_->RowCount())
         return CDRF_DODEFAULT;
       int model_index = view_to_model(view_index);
       LRESULT r = CDRF_DODEFAULT;
       // First let's take care of painting the right icon.
       if (table_type_ == ICON_AND_TEXT) {
         SkBitmap image = model_->GetIcon(model_index);
         if (!image.isNull()) {
           // Get the rect that holds the icon.
-          WTL::CRect icon_rect, client_rect;
+          RECT icon_rect, client_rect;
           if (ListView_GetItemRect(list_view_, view_index, &icon_rect,
                                    LVIR_ICON) &&
               GetClientRect(list_view_, &client_rect)) {
-            WTL::CRect intersection;
+            RECT intersection;
             // Client rect includes the header but we need to make sure we don't
             // paint into it.
             client_rect.top += content_offset_;
             // Make sure the region need to paint is visible.
-            if (intersection.IntersectRect(&icon_rect, &client_rect)) {
-              gfx::Canvas canvas(icon_rect.Width(), icon_rect.Height(), false);
+            if (IntersectRect(&intersection, &icon_rect, &client_rect)) {
+              gfx::Canvas canvas(icon_rect.right - icon_rect.left,
+                                 icon_rect.bottom - icon_rect.top, false);
 
               // It seems the state in nmcd.uItemState is not correct.
               // We'll retrieve it explicitly.
               int selected = ListView_GetItemState(
                   list_view_, view_index, LVIS_SELECTED | LVIS_DROPHILITED);
               bool drop_highlight = ((selected & LVIS_DROPHILITED) != 0);
               int bg_color_index;
               if (!IsEnabled())
                 bg_color_index = COLOR_3DFACE;
               else if (drop_highlight)
@@ skipping 25 matching lines @@
               canvas.getTopPlatformDevice().drawToHDC(draw_info->nmcd.hdc,
                                                       intersection.left,
                                                       intersection.top,
                                                       &to_draw);
               r = CDRF_SKIPDEFAULT;
             }
           }
         }
       }
       if (ImplementPostPaint()) {
-        WTL::CRect cell_rect;
+        RECT cell_rect;
         if (ListView_GetItemRect(list_view_, view_index, &cell_rect,
                                  LVIR_BOUNDS)) {
           PostPaint(model_index, 0, false, gfx::Rect(cell_rect),
                     draw_info->nmcd.hdc);
           r = CDRF_SKIPDEFAULT;
         }
       }
       return r;
     }
     default:
       return CDRF_DODEFAULT;
   }
 }
 
 void TableView::UpdateListViewCache(int start, int length, bool add) {
   ignore_listview_change_ = true;
   UpdateListViewCache0(start, length, add);
   ignore_listview_change_ = false;
 }
 
 void TableView::ResetColumnSizes() {
   if (!list_view_)
     return;
 
   // See comment in TableColumn for what this does.
   int width = this->width();
-  WTL::CRect native_bounds;
-  if (GetClientRect(GetNativeControlHWND(), &native_bounds) &&
-      native_bounds.Width() > 0) {
-    // Prefer the bounds of the window over our bounds, which may be different.
-    width = native_bounds.Width();
+  RECT native_bounds;
+  if (GetClientRect(GetNativeControlHWND(), &native_bounds)) {
+    int window_width = native_bounds.right - native_bounds.left;
+    if (window_width > 0) {
+      // Prefer the bounds of the window over our bounds, which may be
+      // different.
+      width = window_width;
+    }
   }
 
   float percent = 0;
   int fixed_width = 0;
   int autosize_width = 0;
 
   for (std::vector<int>::const_iterator i = visible_columns_.begin();
        i != visible_columns_.end(); ++i) {
     TableColumn& col = all_columns_[*i];
     int col_index = static_cast<int>(i - visible_columns_.begin());
@@ skipping 158 matching lines @@
     table_view_observer_->OnKeyDown(virtual_keycode);
   }
 }
 
 void TableView::OnCheckedStateChanged(int model_row, bool is_checked) {
   if (!ignore_listview_change_)
     model_->SetChecked(model_row, is_checked);
 }
 
 int TableView::PreviousSelectedViewIndex(int view_index) {
-  DCHECK(view_index >= 0);
+  DCHECK_GE(view_index, 0);
   if (!list_view_ || view_index <= 0)
     return -1;
 
   int row_count = RowCount();
   if (row_count == 0)
     return -1;  // Empty table, nothing can be selected.
 
   // For some reason
   // ListView_GetNextItem(list_view_,item, LVNI_SELECTED | LVNI_ABOVE)
   // fails on Vista (always returns -1), so we iterate through the indices.
@@ skipping 12 matching lines @@
   if (!list_view_)
     return;
 
   HWND header = ListView_GetHeader(list_view_);
   if (!header)
     return;
 
   POINT origin = {0, 0};
   MapWindowPoints(header, list_view_, &origin, 1);
 
-  WTL::CRect header_bounds;
+  RECT header_bounds;
   GetWindowRect(header, &header_bounds);
 
-  content_offset_ = origin.y + header_bounds.Height();
+  content_offset_ = origin.y + header_bounds.bottom - header_bounds.top;
 }
 
 //
 // TableSelectionIterator
 //
 TableSelectionIterator::TableSelectionIterator(TableView* view,
                                                int view_index)
     : table_view_(view),
       view_index_(view_index) {
   UpdateModelIndexFromViewIndex();
@@ skipping 25 matching lines @@
 }
 
 void TableSelectionIterator::UpdateModelIndexFromViewIndex() {
   if (view_index_ == -1)
     model_index_ = -1;
   else
     model_index_ = table_view_->view_to_model(view_index_);
 }
 
 }  // namespace views