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 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, 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 478
