views: Fix a couple of other trivial TODOs.

views/controls/table/table_view.cc

 // Copyright (c) 2011 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 <algorithm>
 
 #include "base/i18n/rtl.h"
 #include "base/string_util.h"
 #include "skia/ext/skia_utils_win.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_win.h"
 #include "ui/base/models/table_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/win/hwnd_util.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/icon_util.h"
 #include "views/controls/native/native_view_host.h"
 #include "views/controls/table/table_view_observer.h"
 
-using ui::TableColumn;
-
 namespace {
 
 int GetViewIndexFromPoint(HWND window, const gfx::Point& p) {
   LVHITTESTINFO hit_info = {0};
   hit_info.pt.x = p.x();
   hit_info.pt.y = p.y();
   return ListView_HitTest(window, &hit_info);
 }
 
 }  // namespace
 
 namespace views {
 
 // Added to column width to prevent truncation.
 const int kListViewTextPadding = 15;
 // Additional column width necessary if column has icons.
 const int kListViewIconWidthAndPadding = 18;
 
 // TableView ------------------------------------------------------------------
 
 // static
 const int TableView::kImageSize = 18;
 
-TableView::TableView(TableModel* model,
-                     const std::vector<TableColumn>& columns,
+TableView::TableView(ui::TableModel* model,
+                     const std::vector<ui::TableColumn>& columns,
                      TableTypes table_type,
                      bool single_selection,
                      bool resizable_columns,
                      bool autosize_columns)
     : model_(model),
       table_view_observer_(NULL),
       visible_columns_(),
       all_columns_(),
       column_count_(static_cast<int>(columns.size())),
       table_type_(table_type),
       single_selection_(single_selection),
       ignore_listview_change_(false),
       custom_colors_enabled_(false),
       autosize_columns_(autosize_columns),
       resizable_columns_(resizable_columns),
       list_view_(NULL),
       header_original_handler_(NULL),
       original_handler_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(table_view_wrapper_(this)),
       custom_cell_font_(NULL),
       content_offset_(0) {
-  for (std::vector<TableColumn>::const_iterator i = columns.begin();
-      i != columns.end(); ++i) {
+  for (std::vector<ui::TableColumn>::const_iterator i = columns.begin();
+       i != columns.end(); ++i) {
     AddColumn(*i);
     visible_columns_.push_back(i->id);
   }
 }
 
 TableView::~TableView() {
   if (list_view_) {
     if (model_)
       model_->SetObserver(NULL);
   }
   if (custom_cell_font_)
     DeleteObject(custom_cell_font_);
 }
 
-void TableView::SetModel(TableModel* model) {
+void TableView::SetModel(ui::TableModel* model) {
   if (model == model_)
     return;
 
   if (list_view_ && model_)
     model_->SetObserver(NULL);
   model_ = model;
   if (list_view_ && model_)
     model_->SetObserver(this);
   if (list_view_)
     OnModelChanged();
@@ skipping 247 matching lines @@
   // invoked, so we handle it here.
   //
   // 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) {
+void TableView::AddColumn(const ui::TableColumn& col) {
   DCHECK_EQ(0u, all_columns_.count(col.id));
   all_columns_[col.id] = col;
 }
 
-void TableView::SetColumns(const std::vector<TableColumn>& columns) {
+void TableView::SetColumns(const std::vector<ui::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();
+  for (std::vector<ui::TableColumn>::const_iterator i = columns.begin();
        i != columns.end(); ++i) {
     AddColumn(*i);
   }
 
   // Remove any sort descriptors that are no longer valid.
   SortDescriptors sort = sort_descriptors();
   for (SortDescriptors::iterator i = sort.begin(); i != sort.end();) {
     if (all_columns_.count(i->column_id) == 0)
       i = sort.erase(i);
     else
@@ skipping 24 matching lines @@
         if (list_view_)
           SendMessage(list_view_, LVM_DELETECOLUMN, index, 0);
         visible_columns_.erase(i);
         changed = true;
         break;
       }
     }
   }
   if (is_visible) {
     visible_columns_.push_back(id);
-    TableColumn& column = all_columns_[id];
+    ui::TableColumn& column = all_columns_[id];
     InsertColumn(column, column_count_);
     if (column.min_visible_width == 0) {
       // ListView_GetStringWidth must be padded or else truncation will occur.
       column.min_visible_width = ListView_GetStringWidth(list_view_,
                                                          column.title.c_str()) +
                                  kListViewTextPadding;
     }
     changed = true;
   }
   if (changed)
@@ skipping 25 matching lines @@
 
 bool TableView::IsColumnVisible(int id) const {
   for (std::vector<int>::const_iterator i = visible_columns_.begin();
        i != visible_columns_.end(); ++i)
     if (*i == id) {
       return true;
     }
   return false;
 }
 
-const TableColumn& TableView::GetColumnAtPosition(int pos) {
+const ui::TableColumn& TableView::GetColumnAtPosition(int pos) {
   return all_columns_[visible_columns_[pos]];
 }
 
 bool TableView::HasColumn(int id) {
   return all_columns_.count(id) > 0;
 }
 
 gfx::Point TableView::GetKeyboardContextMenuLocation() {
   int first_selected = FirstSelectedRow();
   int y = height() / 2;
@@ skipping 284 matching lines @@
                         window, message, w_param, l_param);
 }
 
 HWND TableView::CreateNativeControl(HWND parent_container) {
   int style = WS_CHILD | LVS_REPORT | LVS_SHOWSELALWAYS;
   if (single_selection_)
     style |= LVS_SINGLESEL;
   // If there's only one column and the title string is empty, don't show a
   // header.
   if (all_columns_.size() == 1) {
-    std::map<int, TableColumn>::const_iterator first =
-        all_columns_.begin();
+    std::map<int, ui::TableColumn>::const_iterator first = all_columns_.begin();
     if (first->second.title.empty())
       style |= LVS_NOCOLUMNHEADER;
   }
   list_view_ = ::CreateWindowEx(WS_EX_CLIENTEDGE | GetAdditionalRTLStyle(),
                                 WC_LISTVIEW,
                                 L"",
                                 style,
                                 0, 0, width(), height(),
                                 parent_container, NULL, NULL, NULL);
   ui::CheckWindowCreated(list_view_);
@@ skipping 188 matching lines @@
   header_item.mask = HDI_FORMAT;
   Header_GetItem(header, column_index, &header_item);
   header_item.fmt &= ~(HDF_SORTUP | HDF_SORTDOWN);
   if (direction == ASCENDING_SORT)
     header_item.fmt |= HDF_SORTUP;
   else if (direction == DESCENDING_SORT)
     header_item.fmt |= HDF_SORTDOWN;
   Header_SetItem(header, column_index, &header_item);
 }
 
-void TableView::InsertColumn(const TableColumn& tc, int index) {
+void TableView::InsertColumn(const ui::TableColumn& tc, int index) {
   if (!list_view_)
     return;
 
   LVCOLUMN column = { 0 };
   column.mask = LVCF_TEXT|LVCF_FMT;
   column.pszText = const_cast<LPWSTR>(tc.title.c_str());
   switch (tc.alignment) {
-      case TableColumn::LEFT:
+      case ui::TableColumn::LEFT:
         column.fmt = LVCFMT_LEFT;
         break;
-      case TableColumn::RIGHT:
+      case ui::TableColumn::RIGHT:
         column.fmt = LVCFMT_RIGHT;
         break;
-      case TableColumn::CENTER:
+      case ui::TableColumn::CENTER:
         column.fmt = LVCFMT_CENTER;
         break;
       default:
         NOTREACHED();
   }
   if (tc.width != -1) {
     column.mask |= LVCF_WIDTH;
     column.cx = tc.width;
   }
   column.mask |= LVCF_SUBITEM;
@@ skipping 37 matching lines @@
       // Prevent clicks so columns cannot be resized.
       if (!resizable_columns_)
         return TRUE;
       break;
 
     case NM_DBLCLK:
       OnDoubleClick();
       break;
 
     case LVN_COLUMNCLICK: {
-      const TableColumn& column = GetColumnAtPosition(
+      const ui::TableColumn& column = GetColumnAtPosition(
           reinterpret_cast<NMLISTVIEW*>(hdr)->iSubItem);
       if (column.sortable)
         ToggleSortOrder(column.id);
       break;
     }
 
     case LVN_MARQUEEBEGIN:  // We don't want the marquee selection.
       return 1;
 
     case LVN_GETINFOTIP: {
@@ skipping 259 matching lines @@
       column_sizes_valid_ = true;
     }
   }
 
   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];
+    ui::TableColumn& col = all_columns_[*i];
     int col_index = static_cast<int>(i - visible_columns_.begin());
     if (col.width == -1) {
       if (col.percent > 0) {
         percent += col.percent;
       } else {
         autosize_width += col.min_visible_width;
       }
     } else {
       fixed_width += ListView_GetColumnWidth(list_view_, col_index);
     }
   }
 
   // Now do a pass to set the actual sizes of auto-sized and
   // percent-sized columns.
   int available_width = width - fixed_width - autosize_width;
   for (std::vector<int>::const_iterator i = visible_columns_.begin();
        i != visible_columns_.end(); ++i) {
-    TableColumn& col = all_columns_[*i];
+    ui::TableColumn& col = all_columns_[*i];
     if (col.width == -1) {
       int col_index = static_cast<int>(i - visible_columns_.begin());
       if (col.percent > 0) {
         if (available_width > 0) {
           int col_width =
             static_cast<int>(available_width * (col.percent / percent));
           available_width -= col_width;
           percent -= col.percent;
           ListView_SetColumnWidth(list_view_, col_index, col_width);
         }
@@ skipping 72 matching lines @@
       item.lParam = i;
       ListView_InsertItem(list_view_, &item);
     }
   }
 
   memset(&item, 0, sizeof(LVITEM));
   item.mask =
       (table_type_ == ICON_AND_TEXT) ? (LVIF_IMAGE | LVIF_TEXT) : LVIF_TEXT;
   item.stateMask = 0;
   for (int j = 0; j < column_count_; ++j) {
-    TableColumn& col = all_columns_[visible_columns_[j]];
+    ui::TableColumn& col = all_columns_[visible_columns_[j]];
     int max_text_width = ListView_GetStringWidth(list_view_, col.title.c_str());
     for (int i = start; i < start + length; ++i) {
       // Set item.
       item.iItem = add ? i : ModelToView(i);
       item.iSubItem = j;
       std::wstring text = model_->GetText(i, visible_columns_[j]);
       item.pszText = const_cast<LPWSTR>(text.c_str());
       ListView_SetItem(list_view_, &item);
 
       // Compute width in px, using current font.
@@ skipping 101 matching lines @@
 
 void TableView::UpdateGroups() {
   // Add the groups.
   if (model_ && model_->HasGroups()) {
     ListView_RemoveAllGroups(list_view_);
 
     // Windows XP seems to disable groups if we remove them, so we
     // re-enable them.
     ListView_EnableGroupView(list_view_, true);
 
-    TableModel::Groups groups = model_->GetGroups();
+    ui::TableModel::Groups groups = model_->GetGroups();
     LVGROUP group = { 0 };
     group.cbSize = sizeof(LVGROUP);
     group.mask = LVGF_HEADER | LVGF_ALIGN | LVGF_GROUPID;
     group.uAlign = LVGA_HEADER_LEFT;
     for (size_t i = 0; i < groups.size(); ++i) {
       group.pszHeader = const_cast<wchar_t*>(groups[i].title.c_str());
       group.iGroupId = groups[i].id;
       ListView_InsertGroup(list_view_, static_cast<int>(i), &group);
     }
   }
@@ skipping 61 matching lines @@
 }
 
 void TableSelectionIterator::UpdateModelIndexFromViewIndex() {
   if (view_index_ == -1)
     model_index_ = -1;
   else
     model_index_ = table_view_->ViewToModel(view_index_);
 }
 
 }  // namespace views