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 #define _XOPEN_SOURCE
  20 #include <time.h>
  21
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include <gtk/gtk.h>
  26
  27 #include <log.h>
  28 #include <ptime.h>
  29 #include <settings.h>
  30 #include <ui_projecttree.h>
  31 #include <ui_taskpanel.h>
  32 #include <ui_tasktree.h>
  33
  34 static const char * const MENU_NAMES[] = {
  35         "menu_id_visible",
  36         "menu_description_visible",
  37         "menu_project_visible",
  38         "menu_uuid_visible",
  39         "menu_priority_visible",
  40         "menu_urgency_visible",
  41         "menu_creation_date_visible",
  42         "menu_due_visible",
  43         "menu_start_visible",
  44 };
  45
  46 static GtkTreeView *w_treeview;
  47 static GtkMenu *w_menu;
  48 static struct task **current_tasks;
  49
  50 enum {
  51         COL_ID,
  52         COL_DESCRIPTION,
  53         COL_PROJECT,
  54         COL_UUID,
  55         COL_PRIORITY,
  56         COL_URGENCY,
  57         COL_CREATION_DATE,
  58         COL_DUE,
  59         COL_START,
  60         COL_COUNT
  61 };
  62
  63 static GtkTreeViewColumn *w_cols[COL_COUNT];
  64 static GtkCheckMenuItem *w_menus[COL_COUNT];
  65
  66 static int priority_to_int(const char *str)
  67 {
  68         switch (*str) {
  69         case 'H':
  70                 return 3;
  71         case 'M':
  72                 return 2;
  73         case 'L':
  74                 return 1;
  75         default:
  76                 return 0;
  77         }
  78 }
  79
  80 static gint priority_cmp(GtkTreeModel *model,
  81                          GtkTreeIter *a,
  82                          GtkTreeIter *b,
  83                          gpointer user_data)
  84 {
  85         GValue v1 = {0,}, v2 = {0,};
  86         const char *str1, *str2;
  87         int i1, i2;
  88
  89         gtk_tree_model_get_value(model, a, COL_PRIORITY, &v1);
  90         str1 = g_value_get_string(&v1);
  91         i1 = priority_to_int(str1);
  92
  93         gtk_tree_model_get_value(model, b, COL_PRIORITY, &v2);
  94         str2 = g_value_get_string(&v2);
  95         i2 = priority_to_int(str2);
  96
  97         if (i1 < i2)
  98                 return -1;
  99         else if (i1 > i2)
 100                 return 1;
 101         else
 102                 return 0;
 103 }
 104
 105 int tasktree_cursor_changed_cbk(GtkTreeView *treeview, gpointer data)
 106 {
 107         log_fct_enter();
 108
 109         ui_taskpanel_update(ui_tasktree_get_selected_task());
 110
 111         log_fct_exit();
 112
 113         return FALSE;
 114 }
 115
 116 void ui_tasktree_init(GtkBuilder *builder)
 117 {
 118         GtkTreeModel *model;
 119         int i;
 120
 121         w_treeview = GTK_TREE_VIEW(gtk_builder_get_object(builder, "tasktree"));
 122         w_menu = GTK_MENU(gtk_builder_get_object(builder, "tasktree_menu"));
 123         g_object_ref(w_menu);
 124
 125         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
 126         gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model),
 127                                         COL_PRIORITY,
 128                                         priority_cmp,
 129                                         NULL,
 130                                         NULL);
 131
 132         w_cols[COL_ID] = GTK_TREE_VIEW_COLUMN
 133                 (gtk_builder_get_object(builder, "col_id"));
 134         w_cols[COL_DESCRIPTION] = GTK_TREE_VIEW_COLUMN
 135                 (gtk_builder_get_object(builder, "col_description"));
 136         w_cols[COL_PROJECT] = GTK_TREE_VIEW_COLUMN
 137                 (gtk_builder_get_object(builder, "col_project"));
 138         w_cols[COL_UUID] = GTK_TREE_VIEW_COLUMN
 139                 (gtk_builder_get_object(builder, "col_uuid"));
 140         w_cols[COL_PRIORITY] = GTK_TREE_VIEW_COLUMN
 141                 (gtk_builder_get_object(builder, "col_priority"));
 142         w_cols[COL_URGENCY] = GTK_TREE_VIEW_COLUMN
 143                 (gtk_builder_get_object(builder, "col_urgency"));
 144         w_cols[COL_CREATION_DATE] = GTK_TREE_VIEW_COLUMN
 145                 (gtk_builder_get_object(builder, "col_creation_date"));
 146         w_cols[COL_DUE] = GTK_TREE_VIEW_COLUMN
 147                 (gtk_builder_get_object(builder, "col_due"));
 148         w_cols[COL_START] = GTK_TREE_VIEW_COLUMN
 149                 (gtk_builder_get_object(builder, "col_start"));
 150
 151         for (i = 0; i < COL_COUNT; i++)
 152                 w_menus[i] = GTK_CHECK_MENU_ITEM
 153                         (gtk_builder_get_object(builder, MENU_NAMES[i]));
 154 }
 155
 156 void ui_tasktree_load_settings()
 157 {
 158         int sort_col_id, i;
 159         GtkSortType sort_order;
 160         GtkTreeModel *model;
 161         const char *key;
 162         gboolean b;
 163
 164         sort_col_id = settings_get_int(SETTINGS_KEY_TASKS_SORT_COL);
 165         sort_order = settings_get_int(SETTINGS_KEY_TASKS_SORT_ORDER);
 166         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
 167         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model),
 168                                              sort_col_id, sort_order);
 169
 170
 171         for (i = 0; i < COL_COUNT; i++) {
 172                 key = SETTINGS_VISIBLE_COL_KEYS[i];
 173                 b = settings_get_boolean(key);
 174                 gtk_tree_view_column_set_visible(w_cols[i], b);
 175         }
 176
 177         for (i = 0; i < COL_COUNT; i++) {
 178                 key = SETTINGS_VISIBLE_COL_KEYS[i];
 179                 b = settings_get_boolean(key);
 180                 gtk_check_menu_item_set_active(w_menus[i], b);
 181         }
 182 }
 183
 184 void ui_tasktree_save_settings()
 185 {
 186         int sort_col_id;
 187         GtkTreeModel *model;
 188         GtkSortType sort_order;
 189
 190         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
 191         gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(model),
 192                                              &sort_col_id,
 193                                              &sort_order);
 194         log_debug("ui_tasktree_save_settings(): sort_col_id=%d", sort_col_id);
 195         log_debug("ui_tasktree_save_settings(): sort_col_order=%d", sort_order);
 196
 197         settings_set_int(SETTINGS_KEY_TASKS_SORT_COL, sort_col_id);
 198         settings_set_int(SETTINGS_KEY_TASKS_SORT_ORDER, sort_order);
 199 }
 200
 201 const char *ui_tasktree_get_task_uuid()
 202 {
 203         struct task *t;
 204
 205         t = ui_tasktree_get_selected_task();
 206
 207         if (t)
 208                 return t->uuid;
 209         else
 210                 return NULL;
 211 }
 212
 213 struct task *ui_tasktree_get_selected_task()
 214 {
 215         GtkTreePath *path;
 216         GtkTreeViewColumn *cols;
 217         struct task **tasks_cur, *result;
 218         GtkTreeIter iter;
 219         GtkTreeModel *model;
 220         GValue value = {0,};
 221         const char *uuid;
 222
 223         log_fct_enter();
 224
 225         result = NULL;
 226
 227         if (current_tasks) {
 228                 gtk_tree_view_get_cursor(w_treeview, &path, &cols);
 229
 230                 if (path) {
 231                         model = gtk_tree_view_get_model(w_treeview);
 232                         gtk_tree_model_get_iter(model, &iter, path);
 233                         gtk_tree_model_get_value(model,
 234                                                  &iter,
 235                                                  COL_UUID,
 236                                                  &value);
 237
 238                         uuid = g_value_get_string(&value);
 239
 240                         for (tasks_cur = current_tasks; *tasks_cur; tasks_cur++)
 241                                 if (!strcmp((*tasks_cur)->uuid, uuid))
 242                                         result = *tasks_cur;
 243
 244                         gtk_tree_path_free(path);
 245                 }
 246         }
 247
 248         log_fct_exit();
 249
 250         return result;
 251 }
 252
 253 void ui_tasktree_set_selected_task(const char *uuid)
 254 {
 255         GtkTreePath *path;
 256         GtkTreeIter iter;
 257         GtkTreeModel *model;
 258         GValue value = {0,};
 259         const char *c_uuid;
 260
 261         log_fct_enter();
 262
 263         if (current_tasks) {
 264                 model = gtk_tree_view_get_model(w_treeview);
 265
 266                 if (!gtk_tree_model_get_iter_first(model, &iter))
 267                         return ;
 268
 269                 path = NULL;
 270                 while (gtk_tree_model_iter_next(model, &iter)) {
 271                         gtk_tree_model_get_value(model,
 272                                                  &iter,
 273                                                  COL_UUID,
 274                                                  &value);
 275                         c_uuid = g_value_get_string(&value);
 276
 277                         if (!strcmp(uuid, c_uuid)) {
 278                                 path = gtk_tree_model_get_path(model, &iter);
 279                                 break;
 280                         }
 281
 282                         g_value_unset(&value);
 283                 }
 284
 285                 if (!path)
 286                         path = gtk_tree_path_new_first();
 287                 gtk_tree_view_set_cursor(w_treeview, path, NULL, FALSE);
 288         }
 289
 290         log_fct_exit();
 291 }
 292
 293
 294 void ui_tasktree_update(struct task **tasks, const char *prj_filter)
 295 {
 296         GtkTreeModel *model;
 297         struct task **tasks_cur;
 298         struct task *task;
 299         GtkTreeIter iter;
 300         const char *prj;
 301         char *s;
 302
 303         current_tasks = tasks;
 304
 305         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
 306         gtk_list_store_clear(GTK_LIST_STORE(model));
 307
 308         if (current_tasks) {
 309                 for (tasks_cur = current_tasks; *tasks_cur; tasks_cur++) {
 310                         task = (*tasks_cur);
 311
 312                         if (task->project)
 313                                 prj = task->project;
 314                         else
 315                                 prj = "";
 316
 317                         if (prj_filter && strcmp(prj, prj_filter))
 318                                 continue;
 319
 320                         gtk_list_store_append(GTK_LIST_STORE(model), &iter);
 321
 322                         gtk_list_store_set(GTK_LIST_STORE(model),
 323                                            &iter,
 324                                            COL_ID,
 325                                            (*tasks_cur)->id,
 326                                            COL_DESCRIPTION,
 327                                            (*tasks_cur)->description,
 328                                            COL_PROJECT,
 329                                            prj,
 330                                            COL_UUID,
 331                                            (*tasks_cur)->uuid,
 332                                            COL_PRIORITY,
 333                                            (*tasks_cur)->priority,
 334                                            COL_URGENCY,
 335                                            (*tasks_cur)->urgency,
 336                                            -1);
 337
 338                         if ((*tasks_cur)->start) {
 339                                 s = tm_to_str((*tasks_cur)->start);
 340                                 gtk_list_store_set
 341                                         (GTK_LIST_STORE(model),
 342                                          &iter,
 343                                          COL_START,
 344                                          s,
 345                                          -1);
 346                                 free(s);
 347                         }
 348
 349                         if ((*tasks_cur)->due) {
 350                                 s = tm_to_str((*tasks_cur)->due);
 351                                 gtk_list_store_set
 352                                         (GTK_LIST_STORE(model),
 353                                          &iter,
 354                                          COL_DUE,
 355                                          s,
 356                                          -1);
 357                                 free(s);
 358                         }
 359
 360                         if ((*tasks_cur)->entry) {
 361                                 s = tm_to_str((*tasks_cur)->entry);
 362                                 gtk_list_store_set
 363                                         (GTK_LIST_STORE(model),
 364                                          &iter,
 365                                          COL_CREATION_DATE,
 366                                          s,
 367                                          -1);
 368                                 free(s);
 369                         }
 370                 }
 371         }
 372
 373 }
 374
 375 void ui_tasktree_update_filter(const char *prj_filter)
 376 {
 377         ui_tasktree_update(current_tasks, prj_filter);
 378 }
 379
 380 gboolean tasktree_button_press_event_cbk(GtkWidget *widget,
 381                                          GdkEventButton *evt,
 382                                          gpointer data)
 383 {
 384         log_fct_enter();
 385
 386         if (evt->button == 3)
 387                 gtk_menu_popup(w_menu,
 388                                NULL, NULL, NULL, NULL, evt->button, evt->time);
 389
 390         log_fct_exit();
 391
 392         return FALSE;
 393 }
 394
 395 void tasktree_visible_activate_cbk(GtkAction *action, gpointer data)
 396 {
 397         gboolean b;
 398         int id;
 399         const char *aname, *key;
 400
 401         aname = gtk_action_get_name(action);
 402
 403         if (!strcmp(aname, "tasktree_id_visible"))
 404                 id = COL_ID;
 405         else if (!strcmp(aname, "tasktree_description_visible"))
 406                 id = COL_DESCRIPTION;
 407         else if (!strcmp(aname, "tasktree_project_visible"))
 408                 id = COL_PROJECT;
 409         else if (!strcmp(aname, "tasktree_uuid_visible"))
 410                 id = COL_UUID;
 411         else if (!strcmp(aname, "tasktree_priority_visible"))
 412                 id = COL_PRIORITY;
 413         else if (!strcmp(aname, "tasktree_urgency_visible"))
 414                 id = COL_URGENCY;
 415         else if (!strcmp(aname, "tasktree_creation_date_visible"))
 416                 id = COL_CREATION_DATE;
 417         else if (!strcmp(aname, "tasktree_due_visible"))
 418                 id = COL_DUE;
 419         else if (!strcmp(aname, "tasktree_start_visible"))
 420                 id = COL_START;
 421         else
 422                 id = -1;
 423
 424         if (id != -1) {
 425                 key = SETTINGS_VISIBLE_COL_KEYS[id];
 426                 b = settings_get_boolean(key);
 427                 settings_set_boolean(key, !b);
 428                 gtk_tree_view_column_set_visible(w_cols[id], !b);
 429         }
 430 }