src/main.c

   1 /*
   2  * Copyright (C) 2010-2012 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 <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 #include <json/json.h>
  24
  25 #include <gtk/gtk.h>
  26
  27 #include "tw.h"
  28
  29 static struct task **tasks;
  30 static GtkTextView *w_note;
  31 static GtkEntry *w_description;
  32 static GtkEntry *w_project;
  33 static GtkTreeView *w_treeview;
  34 static GtkWidget *w_tasksave_btn;
  35 static GtkComboBox *w_status;
  36 static GtkComboBox *w_priority;
  37
  38 enum {
  39         COL_ID,
  40         COL_DESCRIPTION,
  41         COL_PROJECT,
  42         COL_UUID,
  43         COL_PRIORITY
  44 };
  45
  46 static struct task *get_selected_task(GtkTreeView *treeview)
  47 {
  48         GtkTreePath *path;
  49         GtkTreeViewColumn *cols;
  50         struct task **tasks_cur;
  51         GtkTreeIter iter;
  52         GtkTreeModel *model;
  53         GValue value = {0,};
  54         const char *uuid;
  55
  56         printf("get_selected_task\n");
  57
  58         gtk_tree_view_get_cursor(treeview, &path, &cols);
  59
  60         if (path) {
  61                 model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
  62                 gtk_tree_model_get_iter(model, &iter, path);
  63                 gtk_tree_model_get_value(model, &iter, COL_UUID, &value);
  64
  65                 uuid = g_value_get_string(&value);
  66
  67                 for (tasks_cur = tasks; *tasks_cur; tasks_cur++)
  68                         if (!strcmp((*tasks_cur)->uuid, uuid))
  69                                 return *tasks_cur;
  70
  71                 gtk_tree_path_free(path);
  72         }
  73
  74         return NULL;
  75 }
  76
  77 static void clear_task_panel()
  78 {
  79         GtkTextBuffer *buf;
  80
  81         gtk_widget_set_sensitive(w_tasksave_btn, 0);
  82
  83         buf = gtk_text_view_get_buffer(w_note);
  84         gtk_text_buffer_set_text(buf, "", 0);
  85         gtk_widget_set_sensitive(GTK_WIDGET(w_note), 0);
  86
  87         gtk_entry_set_text(w_description, "");
  88         gtk_widget_set_sensitive(GTK_WIDGET(w_description), 0);
  89
  90         gtk_entry_set_text(w_project, "");
  91         gtk_widget_set_sensitive(GTK_WIDGET(w_project), 0);
  92
  93         gtk_combo_box_set_active(w_priority, 0);
  94         gtk_widget_set_sensitive(GTK_WIDGET(w_priority), 0);
  95 }
  96
  97 static void refresh()
  98 {
  99         GtkTreeModel *model;
 100         struct task **tasks_cur;
 101         struct task *task;
 102         int i;
 103         GtkTreeIter iter;
 104         int status;
 105         const char *project;
 106
 107         printf("refresh\n");
 108         clear_task_panel();
 109
 110         status = gtk_combo_box_get_active(w_status);
 111         printf("status: %d\n", status);
 112
 113         switch (status) {
 114         case 0:
 115                 tasks = tw_get_all_tasks("pending");
 116                 break;
 117         case 1:
 118                 tasks = tw_get_all_tasks("completed");
 119                 break;
 120         default:
 121                 tasks = tw_get_all_tasks("pending");
 122         }
 123
 124         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
 125         gtk_list_store_clear(GTK_LIST_STORE(model));
 126         for (tasks_cur = tasks, i = 0; *tasks_cur; tasks_cur++, i++) {
 127                 task = (*tasks_cur);
 128
 129                 gtk_list_store_append(GTK_LIST_STORE(model), &iter);
 130
 131                 if (task->project)
 132                         project = task->project;
 133                 else
 134                         project = "";
 135
 136                 gtk_list_store_set(GTK_LIST_STORE(model),
 137                                    &iter,
 138                                    COL_ID, (*tasks_cur)->id,
 139                                    COL_DESCRIPTION, (*tasks_cur)->description,
 140                                    COL_PROJECT, project,
 141                                    COL_UUID, (*tasks_cur)->uuid,
 142                                    COL_PRIORITY, (*tasks_cur)->priority,
 143                                    -1);
 144         }
 145         printf("refresh done\n");
 146 }
 147
 148 int taskdone_clicked_cbk(GtkButton *btn, gpointer data)
 149 {
 150         struct task *task;
 151
 152         task = get_selected_task(GTK_TREE_VIEW(w_treeview));
 153         tw_done(task->uuid);
 154         refresh();
 155
 156         return FALSE;
 157 }
 158
 159 static int tasksave_clicked_cbk(GtkButton *btn, gpointer data)
 160 {
 161         struct task *task;
 162         GtkTextBuffer *buf;
 163         char *txt, *pri;
 164         GtkTextIter sIter, eIter;
 165         const char *ctxt;
 166         int priority;
 167
 168         task = get_selected_task(GTK_TREE_VIEW(w_treeview));
 169
 170         printf("tasksave_clicked_cbk %d\n", task->id);
 171
 172         if (task->note) {
 173                 buf = gtk_text_view_get_buffer(w_note);
 174
 175                 gtk_text_buffer_get_iter_at_offset(buf, &sIter, 0);
 176                 gtk_text_buffer_get_iter_at_offset(buf, &eIter, -1);
 177                 txt = gtk_text_buffer_get_text(buf, &sIter, &eIter, TRUE);
 178
 179                 txt = escape(txt);
 180
 181                 printf("%s\n", txt);
 182         }
 183
 184         ctxt = gtk_entry_get_text(w_description);
 185         if (!task->description || strcmp(ctxt, task->description))
 186                 tw_modify_description(task->uuid, ctxt);
 187
 188         ctxt = gtk_entry_get_text(w_project);
 189         if (!task->project || strcmp(ctxt, task->project))
 190                 tw_modify_project(task->uuid, ctxt);
 191
 192         priority = gtk_combo_box_get_active(w_priority);
 193         printf("priority: %d\n", priority);
 194
 195         switch (priority) {
 196         case 3:
 197                 pri = "H";
 198                 break;
 199         case 2:
 200                 pri = "M";
 201                 break;
 202         case 1:
 203                 pri = "L";
 204                 break;
 205         default:
 206                 pri = "";
 207         }
 208
 209         if (strcmp(task->priority, pri))
 210                 tw_modify_priority(task->uuid, pri);
 211
 212         refresh();
 213
 214         return FALSE;
 215 }
 216
 217 int refresh_clicked_cbk(GtkButton *btn, gpointer data)
 218 {
 219         printf("refresh_clicked_cbk\n");
 220         refresh();
 221
 222         return FALSE;
 223 }
 224
 225 int newtask_clicked_cbk(GtkButton *btn, gpointer data)
 226 {
 227         gint result;
 228         static GtkDialog *diag;
 229         GtkBuilder *builder;
 230         GtkEntry *entry;
 231         const char *ctxt;
 232
 233         printf("newtask_clicked_cbk\n");
 234
 235         builder = gtk_builder_new();
 236         gtk_builder_add_from_file
 237                 (builder,
 238                  PACKAGE_DATA_DIR G_DIR_SEPARATOR_S "gtask.glade",
 239                  NULL);
 240         diag = GTK_DIALOG(gtk_builder_get_object(builder, "diag_tasknew"));
 241         gtk_builder_connect_signals(builder, NULL);
 242
 243         result = gtk_dialog_run(diag);
 244
 245         if (result == GTK_RESPONSE_ACCEPT) {
 246                 printf("ok\n");
 247                 entry = GTK_ENTRY(gtk_builder_get_object
 248                                   (builder, "diag_tasknew_description"));
 249                 ctxt = gtk_entry_get_text(entry);
 250
 251                 printf("%s\n", ctxt);
 252
 253                 tw_add(ctxt);
 254                 refresh();
 255         } else {
 256                 printf("cancel\n");
 257         }
 258
 259         g_object_unref(G_OBJECT(builder));
 260
 261         gtk_widget_destroy(GTK_WIDGET(diag));
 262
 263         return FALSE;
 264 }
 265
 266 static int status_changed_cbk(GtkComboBox *w, gpointer data)
 267 {
 268         printf("status_changed_cbk\n");
 269         refresh();
 270
 271         return FALSE;
 272 }
 273
 274 static int priority_to_int(const char *str)
 275 {
 276         switch (*str) {
 277         case 'H':
 278                 return 3;
 279         case 'M':
 280                 return 2;
 281         case 'L':
 282                 return 1;
 283         default:
 284                 return 0;
 285         }
 286 }
 287
 288 static int cursor_changed_cbk(GtkTreeView *treeview, gpointer data)
 289 {
 290         struct task *task;
 291         GtkTextBuffer *buf;
 292         int priority;
 293
 294         printf("cursor_changed_cbk\n");
 295
 296         task = get_selected_task(treeview);
 297
 298         if (task) {
 299
 300                 buf = gtk_text_view_get_buffer(w_note);
 301                 if (task->note)
 302                         gtk_text_buffer_set_text(buf,
 303                                                  task->note,
 304                                                  strlen(task->note));
 305                 else
 306                         gtk_text_buffer_set_text(buf, "", 0);
 307                 gtk_widget_set_sensitive(GTK_WIDGET(w_note), 1);
 308
 309                 gtk_entry_set_text(w_description, task->description);
 310                 gtk_widget_set_sensitive(GTK_WIDGET(w_description), 1);
 311
 312                 if (task->project)
 313                         gtk_entry_set_text(w_project, task->project);
 314                 else
 315                         gtk_entry_set_text(w_project, "");
 316                 gtk_widget_set_sensitive(GTK_WIDGET(w_project), 1);
 317
 318                 gtk_widget_set_sensitive(w_tasksave_btn, 1);
 319
 320                 gtk_widget_set_sensitive(GTK_WIDGET(w_priority), 1);
 321                 priority = priority_to_int(task->priority);
 322                 gtk_combo_box_set_active(w_priority, priority);
 323         } else {
 324                 printf("clear task widgets\n");
 325                 clear_task_panel();
 326                 printf("clear task widgets done\n");
 327         }
 328
 329         return FALSE;
 330 }
 331
 332 static gint priority_cmp(GtkTreeModel *model,
 333                          GtkTreeIter *a,
 334                          GtkTreeIter *b,
 335                          gpointer user_data)
 336 {
 337         GValue v1 = {0,}, v2 = {0,};
 338         const char *str1, *str2;
 339         int i1, i2;
 340
 341         gtk_tree_model_get_value(model, a, COL_PRIORITY, &v1);
 342         str1 = g_value_get_string(&v1);
 343         i1 = priority_to_int(str1);
 344
 345         gtk_tree_model_get_value(model, b, COL_PRIORITY, &v2);
 346         str2 = g_value_get_string(&v2);
 347         i2 = priority_to_int(str2);
 348
 349         if (i1 < i2)
 350                 return -1;
 351         else if (i1 > i2)
 352                 return 1;
 353         else
 354                 return 0;
 355 }
 356
 357 int main(int argc, char **argv)
 358 {
 359         GtkWidget *window;
 360         GtkWidget *btn;
 361         GtkBuilder *builder;
 362         GtkTreeModel *model;
 363
 364         gtk_init(NULL, NULL);
 365         builder = gtk_builder_new();
 366         gtk_builder_add_from_file
 367                 (builder,
 368                  PACKAGE_DATA_DIR G_DIR_SEPARATOR_S "gtask.glade",
 369                  NULL);
 370         window = GTK_WIDGET(gtk_builder_get_object(builder, "window"));
 371
 372         w_treeview = GTK_TREE_VIEW(gtk_builder_get_object(builder, "treeview"));
 373         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
 374         gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model),
 375                                         COL_PRIORITY,
 376                                         priority_cmp,
 377                                         NULL,
 378                                         NULL);
 379
 380         w_note = GTK_TEXT_VIEW(gtk_builder_get_object(builder, "tasknote"));
 381
 382         w_description = GTK_ENTRY(gtk_builder_get_object(builder,
 383                                                          "taskdescription"));
 384         w_project = GTK_ENTRY(gtk_builder_get_object(builder, "taskproject"));
 385         w_status = GTK_COMBO_BOX(gtk_builder_get_object(builder, "status"));
 386         w_priority = GTK_COMBO_BOX(gtk_builder_get_object(builder,
 387                                                           "taskpriority"));
 388
 389         refresh();
 390
 391         gtk_builder_connect_signals(builder, NULL);
 392
 393         g_signal_connect(w_treeview,
 394                          "cursor-changed", (GCallback)cursor_changed_cbk,
 395                          tasks);
 396         g_signal_connect(w_status,
 397                          "changed", (GCallback)status_changed_cbk,
 398                          tasks);
 399         btn = GTK_WIDGET(gtk_builder_get_object(builder, "tasksave"));
 400         g_signal_connect(btn,
 401                          "clicked", (GCallback)tasksave_clicked_cbk, tasks);
 402         gtk_widget_set_sensitive(btn, 0);
 403         w_tasksave_btn = btn;
 404
 405         g_object_unref(G_OBJECT(builder));
 406
 407         gtk_widget_show_all(window);
 408
 409         gtk_main();
 410
 411         exit(EXIT_SUCCESS);
 412 }