[280] | 1 | /* gtkpkglist.cc |
---|
| 2 | * Copyright (C) 2002,2003 Michael Vogt |
---|
| 3 | * |
---|
| 4 | * This library is free software; you can redistribute it and/or |
---|
| 5 | * modify it under the terms of the GNU Library General Public |
---|
| 6 | * License as published by the Free Software Foundation; either |
---|
| 7 | * version 2 of the License, or (at your option) any later version. |
---|
| 8 | * |
---|
| 9 | * This library is distributed in the hope that it will be useful, |
---|
| 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
| 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
---|
| 12 | * Library General Public License for more details. |
---|
| 13 | * |
---|
| 14 | * You should have received a copy of the GNU Library General Public |
---|
| 15 | * License along with this library; if not, write to the |
---|
| 16 | * Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
---|
| 17 | * Boston, MA 02111-1307, USA. |
---|
| 18 | */ |
---|
| 19 | |
---|
| 20 | #include <algorithm> |
---|
| 21 | #include <gtk/gtk.h> |
---|
| 22 | #include <apt-pkg/configuration.h> |
---|
| 23 | #include <apt-pkg/strutl.h> |
---|
| 24 | #include <cassert> |
---|
| 25 | #include "gtkpkglist.h" |
---|
| 26 | #include "rgmisc.h" |
---|
| 27 | #include "rpackagelister.h" |
---|
| 28 | |
---|
| 29 | using namespace std; |
---|
| 30 | |
---|
| 31 | // #define DEBUG_LIST |
---|
| 32 | // #define DEBUG_LIST_FULL |
---|
| 33 | |
---|
| 34 | static void gtk_pkg_list_init(GtkPkgList *pkg_tree); |
---|
| 35 | static void gtk_pkg_list_class_init(GtkPkgListClass *klass); |
---|
| 36 | static void gtk_pkg_list_tree_model_init(GtkTreeModelIface *iface); |
---|
| 37 | static void gtk_pkg_list_sortable_init(GtkTreeSortableIface *iface); |
---|
| 38 | static void gtk_pkg_list_finalize(GObject *object); |
---|
| 39 | static GtkTreeModelFlags gtk_pkg_list_get_flags(GtkTreeModel *tree_model); |
---|
| 40 | static gint gtk_pkg_list_get_n_columns(GtkTreeModel *tree_model); |
---|
| 41 | static GType gtk_pkg_list_get_column_type(GtkTreeModel *tree_model, |
---|
| 42 | gint index); |
---|
| 43 | static gboolean gtk_pkg_list_get_iter(GtkTreeModel *tree_model, |
---|
| 44 | GtkTreeIter *iter, GtkTreePath *path); |
---|
| 45 | static GtkTreePath *gtk_pkg_list_get_path(GtkTreeModel *tree_model, |
---|
| 46 | GtkTreeIter *iter); |
---|
| 47 | static void gtk_pkg_list_get_value(GtkTreeModel *tree_model, |
---|
| 48 | GtkTreeIter *iter, |
---|
| 49 | gint column, GValue * value); |
---|
| 50 | static gboolean gtk_pkg_list_iter_next(GtkTreeModel *tree_model, |
---|
| 51 | GtkTreeIter *iter); |
---|
| 52 | static gboolean gtk_pkg_list_iter_children(GtkTreeModel *tree_model, |
---|
| 53 | GtkTreeIter *iter, |
---|
| 54 | GtkTreeIter *parent); |
---|
| 55 | static gboolean gtk_pkg_list_iter_has_child(GtkTreeModel *tree_model, |
---|
| 56 | GtkTreeIter *iter); |
---|
| 57 | static gint gtk_pkg_list_iter_n_children(GtkTreeModel *tree_model, |
---|
| 58 | GtkTreeIter *iter); |
---|
| 59 | static gboolean gtk_pkg_list_iter_nth_child(GtkTreeModel *tree_model, |
---|
| 60 | GtkTreeIter *iter, |
---|
| 61 | GtkTreeIter *parent, gint n); |
---|
| 62 | static gboolean gtk_pkg_list_iter_parent(GtkTreeModel *tree_model, |
---|
| 63 | GtkTreeIter *iter, |
---|
| 64 | GtkTreeIter *child); |
---|
| 65 | |
---|
| 66 | /* sortable */ |
---|
| 67 | static void gtk_pkg_list_sort(GtkPkgList *pkg_list); |
---|
| 68 | static gboolean gtk_pkg_list_get_sort_column_id(GtkTreeSortable *sortable, |
---|
| 69 | gint *sort_column_id, |
---|
| 70 | GtkSortType *order); |
---|
| 71 | static void gtk_pkg_list_set_sort_column_id(GtkTreeSortable *sortable, |
---|
| 72 | gint sort_column_id, |
---|
| 73 | GtkSortType order); |
---|
| 74 | static gboolean gtk_pkg_list_has_default_sort_func(GtkTreeSortable *sortable); |
---|
| 75 | |
---|
| 76 | |
---|
| 77 | static GObjectClass *parent_class = NULL; |
---|
| 78 | |
---|
| 79 | extern GdkPixbuf *StatusPixbuf[12]; |
---|
| 80 | extern GdkColor *StatusColors[12]; |
---|
| 81 | |
---|
| 82 | void RCacheActorPkgList::run(vector<RPackage *> &List, int Action) |
---|
| 83 | { |
---|
| 84 | static GtkTreeIter iter; |
---|
| 85 | int j; |
---|
| 86 | |
---|
| 87 | for (unsigned int i = 0; i < List.size(); i++) { |
---|
| 88 | RPackage *pkg = List[i]; |
---|
| 89 | |
---|
| 90 | j = _lister->getViewPackageIndex(pkg); |
---|
| 91 | if (j == -1) |
---|
| 92 | continue; |
---|
| 93 | |
---|
| 94 | iter.user_data = pkg; |
---|
| 95 | iter.user_data2 = GINT_TO_POINTER(j); |
---|
| 96 | |
---|
| 97 | // fill in treepath |
---|
| 98 | GtkTreePath *path = gtk_tree_path_new(); |
---|
| 99 | gtk_tree_path_append_index(path, j); |
---|
| 100 | gtk_tree_model_row_changed(GTK_TREE_MODEL(_pkgList), path, &iter); |
---|
| 101 | gtk_tree_path_free(path); |
---|
| 102 | } |
---|
| 103 | |
---|
| 104 | } |
---|
| 105 | |
---|
| 106 | void RPackageListActorPkgList::run(vector<RPackage *> &List, int listEvent) |
---|
| 107 | { |
---|
| 108 | cout << |
---|
| 109 | "RPackageListActorPkgList::run(vector<RPackage*> &List, int pkgEvent)" << |
---|
| 110 | endl; |
---|
| 111 | |
---|
| 112 | cout << "action: " << listEvent << endl; |
---|
| 113 | cout << "listsize: " << List.size() << endl; |
---|
| 114 | |
---|
| 115 | //_pkgList = gtk_pkg_list_new(_lister); |
---|
| 116 | //gtk_tree_view_set_model(GTK_TREE_VIEW(_pkgView), |
---|
| 117 | // GTK_TREE_MODEL(_pkgList)); |
---|
| 118 | //return; |
---|
| 119 | |
---|
| 120 | //mvo: FIXME those nested loops suck as they are slow |
---|
| 121 | if (listEvent == PKG_REMOVED) { |
---|
| 122 | for (int i = (int)List.size() - 1; i >= 0; i--) { |
---|
| 123 | int j; |
---|
| 124 | for (j = 0; j < (int)_lastDisplayList.size(); j++) |
---|
| 125 | if (_lastDisplayList[j] == List[i]) |
---|
| 126 | break; |
---|
| 127 | cout << "Removed at pos: " << j << endl; |
---|
| 128 | GtkTreePath *path = gtk_tree_path_new(); |
---|
| 129 | gtk_tree_path_append_index(path, j); |
---|
| 130 | gtk_tree_model_row_deleted(GTK_TREE_MODEL(_pkgList), path); |
---|
| 131 | gtk_tree_path_free(path); |
---|
| 132 | } |
---|
| 133 | } else if (listEvent == PKG_ADDED) { |
---|
| 134 | static GtkTreeIter iter; |
---|
| 135 | for (int i = 0; i < (int)List.size(); i++) { |
---|
| 136 | int j = _lister->getViewPackageIndex(List[i]); |
---|
| 137 | cout << "Inserted " << List[i]->name() << " at pos: " << j << endl; |
---|
| 138 | GtkTreePath *path = gtk_tree_path_new(); |
---|
| 139 | gtk_tree_path_append_index(path, j); |
---|
| 140 | iter.user_data = List[i]; |
---|
| 141 | iter.user_data2 = GINT_TO_POINTER(j); |
---|
| 142 | iter.stamp = 140677; |
---|
| 143 | gtk_tree_model_row_inserted(GTK_TREE_MODEL(_pkgList), path, &iter); |
---|
| 144 | gtk_tree_path_free(path); |
---|
| 145 | } |
---|
| 146 | } |
---|
| 147 | } |
---|
| 148 | |
---|
| 149 | GType gtk_pkg_list_get_type(void) |
---|
| 150 | { |
---|
| 151 | static GType pkg_list_type = 0; |
---|
| 152 | |
---|
| 153 | if (!pkg_list_type) { |
---|
| 154 | static const GTypeInfo pkg_list_info = { |
---|
| 155 | sizeof(GtkPkgListClass), |
---|
| 156 | NULL, /* base_init */ |
---|
| 157 | NULL, /* base_finalize */ |
---|
| 158 | (GClassInitFunc) gtk_pkg_list_class_init, |
---|
| 159 | NULL, /* class finalize */ |
---|
| 160 | NULL, /* class_data */ |
---|
| 161 | sizeof(GtkPkgList), |
---|
| 162 | 0, /* n_preallocs */ |
---|
| 163 | (GInstanceInitFunc) gtk_pkg_list_init |
---|
| 164 | }; |
---|
| 165 | |
---|
| 166 | static const GInterfaceInfo tree_model_info = { |
---|
| 167 | (GInterfaceInitFunc) gtk_pkg_list_tree_model_init, |
---|
| 168 | NULL, |
---|
| 169 | NULL |
---|
| 170 | }; |
---|
| 171 | |
---|
| 172 | static const GInterfaceInfo sortable_info = { |
---|
| 173 | (GInterfaceInitFunc) gtk_pkg_list_sortable_init, |
---|
| 174 | NULL, |
---|
| 175 | NULL |
---|
| 176 | }; |
---|
| 177 | |
---|
| 178 | pkg_list_type = g_type_register_static(G_TYPE_OBJECT, "GtkPkgList", |
---|
| 179 | &pkg_list_info, (GTypeFlags) 0); |
---|
| 180 | |
---|
| 181 | g_type_add_interface_static(pkg_list_type, |
---|
| 182 | GTK_TYPE_TREE_MODEL, &tree_model_info); |
---|
| 183 | g_type_add_interface_static(pkg_list_type, |
---|
| 184 | GTK_TYPE_TREE_SORTABLE, &sortable_info); |
---|
| 185 | } |
---|
| 186 | |
---|
| 187 | return pkg_list_type; |
---|
| 188 | } |
---|
| 189 | |
---|
| 190 | static void gtk_pkg_list_class_init(GtkPkgListClass *klass) |
---|
| 191 | { |
---|
| 192 | GObjectClass *object_class; |
---|
| 193 | |
---|
| 194 | parent_class = (GObjectClass *) g_type_class_peek_parent(klass); |
---|
| 195 | object_class = (GObjectClass *) klass; |
---|
| 196 | |
---|
| 197 | object_class->finalize = gtk_pkg_list_finalize; |
---|
| 198 | } |
---|
| 199 | |
---|
| 200 | static void gtk_pkg_list_tree_model_init(GtkTreeModelIface *iface) |
---|
| 201 | { |
---|
| 202 | iface->get_flags = gtk_pkg_list_get_flags; |
---|
| 203 | iface->get_n_columns = gtk_pkg_list_get_n_columns; |
---|
| 204 | iface->get_column_type = gtk_pkg_list_get_column_type; |
---|
| 205 | iface->get_iter = gtk_pkg_list_get_iter; |
---|
| 206 | iface->get_path = gtk_pkg_list_get_path; |
---|
| 207 | iface->get_value = gtk_pkg_list_get_value; |
---|
| 208 | iface->iter_next = gtk_pkg_list_iter_next; |
---|
| 209 | iface->iter_children = gtk_pkg_list_iter_children; |
---|
| 210 | iface->iter_has_child = gtk_pkg_list_iter_has_child; |
---|
| 211 | iface->iter_n_children = gtk_pkg_list_iter_n_children; |
---|
| 212 | iface->iter_nth_child = gtk_pkg_list_iter_nth_child; |
---|
| 213 | iface->iter_parent = gtk_pkg_list_iter_parent; |
---|
| 214 | } |
---|
| 215 | |
---|
| 216 | void gtk_pkg_list_sortable_init(GtkTreeSortableIface *iface) |
---|
| 217 | { |
---|
| 218 | iface->get_sort_column_id = gtk_pkg_list_get_sort_column_id; |
---|
| 219 | iface->set_sort_column_id = gtk_pkg_list_set_sort_column_id; |
---|
| 220 | iface->set_sort_func = NULL; |
---|
| 221 | iface->set_default_sort_func = NULL; |
---|
| 222 | iface->has_default_sort_func = gtk_pkg_list_has_default_sort_func; |
---|
| 223 | } |
---|
| 224 | |
---|
| 225 | static void gtk_pkg_list_init(GtkPkgList *pkg_list) |
---|
| 226 | { |
---|
| 227 | //cout << "list_init()" << endl; |
---|
| 228 | pkg_list->n_columns = N_COLUMNS; |
---|
| 229 | pkg_list->column_headers[0] = GDK_TYPE_PIXBUF; |
---|
| 230 | pkg_list->column_headers[1] = GDK_TYPE_PIXBUF; |
---|
| 231 | pkg_list->column_headers[2] = G_TYPE_STRING; |
---|
| 232 | pkg_list->column_headers[3] = G_TYPE_STRING; |
---|
| 233 | pkg_list->column_headers[4] = G_TYPE_STRING; |
---|
| 234 | pkg_list->column_headers[5] = G_TYPE_STRING; |
---|
| 235 | pkg_list->column_headers[6] = G_TYPE_STRING; |
---|
| 236 | pkg_list->column_headers[7] = G_TYPE_STRING; |
---|
| 237 | pkg_list->column_headers[8] = G_TYPE_STRING; |
---|
| 238 | pkg_list->column_headers[9] = G_TYPE_STRING; |
---|
| 239 | pkg_list->column_headers[10] = GDK_TYPE_COLOR; |
---|
| 240 | pkg_list->column_headers[11] = G_TYPE_POINTER; |
---|
| 241 | } |
---|
| 242 | |
---|
| 243 | /** |
---|
| 244 | * gtk_pkg_list_new() |
---|
| 245 | **/ |
---|
| 246 | GtkPkgList *gtk_pkg_list_new(RPackageLister *lister) |
---|
| 247 | { |
---|
| 248 | GtkPkgList *retval = NULL; |
---|
| 249 | |
---|
| 250 | //cout << "pkg_list_new()\n"; |
---|
| 251 | |
---|
| 252 | retval = (GtkPkgList *) g_object_new(GTK_TYPE_PKG_LIST, NULL); |
---|
| 253 | assert(retval); |
---|
| 254 | retval->_lister = lister; |
---|
| 255 | |
---|
| 256 | return retval; |
---|
| 257 | } |
---|
| 258 | |
---|
| 259 | |
---|
| 260 | static void gtk_pkg_list_finalize(GObject *object) |
---|
| 261 | { |
---|
| 262 | // GtkPkgList *pkg_list = GTK_PKG_LIST (object); |
---|
| 263 | |
---|
| 264 | |
---|
| 265 | /* give back all memory */ |
---|
| 266 | |
---|
| 267 | |
---|
| 268 | /* must chain up */ |
---|
| 269 | (*parent_class->finalize) (object); |
---|
| 270 | } |
---|
| 271 | |
---|
| 272 | |
---|
| 273 | static GtkTreeModelFlags gtk_pkg_list_get_flags(GtkTreeModel *tree_model) |
---|
| 274 | { |
---|
| 275 | g_return_val_if_fail(GTK_IS_PKG_LIST(tree_model), (GtkTreeModelFlags) 0); |
---|
| 276 | |
---|
| 277 | return GTK_TREE_MODEL_LIST_ONLY; |
---|
| 278 | } |
---|
| 279 | |
---|
| 280 | |
---|
| 281 | static gint gtk_pkg_list_get_n_columns(GtkTreeModel *tree_model) |
---|
| 282 | { |
---|
| 283 | GtkPkgList *pkg_list = (GtkPkgList *) tree_model; |
---|
| 284 | |
---|
| 285 | g_return_val_if_fail(GTK_IS_PKG_LIST(tree_model), 0); |
---|
| 286 | |
---|
| 287 | return pkg_list->n_columns; |
---|
| 288 | } |
---|
| 289 | |
---|
| 290 | |
---|
| 291 | static GType |
---|
| 292 | gtk_pkg_list_get_column_type(GtkTreeModel *tree_model, gint index) |
---|
| 293 | { |
---|
| 294 | GtkPkgList *tree_store = (GtkPkgList *) tree_model; |
---|
| 295 | |
---|
| 296 | g_return_val_if_fail(GTK_IS_PKG_LIST(tree_model), G_TYPE_INVALID); |
---|
| 297 | g_return_val_if_fail(index < GTK_PKG_LIST(tree_model)->n_columns && |
---|
| 298 | index >= 0, G_TYPE_INVALID); |
---|
| 299 | |
---|
| 300 | return tree_store->column_headers[index]; |
---|
| 301 | } |
---|
| 302 | |
---|
| 303 | |
---|
| 304 | static gboolean |
---|
| 305 | gtk_pkg_list_get_iter(GtkTreeModel *tree_model, |
---|
| 306 | GtkTreeIter *iter, GtkTreePath *path) |
---|
| 307 | { |
---|
| 308 | g_return_val_if_fail(GTK_IS_PKG_LIST(tree_model), FALSE); |
---|
| 309 | |
---|
| 310 | GtkPkgList *pkg_list = (GtkPkgList *) tree_model; |
---|
| 311 | gint *indices; |
---|
| 312 | gint depth; |
---|
| 313 | RPackage *pkg = NULL; |
---|
| 314 | |
---|
| 315 | assert(GTK_IS_PKG_LIST(pkg_list)); |
---|
| 316 | assert(path != NULL); |
---|
| 317 | |
---|
| 318 | indices = gtk_tree_path_get_indices(path); |
---|
| 319 | depth = gtk_tree_path_get_depth(path); |
---|
| 320 | |
---|
| 321 | // we do not support more |
---|
| 322 | assert(depth <= 1); |
---|
| 323 | |
---|
| 324 | int element = indices[0]; |
---|
| 325 | |
---|
| 326 | #ifdef DEBUG_LIST |
---|
| 327 | cout << "get_iter: index " << element << " path: " << path << endl; |
---|
| 328 | #endif |
---|
| 329 | |
---|
| 330 | if (element >= pkg_list->_lister->viewPackagesSize()) { |
---|
| 331 | #ifdef DEBUG_LIST |
---|
| 332 | cout << "indices[0] > pkg_list->_lister->count()" << endl; |
---|
| 333 | cout << indices[0] << " >= " << pkg_list->_lister->viewPackagesSize() << endl; |
---|
| 334 | #endif |
---|
| 335 | //gtk_tree_model_row_deleted(GTK_TREE_MODEL(pkg_list),path); |
---|
| 336 | return FALSE; |
---|
| 337 | } |
---|
| 338 | |
---|
| 339 | pkg = pkg_list->_lister->getViewPackage(element); |
---|
| 340 | assert(pkg); |
---|
| 341 | iter->stamp = 140677; |
---|
| 342 | iter->user_data = pkg; |
---|
| 343 | iter->user_data2 = GINT_TO_POINTER(element); |
---|
| 344 | return TRUE; |
---|
| 345 | } |
---|
| 346 | |
---|
| 347 | static GtkTreePath *gtk_pkg_list_get_path(GtkTreeModel *tree_model, |
---|
| 348 | GtkTreeIter *iter) |
---|
| 349 | { |
---|
| 350 | GtkTreePath *retval; |
---|
| 351 | //GtkPkgList *pkg_list = GTK_PKG_LIST(tree_model); |
---|
| 352 | |
---|
| 353 | g_return_val_if_fail(GTK_IS_PKG_LIST(tree_model), NULL); |
---|
| 354 | g_return_val_if_fail(iter != NULL, NULL); |
---|
| 355 | g_return_val_if_fail(iter->user_data != NULL, NULL); |
---|
| 356 | |
---|
| 357 | retval = gtk_tree_path_new(); |
---|
| 358 | int i = GPOINTER_TO_INT(iter->user_data2); |
---|
| 359 | gtk_tree_path_append_index(retval, i); |
---|
| 360 | |
---|
| 361 | #ifdef DEBUG_LIST |
---|
| 362 | RPackage *pkg = (RPackage *) iter->user_data; |
---|
| 363 | |
---|
| 364 | cout << "get_path() "; |
---|
| 365 | if (pkg != NULL) |
---|
| 366 | cout << ": " << pkg->name() << endl; |
---|
| 367 | else |
---|
| 368 | cout << "(pkg == NULL) " << endl; |
---|
| 369 | |
---|
| 370 | cout << "complete path: " << gtk_tree_path_to_string(retval) << endl; |
---|
| 371 | #endif |
---|
| 372 | |
---|
| 373 | return retval; |
---|
| 374 | } |
---|
| 375 | |
---|
| 376 | static void |
---|
| 377 | gtk_pkg_list_get_value(GtkTreeModel *tree_model, |
---|
| 378 | GtkTreeIter *iter, gint column, GValue * value) |
---|
| 379 | { |
---|
| 380 | g_return_if_fail(GTK_IS_PKG_LIST(tree_model)); |
---|
| 381 | g_return_if_fail(iter != NULL); |
---|
| 382 | g_return_if_fail(column < GTK_PKG_LIST(tree_model)->n_columns); |
---|
| 383 | |
---|
| 384 | g_value_init(value, GTK_PKG_LIST(tree_model)->column_headers[column]); |
---|
| 385 | |
---|
| 386 | RPackage *pkg = (RPackage *) iter->user_data; |
---|
| 387 | |
---|
| 388 | #ifdef DEBUG_LIST_FULL |
---|
| 389 | if (column == NAME_COLUMN) { |
---|
| 390 | cout << "get_value: column: " << column; |
---|
| 391 | if (pkg != NULL) |
---|
| 392 | cout << " name: " << pkg->name() << endl; |
---|
| 393 | } |
---|
| 394 | #endif |
---|
| 395 | |
---|
| 396 | GtkPkgList *pkg_list = GTK_PKG_LIST(tree_model); |
---|
| 397 | int element = GPOINTER_TO_INT(iter->user_data2); |
---|
| 398 | if (element >= pkg_list->_lister->viewPackagesSize()) |
---|
| 399 | return; |
---|
| 400 | |
---|
| 401 | if (pkg == NULL) { |
---|
| 402 | cout << "get_value: pkg == NULL" << endl; |
---|
| 403 | return; |
---|
| 404 | } |
---|
| 405 | |
---|
| 406 | const gchar *str; |
---|
| 407 | switch (column) { |
---|
| 408 | case NAME_COLUMN: |
---|
| 409 | str = utf8(pkg->name()); |
---|
| 410 | g_value_set_string(value, str); |
---|
| 411 | break; |
---|
| 412 | case PKG_SIZE_COLUMN: |
---|
| 413 | if (pkg->installedVersion()) { |
---|
| 414 | str = SizeToStr(pkg->installedSize()).c_str(); |
---|
| 415 | g_value_set_string(value, str); |
---|
| 416 | } |
---|
| 417 | break; |
---|
| 418 | case PKG_DOWNLOAD_SIZE_COLUMN: |
---|
| 419 | str = SizeToStr(pkg->availablePackageSize()).c_str(); |
---|
| 420 | g_value_set_string(value, str); |
---|
| 421 | break; |
---|
| 422 | case SECTION_COLUMN: |
---|
| 423 | str = pkg->section(); |
---|
| 424 | if(str != NULL) |
---|
| 425 | g_value_set_string(value, str); |
---|
| 426 | break; |
---|
| 427 | case COMPONENT_COLUMN: |
---|
| 428 | str = pkg->component().c_str(); |
---|
| 429 | if(str) |
---|
| 430 | g_value_set_string(value, str); |
---|
| 431 | break; |
---|
| 432 | case INSTALLED_VERSION_COLUMN: |
---|
| 433 | str = pkg->installedVersion(); |
---|
| 434 | g_value_set_string(value, str); |
---|
| 435 | break; |
---|
| 436 | case AVAILABLE_VERSION_COLUMN: |
---|
| 437 | str = pkg->availableVersion(); |
---|
| 438 | g_value_set_string(value, str); |
---|
| 439 | break; |
---|
| 440 | case DESCR_COLUMN: |
---|
| 441 | str = utf8(pkg->summary()); |
---|
| 442 | g_value_set_string(value, str); |
---|
| 443 | break; |
---|
| 444 | case PKG_COLUMN: |
---|
| 445 | g_value_set_pointer(value, pkg); |
---|
| 446 | break; |
---|
| 447 | case COLOR_COLUMN: |
---|
| 448 | { |
---|
| 449 | if(_config->FindB("Synaptic::UseStatusColors", TRUE) == FALSE) |
---|
| 450 | return; |
---|
| 451 | GdkColor *bg; |
---|
| 452 | bg = RGPackageStatus::pkgStatus.getBgColor(pkg); |
---|
| 453 | g_value_set_boxed(value, bg); |
---|
| 454 | break; |
---|
| 455 | } |
---|
| 456 | case SUPPORTED_COLUMN: |
---|
| 457 | { |
---|
| 458 | if (pkg == NULL) |
---|
| 459 | return; |
---|
| 460 | GdkPixbuf *pix; |
---|
| 461 | pix = RGPackageStatus::pkgStatus.getSupportedPix(pkg); |
---|
| 462 | g_value_set_object(value, pix); |
---|
| 463 | break; |
---|
| 464 | } |
---|
| 465 | case PIXMAP_COLUMN: |
---|
| 466 | { |
---|
| 467 | GdkPixbuf *pix; |
---|
| 468 | pix = RGPackageStatus::pkgStatus.getPixbuf(pkg); |
---|
| 469 | g_value_set_object(value, pix); |
---|
| 470 | break; |
---|
| 471 | } |
---|
| 472 | } |
---|
| 473 | } |
---|
| 474 | |
---|
| 475 | static gboolean |
---|
| 476 | gtk_pkg_list_iter_next(GtkTreeModel *tree_model, GtkTreeIter *iter) |
---|
| 477 | { |
---|
| 478 | g_return_val_if_fail(GTK_IS_PKG_LIST(tree_model), FALSE); |
---|
| 479 | |
---|
| 480 | if (iter == NULL) |
---|
| 481 | return FALSE; |
---|
| 482 | if (iter->user_data == NULL) |
---|
| 483 | return FALSE; |
---|
| 484 | |
---|
| 485 | GtkPkgList *pkg_list = GTK_PKG_LIST(tree_model); |
---|
| 486 | int i, old; |
---|
| 487 | |
---|
| 488 | old = GPOINTER_TO_INT(iter->user_data2); |
---|
| 489 | |
---|
| 490 | i = old + 1; |
---|
| 491 | if (i >= pkg_list->_lister->viewPackagesSize()) |
---|
| 492 | return FALSE; |
---|
| 493 | |
---|
| 494 | RPackage *pkg = pkg_list->_lister->getViewPackage(i); |
---|
| 495 | |
---|
| 496 | #ifdef DEBUG_LIST_FULL |
---|
| 497 | RPackage *oldpkg = (RPackage *) iter->user_data; |
---|
| 498 | cout << "iter_next() " << endl; |
---|
| 499 | cout << "old: " << oldpkg->name() << " [" << old << "] " << endl; |
---|
| 500 | cout << "new: " << pkg->name() << " [" << i << "] " << endl; |
---|
| 501 | #endif |
---|
| 502 | |
---|
| 503 | iter->stamp = 140677; |
---|
| 504 | iter->user_data = pkg; |
---|
| 505 | iter->user_data2 = GINT_TO_POINTER(i); |
---|
| 506 | return TRUE; |
---|
| 507 | } |
---|
| 508 | |
---|
| 509 | static gboolean |
---|
| 510 | gtk_pkg_list_iter_children(GtkTreeModel *tree_model, |
---|
| 511 | GtkTreeIter *iter, GtkTreeIter *parent) |
---|
| 512 | { |
---|
| 513 | g_return_val_if_fail(parent == NULL || parent->user_data != NULL, FALSE); |
---|
| 514 | g_return_val_if_fail(GTK_IS_PKG_LIST(tree_model), FALSE); |
---|
| 515 | |
---|
| 516 | #ifdef DEBUG_LIST |
---|
| 517 | cout << "iter_children: " << endl; |
---|
| 518 | #endif |
---|
| 519 | |
---|
| 520 | // this is a list, nodes have no children |
---|
| 521 | if (parent) |
---|
| 522 | return FALSE; |
---|
| 523 | |
---|
| 524 | GtkPkgList *pkg_list = (GtkPkgList *) tree_model; |
---|
| 525 | |
---|
| 526 | RPackage *pkg = pkg_list->_lister->getViewPackage(0); |
---|
| 527 | |
---|
| 528 | iter->stamp = 140677; |
---|
| 529 | iter->user_data = pkg; |
---|
| 530 | iter->user_data2 = 0; |
---|
| 531 | return TRUE; |
---|
| 532 | } |
---|
| 533 | |
---|
| 534 | static gboolean |
---|
| 535 | gtk_pkg_list_iter_has_child(GtkTreeModel *tree_model, GtkTreeIter *iter) |
---|
| 536 | { |
---|
| 537 | return FALSE; |
---|
| 538 | } |
---|
| 539 | |
---|
| 540 | static gint |
---|
| 541 | gtk_pkg_list_iter_n_children(GtkTreeModel *tree_model, GtkTreeIter *iter) |
---|
| 542 | { |
---|
| 543 | g_return_val_if_fail(GTK_IS_PKG_LIST(tree_model), -1); |
---|
| 544 | g_return_val_if_fail(iter == NULL || iter->user_data != NULL, FALSE); |
---|
| 545 | |
---|
| 546 | GtkPkgList *pkg_list = GTK_PKG_LIST(tree_model); |
---|
| 547 | |
---|
| 548 | #ifdef DEBUG_LIST |
---|
| 549 | cout << "iter_n_children" << endl; |
---|
| 550 | #endif |
---|
| 551 | |
---|
| 552 | if (iter == NULL) |
---|
| 553 | return pkg_list->_lister->viewPackagesSize(); |
---|
| 554 | |
---|
| 555 | return 0; |
---|
| 556 | } |
---|
| 557 | |
---|
| 558 | static gboolean |
---|
| 559 | gtk_pkg_list_iter_nth_child(GtkTreeModel *tree_model, |
---|
| 560 | GtkTreeIter *iter, GtkTreeIter *parent, gint n) |
---|
| 561 | { |
---|
| 562 | g_return_val_if_fail(GTK_IS_PKG_LIST(tree_model), FALSE); |
---|
| 563 | GtkPkgList *pkg_list = (GtkPkgList *) tree_model; |
---|
| 564 | |
---|
| 565 | if (parent) { |
---|
| 566 | cout << "parent != NULL" << endl; |
---|
| 567 | return FALSE; |
---|
| 568 | } |
---|
| 569 | |
---|
| 570 | if (n >= (gint) pkg_list->_lister->viewPackagesSize()) |
---|
| 571 | return FALSE; |
---|
| 572 | |
---|
| 573 | RPackage *pkg = pkg_list->_lister->getViewPackage(n); |
---|
| 574 | assert(pkg); |
---|
| 575 | |
---|
| 576 | #ifdef DEBUG_LIST |
---|
| 577 | cout << "iter_nth_child(): " << n << " is: " << pkg->name() << endl; |
---|
| 578 | #endif |
---|
| 579 | |
---|
| 580 | iter->stamp = 140677; |
---|
| 581 | iter->user_data = pkg; |
---|
| 582 | iter->user_data2 = GINT_TO_POINTER(n); |
---|
| 583 | return TRUE; |
---|
| 584 | } |
---|
| 585 | |
---|
| 586 | static gboolean |
---|
| 587 | gtk_pkg_list_iter_parent(GtkTreeModel *tree_model, |
---|
| 588 | GtkTreeIter *iter, GtkTreeIter *child) |
---|
| 589 | { |
---|
| 590 | return FALSE; |
---|
| 591 | } |
---|
| 592 | |
---|
| 593 | |
---|
| 594 | |
---|
| 595 | // sortable |
---|
| 596 | static gboolean gtk_pkg_list_get_sort_column_id(GtkTreeSortable *sortable, |
---|
| 597 | gint *sort_column_id, |
---|
| 598 | GtkSortType *order) |
---|
| 599 | { |
---|
| 600 | GtkPkgList *pkg_list = (GtkPkgList *) sortable; |
---|
| 601 | g_return_val_if_fail(GTK_IS_PKG_LIST(sortable), FALSE); |
---|
| 602 | |
---|
| 603 | //cout << " gtk_pkg_list_get_sort_column_id()" << endl; |
---|
| 604 | |
---|
| 605 | if (sort_column_id) |
---|
| 606 | *sort_column_id = pkg_list->sort_column_id; |
---|
| 607 | if (order) |
---|
| 608 | *order = pkg_list->order; |
---|
| 609 | return TRUE; |
---|
| 610 | } |
---|
| 611 | |
---|
| 612 | |
---|
| 613 | static void gtk_pkg_list_set_sort_column_id(GtkTreeSortable *sortable, |
---|
| 614 | gint sort_column_id, |
---|
| 615 | GtkSortType order) |
---|
| 616 | { |
---|
| 617 | GtkPkgList *pkg_list = (GtkPkgList *) sortable; |
---|
| 618 | g_return_if_fail(GTK_IS_PKG_LIST(sortable)); |
---|
| 619 | |
---|
| 620 | //cout << "gtk_pkg_list_set_sort_column_id(): " << sort_column_id << endl; |
---|
| 621 | |
---|
| 622 | if ((pkg_list->sort_column_id == sort_column_id) && |
---|
| 623 | (pkg_list->order == order)) |
---|
| 624 | return; |
---|
| 625 | |
---|
| 626 | pkg_list->sort_column_id = sort_column_id; |
---|
| 627 | pkg_list->order = order; |
---|
| 628 | |
---|
| 629 | gtk_tree_sortable_sort_column_changed(sortable); |
---|
| 630 | gtk_pkg_list_sort(pkg_list); |
---|
| 631 | } |
---|
| 632 | |
---|
| 633 | static gboolean gtk_pkg_list_has_default_sort_func(GtkTreeSortable *sortable) |
---|
| 634 | { |
---|
| 635 | g_return_val_if_fail(GTK_IS_PKG_LIST(sortable), FALSE); |
---|
| 636 | return TRUE; |
---|
| 637 | } |
---|
| 638 | |
---|
| 639 | static void gtk_pkg_list_sort(GtkPkgList *pkg_list) |
---|
| 640 | { |
---|
| 641 | //cout << "gtk_pkg_list_sort(GtkPkgList *pkg_list)" << endl; |
---|
| 642 | g_return_if_fail(GTK_IS_PKG_LIST(pkg_list)); |
---|
| 643 | |
---|
| 644 | switch (pkg_list->sort_column_id) { |
---|
| 645 | case COLOR_COLUMN: |
---|
| 646 | if(pkg_list->order) |
---|
| 647 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_STATUS_ASC); |
---|
| 648 | else |
---|
| 649 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_STATUS_DES); |
---|
| 650 | break; |
---|
| 651 | case SUPPORTED_COLUMN: |
---|
| 652 | if(pkg_list->order) |
---|
| 653 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_SUPPORTED_ASC); |
---|
| 654 | else |
---|
| 655 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_SUPPORTED_DES); |
---|
| 656 | break; |
---|
| 657 | case NAME_COLUMN: |
---|
| 658 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_NAME); |
---|
| 659 | break; |
---|
| 660 | case PKG_SIZE_COLUMN: |
---|
| 661 | if(pkg_list->order) |
---|
| 662 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_SIZE_ASC); |
---|
| 663 | else |
---|
| 664 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_SIZE_DES); |
---|
| 665 | break; |
---|
| 666 | case COMPONENT_COLUMN: |
---|
| 667 | if(pkg_list->order) |
---|
| 668 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_COMPONENT_ASC); |
---|
| 669 | else |
---|
| 670 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_COMPONENT_DES); |
---|
| 671 | break; |
---|
| 672 | case SECTION_COLUMN: |
---|
| 673 | if(pkg_list->order) |
---|
| 674 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_SECTION_ASC); |
---|
| 675 | else |
---|
| 676 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_SECTION_DES); |
---|
| 677 | break; |
---|
| 678 | case PKG_DOWNLOAD_SIZE_COLUMN: |
---|
| 679 | if(pkg_list->order) |
---|
| 680 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_DLSIZE_ASC); |
---|
| 681 | else |
---|
| 682 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_DLSIZE_DES); |
---|
| 683 | break; |
---|
| 684 | case AVAILABLE_VERSION_COLUMN: |
---|
| 685 | if(pkg_list->order) |
---|
| 686 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_VERSION_ASC); |
---|
| 687 | else |
---|
| 688 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_VERSION_DES); |
---|
| 689 | break; |
---|
| 690 | case INSTALLED_VERSION_COLUMN: |
---|
| 691 | if(pkg_list->order) |
---|
| 692 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_INST_VERSION_ASC); |
---|
| 693 | else |
---|
| 694 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_INST_VERSION_DES); |
---|
| 695 | break; |
---|
| 696 | default: |
---|
| 697 | //cerr << "unknown sort column: " << pkg_list->sort_column_id << endl; |
---|
| 698 | pkg_list->_lister->sortPackages(RPackageLister::LIST_SORT_NAME); |
---|
| 699 | } |
---|
| 700 | } |
---|
| 701 | |
---|
| 702 | // vim:ts=3:sw=3:et |
---|