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