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
 106         clear_task_panel();
 107
 108         status = gtk_combo_box_get_active(w_status);
 109         printf("status: %d\n", status);
 110
 111         switch (status) {
 112         case 0:
 113                 tasks = tw_get_all_tasks("pending");
 114                 break;
 115         case 1:
 116                 tasks = tw_get_all_tasks("completed");
 117                 break;
 118         default:
 119                 tasks = tw_get_all_tasks("pending");
 120         }
 121
 122         model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview));
 123         gtk_list_store_clear(GTK_LIST_STORE(model));
 124         for (tasks_cur = tasks, i = 0; *tasks_cur; tasks_cur++, i++) {
 125                 task = (*tasks_cur);
 126
 127                 gtk_list_store_append(GTK_LIST_STORE(model), &iter);
 128
 129                 if (task->project)
 130                         gtk_list_store_set(GTK_LIST_STORE(model),
 131                                            &iter,
 132                                            COL_PROJECT, task->project,
 133                                            -1);
 134
 135                 gtk_list_store_set(GTK_LIST_STORE(model),
 136                                    &iter,
 137                                    COL_ID, (*tasks_cur)->id,
 138                                    COL_DESCRIPTION, (*tasks_cur)->description,
 139                                    COL_UUID, (*tasks_cur)->uuid,
 140                                    COL_PRIORITY, (*tasks_cur)->priority,
 141                                    -1);
 142         }
 143 }
 144
 145 static int tasksave_clicked_cbk(GtkButton *btn, gpointer data)
 146 {
 147         struct task *task;
 148         GtkTextBuffer *buf;
 149         char *txt, *pri;
 150         GtkTextIter sIter, eIter;
 151         const char *ctxt;
 152         int priority;
 153
 154         task = get_selected_task(GTK_TREE_VIEW(w_treeview));
 155
 156         printf("tasksave_clicked_cbk %d\n", task->id);
 157
 158         if (task->note) {
 159                 buf = gtk_text_view_get_buffer(w_note);
 160
 161                 gtk_text_buffer_get_iter_at_offset(buf, &sIter, 0);
 162                 gtk_text_buffer_get_iter_at_offset(buf, &eIter, -1);
 163                 txt = gtk_text_buffer_get_text(buf, &sIter, &eIter, TRUE);
 164
 165                 txt = escape(txt);
 166
 167                 printf("%s\n", txt);
 168         }
 169
 170         ctxt = gtk_entry_get_text(w_description);
 171         if (!task->description || strcmp(ctxt, task->description))
 172                 tw_modify_description(task->uuid, ctxt);
 173
 174         ctxt = gtk_entry_get_text(w_project);
 175         if (!task->project || strcmp(ctxt, task->project))
 176                 tw_modify_project(task->uuid, ctxt);
 177
 178         priority = gtk_combo_box_get_active(w_priority);
 179         printf("priority: %d\n", priority);
 180
 181         switch (priority) {
 182         case 1:
 183                 pri = "H";
 184                 break;
 185         case 2:
 186                 pri = "M";
 187                 break;
 188         case 3:
 189                 pri = "L";
 190                 break;
 191         default:
 192                 pri = "";
 193         }
 194
 195         if (strcmp(task->priority, pri))
 196                 tw_modify_priority(task->uuid, pri);
 197
 198         refresh();
 199
 200         return FALSE;
 201 }
 202
 203 int refresh_clicked_cbk(GtkButton *btn, gpointer data)
 204 {
 205         printf("refresh_clicked_cbk\n");
 206         refresh();
 207
 208         return FALSE;
 209 }
 210
 211 int newtask_clicked_cbk(GtkButton *btn, gpointer data)
 212 {
 213         gint result;
 214         static GtkDialog *diag;
 215         GtkBuilder *builder;
 216         GtkEntry *entry;
 217         const char *ctxt;
 218
 219         printf("newtask_clicked_cbk\n");
 220
 221         builder = gtk_builder_new();
 222         gtk_builder_add_from_file
 223                 (builder,
 224                  PACKAGE_DATA_DIR G_DIR_SEPARATOR_S "gtask.glade",
 225                  NULL);
 226         diag = GTK_DIALOG(gtk_builder_get_object(builder, "diag_tasknew"));
 227         gtk_builder_connect_signals(builder, NULL);
 228
 229         result = gtk_dialog_run(diag);
 230
 231         if (result == GTK_RESPONSE_ACCEPT) {
 232                 printf("ok\n");
 233                 entry = GTK_ENTRY(gtk_builder_get_object
 234                                   (builder, "diag_tasknew_description"));
 235                 ctxt = gtk_entry_get_text(entry);
 236
 237                 printf("%s\n", ctxt);
 238
 239                 tw_add(ctxt);
 240                 refresh();
 241         } else {
 242                 printf("cancel\n");
 243         }
 244
 245         g_object_unref(G_OBJECT(builder));
 246
 247         gtk_widget_destroy(GTK_WIDGET(diag));
 248
 249         return FALSE;
 250 }
 251
 252 static int status_changed_cbk(GtkComboBox *w, gpointer data)
 253 {
 254         printf("status_changed_cbk\n");
 255         refresh();
 256
 257         return FALSE;
 258 }
 259
 260 static int cursor_changed_cbk(GtkTreeView *treeview, gpointer data)
 261 {
 262         struct task *task;
 263         GtkTextBuffer *buf;
 264         int priority;
 265
 266         printf("cursor_changed_cbk\n");
 267
 268         task = get_selected_task(treeview);
 269
 270         if (task) {
 271
 272                 buf = gtk_text_view_get_buffer(w_note);
 273                 if (task->note)
 274                         gtk_text_buffer_set_text(buf,
 275                                                  task->note,
 276                                                  strlen(task->note));
 277                 else
 278                         gtk_text_buffer_set_text(buf, "", 0);
 279                 gtk_widget_set_sensitive(GTK_WIDGET(w_note), 1);
 280
 281                 gtk_entry_set_text(w_description, task->description);
 282                 gtk_widget_set_sensitive(GTK_WIDGET(w_description), 1);
 283
 284                 if (task->project)
 285                         gtk_entry_set_text(w_project, task->project);
 286                 else
 287                         gtk_entry_set_text(w_project, "");
 288                 gtk_widget_set_sensitive(GTK_WIDGET(w_project), 1);
 289
 290                 gtk_widget_set_sensitive(w_tasksave_btn, 1);
 291
 292                 gtk_widget_set_sensitive(GTK_WIDGET(w_priority), 1);
 293                 if (!strcmp(task->priority, "H"))
 294                         priority = 1;
 295                 else if (!strcmp(task->priority, "M"))
 296                         priority = 2;
 297                 else if (!strcmp(task->priority, "L"))
 298                         priority = 3;
 299                 else
 300                         priority = 0;
 301
 302                 gtk_combo_box_set_active(w_priority, priority);
 303         } else {
 304                 printf("clear task widgets\n");
 305                 clear_task_panel();
 306         }
 307
 308         return FALSE;
 309 }
 310
 311 int main(int argc, char **argv)
 312 {
 313         GtkWidget *window;
 314         GtkWidget *btn;
 315         GtkBuilder *builder;
 316
 317         gtk_init(NULL, NULL);
 318         builder = gtk_builder_new();
 319         gtk_builder_add_from_file
 320                 (builder,
 321                  PACKAGE_DATA_DIR G_DIR_SEPARATOR_S "gtask.glade",
 322                  NULL);
 323         window = GTK_WIDGET(gtk_builder_get_object(builder, "window"));
 324
 325         w_treeview = GTK_TREE_VIEW(gtk_builder_get_object(builder, "treeview"));
 326
 327         w_note = GTK_TEXT_VIEW(gtk_builder_get_object(builder, "tasknote"));
 328
 329         w_description = GTK_ENTRY(gtk_builder_get_object(builder,
 330                                                          "taskdescription"));
 331         w_project = GTK_ENTRY(gtk_builder_get_object(builder, "taskproject"));
 332         w_status = GTK_COMBO_BOX(gtk_builder_get_object(builder, "status"));
 333         w_priority = GTK_COMBO_BOX(gtk_builder_get_object(builder,
 334                                                           "taskpriority"));
 335
 336         refresh();
 337
 338         gtk_builder_connect_signals(builder, NULL);
 339
 340         g_signal_connect(w_treeview,
 341                          "cursor-changed", (GCallback)cursor_changed_cbk,
 342                          tasks);
 343         g_signal_connect(w_status,
 344                          "changed", (GCallback)status_changed_cbk,
 345                          tasks);
 346         btn = GTK_WIDGET(gtk_builder_get_object(builder, "tasksave"));
 347         g_signal_connect(btn,
 348                          "clicked", (GCallback)tasksave_clicked_cbk, tasks);
 349         gtk_widget_set_sensitive(btn, 0);
 350         w_tasksave_btn = btn;
 351
 352         /*btn = GTK_WIDGET(gtk_builder_get_object(builder, "refresh"));
 353         g_signal_connect(btn,
 354         "clicked", (GCallback)refresh_clicked_cbk, tasks);*/
 355
 356         g_object_unref(G_OBJECT(builder));
 357
 358         gtk_widget_show_all(window);
 359
 360         gtk_main();
 361
 362         exit(EXIT_SUCCESS);
 363 }