src/ui_tasktree.c

   1 /*
   2  * Copyright (C) 2012-2013 jeanfi@gmail.com
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301 USA
  18  */
  19 #include <string.h>
  20
  21 #include <gtk/gtk.h>
  22
  23 #include <log.h>
  24 #include <ui_projecttree.h>
  25 #include <ui_tasktree.h>
  26
  27 static GtkTreeView *w_treeview;
  28 static struct task **current_tasks;
  29
  30 enum {
  31         COL_ID,
  32         COL_DESCRIPTION,
  33         COL_PROJECT,
  34         COL_UUID,
  35         COL_PRIORITY
  36 };
  37
  38 static int priority_to_int(const char *str)
  39 {
  40         switch (*str) {
  41         case 'H':
  42                 return 3;
  43         case 'M':
  44                 return 2;
  45         case 'L':
  46                 return 1;
  47         default:
  48                 return 0;
  49         }
  50 }
  51
  52 static gint priority_cmp(GtkTreeModel *model,
  53                          GtkTreeIter *a,
  54                          GtkTreeIter *b,
  55                          gpointer user_data)
  56 {
  57         GValue v1 = {0,}, v2 = {0,};
  58         const char *str1, *str2;
  59         int i1, i2;
  60
  61         gtk_tree_model_get_value(model, a, COL_PRIORITY, &v1);
  62         str1 = g_value_get_string(&v1);
  63         i1 = priority_to_int(str1);
  64
  65         gtk_tree_model_get_value(model, b, COL_PRIORITY, &v2);
  66         str2 = g_value_get_string(&v2);
  67         i2 = priority_to_int(str2);
  68
  69         if (i1 < i2)
  70                 return -1;
  71         else if (i1 > i2)
  72                 return 1;
  73         else
  74                 return 0;
  75 }
  76
  77 void ui_tasktree_init(GtkBuilder *builder)
  78 {
  79         GtkTreeModel *model;
  80
  81         w_treeview = GTK_TREE_VIEW(gtk_builder_get_object(builder, "tasktree"));
  82
  83         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
  84         gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model),
  85                                         COL_PRIORITY,
  86                                         priority_cmp,
  87                                         NULL,
  88                                         NULL);
  89 }
  90
  91 void ui_tasktree_load_settings(GSettings *settings)
  92 {
  93         int sort_col_id;
  94         GtkSortType sort_order;
  95         GtkTreeModel *model;
  96
  97         sort_col_id = g_settings_get_int(settings, "tasks-sort-col");
  98         sort_order = g_settings_get_int(settings, "tasks-sort-order");
  99         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
 100         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model),
 101                                              sort_col_id, sort_order);
 102 }
 103
 104 void ui_tasktree_save_settings(GSettings *settings)
 105 {
 106         int sort_col_id;
 107         GtkTreeModel *model;
 108         GtkSortType sort_order;
 109
 110         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
 111         gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(model),
 112                                              &sort_col_id,
 113                                              &sort_order);
 114         log_debug("ui_tasktree_save_settings(): sort_col_id=%d", sort_col_id);
 115         log_debug("ui_tasktree_save_settings(): sort_col_order=%d", sort_order);
 116
 117         g_settings_set_int(settings, "tasks-sort-col", sort_col_id);
 118         g_settings_set_int(settings, "tasks-sort-order", sort_order);
 119 }
 120
 121 const char *ui_tasktree_get_task_uuid()
 122 {
 123         struct task *t;
 124
 125         t = ui_tasktree_get_selected_task();
 126
 127         if (t)
 128                 return t->uuid;
 129         else
 130                 return NULL;
 131 }
 132
 133 struct task *ui_tasktree_get_selected_task()
 134 {
 135         GtkTreePath *path;
 136         GtkTreeViewColumn *cols;
 137         struct task **tasks_cur, *result;
 138         GtkTreeIter iter;
 139         GtkTreeModel *model;
 140         GValue value = {0,};
 141         const char *uuid;
 142
 143         log_fct_enter();
 144
 145         result = NULL;
 146
 147         if (current_tasks) {
 148                 gtk_tree_view_get_cursor(w_treeview, &path, &cols);
 149
 150                 if (path) {
 151                         model = gtk_tree_view_get_model(w_treeview);
 152                         gtk_tree_model_get_iter(model, &iter, path);
 153                         gtk_tree_model_get_value(model,
 154                                                  &iter,
 155                                                  COL_UUID,
 156                                                  &value);
 157
 158                         uuid = g_value_get_string(&value);
 159
 160                         for (tasks_cur = current_tasks; *tasks_cur; tasks_cur++)
 161                                 if (!strcmp((*tasks_cur)->uuid, uuid))
 162                                         result = *tasks_cur;
 163
 164                         gtk_tree_path_free(path);
 165                 }
 166         }
 167
 168         log_fct_exit();
 169
 170         return result;
 171 }
 172
 173 void ui_tasktree_update(struct task **tasks,
 174                         const char *prj_filter,
 175                         const char *task_uuid)
 176 {
 177         GtkTreeModel *model;
 178         struct task **tasks_cur;
 179         struct task *task;
 180         GtkTreeIter iter;
 181         const char *prj;
 182         GtkTreePath *p;
 183
 184         current_tasks = tasks;
 185
 186         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
 187         gtk_list_store_clear(GTK_LIST_STORE(model));
 188         p = NULL;
 189
 190         if (current_tasks) {
 191                 for (tasks_cur = current_tasks; *tasks_cur; tasks_cur++) {
 192                         task = (*tasks_cur);
 193
 194                         if (task->project)
 195                                 prj = task->project;
 196                         else
 197                                 prj = "";
 198
 199                         if (prj_filter && strcmp(prj, prj_filter))
 200                                 continue;
 201
 202                         gtk_list_store_append(GTK_LIST_STORE(model), &iter);
 203
 204                         gtk_list_store_set(GTK_LIST_STORE(model),
 205                                            &iter,
 206                                            COL_ID, (*tasks_cur)->id,
 207                                            COL_DESCRIPTION,
 208                                            (*tasks_cur)->description,
 209                                            COL_PROJECT, prj,
 210                                            COL_UUID, (*tasks_cur)->uuid,
 211                                            COL_PRIORITY, (*tasks_cur)->priority,
 212                                            -1);
 213
 214                         if (task_uuid && !strcmp(task->uuid, task_uuid))
 215                                 p = gtk_tree_model_get_path(model, &iter);
 216                 }
 217
 218                 if (!p)
 219                         p = gtk_tree_path_new_first();
 220                 gtk_tree_view_set_cursor(w_treeview, p, NULL, FALSE);
 221         }
 222
 223 }
 224
 225 void ui_tasktree_update_filter(const char *prj_filter)
 226 {
 227         ui_tasktree_update(current_tasks, prj_filter, NULL);
 228 }