| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "ui/views/controls/table/table_view.h" | |
| 6 | |
| 7 #include <map> | |
| 8 | |
| 9 #include "base/auto_reset.h" | |
| 10 #include "base/i18n/rtl.h" | |
| 11 #include "ui/events/event.h" | |
| 12 #include "ui/gfx/canvas.h" | |
| 13 #include "ui/gfx/image/image_skia.h" | |
| 14 #include "ui/gfx/rect_conversions.h" | |
| 15 #include "ui/gfx/skia_util.h" | |
| 16 #include "ui/gfx/text_utils.h" | |
| 17 #include "ui/native_theme/native_theme.h" | |
| 18 #include "ui/views/controls/scroll_view.h" | |
| 19 #include "ui/views/controls/table/table_grouper.h" | |
| 20 #include "ui/views/controls/table/table_header.h" | |
| 21 #include "ui/views/controls/table/table_utils.h" | |
| 22 #include "ui/views/controls/table/table_view_observer.h" | |
| 23 #include "ui/views/controls/table/table_view_row_background_painter.h" | |
| 24 | |
| 25 // Padding around the text (on each side). | |
| 26 static const int kTextVerticalPadding = 3; | |
| 27 static const int kTextHorizontalPadding = 6; | |
| 28 | |
| 29 // Size of images. | |
| 30 static const int kImageSize = 16; | |
| 31 | |
| 32 static const int kGroupingIndicatorSize = 6; | |
| 33 | |
| 34 namespace views { | |
| 35 | |
| 36 namespace { | |
| 37 | |
| 38 // Returns result, unless ascending is false in which case -result is returned. | |
| 39 int SwapCompareResult(int result, bool ascending) { | |
| 40 return ascending ? result : -result; | |
| 41 } | |
| 42 | |
| 43 // Populates |model_index_to_range_start| based on the |grouper|. | |
| 44 void GetModelIndexToRangeStart(TableGrouper* grouper, | |
| 45 int row_count, | |
| 46 std::map<int, int>* model_index_to_range_start) { | |
| 47 for (int model_index = 0; model_index < row_count;) { | |
| 48 GroupRange range; | |
| 49 grouper->GetGroupRange(model_index, &range); | |
| 50 DCHECK_GT(range.length, 0); | |
| 51 for (int range_counter = 0; range_counter < range.length; range_counter++) | |
| 52 (*model_index_to_range_start)[range_counter + model_index] = model_index; | |
| 53 model_index += range.length; | |
| 54 } | |
| 55 } | |
| 56 | |
| 57 // Returns the color id for the background of selected text. |has_focus| | |
| 58 // indicates if the table has focus. | |
| 59 ui::NativeTheme::ColorId text_background_color_id(bool has_focus) { | |
| 60 return has_focus ? | |
| 61 ui::NativeTheme::kColorId_TableSelectionBackgroundFocused : | |
| 62 ui::NativeTheme::kColorId_TableSelectionBackgroundUnfocused; | |
| 63 } | |
| 64 | |
| 65 // Returns the color id for text. |has_focus| indicates if the table has focus. | |
| 66 ui::NativeTheme::ColorId selected_text_color_id(bool has_focus) { | |
| 67 return has_focus ? ui::NativeTheme::kColorId_TableSelectedText : | |
| 68 ui::NativeTheme::kColorId_TableSelectedTextUnfocused; | |
| 69 } | |
| 70 | |
| 71 } // namespace | |
| 72 | |
| 73 // Used as the comparator to sort the contents of the table. | |
| 74 struct TableView::SortHelper { | |
| 75 explicit SortHelper(TableView* table) : table(table) {} | |
| 76 | |
| 77 bool operator()(int model_index1, int model_index2) { | |
| 78 return table->CompareRows(model_index1, model_index2) < 0; | |
| 79 } | |
| 80 | |
| 81 TableView* table; | |
| 82 }; | |
| 83 | |
| 84 // Used as the comparator to sort the contents of the table when a TableGrouper | |
| 85 // is present. When groups are present we sort the groups based on the first row | |
| 86 // in the group and within the groups we keep the same order as the model. | |
| 87 struct TableView::GroupSortHelper { | |
| 88 explicit GroupSortHelper(TableView* table) : table(table) {} | |
| 89 | |
| 90 bool operator()(int model_index1, int model_index2) { | |
| 91 const int range1 = model_index_to_range_start[model_index1]; | |
| 92 const int range2 = model_index_to_range_start[model_index2]; | |
| 93 if (range1 == range2) { | |
| 94 // The two rows are in the same group, sort so that items in the same | |
| 95 // group always appear in the same order. | |
| 96 return model_index1 < model_index2; | |
| 97 } | |
| 98 return table->CompareRows(range1, range2) < 0; | |
| 99 } | |
| 100 | |
| 101 TableView* table; | |
| 102 std::map<int, int> model_index_to_range_start; | |
| 103 }; | |
| 104 | |
| 105 TableView::VisibleColumn::VisibleColumn() : x(0), width(0) {} | |
| 106 | |
| 107 TableView::VisibleColumn::~VisibleColumn() {} | |
| 108 | |
| 109 TableView::PaintRegion::PaintRegion() | |
| 110 : min_row(0), | |
| 111 max_row(0), | |
| 112 min_column(0), | |
| 113 max_column(0) { | |
| 114 } | |
| 115 | |
| 116 TableView::PaintRegion::~PaintRegion() {} | |
| 117 | |
| 118 TableView::TableView(ui::TableModel* model, | |
| 119 const std::vector<ui::TableColumn>& columns, | |
| 120 TableTypes table_type, | |
| 121 bool single_selection) | |
| 122 : model_(NULL), | |
| 123 columns_(columns), | |
| 124 header_(NULL), | |
| 125 table_type_(table_type), | |
| 126 single_selection_(single_selection), | |
| 127 table_view_observer_(NULL), | |
| 128 row_height_(font_list_.GetHeight() + kTextVerticalPadding * 2), | |
| 129 last_parent_width_(0), | |
| 130 layout_width_(0), | |
| 131 grouper_(NULL), | |
| 132 in_set_visible_column_width_(false) { | |
| 133 for (size_t i = 0; i < columns.size(); ++i) { | |
| 134 VisibleColumn visible_column; | |
| 135 visible_column.column = columns[i]; | |
| 136 visible_columns_.push_back(visible_column); | |
| 137 } | |
| 138 SetFocusable(true); | |
| 139 SetModel(model); | |
| 140 } | |
| 141 | |
| 142 TableView::~TableView() { | |
| 143 if (model_) | |
| 144 model_->SetObserver(NULL); | |
| 145 } | |
| 146 | |
| 147 // TODO: this doesn't support arbitrarily changing the model, rename this to | |
| 148 // ClearModel() or something. | |
| 149 void TableView::SetModel(ui::TableModel* model) { | |
| 150 if (model == model_) | |
| 151 return; | |
| 152 | |
| 153 if (model_) | |
| 154 model_->SetObserver(NULL); | |
| 155 model_ = model; | |
| 156 selection_model_.Clear(); | |
| 157 if (model_) | |
| 158 model_->SetObserver(this); | |
| 159 } | |
| 160 | |
| 161 View* TableView::CreateParentIfNecessary() { | |
| 162 ScrollView* scroll_view = ScrollView::CreateScrollViewWithBorder(); | |
| 163 scroll_view->SetContents(this); | |
| 164 CreateHeaderIfNecessary(); | |
| 165 if (header_) | |
| 166 scroll_view->SetHeader(header_); | |
| 167 return scroll_view; | |
| 168 } | |
| 169 | |
| 170 void TableView::SetRowBackgroundPainter( | |
| 171 scoped_ptr<TableViewRowBackgroundPainter> painter) { | |
| 172 row_background_painter_ = painter.Pass(); | |
| 173 } | |
| 174 | |
| 175 void TableView::SetGrouper(TableGrouper* grouper) { | |
| 176 grouper_ = grouper; | |
| 177 SortItemsAndUpdateMapping(); | |
| 178 } | |
| 179 | |
| 180 int TableView::RowCount() const { | |
| 181 return model_ ? model_->RowCount() : 0; | |
| 182 } | |
| 183 | |
| 184 int TableView::SelectedRowCount() { | |
| 185 return static_cast<int>(selection_model_.size()); | |
| 186 } | |
| 187 | |
| 188 void TableView::Select(int model_row) { | |
| 189 if (!model_) | |
| 190 return; | |
| 191 | |
| 192 SelectByViewIndex(model_row == -1 ? -1 : ModelToView(model_row)); | |
| 193 } | |
| 194 | |
| 195 int TableView::FirstSelectedRow() { | |
| 196 return SelectedRowCount() == 0 ? -1 : selection_model_.selected_indices()[0]; | |
| 197 } | |
| 198 | |
| 199 void TableView::SetColumnVisibility(int id, bool is_visible) { | |
| 200 if (is_visible == IsColumnVisible(id)) | |
| 201 return; | |
| 202 | |
| 203 if (is_visible) { | |
| 204 VisibleColumn visible_column; | |
| 205 visible_column.column = FindColumnByID(id); | |
| 206 visible_columns_.push_back(visible_column); | |
| 207 } else { | |
| 208 for (size_t i = 0; i < visible_columns_.size(); ++i) { | |
| 209 if (visible_columns_[i].column.id == id) { | |
| 210 visible_columns_.erase(visible_columns_.begin() + i); | |
| 211 break; | |
| 212 } | |
| 213 } | |
| 214 } | |
| 215 UpdateVisibleColumnSizes(); | |
| 216 PreferredSizeChanged(); | |
| 217 SchedulePaint(); | |
| 218 if (header_) | |
| 219 header_->SchedulePaint(); | |
| 220 } | |
| 221 | |
| 222 void TableView::ToggleSortOrder(int visible_column_index) { | |
| 223 DCHECK(visible_column_index >= 0 && | |
| 224 visible_column_index < static_cast<int>(visible_columns_.size())); | |
| 225 if (!visible_columns_[visible_column_index].column.sortable) | |
| 226 return; | |
| 227 const int column_id = visible_columns_[visible_column_index].column.id; | |
| 228 SortDescriptors sort(sort_descriptors_); | |
| 229 if (!sort.empty() && sort[0].column_id == column_id) { | |
| 230 sort[0].ascending = !sort[0].ascending; | |
| 231 } else { | |
| 232 SortDescriptor descriptor(column_id, true); | |
| 233 sort.insert(sort.begin(), descriptor); | |
| 234 // Only persist two sort descriptors. | |
| 235 if (sort.size() > 2) | |
| 236 sort.resize(2); | |
| 237 } | |
| 238 SetSortDescriptors(sort); | |
| 239 } | |
| 240 | |
| 241 bool TableView::IsColumnVisible(int id) const { | |
| 242 for (size_t i = 0; i < visible_columns_.size(); ++i) { | |
| 243 if (visible_columns_[i].column.id == id) | |
| 244 return true; | |
| 245 } | |
| 246 return false; | |
| 247 } | |
| 248 | |
| 249 void TableView::AddColumn(const ui::TableColumn& col) { | |
| 250 DCHECK(!HasColumn(col.id)); | |
| 251 columns_.push_back(col); | |
| 252 } | |
| 253 | |
| 254 bool TableView::HasColumn(int id) const { | |
| 255 for (size_t i = 0; i < columns_.size(); ++i) { | |
| 256 if (columns_[i].id == id) | |
| 257 return true; | |
| 258 } | |
| 259 return false; | |
| 260 } | |
| 261 | |
| 262 void TableView::SetVisibleColumnWidth(int index, int width) { | |
| 263 DCHECK(index >= 0 && index < static_cast<int>(visible_columns_.size())); | |
| 264 if (visible_columns_[index].width == width) | |
| 265 return; | |
| 266 base::AutoReset<bool> reseter(&in_set_visible_column_width_, true); | |
| 267 visible_columns_[index].width = width; | |
| 268 for (size_t i = index + 1; i < visible_columns_.size(); ++i) { | |
| 269 visible_columns_[i].x = | |
| 270 visible_columns_[i - 1].x + visible_columns_[i - 1].width; | |
| 271 } | |
| 272 PreferredSizeChanged(); | |
| 273 SchedulePaint(); | |
| 274 } | |
| 275 | |
| 276 int TableView::ModelToView(int model_index) const { | |
| 277 if (!is_sorted()) | |
| 278 return model_index; | |
| 279 DCHECK_GE(model_index, 0) << " negative model_index " << model_index; | |
| 280 DCHECK_LT(model_index, RowCount()) << " out of bounds model_index " << | |
| 281 model_index; | |
| 282 return model_to_view_[model_index]; | |
| 283 } | |
| 284 | |
| 285 int TableView::ViewToModel(int view_index) const { | |
| 286 if (!is_sorted()) | |
| 287 return view_index; | |
| 288 DCHECK_GE(view_index, 0) << " negative view_index " << view_index; | |
| 289 DCHECK_LT(view_index, RowCount()) << " out of bounds view_index " << | |
| 290 view_index; | |
| 291 return view_to_model_[view_index]; | |
| 292 } | |
| 293 | |
| 294 void TableView::Layout() { | |
| 295 // parent()->parent() is the scrollview. When its width changes we force | |
| 296 // recalculating column sizes. | |
| 297 View* scroll_view = parent() ? parent()->parent() : NULL; | |
| 298 if (scroll_view) { | |
| 299 const int scroll_view_width = scroll_view->GetContentsBounds().width(); | |
| 300 if (scroll_view_width != last_parent_width_) { | |
| 301 last_parent_width_ = scroll_view_width; | |
| 302 if (!in_set_visible_column_width_) { | |
| 303 // Layout to the parent (the Viewport), which differs from | |
| 304 // |scroll_view_width| when scrollbars are present. | |
| 305 layout_width_ = parent()->width(); | |
| 306 UpdateVisibleColumnSizes(); | |
| 307 } | |
| 308 } | |
| 309 } | |
| 310 // We have to override Layout like this since we're contained in a ScrollView. | |
| 311 gfx::Size pref = GetPreferredSize(); | |
| 312 int width = pref.width(); | |
| 313 int height = pref.height(); | |
| 314 if (parent()) { | |
| 315 width = std::max(parent()->width(), width); | |
| 316 height = std::max(parent()->height(), height); | |
| 317 } | |
| 318 SetBounds(x(), y(), width, height); | |
| 319 } | |
| 320 | |
| 321 gfx::Size TableView::GetPreferredSize() const { | |
| 322 int width = 50; | |
| 323 if (header_ && !visible_columns_.empty()) | |
| 324 width = visible_columns_.back().x + visible_columns_.back().width; | |
| 325 return gfx::Size(width, RowCount() * row_height_); | |
| 326 } | |
| 327 | |
| 328 bool TableView::OnKeyPressed(const ui::KeyEvent& event) { | |
| 329 if (!HasFocus()) | |
| 330 return false; | |
| 331 | |
| 332 switch (event.key_code()) { | |
| 333 case ui::VKEY_A: | |
| 334 // control-a selects all. | |
| 335 if (event.IsControlDown() && !single_selection_ && RowCount()) { | |
| 336 ui::ListSelectionModel selection_model; | |
| 337 selection_model.SetSelectedIndex(selection_model_.active()); | |
| 338 for (int i = 0; i < RowCount(); ++i) | |
| 339 selection_model.AddIndexToSelection(i); | |
| 340 SetSelectionModel(selection_model); | |
| 341 return true; | |
| 342 } | |
| 343 break; | |
| 344 | |
| 345 case ui::VKEY_HOME: | |
| 346 if (RowCount()) | |
| 347 SelectByViewIndex(0); | |
| 348 return true; | |
| 349 | |
| 350 case ui::VKEY_END: | |
| 351 if (RowCount()) | |
| 352 SelectByViewIndex(RowCount() - 1); | |
| 353 return true; | |
| 354 | |
| 355 case ui::VKEY_UP: | |
| 356 AdvanceSelection(ADVANCE_DECREMENT); | |
| 357 return true; | |
| 358 | |
| 359 case ui::VKEY_DOWN: | |
| 360 AdvanceSelection(ADVANCE_INCREMENT); | |
| 361 return true; | |
| 362 | |
| 363 default: | |
| 364 break; | |
| 365 } | |
| 366 if (table_view_observer_) | |
| 367 table_view_observer_->OnKeyDown(event.key_code()); | |
| 368 return false; | |
| 369 } | |
| 370 | |
| 371 bool TableView::OnMousePressed(const ui::MouseEvent& event) { | |
| 372 RequestFocus(); | |
| 373 if (!event.IsOnlyLeftMouseButton()) | |
| 374 return true; | |
| 375 | |
| 376 const int row = event.y() / row_height_; | |
| 377 if (row < 0 || row >= RowCount()) | |
| 378 return true; | |
| 379 | |
| 380 if (event.GetClickCount() == 2) { | |
| 381 SelectByViewIndex(row); | |
| 382 if (table_view_observer_) | |
| 383 table_view_observer_->OnDoubleClick(); | |
| 384 } else if (event.GetClickCount() == 1) { | |
| 385 ui::ListSelectionModel new_model; | |
| 386 ConfigureSelectionModelForEvent(event, &new_model); | |
| 387 SetSelectionModel(new_model); | |
| 388 } | |
| 389 | |
| 390 return true; | |
| 391 } | |
| 392 | |
| 393 void TableView::OnGestureEvent(ui::GestureEvent* event) { | |
| 394 if (event->type() != ui::ET_GESTURE_TAP) | |
| 395 return; | |
| 396 | |
| 397 const int row = event->y() / row_height_; | |
| 398 if (row < 0 || row >= RowCount()) | |
| 399 return; | |
| 400 | |
| 401 event->StopPropagation(); | |
| 402 ui::ListSelectionModel new_model; | |
| 403 ConfigureSelectionModelForEvent(*event, &new_model); | |
| 404 SetSelectionModel(new_model); | |
| 405 } | |
| 406 | |
| 407 bool TableView::GetTooltipText(const gfx::Point& p, | |
| 408 base::string16* tooltip) const { | |
| 409 return GetTooltipImpl(p, tooltip, NULL); | |
| 410 } | |
| 411 | |
| 412 bool TableView::GetTooltipTextOrigin(const gfx::Point& p, | |
| 413 gfx::Point* loc) const { | |
| 414 return GetTooltipImpl(p, NULL, loc); | |
| 415 } | |
| 416 | |
| 417 void TableView::OnModelChanged() { | |
| 418 selection_model_.Clear(); | |
| 419 NumRowsChanged(); | |
| 420 } | |
| 421 | |
| 422 void TableView::OnItemsChanged(int start, int length) { | |
| 423 SortItemsAndUpdateMapping(); | |
| 424 } | |
| 425 | |
| 426 void TableView::OnItemsAdded(int start, int length) { | |
| 427 for (int i = 0; i < length; ++i) | |
| 428 selection_model_.IncrementFrom(start); | |
| 429 NumRowsChanged(); | |
| 430 } | |
| 431 | |
| 432 void TableView::OnItemsRemoved(int start, int length) { | |
| 433 // Determine the currently selected index in terms of the view. We inline the | |
| 434 // implementation here since ViewToModel() has DCHECKs that fail since the | |
| 435 // model has changed but |model_to_view_| has not been updated yet. | |
| 436 const int previously_selected_model_index = FirstSelectedRow(); | |
| 437 int previously_selected_view_index = previously_selected_model_index; | |
| 438 if (previously_selected_model_index != -1 && is_sorted()) | |
| 439 previously_selected_view_index = | |
| 440 model_to_view_[previously_selected_model_index]; | |
| 441 for (int i = 0; i < length; ++i) | |
| 442 selection_model_.DecrementFrom(start); | |
| 443 NumRowsChanged(); | |
| 444 // If the selection was empty and is no longer empty select the same visual | |
| 445 // index. | |
| 446 if (selection_model_.empty() && previously_selected_view_index != -1 && | |
| 447 RowCount()) { | |
| 448 selection_model_.SetSelectedIndex( | |
| 449 ViewToModel(std::min(RowCount() - 1, previously_selected_view_index))); | |
| 450 } | |
| 451 if (table_view_observer_) | |
| 452 table_view_observer_->OnSelectionChanged(); | |
| 453 } | |
| 454 | |
| 455 gfx::Point TableView::GetKeyboardContextMenuLocation() { | |
| 456 int first_selected = FirstSelectedRow(); | |
| 457 gfx::Rect vis_bounds(GetVisibleBounds()); | |
| 458 int y = vis_bounds.height() / 2; | |
| 459 if (first_selected != -1) { | |
| 460 gfx::Rect cell_bounds(GetRowBounds(first_selected)); | |
| 461 if (cell_bounds.bottom() >= vis_bounds.y() && | |
| 462 cell_bounds.bottom() < vis_bounds.bottom()) { | |
| 463 y = cell_bounds.bottom(); | |
| 464 } | |
| 465 } | |
| 466 gfx::Point screen_loc(0, y); | |
| 467 if (base::i18n::IsRTL()) | |
| 468 screen_loc.set_x(width()); | |
| 469 ConvertPointToScreen(this, &screen_loc); | |
| 470 return screen_loc; | |
| 471 } | |
| 472 | |
| 473 void TableView::OnPaint(gfx::Canvas* canvas) { | |
| 474 // Don't invoke View::OnPaint so that we can render our own focus border. | |
| 475 | |
| 476 canvas->DrawColor(GetNativeTheme()->GetSystemColor( | |
| 477 ui::NativeTheme::kColorId_TableBackground)); | |
| 478 | |
| 479 if (!RowCount() || visible_columns_.empty()) | |
| 480 return; | |
| 481 | |
| 482 const PaintRegion region(GetPaintRegion(GetPaintBounds(canvas))); | |
| 483 if (region.min_column == -1) | |
| 484 return; // No need to paint anything. | |
| 485 | |
| 486 const SkColor selected_bg_color = GetNativeTheme()->GetSystemColor( | |
| 487 text_background_color_id(HasFocus())); | |
| 488 const SkColor fg_color = GetNativeTheme()->GetSystemColor( | |
| 489 ui::NativeTheme::kColorId_TableText); | |
| 490 const SkColor selected_fg_color = GetNativeTheme()->GetSystemColor( | |
| 491 selected_text_color_id(HasFocus())); | |
| 492 for (int i = region.min_row; i < region.max_row; ++i) { | |
| 493 const int model_index = ViewToModel(i); | |
| 494 const bool is_selected = selection_model_.IsSelected(model_index); | |
| 495 if (is_selected) { | |
| 496 canvas->FillRect(GetRowBounds(i), selected_bg_color); | |
| 497 } else if (row_background_painter_) { | |
| 498 row_background_painter_->PaintRowBackground(model_index, | |
| 499 GetRowBounds(i), | |
| 500 canvas); | |
| 501 } | |
| 502 if (selection_model_.active() == i && HasFocus()) | |
| 503 canvas->DrawFocusRect(GetRowBounds(i)); | |
| 504 for (int j = region.min_column; j < region.max_column; ++j) { | |
| 505 const gfx::Rect cell_bounds(GetCellBounds(i, j)); | |
| 506 int text_x = kTextHorizontalPadding + cell_bounds.x(); | |
| 507 | |
| 508 // Provide space for the grouping indicator, but draw it separately. | |
| 509 if (j == 0 && grouper_) | |
| 510 text_x += kGroupingIndicatorSize + kTextHorizontalPadding; | |
| 511 | |
| 512 // Always paint the icon in the first visible column. | |
| 513 if (j == 0 && table_type_ == ICON_AND_TEXT) { | |
| 514 gfx::ImageSkia image = model_->GetIcon(model_index); | |
| 515 if (!image.isNull()) { | |
| 516 int image_x = GetMirroredXWithWidthInView(text_x, kImageSize); | |
| 517 canvas->DrawImageInt( | |
| 518 image, 0, 0, image.width(), image.height(), | |
| 519 image_x, | |
| 520 cell_bounds.y() + (cell_bounds.height() - kImageSize) / 2, | |
| 521 kImageSize, kImageSize, true); | |
| 522 } | |
| 523 text_x += kImageSize + kTextHorizontalPadding; | |
| 524 } | |
| 525 if (text_x < cell_bounds.right() - kTextHorizontalPadding) { | |
| 526 canvas->DrawStringRectWithFlags( | |
| 527 model_->GetText(model_index, visible_columns_[j].column.id), | |
| 528 font_list_, is_selected ? selected_fg_color : fg_color, | |
| 529 gfx::Rect(GetMirroredXWithWidthInView( | |
| 530 text_x, cell_bounds.right() - text_x - kTextHorizontalPadding), | |
| 531 cell_bounds.y() + kTextVerticalPadding, | |
| 532 cell_bounds.right() - text_x, | |
| 533 cell_bounds.height() - kTextVerticalPadding * 2), | |
| 534 TableColumnAlignmentToCanvasAlignment( | |
| 535 visible_columns_[j].column.alignment)); | |
| 536 } | |
| 537 } | |
| 538 } | |
| 539 | |
| 540 if (!grouper_ || region.min_column > 0) | |
| 541 return; | |
| 542 | |
| 543 const SkColor grouping_color = GetNativeTheme()->GetSystemColor( | |
| 544 ui::NativeTheme::kColorId_TableGroupingIndicatorColor); | |
| 545 SkPaint grouping_paint; | |
| 546 grouping_paint.setColor(grouping_color); | |
| 547 grouping_paint.setStyle(SkPaint::kFill_Style); | |
| 548 grouping_paint.setAntiAlias(true); | |
| 549 const int group_indicator_x = GetMirroredXInView(GetCellBounds(0, 0).x() + | |
| 550 kTextHorizontalPadding + kGroupingIndicatorSize / 2); | |
| 551 for (int i = region.min_row; i < region.max_row; ) { | |
| 552 const int model_index = ViewToModel(i); | |
| 553 GroupRange range; | |
| 554 grouper_->GetGroupRange(model_index, &range); | |
| 555 DCHECK_GT(range.length, 0); | |
| 556 // The order of rows in a group is consistent regardless of sort, so it's ok | |
| 557 // to do this calculation. | |
| 558 const int start = i - (model_index - range.start); | |
| 559 const int last = start + range.length - 1; | |
| 560 const gfx::Rect start_cell_bounds(GetCellBounds(start, 0)); | |
| 561 if (start != last) { | |
| 562 const gfx::Rect last_cell_bounds(GetCellBounds(last, 0)); | |
| 563 canvas->FillRect(gfx::Rect( | |
| 564 group_indicator_x - kGroupingIndicatorSize / 2, | |
| 565 start_cell_bounds.CenterPoint().y(), | |
| 566 kGroupingIndicatorSize, | |
| 567 last_cell_bounds.y() - start_cell_bounds.y()), | |
| 568 grouping_color); | |
| 569 canvas->DrawCircle(gfx::Point(group_indicator_x, | |
| 570 last_cell_bounds.CenterPoint().y()), | |
| 571 kGroupingIndicatorSize / 2, grouping_paint); | |
| 572 } | |
| 573 canvas->DrawCircle(gfx::Point(group_indicator_x, | |
| 574 start_cell_bounds.CenterPoint().y()), | |
| 575 kGroupingIndicatorSize / 2, grouping_paint); | |
| 576 i = last + 1; | |
| 577 } | |
| 578 } | |
| 579 | |
| 580 void TableView::OnFocus() { | |
| 581 SchedulePaintForSelection(); | |
| 582 } | |
| 583 | |
| 584 void TableView::OnBlur() { | |
| 585 SchedulePaintForSelection(); | |
| 586 } | |
| 587 | |
| 588 void TableView::NumRowsChanged() { | |
| 589 SortItemsAndUpdateMapping(); | |
| 590 PreferredSizeChanged(); | |
| 591 SchedulePaint(); | |
| 592 } | |
| 593 | |
| 594 void TableView::SetSortDescriptors(const SortDescriptors& sort_descriptors) { | |
| 595 sort_descriptors_ = sort_descriptors; | |
| 596 SortItemsAndUpdateMapping(); | |
| 597 if (header_) | |
| 598 header_->SchedulePaint(); | |
| 599 } | |
| 600 | |
| 601 void TableView::SortItemsAndUpdateMapping() { | |
| 602 if (!is_sorted()) { | |
| 603 view_to_model_.clear(); | |
| 604 model_to_view_.clear(); | |
| 605 } else { | |
| 606 const int row_count = RowCount(); | |
| 607 view_to_model_.resize(row_count); | |
| 608 model_to_view_.resize(row_count); | |
| 609 for (int i = 0; i < row_count; ++i) | |
| 610 view_to_model_[i] = i; | |
| 611 if (grouper_) { | |
| 612 GroupSortHelper sort_helper(this); | |
| 613 GetModelIndexToRangeStart(grouper_, RowCount(), | |
| 614 &sort_helper.model_index_to_range_start); | |
| 615 std::sort(view_to_model_.begin(), view_to_model_.end(), sort_helper); | |
| 616 } else { | |
| 617 std::sort(view_to_model_.begin(), view_to_model_.end(), SortHelper(this)); | |
| 618 } | |
| 619 for (int i = 0; i < row_count; ++i) | |
| 620 model_to_view_[view_to_model_[i]] = i; | |
| 621 model_->ClearCollator(); | |
| 622 } | |
| 623 SchedulePaint(); | |
| 624 } | |
| 625 | |
| 626 int TableView::CompareRows(int model_row1, int model_row2) { | |
| 627 const int sort_result = model_->CompareValues( | |
| 628 model_row1, model_row2, sort_descriptors_[0].column_id); | |
| 629 if (sort_result == 0 && sort_descriptors_.size() > 1) { | |
| 630 // Try the secondary sort. | |
| 631 return SwapCompareResult( | |
| 632 model_->CompareValues(model_row1, model_row2, | |
| 633 sort_descriptors_[1].column_id), | |
| 634 sort_descriptors_[1].ascending); | |
| 635 } | |
| 636 return SwapCompareResult(sort_result, sort_descriptors_[0].ascending); | |
| 637 } | |
| 638 | |
| 639 gfx::Rect TableView::GetRowBounds(int row) const { | |
| 640 return gfx::Rect(0, row * row_height_, width(), row_height_); | |
| 641 } | |
| 642 | |
| 643 gfx::Rect TableView::GetCellBounds(int row, int visible_column_index) const { | |
| 644 if (!header_) | |
| 645 return GetRowBounds(row); | |
| 646 const VisibleColumn& vis_col(visible_columns_[visible_column_index]); | |
| 647 return gfx::Rect(vis_col.x, row * row_height_, vis_col.width, row_height_); | |
| 648 } | |
| 649 | |
| 650 void TableView::AdjustCellBoundsForText(int visible_column_index, | |
| 651 gfx::Rect* bounds) const { | |
| 652 int text_x = kTextHorizontalPadding + bounds->x(); | |
| 653 if (visible_column_index == 0) { | |
| 654 if (grouper_) | |
| 655 text_x += kGroupingIndicatorSize + kTextHorizontalPadding; | |
| 656 if (table_type_ == ICON_AND_TEXT) | |
| 657 text_x += kImageSize + kTextHorizontalPadding; | |
| 658 } | |
| 659 bounds->set_x(text_x); | |
| 660 bounds->set_width( | |
| 661 std::max(0, bounds->right() - kTextHorizontalPadding - text_x)); | |
| 662 } | |
| 663 | |
| 664 void TableView::CreateHeaderIfNecessary() { | |
| 665 // Only create a header if there is more than one column or the title of the | |
| 666 // only column is not empty. | |
| 667 if (header_ || (columns_.size() == 1 && columns_[0].title.empty())) | |
| 668 return; | |
| 669 | |
| 670 header_ = new TableHeader(this); | |
| 671 } | |
| 672 | |
| 673 void TableView::UpdateVisibleColumnSizes() { | |
| 674 if (!header_) | |
| 675 return; | |
| 676 | |
| 677 std::vector<ui::TableColumn> columns; | |
| 678 for (size_t i = 0; i < visible_columns_.size(); ++i) | |
| 679 columns.push_back(visible_columns_[i].column); | |
| 680 | |
| 681 int first_column_padding = 0; | |
| 682 if (table_type_ == ICON_AND_TEXT && header_) | |
| 683 first_column_padding += kImageSize + kTextHorizontalPadding; | |
| 684 if (grouper_) | |
| 685 first_column_padding += kGroupingIndicatorSize + kTextHorizontalPadding; | |
| 686 | |
| 687 std::vector<int> sizes = views::CalculateTableColumnSizes( | |
| 688 layout_width_, first_column_padding, header_->font_list(), font_list_, | |
| 689 std::max(kTextHorizontalPadding, TableHeader::kHorizontalPadding) * 2, | |
| 690 TableHeader::kSortIndicatorWidth, columns, model_); | |
| 691 DCHECK_EQ(visible_columns_.size(), sizes.size()); | |
| 692 int x = 0; | |
| 693 for (size_t i = 0; i < visible_columns_.size(); ++i) { | |
| 694 visible_columns_[i].x = x; | |
| 695 visible_columns_[i].width = sizes[i]; | |
| 696 x += sizes[i]; | |
| 697 } | |
| 698 } | |
| 699 | |
| 700 TableView::PaintRegion TableView::GetPaintRegion( | |
| 701 const gfx::Rect& bounds) const { | |
| 702 DCHECK(!visible_columns_.empty()); | |
| 703 DCHECK(RowCount()); | |
| 704 | |
| 705 PaintRegion region; | |
| 706 region.min_row = std::min(RowCount() - 1, | |
| 707 std::max(0, bounds.y() / row_height_)); | |
| 708 region.max_row = bounds.bottom() / row_height_; | |
| 709 if (bounds.bottom() % row_height_ != 0) | |
| 710 region.max_row++; | |
| 711 region.max_row = std::min(region.max_row, RowCount()); | |
| 712 | |
| 713 if (!header_) { | |
| 714 region.max_column = 1; | |
| 715 return region; | |
| 716 } | |
| 717 | |
| 718 const int paint_x = GetMirroredXForRect(bounds); | |
| 719 const int paint_max_x = paint_x + bounds.width(); | |
| 720 region.min_column = -1; | |
| 721 region.max_column = visible_columns_.size(); | |
| 722 for (size_t i = 0; i < visible_columns_.size(); ++i) { | |
| 723 int max_x = visible_columns_[i].x + visible_columns_[i].width; | |
| 724 if (region.min_column == -1 && max_x >= paint_x) | |
| 725 region.min_column = static_cast<int>(i); | |
| 726 if (region.min_column != -1 && visible_columns_[i].x >= paint_max_x) { | |
| 727 region.max_column = i; | |
| 728 break; | |
| 729 } | |
| 730 } | |
| 731 return region; | |
| 732 } | |
| 733 | |
| 734 gfx::Rect TableView::GetPaintBounds(gfx::Canvas* canvas) const { | |
| 735 SkRect sk_clip_rect; | |
| 736 if (canvas->sk_canvas()->getClipBounds(&sk_clip_rect)) | |
| 737 return gfx::ToEnclosingRect(gfx::SkRectToRectF(sk_clip_rect)); | |
| 738 return GetVisibleBounds(); | |
| 739 } | |
| 740 | |
| 741 void TableView::SchedulePaintForSelection() { | |
| 742 if (selection_model_.size() == 1) { | |
| 743 const int first_model_row = FirstSelectedRow(); | |
| 744 SchedulePaintInRect(GetRowBounds(ModelToView(first_model_row))); | |
| 745 if (first_model_row != selection_model_.active()) | |
| 746 SchedulePaintInRect(GetRowBounds(ModelToView(selection_model_.active()))); | |
| 747 } else if (selection_model_.size() > 1) { | |
| 748 SchedulePaint(); | |
| 749 } | |
| 750 } | |
| 751 | |
| 752 ui::TableColumn TableView::FindColumnByID(int id) const { | |
| 753 for (size_t i = 0; i < columns_.size(); ++i) { | |
| 754 if (columns_[i].id == id) | |
| 755 return columns_[i]; | |
| 756 } | |
| 757 NOTREACHED(); | |
| 758 return ui::TableColumn(); | |
| 759 } | |
| 760 | |
| 761 void TableView::SelectByViewIndex(int view_index) { | |
| 762 ui::ListSelectionModel new_selection; | |
| 763 if (view_index != -1) { | |
| 764 SelectRowsInRangeFrom(view_index, true, &new_selection); | |
| 765 new_selection.set_anchor(ViewToModel(view_index)); | |
| 766 new_selection.set_active(ViewToModel(view_index)); | |
| 767 } | |
| 768 | |
| 769 SetSelectionModel(new_selection); | |
| 770 } | |
| 771 | |
| 772 void TableView::SetSelectionModel(const ui::ListSelectionModel& new_selection) { | |
| 773 if (new_selection.Equals(selection_model_)) | |
| 774 return; | |
| 775 | |
| 776 SchedulePaintForSelection(); | |
| 777 selection_model_.Copy(new_selection); | |
| 778 SchedulePaintForSelection(); | |
| 779 | |
| 780 // Scroll the group for the active item to visible. | |
| 781 if (selection_model_.active() != -1) { | |
| 782 gfx::Rect vis_rect(GetVisibleBounds()); | |
| 783 const GroupRange range(GetGroupRange(selection_model_.active())); | |
| 784 const int start_y = GetRowBounds(ModelToView(range.start)).y(); | |
| 785 const int end_y = | |
| 786 GetRowBounds(ModelToView(range.start + range.length - 1)).bottom(); | |
| 787 vis_rect.set_y(start_y); | |
| 788 vis_rect.set_height(end_y - start_y); | |
| 789 ScrollRectToVisible(vis_rect); | |
| 790 } | |
| 791 | |
| 792 if (table_view_observer_) | |
| 793 table_view_observer_->OnSelectionChanged(); | |
| 794 } | |
| 795 | |
| 796 void TableView::AdvanceSelection(AdvanceDirection direction) { | |
| 797 if (selection_model_.active() == -1) { | |
| 798 SelectByViewIndex(0); | |
| 799 return; | |
| 800 } | |
| 801 int view_index = ModelToView(selection_model_.active()); | |
| 802 if (direction == ADVANCE_DECREMENT) | |
| 803 view_index = std::max(0, view_index - 1); | |
| 804 else | |
| 805 view_index = std::min(RowCount() - 1, view_index + 1); | |
| 806 SelectByViewIndex(view_index); | |
| 807 } | |
| 808 | |
| 809 void TableView::ConfigureSelectionModelForEvent( | |
| 810 const ui::LocatedEvent& event, | |
| 811 ui::ListSelectionModel* model) const { | |
| 812 const int view_index = event.y() / row_height_; | |
| 813 DCHECK(view_index >= 0 && view_index < RowCount()); | |
| 814 | |
| 815 if (selection_model_.anchor() == -1 || | |
| 816 single_selection_ || | |
| 817 (!event.IsControlDown() && !event.IsShiftDown())) { | |
| 818 SelectRowsInRangeFrom(view_index, true, model); | |
| 819 model->set_anchor(ViewToModel(view_index)); | |
| 820 model->set_active(ViewToModel(view_index)); | |
| 821 return; | |
| 822 } | |
| 823 if ((event.IsControlDown() && event.IsShiftDown()) || event.IsShiftDown()) { | |
| 824 // control-shift: copy existing model and make sure rows between anchor and | |
| 825 // |view_index| are selected. | |
| 826 // shift: reset selection so that only rows between anchor and |view_index| | |
| 827 // are selected. | |
| 828 if (event.IsControlDown() && event.IsShiftDown()) | |
| 829 model->Copy(selection_model_); | |
| 830 else | |
| 831 model->set_anchor(selection_model_.anchor()); | |
| 832 for (int i = std::min(view_index, ModelToView(model->anchor())), | |
| 833 end = std::max(view_index, ModelToView(model->anchor())); | |
| 834 i <= end; ++i) { | |
| 835 SelectRowsInRangeFrom(i, true, model); | |
| 836 } | |
| 837 model->set_active(ViewToModel(view_index)); | |
| 838 } else { | |
| 839 DCHECK(event.IsControlDown()); | |
| 840 // Toggle the selection state of |view_index| and set the anchor/active to | |
| 841 // it and don't change the state of any other rows. | |
| 842 model->Copy(selection_model_); | |
| 843 model->set_anchor(ViewToModel(view_index)); | |
| 844 model->set_active(ViewToModel(view_index)); | |
| 845 SelectRowsInRangeFrom(view_index, | |
| 846 !model->IsSelected(ViewToModel(view_index)), | |
| 847 model); | |
| 848 } | |
| 849 } | |
| 850 | |
| 851 void TableView::SelectRowsInRangeFrom(int view_index, | |
| 852 bool select, | |
| 853 ui::ListSelectionModel* model) const { | |
| 854 const GroupRange range(GetGroupRange(ViewToModel(view_index))); | |
| 855 for (int i = 0; i < range.length; ++i) { | |
| 856 if (select) | |
| 857 model->AddIndexToSelection(range.start + i); | |
| 858 else | |
| 859 model->RemoveIndexFromSelection(range.start + i); | |
| 860 } | |
| 861 } | |
| 862 | |
| 863 GroupRange TableView::GetGroupRange(int model_index) const { | |
| 864 GroupRange range; | |
| 865 if (grouper_) { | |
| 866 grouper_->GetGroupRange(model_index, &range); | |
| 867 } else { | |
| 868 range.start = model_index; | |
| 869 range.length = 1; | |
| 870 } | |
| 871 return range; | |
| 872 } | |
| 873 | |
| 874 bool TableView::GetTooltipImpl(const gfx::Point& location, | |
| 875 base::string16* tooltip, | |
| 876 gfx::Point* tooltip_origin) const { | |
| 877 const int row = location.y() / row_height_; | |
| 878 if (row < 0 || row >= RowCount() || visible_columns_.empty()) | |
| 879 return false; | |
| 880 | |
| 881 const int x = GetMirroredXInView(location.x()); | |
| 882 const int column = GetClosestVisibleColumnIndex(this, x); | |
| 883 if (x < visible_columns_[column].x || | |
| 884 x > (visible_columns_[column].x + visible_columns_[column].width)) | |
| 885 return false; | |
| 886 | |
| 887 const base::string16 text(model_->GetText(ViewToModel(row), | |
| 888 visible_columns_[column].column.id)); | |
| 889 if (text.empty()) | |
| 890 return false; | |
| 891 | |
| 892 gfx::Rect cell_bounds(GetCellBounds(row, column)); | |
| 893 AdjustCellBoundsForText(column, &cell_bounds); | |
| 894 const int right = std::min(GetVisibleBounds().right(), cell_bounds.right()); | |
| 895 if (right > cell_bounds.x() && | |
| 896 gfx::GetStringWidth(text, font_list_) <= (right - cell_bounds.x())) | |
| 897 return false; | |
| 898 | |
| 899 if (tooltip) | |
| 900 *tooltip = text; | |
| 901 if (tooltip_origin) { | |
| 902 tooltip_origin->SetPoint(cell_bounds.x(), | |
| 903 cell_bounds.y() + kTextVerticalPadding); | |
| 904 } | |
| 905 return true; | |
| 906 } | |
| 907 | |
| 908 } // namespace views | |
| OLD | NEW |
|---|
Chromium Code Reviews
