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 static int match_search_keywords(struct task *task)
 296 {
 297         gchar *desc;
 298         int ret;
 299         char **tags;
 300         gchar *tag;
 301
 302         if (!search_keywords || !strlen(search_keywords))
 303                 return 1;
 304
 305         if (!task->description || !strlen(task->description))
 306                 return 0;
 307
 308         desc = g_ascii_strup(task->description, -1);
 309
 310         if (strstr(desc, search_keywords))
 311                 ret = 1;
 312         else
 313                 ret = 0;
 314
 315         free(desc);
 316
 317         if (ret)
 318                 return 1;
 319
 320         tags = task->tags;
 321         if (!tags)
 322                 return 0;
 323
 324         while (*tags) {
 325                 tag = g_ascii_strup(*tags, -1);
 326
 327                 if (strstr(tag, search_keywords))
 328                         ret = 1;
 329
 330                 free(tag);
 331
 332                 if (ret)
 333                         return 1;
 334
 335                 tags++;
 336         }
 337
 338         return 0;
 339 }
 340
 341 void ui_tasktree_update(struct task **tasks)
 342 {
 343         GtkTreeModel *model;
 344         struct task **tasks_cur;
 345         struct task *task;
 346         GtkTreeIter iter;
 347         const char *prj, *prj_filter;
 348         char *s;
 349
 350         prj_filter = ui_projecttree_get_project();
 351
 352         current_tasks = tasks;
 353
 354         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
 355         gtk_list_store_clear(GTK_LIST_STORE(model));
 356
 357         if (current_tasks) {
 358                 for (tasks_cur = current_tasks; *tasks_cur; tasks_cur++) {
 359                         task = (*tasks_cur);
 360
 361                         if (task->project)
 362                                 prj = task->project;
 363                         else
 364                                 prj = "";
 365
 366                         if (prj_filter && strcmp(prj, prj_filter))
 367                                 continue;
 368
 369                         if (!match_search_keywords(task))
 370                                 continue;
 371
 372                         gtk_list_store_append(GTK_LIST_STORE(model), &iter);
 373
 374                         gtk_list_store_set(GTK_LIST_STORE(model),
 375                                            &iter,
 376                                            COL_ID,
 377                                            (*tasks_cur)->id,
 378                                            COL_DESCRIPTION,
 379                                            (*tasks_cur)->description,
 380                                            COL_PROJECT,
 381                                            prj,
 382                                            COL_UUID,
 383                                            (*tasks_cur)->uuid,
 384                                            COL_PRIORITY,
 385                                            (*tasks_cur)->priority,
 386                                            COL_URGENCY,
 387                                            (*tasks_cur)->urgency,
 388                                            -1);
 389
 390                         if ((*tasks_cur)->start) {
 391                                 s = tm_to_str((*tasks_cur)->start);
 392                                 gtk_list_store_set
 393                                         (GTK_LIST_STORE(model),
 394                                          &iter,
 395                                          COL_START,
 396                                          s,
 397                                          -1);
 398                                 free(s);
 399                         }
 400
 401                         if ((*tasks_cur)->due) {
 402                                 s = tm_to_str((*tasks_cur)->due);
 403                                 gtk_list_store_set
 404                                         (GTK_LIST_STORE(model),
 405                                          &iter,
 406                                          COL_DUE,
 407                                          s,
 408                                          -1);
 409                                 free(s);
 410                         }
 411
 412                         if ((*tasks_cur)->entry) {
 413                                 s = tm_to_str((*tasks_cur)->entry);
 414                                 gtk_list_store_set
 415                                         (GTK_LIST_STORE(model),
 416                                          &iter,
 417                                          COL_CREATION_DATE,
 418                                          s,
 419                                          -1);
 420                                 free(s);
 421                         }
 422                 }
 423         }
 424
 425 }
 426
 427 gboolean tasktree_button_press_event_cbk(GtkWidget *widget,
 428                                          GdkEventButton *evt,
 429                                          gpointer data)
 430 {
 431         log_fct_enter();
 432
 433         if (evt->button == 3)
 434                 gtk_menu_popup(w_menu,
 435                                NULL, NULL, NULL, NULL, evt->button, evt->time);
 436
 437         log_fct_exit();
 438
 439         return FALSE;
 440 }
 441
 442 void tasktree_visible_activate_cbk(GtkAction *action, gpointer data)
 443 {
 444         gboolean b;
 445         int id;
 446         const char *aname, *key;
 447
 448         aname = gtk_action_get_name(action);
 449
 450         if (!strcmp(aname, "tasktree_id_visible"))
 451                 id = COL_ID;
 452         else if (!strcmp(aname, "tasktree_description_visible"))
 453                 id = COL_DESCRIPTION;
 454         else if (!strcmp(aname, "tasktree_project_visible"))
 455                 id = COL_PROJECT;
 456         else if (!strcmp(aname, "tasktree_uuid_visible"))
 457                 id = COL_UUID;
 458         else if (!strcmp(aname, "tasktree_priority_visible"))
 459                 id = COL_PRIORITY;
 460         else if (!strcmp(aname, "tasktree_urgency_visible"))
 461                 id = COL_URGENCY;
 462         else if (!strcmp(aname, "tasktree_creation_date_visible"))
 463                 id = COL_CREATION_DATE;
 464         else if (!strcmp(aname, "tasktree_due_visible"))
 465                 id = COL_DUE;
 466         else if (!strcmp(aname, "tasktree_start_visible"))
 467                 id = COL_START;
 468         else
 469                 id = -1;
 470
 471         if (id != -1) {
 472                 key = SETTINGS_VISIBLE_COL_KEYS[id];
 473                 b = settings_get_boolean(key);
 474                 settings_set_boolean(key, !b);
 475                 gtk_tree_view_column_set_visible(w_cols[id], !b);
 476         }
 477 }
 478
 479 void tasktree_done_activate_cbk(GtkAction *action, gpointer data)
 480 {
 481         struct task *t;
 482
 483         log_fct_enter();
 484
 485         t = ui_tasktree_get_selected_task();
 486
 487         if (t) {
 488                 tw_task_done(t->uuid);
 489                 refresh();
 490         }
 491
 492         log_fct_exit();
 493 }
 494
 495 void tasktree_start_activate_cbk(GtkAction *action, gpointer data)
 496 {
 497         struct task *t;
 498
 499         log_fct_enter();
 500
 501         t = ui_tasktree_get_selected_task();
 502
 503         if (t) {
 504                 tw_task_start(t->uuid);
 505                 refresh();
 506         }
 507
 508         log_fct_exit();
 509 }
 510
 511 void tasktree_stop_activate_cbk(GtkAction *action, gpointer data)
 512 {
 513         struct task *t;
 514
 515         log_fct_enter();
 516
 517         t = ui_tasktree_get_selected_task();
 518
 519         if (t) {
 520                 tw_task_stop(t->uuid);
 521                 refresh();
 522         }
 523
 524         log_fct_exit();
 525 }
 526
 527 void
 528 ui_tasktree_search_changed_cbk(GtkEntry *entry, gchar *preedit, gpointer data)
 529 {
 530         if (search_keywords)
 531                 g_free(search_keywords);
 532
 533         search_keywords = g_ascii_strup(gtk_entry_get_text(entry), -1);
 534
 535         ui_tasktree_update(current_tasks);
 536 }
 537
 538 void ui_tasktree_update_filter(const char *prj)
 539 {
 540         ui_tasktree_update(current_tasks);
 541 }