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