source: projects/synaptic/trunk/gtk/gtkpkglist.cc @ 280

Revision 280, 21.3 KB checked in by yasumichi, 15 years ago (diff)

first import

Line 
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
29using namespace std;
30
31// #define DEBUG_LIST
32// #define DEBUG_LIST_FULL
33
34static void gtk_pkg_list_init(GtkPkgList *pkg_tree);
35static void gtk_pkg_list_class_init(GtkPkgListClass *klass);
36static void gtk_pkg_list_tree_model_init(GtkTreeModelIface *iface);
37static void gtk_pkg_list_sortable_init(GtkTreeSortableIface *iface);
38static void gtk_pkg_list_finalize(GObject *object);
39static GtkTreeModelFlags gtk_pkg_list_get_flags(GtkTreeModel *tree_model);
40static gint gtk_pkg_list_get_n_columns(GtkTreeModel *tree_model);
41static GType gtk_pkg_list_get_column_type(GtkTreeModel *tree_model,
42                                          gint index);
43static gboolean gtk_pkg_list_get_iter(GtkTreeModel *tree_model,
44                                      GtkTreeIter *iter, GtkTreePath *path);
45static GtkTreePath *gtk_pkg_list_get_path(GtkTreeModel *tree_model,
46                                          GtkTreeIter *iter);
47static void gtk_pkg_list_get_value(GtkTreeModel *tree_model,
48                                   GtkTreeIter *iter,
49                                   gint column, GValue * value);
50static gboolean gtk_pkg_list_iter_next(GtkTreeModel *tree_model,
51                                       GtkTreeIter *iter);
52static gboolean gtk_pkg_list_iter_children(GtkTreeModel *tree_model,
53                                           GtkTreeIter *iter,
54                                           GtkTreeIter *parent);
55static gboolean gtk_pkg_list_iter_has_child(GtkTreeModel *tree_model,
56                                            GtkTreeIter *iter);
57static gint gtk_pkg_list_iter_n_children(GtkTreeModel *tree_model,
58                                         GtkTreeIter *iter);
59static gboolean gtk_pkg_list_iter_nth_child(GtkTreeModel *tree_model,
60                                            GtkTreeIter *iter,
61                                            GtkTreeIter *parent, gint n);
62static gboolean gtk_pkg_list_iter_parent(GtkTreeModel *tree_model,
63                                         GtkTreeIter *iter,
64                                         GtkTreeIter *child);
65
66/* sortable */
67static void gtk_pkg_list_sort(GtkPkgList *pkg_list);
68static gboolean gtk_pkg_list_get_sort_column_id(GtkTreeSortable *sortable,
69                                                gint *sort_column_id,
70                                                GtkSortType *order);
71static void gtk_pkg_list_set_sort_column_id(GtkTreeSortable *sortable,
72                                            gint sort_column_id,
73                                            GtkSortType order);
74static gboolean gtk_pkg_list_has_default_sort_func(GtkTreeSortable *sortable);
75
76
77static GObjectClass *parent_class = NULL;
78
79extern GdkPixbuf *StatusPixbuf[12];
80extern GdkColor *StatusColors[12];
81
82void 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
106void 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
149GType 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
190static 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
200static 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
216void 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
225static 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 **/
246GtkPkgList *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
260static 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
273static 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
281static 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
291static GType
292gtk_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
304static gboolean
305gtk_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
347static 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
376static void
377gtk_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
475static gboolean
476gtk_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
509static gboolean
510gtk_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
534static gboolean
535gtk_pkg_list_iter_has_child(GtkTreeModel *tree_model, GtkTreeIter *iter)
536{
537   return FALSE;
538}
539
540static gint
541gtk_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
558static gboolean
559gtk_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
586static gboolean
587gtk_pkg_list_iter_parent(GtkTreeModel *tree_model,
588                         GtkTreeIter *iter, GtkTreeIter *child)
589{
590   return FALSE;
591}
592
593
594
595// sortable
596static 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
613static 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
633static 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
639static 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
Note: See TracBrowser for help on using the repository browser.