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_taskpanel.h>
  26 #include <ui_tasktree.h>
  27
  28 static GtkTreeView *w_treeview;
  29 static struct task **current_tasks;
  30
  31 enum {
  32         COL_ID,
  33         COL_DESCRIPTION,
  34         COL_PROJECT,
  35         COL_UUID,
  36         COL_PRIORITY,
  37         COL_URGENCY
  38 };
  39
  40 static int priority_to_int(const char *str)
  41 {
  42         switch (*str) {
  43         case 'H':
  44                 return 3;
  45         case 'M':
  46                 return 2;
  47         case 'L':
  48                 return 1;
  49         default:
  50                 return 0;
  51         }
  52 }
  53
  54 static gint priority_cmp(GtkTreeModel *model,
  55                          GtkTreeIter *a,
  56                          GtkTreeIter *b,
  57                          gpointer user_data)
  58 {
  59         GValue v1 = {0,}, v2 = {0,};
  60         const char *str1, *str2;
  61         int i1, i2;
  62
  63         gtk_tree_model_get_value(model, a, COL_PRIORITY, &v1);
  64         str1 = g_value_get_string(&v1);
  65         i1 = priority_to_int(str1);
  66
  67         gtk_tree_model_get_value(model, b, COL_PRIORITY, &v2);
  68         str2 = g_value_get_string(&v2);
  69         i2 = priority_to_int(str2);
  70
  71         if (i1 < i2)
  72                 return -1;
  73         else if (i1 > i2)
  74                 return 1;
  75         else
  76                 return 0;
  77 }
  78
  79 int tasktree_cursor_changed_cbk(GtkTreeView *treeview, gpointer data)
  80 {
  81         log_fct_enter();
  82
  83         ui_taskpanel_update(ui_tasktree_get_selected_task());
  84
  85         log_fct_exit();
  86
  87         return FALSE;
  88 }
  89
  90 void ui_tasktree_init(GtkBuilder *builder)
  91 {
  92         GtkTreeModel *model;
  93
  94         w_treeview = GTK_TREE_VIEW(gtk_builder_get_object(builder, "tasktree"));
  95
  96         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
  97         gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model),
  98                                         COL_PRIORITY,
  99                                         priority_cmp,
 100                                         NULL,
 101                                         NULL);
 102 }
 103
 104 void ui_tasktree_load_settings(GSettings *settings)
 105 {
 106         int sort_col_id;
 107         GtkSortType sort_order;
 108         GtkTreeModel *model;
 109
 110         sort_col_id = g_settings_get_int(settings, "tasks-sort-col");
 111         sort_order = g_settings_get_int(settings, "tasks-sort-order");
 112         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
 113         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model),
 114                                              sort_col_id, sort_order);
 115 }
 116
 117 void ui_tasktree_save_settings(GSettings *settings)
 118 {
 119         int sort_col_id;
 120         GtkTreeModel *model;
 121         GtkSortType sort_order;
 122
 123         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
 124         gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(model),
 125                                              &sort_col_id,
 126                                              &sort_order);
 127         log_debug("ui_tasktree_save_settings(): sort_col_id=%d", sort_col_id);
 128         log_debug("ui_tasktree_save_settings(): sort_col_order=%d", sort_order);
 129
 130         g_settings_set_int(settings, "tasks-sort-col", sort_col_id);
 131         g_settings_set_int(settings, "tasks-sort-order", sort_order);
 132 }
 133
 134 const char *ui_tasktree_get_task_uuid()
 135 {
 136         struct task *t;
 137
 138         t = ui_tasktree_get_selected_task();
 139
 140         if (t)
 141                 return t->uuid;
 142         else
 143                 return NULL;
 144 }
 145
 146 struct task *ui_tasktree_get_selected_task()
 147 {
 148         GtkTreePath *path;
 149         GtkTreeViewColumn *cols;
 150         struct task **tasks_cur, *result;
 151         GtkTreeIter iter;
 152         GtkTreeModel *model;
 153         GValue value = {0,};
 154         const char *uuid;
 155
 156         log_fct_enter();
 157
 158         result = NULL;
 159
 160         if (current_tasks) {
 161                 gtk_tree_view_get_cursor(w_treeview, &path, &cols);
 162
 163                 if (path) {
 164                         model = gtk_tree_view_get_model(w_treeview);
 165                         gtk_tree_model_get_iter(model, &iter, path);
 166                         gtk_tree_model_get_value(model,
 167                                                  &iter,
 168                                                  COL_UUID,
 169                                                  &value);
 170
 171                         uuid = g_value_get_string(&value);
 172
 173                         for (tasks_cur = current_tasks; *tasks_cur; tasks_cur++)
 174                                 if (!strcmp((*tasks_cur)->uuid, uuid))
 175                                         result = *tasks_cur;
 176
 177                         gtk_tree_path_free(path);
 178                 }
 179         }
 180
 181         log_fct_exit();
 182
 183         return result;
 184 }
 185
 186 void ui_tasktree_set_selected_task(const char *uuid)
 187 {
 188         GtkTreePath *path;
 189         GtkTreeIter iter;
 190         GtkTreeModel *model;
 191         GValue value = {0,};
 192         const char *c_uuid;
 193
 194         log_fct_enter();
 195
 196         if (current_tasks) {
 197                 model = gtk_tree_view_get_model(w_treeview);
 198
 199                 if (!gtk_tree_model_get_iter_first(model, &iter))
 200                         return ;
 201
 202                 path = NULL;
 203                 while (gtk_tree_model_iter_next(model, &iter)) {
 204                         gtk_tree_model_get_value(model,
 205                                                  &iter,
 206                                                  COL_UUID,
 207                                                  &value);
 208                         c_uuid = g_value_get_string(&value);
 209
 210                         if (!strcmp(uuid, c_uuid)) {
 211                                 path = gtk_tree_model_get_path(model, &iter);
 212                                 break;
 213                         }
 214
 215                         g_value_unset(&value);
 216                 }
 217
 218                 if (!path)
 219                         path = gtk_tree_path_new_first();
 220                 gtk_tree_view_set_cursor(w_treeview, path, NULL, FALSE);
 221         }
 222
 223         log_fct_exit();
 224 }
 225
 226
 227 void ui_tasktree_update(struct task **tasks, const char *prj_filter)
 228 {
 229         GtkTreeModel *model;
 230         struct task **tasks_cur;
 231         struct task *task;
 232         GtkTreeIter iter;
 233         const char *prj;
 234
 235         current_tasks = tasks;
 236
 237         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
 238         gtk_list_store_clear(GTK_LIST_STORE(model));
 239
 240         if (current_tasks) {
 241                 for (tasks_cur = current_tasks; *tasks_cur; tasks_cur++) {
 242                         task = (*tasks_cur);
 243
 244                         if (task->project)
 245                                 prj = task->project;
 246                         else
 247                                 prj = "";
 248
 249                         if (prj_filter && strcmp(prj, prj_filter))
 250                                 continue;
 251
 252                         gtk_list_store_append(GTK_LIST_STORE(model), &iter);
 253
 254                         gtk_list_store_set(GTK_LIST_STORE(model),
 255                                            &iter,
 256                                            COL_ID, (*tasks_cur)->id,
 257                                            COL_DESCRIPTION,
 258                                            (*tasks_cur)->description,
 259                                            COL_PROJECT, prj,
 260                                            COL_UUID, (*tasks_cur)->uuid,
 261                                            COL_PRIORITY, (*tasks_cur)->priority,
 262                                            COL_URGENCY, (*tasks_cur)->urgency,
 263                                            -1);
 264                 }
 265         }
 266
 267 }
 268
 269 void ui_tasktree_update_filter(const char *prj_filter)
 270 {
 271         ui_tasktree_update(current_tasks, prj_filter);
 272 }