| 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 "chrome/browser/ui/gtk/gtk_tree.h" | |
| 6 | |
| 7 #include "base/logging.h" | |
| 8 #include "base/strings/utf_string_conversions.h" | |
| 9 #include "chrome/browser/ui/gtk/gtk_theme_service.h" | |
| 10 #include "third_party/skia/include/core/SkBitmap.h" | |
| 11 #include "ui/base/models/table_model.h" | |
| 12 #include "ui/gfx/gtk_util.h" | |
| 13 #include "ui/gfx/image/image.h" | |
| 14 #include "ui/gfx/image/image_skia.h" | |
| 15 | |
| 16 namespace gtk_tree { | |
| 17 | |
| 18 gint GetRowNumForPath(GtkTreePath* path) { | |
| 19 gint* indices = gtk_tree_path_get_indices(path); | |
| 20 if (!indices) { | |
| 21 NOTREACHED(); | |
| 22 return -1; | |
| 23 } | |
| 24 return indices[0]; | |
| 25 } | |
| 26 | |
| 27 gint GetRowNumForIter(GtkTreeModel* model, GtkTreeIter* iter) { | |
| 28 GtkTreePath* path = gtk_tree_model_get_path(model, iter); | |
| 29 int row = GetRowNumForPath(path); | |
| 30 gtk_tree_path_free(path); | |
| 31 return row; | |
| 32 } | |
| 33 | |
| 34 gint GetTreeSortChildRowNumForPath(GtkTreeModel* sort_model, | |
| 35 GtkTreePath* sort_path) { | |
| 36 GtkTreePath *child_path = gtk_tree_model_sort_convert_path_to_child_path( | |
| 37 GTK_TREE_MODEL_SORT(sort_model), sort_path); | |
| 38 int row = GetRowNumForPath(child_path); | |
| 39 gtk_tree_path_free(child_path); | |
| 40 return row; | |
| 41 } | |
| 42 | |
| 43 void SelectAndFocusRowNum(int row, GtkTreeView* tree_view) { | |
| 44 GtkTreeModel* model = gtk_tree_view_get_model(tree_view); | |
| 45 if (!model) { | |
| 46 NOTREACHED(); | |
| 47 return; | |
| 48 } | |
| 49 GtkTreeIter iter; | |
| 50 if (!gtk_tree_model_iter_nth_child(model, &iter, NULL, row)) { | |
| 51 NOTREACHED(); | |
| 52 return; | |
| 53 } | |
| 54 GtkTreePath* path = gtk_tree_model_get_path(model, &iter); | |
| 55 gtk_tree_view_set_cursor(tree_view, path, NULL, FALSE); | |
| 56 gtk_tree_path_free(path); | |
| 57 } | |
| 58 | |
| 59 bool RemoveRecursively(GtkTreeStore* tree_store, GtkTreeIter* iter) { | |
| 60 GtkTreeIter child; | |
| 61 if (gtk_tree_model_iter_children(GTK_TREE_MODEL(tree_store), &child, iter)) { | |
| 62 while (true) { | |
| 63 if (!RemoveRecursively(tree_store, &child)) | |
| 64 break; | |
| 65 } | |
| 66 } | |
| 67 return gtk_tree_store_remove(tree_store, iter); | |
| 68 } | |
| 69 | |
| 70 void GetSelectedIndices(GtkTreeSelection* selection, std::set<int>* out) { | |
| 71 GList* list = gtk_tree_selection_get_selected_rows( | |
| 72 selection, NULL); | |
| 73 GList* node; | |
| 74 for (node = list; node != NULL; node = node->next) { | |
| 75 out->insert( | |
| 76 gtk_tree::GetRowNumForPath(static_cast<GtkTreePath*>(node->data))); | |
| 77 } | |
| 78 g_list_foreach(list, (GFunc)gtk_tree_path_free, NULL); | |
| 79 g_list_free(list); | |
| 80 } | |
| 81 | |
| 82 //////////////////////////////////////////////////////////////////////////////// | |
| 83 // TableAdapter | |
| 84 | |
| 85 TableAdapter::TableAdapter(Delegate* delegate, GtkListStore* list_store, | |
| 86 ui::TableModel* table_model) | |
| 87 : delegate_(delegate), list_store_(list_store), table_model_(table_model) { | |
| 88 if (table_model) | |
| 89 table_model->SetObserver(this); | |
| 90 } | |
| 91 | |
| 92 void TableAdapter::SetModel(ui::TableModel* table_model) { | |
| 93 table_model_ = table_model; | |
| 94 table_model_->SetObserver(this); | |
| 95 } | |
| 96 | |
| 97 bool TableAdapter::IsGroupRow(GtkTreeIter* iter) const { | |
| 98 if (!table_model_->HasGroups()) | |
| 99 return false; | |
| 100 gboolean is_header = false; | |
| 101 gboolean is_separator = false; | |
| 102 gtk_tree_model_get(GTK_TREE_MODEL(list_store_), | |
| 103 iter, | |
| 104 COL_IS_HEADER, | |
| 105 &is_header, | |
| 106 COL_IS_SEPARATOR, | |
| 107 &is_separator, | |
| 108 -1); | |
| 109 return is_header || is_separator; | |
| 110 } | |
| 111 | |
| 112 static int OffsetForGroupIndex(size_t group_index) { | |
| 113 // Every group consists of a header and a separator row, and there is a blank | |
| 114 // row between groups. | |
| 115 return 3 * group_index + 2; | |
| 116 } | |
| 117 | |
| 118 void TableAdapter::MapListStoreIndicesToModelRows( | |
| 119 const std::set<int>& list_store_indices, | |
| 120 RemoveRowsTableModel::Rows* model_rows) { | |
| 121 if (!table_model_->HasGroups()) { | |
| 122 for (std::set<int>::const_iterator it = list_store_indices.begin(); | |
| 123 it != list_store_indices.end(); | |
| 124 ++it) { | |
| 125 model_rows->insert(*it); | |
| 126 } | |
| 127 return; | |
| 128 } | |
| 129 | |
| 130 const ui::TableModel::Groups& groups = table_model_->GetGroups(); | |
| 131 ui::TableModel::Groups::const_iterator group_it = groups.begin(); | |
| 132 for (std::set<int>::const_iterator list_store_it = list_store_indices.begin(); | |
| 133 list_store_it != list_store_indices.end(); | |
| 134 ++list_store_it) { | |
| 135 int list_store_index = *list_store_it; | |
| 136 GtkTreeIter iter; | |
| 137 bool rv = gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store_), | |
| 138 &iter, | |
| 139 NULL, | |
| 140 list_store_index); | |
| 141 if (!rv) { | |
| 142 NOTREACHED(); | |
| 143 return; | |
| 144 } | |
| 145 int group = -1; | |
| 146 gtk_tree_model_get(GTK_TREE_MODEL(list_store_), | |
| 147 &iter, | |
| 148 COL_GROUP_ID, | |
| 149 &group, | |
| 150 -1); | |
| 151 while (group_it->id != group) { | |
| 152 ++group_it; | |
| 153 if (group_it == groups.end()) { | |
| 154 NOTREACHED(); | |
| 155 return; | |
| 156 } | |
| 157 } | |
| 158 int offset = OffsetForGroupIndex(group_it - groups.begin()); | |
| 159 model_rows->insert(list_store_index - offset); | |
| 160 } | |
| 161 } | |
| 162 | |
| 163 int TableAdapter::GetListStoreIndexForModelRow(int model_row) const { | |
| 164 if (!table_model_->HasGroups()) | |
| 165 return model_row; | |
| 166 int group = table_model_->GetGroupID(model_row); | |
| 167 const ui::TableModel::Groups& groups = table_model_->GetGroups(); | |
| 168 for (ui::TableModel::Groups::const_iterator it = groups.begin(); | |
| 169 it != groups.end(); ++it) { | |
| 170 if (it->id == group) { | |
| 171 return model_row + OffsetForGroupIndex(it - groups.begin()); | |
| 172 } | |
| 173 } | |
| 174 NOTREACHED(); | |
| 175 return -1; | |
| 176 } | |
| 177 | |
| 178 void TableAdapter::AddNodeToList(int row) { | |
| 179 GtkTreeIter iter; | |
| 180 int list_store_index = GetListStoreIndexForModelRow(row); | |
| 181 if (list_store_index == 0) { | |
| 182 gtk_list_store_prepend(list_store_, &iter); | |
| 183 } else { | |
| 184 GtkTreeIter sibling; | |
| 185 gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store_), &sibling, NULL, | |
| 186 list_store_index - 1); | |
| 187 gtk_list_store_insert_after(list_store_, &iter, &sibling); | |
| 188 } | |
| 189 | |
| 190 if (table_model_->HasGroups()) { | |
| 191 gtk_list_store_set(list_store_, | |
| 192 &iter, | |
| 193 COL_WEIGHT, PANGO_WEIGHT_NORMAL, | |
| 194 COL_WEIGHT_SET, TRUE, | |
| 195 COL_GROUP_ID, table_model_->GetGroupID(row), | |
| 196 -1); | |
| 197 } | |
| 198 delegate_->SetColumnValues(row, &iter); | |
| 199 } | |
| 200 | |
| 201 void TableAdapter::OnModelChanged() { | |
| 202 delegate_->OnAnyModelUpdateStart(); | |
| 203 gtk_list_store_clear(list_store_); | |
| 204 delegate_->OnModelChanged(); | |
| 205 | |
| 206 if (table_model_->HasGroups()) { | |
| 207 const ui::TableModel::Groups& groups = table_model_->GetGroups(); | |
| 208 for (ui::TableModel::Groups::const_iterator it = groups.begin(); | |
| 209 it != groups.end(); ++it) { | |
| 210 GtkTreeIter iter; | |
| 211 if (it != groups.begin()) { | |
| 212 // Blank row between groups. | |
| 213 gtk_list_store_append(list_store_, &iter); | |
| 214 gtk_list_store_set(list_store_, &iter, COL_IS_HEADER, TRUE, -1); | |
| 215 } | |
| 216 // Group title. | |
| 217 gtk_list_store_append(list_store_, &iter); | |
| 218 gtk_list_store_set(list_store_, | |
| 219 &iter, | |
| 220 COL_WEIGHT, | |
| 221 PANGO_WEIGHT_BOLD, | |
| 222 COL_WEIGHT_SET, | |
| 223 TRUE, | |
| 224 COL_TITLE, | |
| 225 base::UTF16ToUTF8(it->title).c_str(), | |
| 226 COL_IS_HEADER, | |
| 227 TRUE, | |
| 228 -1); | |
| 229 // Group separator. | |
| 230 gtk_list_store_append(list_store_, &iter); | |
| 231 gtk_list_store_set(list_store_, | |
| 232 &iter, | |
| 233 COL_IS_HEADER, | |
| 234 TRUE, | |
| 235 COL_IS_SEPARATOR, | |
| 236 TRUE, | |
| 237 -1); | |
| 238 } | |
| 239 } | |
| 240 | |
| 241 for (int i = 0; i < table_model_->RowCount(); ++i) | |
| 242 AddNodeToList(i); | |
| 243 delegate_->OnAnyModelUpdate(); | |
| 244 } | |
| 245 | |
| 246 void TableAdapter::OnItemsChanged(int start, int length) { | |
| 247 if (length == 0) | |
| 248 return; | |
| 249 delegate_->OnAnyModelUpdateStart(); | |
| 250 int list_store_index = GetListStoreIndexForModelRow(start); | |
| 251 GtkTreeIter iter; | |
| 252 bool rv = gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store_), | |
| 253 &iter, | |
| 254 NULL, | |
| 255 list_store_index); | |
| 256 for (int i = 0; i < length; ++i) { | |
| 257 if (!rv) { | |
| 258 NOTREACHED(); | |
| 259 return; | |
| 260 } | |
| 261 while (IsGroupRow(&iter)) { | |
| 262 rv = gtk_tree_model_iter_next(GTK_TREE_MODEL(list_store_), &iter); | |
| 263 if (!rv) { | |
| 264 NOTREACHED(); | |
| 265 return; | |
| 266 } | |
| 267 } | |
| 268 delegate_->SetColumnValues(start + i, &iter); | |
| 269 rv = gtk_tree_model_iter_next(GTK_TREE_MODEL(list_store_), &iter); | |
| 270 } | |
| 271 delegate_->OnAnyModelUpdate(); | |
| 272 } | |
| 273 | |
| 274 void TableAdapter::OnItemsAdded(int start, int length) { | |
| 275 delegate_->OnAnyModelUpdateStart(); | |
| 276 for (int i = 0; i < length; ++i) { | |
| 277 AddNodeToList(start + i); | |
| 278 } | |
| 279 delegate_->OnAnyModelUpdate(); | |
| 280 } | |
| 281 | |
| 282 void TableAdapter::OnItemsRemoved(int start, int length) { | |
| 283 if (length == 0) | |
| 284 return; | |
| 285 delegate_->OnAnyModelUpdateStart(); | |
| 286 // When this method is called, the model has already removed the items, so | |
| 287 // accessing items in the model from |start| on may not be possible anymore. | |
| 288 // Therefore we use the item right before that, if it exists. | |
| 289 int list_store_index = 0; | |
| 290 if (start > 0) | |
| 291 list_store_index = GetListStoreIndexForModelRow(start - 1) + 1; | |
| 292 GtkTreeIter iter; | |
| 293 bool rv = gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store_), | |
| 294 &iter, | |
| 295 NULL, | |
| 296 list_store_index); | |
| 297 if (!rv) { | |
| 298 NOTREACHED(); | |
| 299 return; | |
| 300 } | |
| 301 for (int i = 0; i < length; ++i) { | |
| 302 while (IsGroupRow(&iter)) { | |
| 303 rv = gtk_tree_model_iter_next(GTK_TREE_MODEL(list_store_), &iter); | |
| 304 if (!rv) { | |
| 305 NOTREACHED(); | |
| 306 return; | |
| 307 } | |
| 308 } | |
| 309 gtk_list_store_remove(list_store_, &iter); | |
| 310 } | |
| 311 delegate_->OnAnyModelUpdate(); | |
| 312 } | |
| 313 | |
| 314 // static | |
| 315 gboolean TableAdapter::OnCheckRowIsSeparator(GtkTreeModel* model, | |
| 316 GtkTreeIter* iter, | |
| 317 gpointer user_data) { | |
| 318 gboolean is_separator; | |
| 319 gtk_tree_model_get(model, | |
| 320 iter, | |
| 321 COL_IS_SEPARATOR, | |
| 322 &is_separator, | |
| 323 -1); | |
| 324 return is_separator; | |
| 325 } | |
| 326 | |
| 327 // static | |
| 328 gboolean TableAdapter::OnSelectionFilter(GtkTreeSelection* selection, | |
| 329 GtkTreeModel* model, | |
| 330 GtkTreePath* path, | |
| 331 gboolean path_currently_selected, | |
| 332 gpointer user_data) { | |
| 333 GtkTreeIter iter; | |
| 334 if (!gtk_tree_model_get_iter(model, &iter, path)) { | |
| 335 NOTREACHED(); | |
| 336 return TRUE; | |
| 337 } | |
| 338 gboolean is_header; | |
| 339 gtk_tree_model_get(model, &iter, COL_IS_HEADER, &is_header, -1); | |
| 340 return !is_header; | |
| 341 } | |
| 342 | |
| 343 //////////////////////////////////////////////////////////////////////////////// | |
| 344 // TreeAdapter | |
| 345 | |
| 346 TreeAdapter::TreeAdapter(Delegate* delegate, ui::TreeModel* tree_model) | |
| 347 : delegate_(delegate), | |
| 348 tree_model_(tree_model) { | |
| 349 tree_store_ = gtk_tree_store_new(COL_COUNT, | |
| 350 GDK_TYPE_PIXBUF, | |
| 351 G_TYPE_STRING, | |
| 352 G_TYPE_POINTER); | |
| 353 tree_model->AddObserver(this); | |
| 354 | |
| 355 std::vector<gfx::ImageSkia> icons; | |
| 356 tree_model->GetIcons(&icons); | |
| 357 for (size_t i = 0; i < icons.size(); ++i) { | |
| 358 pixbufs_.push_back(gfx::GdkPixbufFromSkBitmap(*icons[i].bitmap())); | |
| 359 } | |
| 360 } | |
| 361 | |
| 362 TreeAdapter::~TreeAdapter() { | |
| 363 g_object_unref(tree_store_); | |
| 364 for (size_t i = 0; i < pixbufs_.size(); ++i) | |
| 365 g_object_unref(pixbufs_[i]); | |
| 366 } | |
| 367 | |
| 368 void TreeAdapter::Init() { | |
| 369 gtk_tree_store_clear(tree_store_); | |
| 370 Fill(NULL, tree_model_->GetRoot()); | |
| 371 } | |
| 372 | |
| 373 | |
| 374 ui::TreeModelNode* TreeAdapter::GetNode(GtkTreeIter* iter) { | |
| 375 ui::TreeModelNode* node; | |
| 376 gtk_tree_model_get(GTK_TREE_MODEL(tree_store_), iter, | |
| 377 COL_NODE_PTR, &node, | |
| 378 -1); | |
| 379 return node; | |
| 380 } | |
| 381 | |
| 382 void TreeAdapter::FillRow(GtkTreeIter* iter, ui::TreeModelNode* node) { | |
| 383 GdkPixbuf* pixbuf = NULL; | |
| 384 int icon_index = tree_model_->GetIconIndex(node); | |
| 385 if (icon_index >= 0 && icon_index < static_cast<int>(pixbufs_.size())) | |
| 386 pixbuf = pixbufs_[icon_index]; | |
| 387 else | |
| 388 pixbuf = GtkThemeService::GetFolderIcon(true).ToGdkPixbuf(); | |
| 389 gtk_tree_store_set(tree_store_, iter, | |
| 390 COL_ICON, pixbuf, | |
| 391 COL_TITLE, base::UTF16ToUTF8(node->GetTitle()).c_str(), | |
| 392 COL_NODE_PTR, node, | |
| 393 -1); | |
| 394 } | |
| 395 | |
| 396 void TreeAdapter::Fill(GtkTreeIter* parent_iter, | |
| 397 ui::TreeModelNode* parent_node) { | |
| 398 if (parent_iter) | |
| 399 FillRow(parent_iter, parent_node); | |
| 400 GtkTreeIter iter; | |
| 401 int child_count = tree_model_->GetChildCount(parent_node); | |
| 402 for (int i = 0; i < child_count; ++i) { | |
| 403 ui::TreeModelNode* node = tree_model_->GetChild(parent_node, i); | |
| 404 gtk_tree_store_append(tree_store_, &iter, parent_iter); | |
| 405 Fill(&iter, node); | |
| 406 } | |
| 407 } | |
| 408 | |
| 409 GtkTreePath* TreeAdapter::GetTreePath(ui::TreeModelNode* node) { | |
| 410 GtkTreePath* path = gtk_tree_path_new(); | |
| 411 ui::TreeModelNode* parent = node; | |
| 412 while (parent) { | |
| 413 parent = tree_model_->GetParent(parent); | |
| 414 if (parent) { | |
| 415 int idx = tree_model_->GetIndexOf(parent, node); | |
| 416 gtk_tree_path_prepend_index(path, idx); | |
| 417 node = parent; | |
| 418 } | |
| 419 } | |
| 420 return path; | |
| 421 } | |
| 422 | |
| 423 bool TreeAdapter::GetTreeIter(ui::TreeModelNode* node, GtkTreeIter* iter) { | |
| 424 GtkTreePath* path = GetTreePath(node); | |
| 425 bool rv = false; | |
| 426 // Check the path ourselves since gtk_tree_model_get_iter prints a warning if | |
| 427 // given an empty path. The path will be empty when it points to the root | |
| 428 // node and we are using SetRootShown(false). | |
| 429 if (gtk_tree_path_get_depth(path) > 0) | |
| 430 rv = gtk_tree_model_get_iter(GTK_TREE_MODEL(tree_store_), iter, path); | |
| 431 gtk_tree_path_free(path); | |
| 432 return rv; | |
| 433 } | |
| 434 | |
| 435 void TreeAdapter::TreeNodesAdded(ui::TreeModel* model, | |
| 436 ui::TreeModelNode* parent, | |
| 437 int start, | |
| 438 int count) { | |
| 439 delegate_->OnAnyModelUpdateStart(); | |
| 440 GtkTreeIter parent_iter; | |
| 441 GtkTreeIter* parent_iter_ptr = NULL; | |
| 442 GtkTreeIter iter; | |
| 443 if (GetTreeIter(parent, &parent_iter)) | |
| 444 parent_iter_ptr = &parent_iter; | |
| 445 for (int i = 0; i < count; ++i) { | |
| 446 gtk_tree_store_insert(tree_store_, &iter, parent_iter_ptr, start + i); | |
| 447 Fill(&iter, tree_model_->GetChild(parent, start + i)); | |
| 448 } | |
| 449 delegate_->OnAnyModelUpdate(); | |
| 450 } | |
| 451 | |
| 452 void TreeAdapter::TreeNodesRemoved(ui::TreeModel* model, | |
| 453 ui::TreeModelNode* parent, | |
| 454 int start, | |
| 455 int count) { | |
| 456 delegate_->OnAnyModelUpdateStart(); | |
| 457 GtkTreeIter iter; | |
| 458 GtkTreePath* path = GetTreePath(parent); | |
| 459 gtk_tree_path_append_index(path, start); | |
| 460 gtk_tree_model_get_iter(GTK_TREE_MODEL(tree_store_), &iter, path); | |
| 461 gtk_tree_path_free(path); | |
| 462 for (int i = 0; i < count; ++i) { | |
| 463 RemoveRecursively(tree_store_, &iter); | |
| 464 } | |
| 465 delegate_->OnAnyModelUpdate(); | |
| 466 } | |
| 467 | |
| 468 void TreeAdapter::TreeNodeChanged(ui::TreeModel* model, | |
| 469 ui::TreeModelNode* node) { | |
| 470 delegate_->OnAnyModelUpdateStart(); | |
| 471 GtkTreeIter iter; | |
| 472 if (GetTreeIter(node, &iter)) | |
| 473 FillRow(&iter, node); | |
| 474 delegate_->OnAnyModelUpdate(); | |
| 475 } | |
| 476 | |
| 477 } // namespace gtk_tree | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 231733005:
Delete the GTK+ port of Chrome. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src