?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Don't toggle fullscreen in rich text mode
[maepad.git] / src / ui / callbacks.c
blob504166c765c60c230a989429d037785ca6b3fd1d
1 /*
2 * This file is part of MaePad
3 * Copyright (c) 2010 Thomas Perl <thp@thpinfo.com>
4 * http://thpinfo.com/2010/maepad/
5 *
6 * Based on Maemopad+:
7 * Copyright (c) 2006-2008 Kemal Hadimli
8 * Copyright (c) 2008 Thomas Perl
9 *
10 * This software is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public License
12 * as published by the Free Software Foundation; either version 2.1 of
13 * the License, or (at your option) any later version.
14 *
15 * This software is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this software; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
23 * 02110-1301 USA
24 *
25 */
26
27 #include <ui/callbacks.h>
28 #include <ui/interface.h>
29 #include <gtk/gtk.h>
30 #include <gdk/gdkkeysyms.h>
31 #include <libintl.h>
32
33 #include <glib.h>
34
35 /*
36 * strlen needed from string.h
37 */
38 #include <string.h>
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #include <unistd.h>
42 #include <stdlib.h>
43 #include <stdio.h>
44 #include <config.h>
45 #include <time.h>
46
47 #include <hildon/hildon.h>
48 #include <hildon/hildon-banner.h>
49 #include <hildon/hildon-note.h>
50 #include <hildon/hildon-font-selection-dialog.h>
51 #include <tablet-browser-interface.h>
52
53 #include <libgnomevfs/gnome-vfs.h>
54
55 #include <sharingdialog/sharing-dialog.h>
56
57 #include "sketchwidget.h"
58
59 #include "../he/he-about-dialog.h"
60 #include "../he/he-simple-color-dialog.h"
61
62 /*
63 * "Busy" status handling
64 *
65 * Use "busy_reset" to reset the busy status (turn off)
66 * Use "busy_enter" when starting time-consuming processing
67 * Use "busy_leave" when processing has been finished
68 */
69 typedef enum {
70 BUSY_RESET = 0,
71 BUSY_INCREMENT,
72 BUSY_DECREMENT,
73 } SetBusyType;
74
75 /* Don't use this directly, but make use of the macros defined below */
76 void set_busy(MainView* mainview, SetBusyType update);
77
78 #define busy_reset(mainview) set_busy(mainview, BUSY_RESET)
79 #define busy_enter(mainview) set_busy(mainview, BUSY_INCREMENT)
80 #define busy_leave(mainview) set_busy(mainview, BUSY_DECREMENT)
81
82
83 /*
84 * Privates:
85 */
86 void checklist_abort_longpress(MainView* mainview);
87 gboolean read_file_to_buffer(MainView * mainview);
88 void write_buffer_to_file(MainView * mainview);
89 void new_node_dialog(nodeType typ, MainView * mainview);
90 gboolean foreach_func_update_ord (GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter, MainView *mainview);
91 void move_nodes_up(GtkTreeModel * model, GtkTreeRowReference * topnode, GtkTreeRowReference * newtop);
92 GtkTreeRowReference *iter2ref(GtkTreeModel * model, GtkTreeIter * iter);
93 gboolean exec_command_on_db(MainView *mainview,char sql_string[]);
94 int get_node_id_on_tmp_db(GtkTreeModel *model,GtkTreeIter *iter);
95 gint get_branch_node_index(GtkTreePath *path);
96 gboolean move_node(MainView *mainview,GtkTreeIter *new_parent,GtkTreeIter *item_to_move,GtkTreeIter *item_befor);
97 gboolean tree_model_iter_prev(GtkTreeModel *tree_model,GtkTreeIter *iter);
98 gboolean show_confirmation(MainView* mainview, gchar* question);
99
100
101
102 gboolean callback_node_view_window_state(GtkWidget* window,
103 GdkEventWindowState* event, gpointer user_data)
104 {
105 MainView* mainview = (MainView*)user_data;
106 GtkWidget* sketch_scroll = NULL;
107
108 if (mainview->toolbar == NULL || mainview->sk == NULL) {
109 return FALSE;
110 }
111
112 sketch_scroll = GTK_WIDGET(sketchwidget_get_mainwidget(mainview->sk));
113
114 if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) {
115 if (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) {
116 gtk_widget_hide(mainview->toolbar);
117 gtk_scrolled_window_set_policy(
118 GTK_SCROLLED_WINDOW(sketch_scroll),
119 GTK_POLICY_NEVER,
120 GTK_POLICY_NEVER);
121 } else {
122 gtk_widget_show(mainview->toolbar);
123 gtk_scrolled_window_set_policy(
124 GTK_SCROLLED_WINDOW(sketch_scroll),
125 GTK_POLICY_AUTOMATIC,
126 GTK_POLICY_AUTOMATIC);
127 }
128 }
129
130 return FALSE;
131 }
132
133 void set_busy(MainView* mainview, SetBusyType update)
134 {
135 switch (update) {
136 case BUSY_RESET:
137 mainview->busyrefcount = 0;
138 break;
139 case BUSY_INCREMENT:
140 mainview->busyrefcount++;
141 break;
142 case BUSY_DECREMENT:
143 if (mainview->busyrefcount > 0) {
144 mainview->busyrefcount--;
145 }
146 break;
147 default:
148 g_assert_not_reached();
149 return;
150 }
151
152 hildon_gtk_window_set_progress_indicator(GTK_WINDOW(mainview->data->main_view), (mainview->busyrefcount > 0));
153 hildon_gtk_window_set_progress_indicator(GTK_WINDOW(mainview->data->node_view), (mainview->busyrefcount > 0));
154 }
155
156 void prepareUIforNodeChange(MainView * mainview, nodeType typ)
157 {
158 gtk_widget_set_sensitive(GTK_WIDGET(mainview->undo_tb), TRUE);
159 gtk_widget_set_sensitive(GTK_WIDGET(mainview->redo_tb), TRUE);
160
161 if (typ == NODE_TEXT)
162 {
163 gtk_widget_show(GTK_WIDGET(mainview->font_tb));
164 gtk_widget_show(GTK_WIDGET(mainview->bold_tb));
165 gtk_widget_show(GTK_WIDGET(mainview->italic_tb));
166 gtk_widget_show(GTK_WIDGET(mainview->underline_tb));
167 gtk_widget_show(GTK_WIDGET(mainview->bullet_tb));
168 gtk_widget_show(mainview->tools_font);
169 }
170 else
171 {
172 gtk_widget_hide(GTK_WIDGET(mainview->font_tb));
173 gtk_widget_hide(GTK_WIDGET(mainview->bold_tb));
174 gtk_widget_hide(GTK_WIDGET(mainview->italic_tb));
175 gtk_widget_hide(GTK_WIDGET(mainview->underline_tb));
176 gtk_widget_hide(GTK_WIDGET(mainview->bullet_tb));
177 gtk_widget_hide(mainview->tools_font);
178 }
179
180 if (typ == NODE_SKETCH)
181 {
182 /* gtk_widget_show(GTK_WIDGET(mainview->colorbutton_tb));*/
183 gtk_widget_show(GTK_WIDGET(mainview->eraser_tb));
184 gtk_widget_show(GTK_WIDGET(mainview->brushsize_tb));
185 gtk_widget_show(GTK_WIDGET(mainview->sketchlines_tb));
186 gtk_widget_show(GTK_WIDGET(mainview->shape_tb));
187 gtk_widget_show(GTK_WIDGET(mainview->sharing_tb));
188 gtk_widget_show(mainview->tools_color);
189 gtk_widget_show(mainview->tools_brushsize);
190 gtk_widget_show(mainview->tools_pagestyle);
191 gtk_widget_show(mainview->tools_shape);
192 gtk_widget_show(mainview->tools_pressure);
193 }
194 else
195 {
196 /* gtk_widget_hide(GTK_WIDGET(mainview->colorbutton_tb));*/
197 gtk_widget_hide(GTK_WIDGET(mainview->eraser_tb));
198 gtk_widget_hide(GTK_WIDGET(mainview->brushsize_tb));
199 gtk_widget_hide(GTK_WIDGET(mainview->sketchlines_tb));
200 gtk_widget_hide(GTK_WIDGET(mainview->shape_tb));
201 gtk_widget_hide(GTK_WIDGET(mainview->sharing_tb));
202 gtk_widget_hide(mainview->tools_color);
203 gtk_widget_hide(mainview->tools_brushsize);
204 gtk_widget_hide(mainview->tools_pagestyle);
205 gtk_widget_hide(mainview->tools_shape);
206 gtk_widget_hide(mainview->tools_pressure);
207 }
208
209 if (typ == NODE_CHECKLIST)
210 {
211 gtk_widget_show(GTK_WIDGET(mainview->bold_tb));
212 gtk_widget_show(GTK_WIDGET(mainview->strikethru_tb));
213 gtk_widget_show(GTK_WIDGET(mainview->check_tb));
214 gtk_widget_show(GTK_WIDGET(mainview->checkadd_tb));
215 gtk_widget_show(GTK_WIDGET(mainview->checkedit_tb));
216 gtk_widget_show(GTK_WIDGET(mainview->checkdel_tb));
217 gtk_widget_hide(GTK_WIDGET(mainview->undo_tb));
218 gtk_widget_hide(GTK_WIDGET(mainview->redo_tb));
219 }
220 else
221 {
222 gtk_widget_hide(GTK_WIDGET(mainview->strikethru_tb));
223 gtk_widget_hide(GTK_WIDGET(mainview->check_tb));
224 gtk_widget_hide(GTK_WIDGET(mainview->checkadd_tb));
225 gtk_widget_hide(GTK_WIDGET(mainview->checkedit_tb));
226 gtk_widget_hide(GTK_WIDGET(mainview->checkdel_tb));
227 gtk_widget_show(GTK_WIDGET(mainview->undo_tb));
228 gtk_widget_show(GTK_WIDGET(mainview->redo_tb));
229 }
230
231 if (typ == NODE_TEXT)
232 {
233 gtk_widget_hide(GTK_WIDGET(mainview->colorbutton_tb));
234 gtk_widget_hide(sketchwidget_get_mainwidget(mainview->sk));
235 gtk_widget_hide(mainview->listscroll);
236 gtk_widget_show(GTK_WIDGET(mainview->scrolledwindow));
237 gtk_widget_show(mainview->tools_item);
238 }
239 else if (typ == NODE_SKETCH)
240 {
241 gtk_widget_show(GTK_WIDGET(mainview->colorbutton_tb));
242 gtk_widget_hide(GTK_WIDGET(mainview->scrolledwindow));
243 gtk_widget_hide(mainview->listscroll);
244 gtk_widget_show(sketchwidget_get_mainwidget(mainview->sk));
245 gtk_widget_show(mainview->tools_item);
246 }
247 else if (typ == NODE_CHECKLIST)
248 {
249 gtk_widget_show(GTK_WIDGET(mainview->colorbutton_tb));
250 gtk_widget_hide(GTK_WIDGET(mainview->scrolledwindow));
251 gtk_widget_hide(sketchwidget_get_mainwidget(mainview->sk));
252 gtk_widget_hide(mainview->tools_item);
253 gtk_widget_show(mainview->listscroll);
254 }
255 else
256 {
257 gtk_widget_hide(GTK_WIDGET(mainview->colorbutton_tb));
258 gtk_widget_hide(GTK_WIDGET(mainview->scrolledwindow));
259 gtk_widget_hide(sketchwidget_get_mainwidget(mainview->sk));
260 gtk_widget_hide(mainview->tools_item);
261 gtk_widget_hide(mainview->listscroll);
262 }
263 }
264
265 nodeData *getSelectedNode(MainView * mainview)
266 {
267 GtkTreeIter iter;
268 GtkTreeModel *model;
269
270 nodeData *nd;
271
272 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
273
274 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
275 return (NULL);
276
277 gtk_tree_model_get(model, &iter, NODE_DATA, &nd, -1);
278
279 return (nd);
280 }
281
282 void saveCurrentData(MainView * mainview)
283 {
284 nodeData *selnode = getSelectedNode(mainview);
285 saveDataToNode(mainview, selnode);
286 }
287
288 void saveDataToNode(MainView * mainview, nodeData *selnode)
289 {
290 if (selnode == NULL)
291 return;
292
293 if (
294 (selnode->typ == NODE_SKETCH && sketchwidget_get_edited(mainview->sk) == FALSE) ||
295 (selnode->typ == NODE_TEXT && wp_text_buffer_is_modified(mainview->buffer)==FALSE) ||
296 (selnode->typ == NODE_CHECKLIST && mainview->checklist_edited==FALSE)
297 )
298 {
299 maepad_message("node not edited, not saving");
300 return;
301 }
302
303 mainview->file_edited = TRUE;
304
305 busy_enter(mainview);
306 maepad_debug("saveDataToNode working");
307
308 gboolean goterr = TRUE;
309 gchar *textdata = NULL;
310 GdkPixbuf *pixbuf = NULL;
311 gchar *sketchdata = NULL;
312 gsize datalen = 0;
313 char tq[512];
314
315 if (selnode->typ == NODE_TEXT)
316 {
317 #if 0
318 GtkTextIter start, end;
319 gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(mainview->buffer), &start, &end);
320 textdata = gtk_text_buffer_serialize_rich_text(GTK_TEXT_BUFFER(mainview->buffer), &start, &end, &datalen);
321 #endif
322
323 GString *gstr=g_string_sized_new(4096);
324 wp_text_buffer_save_document(mainview->buffer, (WPDocumentSaveCallback)(wp_savecallback), gstr);
325
326 datalen=gstr->len;
327 textdata=g_string_free(gstr, FALSE);
328
329 /* g_snprintf(tq, sizeof(tq), "UPDATE %s SET bodytype=%d, bodyblob=NULL, body=?, flags=%d WHERE nodeid=%d", datatable_tmpname, selnode->typ, selnode->flags, selnode->sql3id);*/
330 g_snprintf(tq, sizeof(tq), "UPDATE %s SET bodytype=%d, bodyblob=?, body=NULL, flags=%d WHERE nodeid=%d", datatable_tmpname, selnode->typ, selnode->flags, selnode->sql3id);
331 }
332 else if (selnode->typ == NODE_SKETCH)
333 {
334 GError *err = NULL;
335 GdkPixmap *skpix = sketchwidget_get_Pixmap(mainview->sk);
336 GtkWidget *skdr = sketchwidget_get_drawingarea(mainview->sk);
337
338 pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE(skpix), NULL, 0, 0, 0, 0, skdr->allocation.width, skdr->allocation.height);
339 if (pixbuf == NULL)
340 {
341 maepad_warning("error saving: pixbuf is null");
342 }
343 else
344 {
345 double w, h;
346 GdkPixbuf *pixbuf2 = sketchwidget_trim_image(pixbuf, skdr->allocation.width, skdr->allocation.height, &w, &h, FALSE);
347
348 if (pixbuf2!=NULL)
349 {
350 if (gdk_pixbuf_save_to_buffer(pixbuf2, &sketchdata, &datalen, "png", &err, NULL) == FALSE)
351 {
352 sketchdata = NULL;
353 datalen = 0;
354 maepad_warning("Error saving sketch: %s", err->message);
355 g_error_free(err);
356 }
357 gdk_pixbuf_unref(pixbuf2);
358 }
359 }
360 g_snprintf(tq, sizeof(tq), "UPDATE %s SET bodytype=%d, body=NULL, bodyblob=?, flags=%d WHERE nodeid=%d", datatable_tmpname, selnode->typ, selnode->flags, selnode->sql3id);
361 maepad_debug("storing sketch in db: %d bytes", datalen);
362 if (skpix && G_IS_OBJECT(skpix)) g_object_unref(skpix);
363 }
364 else if (selnode->typ == NODE_CHECKLIST)
365 {
366 g_snprintf(tq, sizeof(tq), "UPDATE %s SET bodytype=%d, body=NULL, bodyblob=NULL, flags=%d WHERE nodeid=%d", datatable_tmpname, selnode->typ, selnode->flags, selnode->sql3id);
367 }
368
369 do
370 {
371 sqlite3_stmt *stmt = NULL;
372 const char *dum;
373 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt, &dum);
374
375 if (rc)
376 {
377 maepad_warning("Error updating: %s", sqlite3_errmsg(mainview->db));
378 break;
379 }
380 if (selnode->typ == NODE_TEXT)
381 sqlite3_bind_text(stmt, 1, textdata, datalen, /*strlen(textdata),*/ SQLITE_TRANSIENT);
382 else if (selnode->typ == NODE_SKETCH)
383 sqlite3_bind_blob(stmt, 1, sketchdata, datalen, SQLITE_TRANSIENT);
384
385 rc = SQLITE_BUSY;
386 while(rc == SQLITE_BUSY)
387 {
388 rc = sqlite3_step(stmt);
389 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
390 break;
391 }
392 sqlite3_finalize(stmt);
393
394 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE)
395 {
396 maepad_warning("Error saving node: %s", sqlite3_errmsg(mainview->db));
397 }
398 else
399 {
400 if (selnode->typ == NODE_TEXT)
401 gtk_text_buffer_set_modified(GTK_TEXT_BUFFER(mainview->buffer), FALSE);
402 else if (selnode->typ == NODE_SKETCH)
403 sketchwidget_set_edited(mainview->sk, FALSE);
404 else if (selnode->typ == NODE_CHECKLIST)
405 mainview->checklist_edited = FALSE;
406 goterr = FALSE;
407 }
408 }while(FALSE);
409
410 while(goterr==FALSE && selnode->typ == NODE_CHECKLIST)
411 {
412 GtkTreeModel *model=gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
413
414 char tq[512];
415 g_snprintf(tq, sizeof(tq), "DELETE FROM %s WHERE nodeid=%d", checklisttable_tmpname, selnode->sql3id);
416 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
417
418 GtkTreeIter iter;
419 if (gtk_tree_model_get_iter_first(model, &iter)==FALSE) break;
420
421 do
422 {
423 gint styletoset_weight;
424 gboolean styletoset_strike;
425 gboolean ischecked;
426 gchar *text;
427 gchar *color;
428 unsigned long col=0;
429
430 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, CHECKNODE_BOLD, &styletoset_weight, CHECKNODE_STRIKE, &styletoset_strike, CHECKNODE_CHECKED, &ischecked, CHECKNODE_TEXT, &text, CHECKNODE_COLOR, &color, -1);
431
432 GdkColor tmpcol;
433 if (color!=NULL && strcmp(color, "(null)")!=0 && gdk_color_parse(color, &tmpcol))
434 {
435 col=((tmpcol.red>>8)<<16)|((tmpcol.green>>8)<<8)|(tmpcol.blue>>8);
436 }
437
438 gint style=0;
439 if (ischecked) style|=CHECKSTYLE_CHECKED;
440 if (styletoset_weight==PANGO_WEIGHT_BOLD) style|=CHECKSTYLE_BOLD;
441 if (styletoset_strike) style|=CHECKSTYLE_STRIKE;
442
443 g_snprintf(tq, sizeof(tq), "INSERT INTO %s (nodeid, name, style, color, ord) VALUES(%d, ?, %d, %lu, 0)", checklisttable_tmpname, selnode->sql3id, style, col);
444 sqlite3_stmt *stmt = NULL;
445 const char *dum;
446 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt, &dum);
447
448 if (rc)
449 {
450 goterr=TRUE;
451 maepad_warning("Error while saving checklist: %s", sqlite3_errmsg(mainview->db));
452 break;
453 }
454 sqlite3_bind_text(stmt, 1, text, strlen(text), SQLITE_TRANSIENT);
455
456 rc = SQLITE_BUSY;
457 while(rc == SQLITE_BUSY)
458 {
459 rc = sqlite3_step(stmt);
460 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
461 break;
462 }
463 sqlite3_finalize(stmt);
464
465 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE)
466 {
467 goterr=TRUE;
468 maepad_warning("Error while saving checklist (2): %s", sqlite3_errmsg(mainview->db));
469 }
470
471 g_free(color);
472 g_free(text);
473
474 }while(gtk_tree_model_iter_next(model, &iter)==TRUE);
475
476 break;
477 }
478
479 if (textdata)
480 g_free(textdata);
481 if (sketchdata)
482 g_free(sketchdata);
483 if (goterr == TRUE)
484 {
485 show_banner(mainview, _("Error saving memo"));
486 }
487 busy_leave(mainview);
488 }
489
490 gboolean callback_treeview_button_press(GtkTreeView* treeview, GdkEventButton* event, gpointer user_data)
491 {
492 MainView* mainview = (MainView*)user_data;
493 GtkTreePath* path;
494
495 if (mainview->node_list_longpress_path != NULL) {
496 /* Forget old, remembered tree path for longpress */
497 gtk_tree_path_free(mainview->node_list_longpress_path);
498 mainview->node_list_longpress_path = NULL;
499 }
500
501 if (gtk_tree_view_get_path_at_pos(treeview,
502 event->x, event->y, &path, NULL, NULL, NULL)) {
503 /**
504 * Save this path in case we open the longpress menu to
505 * set the cursor in the treeview to the correct row.
506 *
507 * See on_node_menu_show() on how this is further used.
508 **/
509 mainview->node_list_longpress_path = path;
510 }
511
512 mainview->can_show_node_view = TRUE;
513
514 return FALSE;
515 }
516
517 void callback_treeview_celldatafunc(GtkTreeViewColumn * tree_column, GtkCellRenderer * cell, GtkTreeModel * tree_model, GtkTreeIter * iter, gpointer data)
518 {
519 MainView *mainview = ( MainView * ) data;
520 g_assert(mainview != NULL && mainview->data != NULL );
521
522 nodeData *nd;
523
524 gtk_tree_model_get(tree_model, iter, NODE_DATA, &nd, -1);
525 if (nd == NULL)
526 return;
527
528 if (nd->namepix == NULL)
529 {
530 g_object_set(cell, "visible", FALSE, NULL);
531 }
532 else
533 {
534 g_object_set(cell, "visible", TRUE, NULL);
535 g_object_set(cell, "width", SKETCHNODE_RX, NULL);
536 g_object_set(cell, "height", SKETCHNODE_RY, NULL);
537 }
538 }
539
540 void callback_treeview_change(GtkTreeSelection * selection, gpointer data)
541 {
542 MainView *mainview = (MainView *) data;
543 g_assert(mainview != NULL && mainview->data != NULL);
544
545 nodeData *nd = getSelectedNode(mainview);
546
547 gchar* nodeName = _("View memo");
548
549 if (nd != NULL && nd->name != NULL) {
550 nodeName = nd->name;
551 }
552
553 /* Show node view with selected node */
554 gtk_window_set_title(GTK_WINDOW(mainview->data->node_view),
555 nodeName);
556
557 if (mainview->can_show_node_view) {
558 gtk_widget_show(GTK_WIDGET(mainview->data->node_view));
559 }
560
561 /* Make sure we don't accidentally collapse any nodes */
562 gtk_tree_view_expand_all(GTK_TREE_VIEW(mainview->treeview));
563
564 guint tm=time(NULL);
565 if (mainview->cansel_time>0 && mainview->cansel_time+1.0<tm) mainview->cansel_node=NULL;
566
567 if (nd==NULL)
568 {
569 if (mainview->cansel_node!=NULL)
570 {
571 maepad_debug("[SELLOGIC] saving %d to unselect all nodes", (mainview->cansel_node)->sql3id);
572 saveDataToNode(mainview, (mainview->cansel_node));
573 mainview->cansel_node=NULL;
574 }
575 return;
576 }
577
578 if (mainview->cansel_node!=NULL)
579 {
580 if (nd->sql3id == (mainview->cansel_node)->sql3id)
581 {
582 mainview->cansel_node=NULL;
583 maepad_debug("[SELLOGIC] doubly selected %d, doing nothing", nd->sql3id);
584 prepareUIforNodeChange(mainview, nd->typ);
585 return;
586 }
587 else
588 {
589 maepad_debug("[SELLOGIC] saving %d to load new node", (mainview->cansel_node)->sql3id);
590 saveDataToNode(mainview, (mainview->cansel_node));
591 mainview->cansel_node=NULL;
592 }
593 }
594
595 if (nd == NULL) return;
596
597 busy_enter(mainview);
598
599 gboolean goterr = TRUE;
600 char *textdata = NULL;
601 char *blob = NULL;
602 int blobsize = 0, textsize = 0;
603
604 char tq[512];
605
606 g_snprintf(tq, sizeof(tq), "SELECT bodytype, body, bodyblob, flags FROM %s WHERE nodeid=%d", datatable_tmpname, nd->sql3id);
607 sqlite3_stmt *stmt = NULL;
608 const char *dum;
609 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt, &dum);
610
611 if (rc)
612 {
613 maepad_warning("Error reading (1): %s", sqlite3_errmsg(mainview->db));
614 }
615 else
616 {
617 rc = SQLITE_BUSY;
618 while(rc == SQLITE_BUSY || rc == SQLITE_ROW)
619 {
620 rc = sqlite3_step(stmt);
621 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
622 break;
623 else if (rc == SQLITE_ROW)
624 {
625 nd->typ = sqlite3_column_int(stmt, 0);
626 nd->flags = sqlite3_column_int(stmt, 3);
627
628 prepareUIforNodeChange(mainview, nd->typ);
629 if (nd->typ == NODE_TEXT)
630 {
631 gboolean file_edited_backup = mainview->file_edited;
632
633 blobsize = sqlite3_column_bytes(stmt, 2);
634 blob = (char *)sqlite3_column_blob(stmt, 2);
635
636 textdata = (char *)sqlite3_column_text(stmt, 1);
637 textsize = sqlite3_column_bytes(stmt, 1);
638
639 /* gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mainview->buffer), "", -1);*/
640 wp_text_buffer_reset_buffer(mainview->buffer, TRUE);
641
642 gboolean richtext=FALSE;
643
644 if (blob != NULL)
645 {
646 #if 0
647 gboolean oldway=FALSE;
648 if (blobsize>8)
649 {
650 char tst[8];
651 strncpy(tst, blob, 8);
652 tst[8]=0;
653 if (strcmp(tst, "RICHTEXT")==0) oldway=TRUE;
654 }
655 if (oldway)
656 {
657 GError *err = NULL;
658 GtkTextIter iter;
659 gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER(mainview->buffer), &iter);
660 gtk_text_buffer_deserialize_rich_text(GTK_TEXT_BUFFER(mainview->buffer), &iter, blob, blobsize, TRUE, &err);
661 if (err != NULL)
662 {
663 g_error_free(err);
664 }
665 else
666 {
667 richtext=TRUE;
668 }
669 }
670 #endif
671
672 if (richtext==FALSE)
673 {
674 wp_text_buffer_load_document_begin(mainview->buffer, TRUE);
675 wp_text_buffer_load_document_write(mainview->buffer, blob, blobsize);
676 wp_text_buffer_load_document_end(mainview->buffer);
677 richtext=TRUE;
678 }
679 }
680 if (richtext==FALSE && !(textdata == NULL || g_utf8_validate(textdata, textsize, NULL) == FALSE))
681 {
682 /* gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mainview->buffer), textdata, textsize);*/
683 wp_text_buffer_load_document_begin(mainview->buffer, FALSE);
684 wp_text_buffer_load_document_write(mainview->buffer, textdata, textsize);
685 wp_text_buffer_load_document_end(mainview->buffer);
686 }
687
688 wp_text_buffer_enable_rich_text(mainview->buffer, TRUE);
689 hildon_check_button_set_active(HILDON_CHECK_BUTTON(mainview->menu_button_wordwrap),
690 (nd->flags & NODEFLAG_WORDWRAP)?(TRUE):(FALSE));
691
692 gtk_text_buffer_set_modified(GTK_TEXT_BUFFER(mainview->buffer), FALSE); /*we probably don't need this*/
693
694 callback_undotoggle((gpointer)mainview->buffer, FALSE, mainview); /*we need these*/
695 callback_redotoggle((gpointer)mainview->buffer, FALSE, mainview);
696
697 if (file_edited_backup==FALSE) mainview->file_edited=FALSE; /*textview changed event toggles this?*/
698 goterr = FALSE;
699 }
700 else if (nd->typ == NODE_SKETCH)
701 {
702 sketchwidget_wipe_undo(mainview->sk);
703
704 /* Disable squared and filled mode when opening a sketch */
705 hildon_check_button_set_active(HILDON_CHECK_BUTTON(mainview->menu_button_square), FALSE);
706 hildon_check_button_set_active(HILDON_CHECK_BUTTON(mainview->menu_button_filled), FALSE);
707
708 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->shapemenuitems[1]), TRUE);
709 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->shapemenuitems[0]), TRUE);
710
711 blobsize = sqlite3_column_bytes(stmt, 2);
712 blob = (char *)sqlite3_column_blob(stmt, 2);
713 gboolean clear = TRUE;
714
715 if (blob == NULL)
716 goterr = FALSE;
717 if (blob != NULL)
718 {
719 maepad_debug("blob size: %d", blobsize);
720 GdkPixbufLoader *pl = gdk_pixbuf_loader_new_with_type("png", NULL);
721 GError *err = NULL;
722
723 gdk_pixbuf_loader_write(pl, (guchar *) blob, blobsize, &err);
724 if (err != NULL)
725 {
726 maepad_warning("Error loading sketch: %s", err->message);
727 g_error_free(err);
728 err = NULL;
729 }
730 gdk_pixbuf_loader_close(pl, NULL);
731 GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf(pl);
732
733 if (GDK_IS_PIXBUF(pixbuf))
734 {
735 GtkWidget *skdr = sketchwidget_get_drawingarea(mainview->sk);
736 GtkPixmap *skpix = (GtkPixmap *) sketchwidget_get_Pixmap(mainview->sk);
737
738 int w=gdk_pixbuf_get_width(pixbuf);
739 int h=gdk_pixbuf_get_height(pixbuf);
740 if (w!=skdr->allocation.width || h!=skdr->allocation.height)
741 {
742 if (w>skdr->allocation.width) w=skdr->allocation.width;
743 if (h>skdr->allocation.height) h=skdr->allocation.height;
744 sketchwidget_clear_real(mainview->sk);
745 }
746 gdk_draw_pixbuf(GDK_DRAWABLE(skpix), NULL, pixbuf, 0, 0, 0, 0, w, h, GDK_RGB_DITHER_NONE, 0, 0);
747
748 clear = FALSE;
749 goterr = FALSE;
750
751 if (skpix && G_IS_OBJECT(skpix)) g_object_unref(skpix);
752 }
753 else
754 {
755 maepad_warning("Error loading pixbuf");
756 }
757 g_object_unref(pl);
758 }
759 if (clear == TRUE)
760 {
761 maepad_message("Clearing sketch widget");
762 sketchwidget_clear_real(mainview->sk);
763 }
764 gtk_widget_queue_draw(sketchwidget_get_drawingarea(mainview->sk));
765 }
766 else if (nd->typ == NODE_CHECKLIST)
767 {
768 mainview->checklist_edited = FALSE;
769 GtkTreeModel *model=gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
770 g_object_ref(model);
771 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->listview), NULL);
772 gtk_list_store_clear(GTK_LIST_STORE(model));
773
774 g_snprintf(tq, sizeof(tq), "SELECT name, style, color FROM %s WHERE nodeid=%d ORDER BY ord, idx", checklisttable_tmpname, nd->sql3id);
775 sqlite3_stmt *stmt2 = NULL;
776 const char *dum;
777 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt2, &dum);
778 if (rc)
779 {
780 maepad_warning("Error reading checklist (1) %s", sqlite3_errmsg(mainview->db));
781 }
782 else
783 {
784 goterr=FALSE;
785 rc = SQLITE_BUSY;
786 while(rc == SQLITE_BUSY || rc == SQLITE_ROW)
787 {
788 rc = sqlite3_step(stmt2);
789 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
790 break;
791 else if (rc == SQLITE_ROW)
792 {
793 char *textdata = (char *)sqlite3_column_text(stmt2, 0);
794 int style = sqlite3_column_int(stmt2, 1);
795 unsigned long col = sqlite3_column_int(stmt2, 2);
796
797 GtkTreeIter toplevel;
798 gtk_list_store_append(GTK_LIST_STORE(model), &toplevel);
799 gtk_list_store_set(GTK_LIST_STORE(model), &toplevel, CHECKNODE_TEXT, textdata, CHECKNODE_CHECKED, FALSE, -1);
800 if ((style & CHECKSTYLE_CHECKED)>0) {
801 gtk_list_store_set(GTK_LIST_STORE(model), &toplevel, CHECKNODE_CHECKED, TRUE, -1);
802 gtk_list_store_set(GTK_LIST_STORE(model), &toplevel, CHECKNODE_ICON_NAME, "widgets_tickmark_list", -1);
803 }
804 if ((style & CHECKSTYLE_BOLD)>0) gtk_list_store_set(GTK_LIST_STORE(model), &toplevel, CHECKNODE_BOLD, PANGO_WEIGHT_BOLD, -1);
805 if ((style & CHECKSTYLE_STRIKE)>0) gtk_list_store_set(GTK_LIST_STORE(model), &toplevel, CHECKNODE_STRIKE, TRUE, -1);
806
807 if (col>0)
808 {
809 char tmp[10];
810 g_snprintf(tmp, sizeof(tmp), "#%02lx%02lx%02lx", ((col & 0xFF0000) >> 16), ((col & 0xFF00) >> 8), (col & 0xFF));
811 gtk_list_store_set(GTK_LIST_STORE(model), &toplevel, CHECKNODE_COLOR, tmp, -1);
812 }
813
814 }
815 }
816 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE)
817 {
818 maepad_warning("Error reading checklist (2): %s", sqlite3_errmsg(mainview->db));
819 goterr=TRUE;
820 }
821
822 sqlite3_finalize(stmt2);
823 }
824
825 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->listview), model);
826 g_object_unref(model);
827 }
828
829 if ((nd->flags & NODEFLAG_SKETCHLINES) > 0)
830 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->sketchlinesmenuitems[1]), TRUE);
831 else if ((nd->flags & NODEFLAG_SKETCHGRAPH) > 0)
832 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->sketchlinesmenuitems[2]), TRUE);
833 else
834 {
835 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->sketchlinesmenuitems[0]), TRUE);
836 callback_sketchlines(NULL, mainview->sketchlinesmenuitems[0]); /*FIXME:ugly */
837 }
838 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->tools_pressure), TRUE);
839
840 break;
841 }
842 }
843 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE) {
844 maepad_warning("Error reading (2): %s", sqlite3_errmsg(mainview->db));
845 }
846
847 sqlite3_finalize(stmt);
848 }
849
850 busy_leave(mainview);
851
852 /* Show / hide the sketch-related menu widgets */
853 if (nd->typ == NODE_SKETCH) {
854 gtk_widget_show(mainview->menu_button_square);
855 gtk_widget_show(mainview->menu_button_filled);
856 } else {
857 gtk_widget_hide(mainview->menu_button_square);
858 gtk_widget_hide(mainview->menu_button_filled);
859 }
860
861 /* Show/hide the rich text-related menu widgets */
862 if (nd->typ == NODE_TEXT) {
863 gtk_widget_show(mainview->menu_button_wordwrap);
864 } else {
865 gtk_widget_hide(mainview->menu_button_wordwrap);
866 }
867
868 /* Show/hide the checklist-related menu widgets */
869 if (nd->typ == NODE_CHECKLIST) {
870 gtk_widget_show(mainview->menu_button_remove_checked);
871 } else {
872 gtk_widget_hide(mainview->menu_button_remove_checked);
873 }
874
875 if (goterr == TRUE)
876 {
877 show_banner(mainview, _("Error loading memo"));
878 }
879 }
880
881 gboolean treeview_canselect(GtkTreeSelection * selection, GtkTreeModel * model, GtkTreePath * path, gboolean path_currently_selected, gpointer userdata)
882 {
883 MainView *mainview = (MainView *) userdata;
884 g_assert(mainview != NULL && mainview->data != NULL);
885
886 if (path_currently_selected)
887 {
888 GtkTreeIter iter;
889 gtk_tree_model_get_iter(model, &iter, path);
890
891 gtk_tree_model_get(model, &iter, NODE_DATA, &(mainview->cansel_node), -1);
892 mainview->cansel_time=time(NULL);
893 }
894
895 return (TRUE);
896 }
897
898 gboolean newnodedlg_key_press_cb(GtkWidget * widget, GdkEventKey * event, GtkWidget * dlg)
899 {
900 SketchWidget *s = gtk_object_get_data(GTK_OBJECT(dlg), "sk");
901
902 switch (event->keyval)
903 {
904 case GDK_F7:
905 sketchwidget_redo(s);
906 return TRUE;
907 case GDK_F8:
908 sketchwidget_undo(s);
909 return TRUE;
910 }
911 return FALSE;
912 }
913
914
915 /* This struct will hold all our toggle buttons, so we can
916 * only allow one to be active at a time (i.e. radio buttons) */
917 typedef struct _newNodeToggleButtons newNodeToggleButtons;
918 struct _newNodeToggleButtons
919 {
920 GtkWidget *rbt; /* Text */
921 GtkWidget *rbs; /* Sketch */
922 GtkWidget *rbc; /* Checklist */
923 };
924
925 void show_sketch_widget(GtkWidget *widget, gpointer user_data)
926 {
927 GtkWidget *dialog = (GtkWidget*)user_data;
928
929 /* Show the sketch widget and hide the entry + draw button */
930 gtk_widget_show(gtk_object_get_data(GTK_OBJECT(dialog), "al"));
931 gtk_widget_hide(gtk_object_get_data(GTK_OBJECT(dialog), "draw_button"));
932 gtk_widget_hide(gtk_object_get_user_data(GTK_OBJECT(dialog)));
933 }
934
935 void new_node_dialog(nodeType typ, MainView * mainview)
936 {
937 GtkWidget *dialog, *entry, *but_ok, *vbox, *hbox, *al, *cb;
938 GtkWidget *rb1, *rb2, *rb3;
939 GtkWidget *hb;
940 gchar datetime_str[200];
941 time_t t_now;
942 struct tm *tm_now;
943 gboolean datetime_written = FALSE;
944
945 t_now = time(NULL);
946 tm_now = localtime(&t_now);
947
948 if (tm_now != NULL) {
949 if (strftime(datetime_str, sizeof(datetime_str), "%y-%m-%d %H:%M", tm_now) != 0) {
950 datetime_written = TRUE;
951 }
952 }
953
954 if (datetime_written == FALSE) {
955 /* Was not able to determine a datetime string - use default */
956 maepad_warning("Cannot determine current time");
957 strncpy(datetime_str, _("New memo"), sizeof(datetime_str));
958 datetime_str[sizeof(datetime_str)-1] = '\0';
959 }
960
961 newNodeToggleButtons *nntb = g_malloc(sizeof(newNodeToggleButtons));
962
963 dialog = gtk_dialog_new();
964 gtk_window_set_title(GTK_WINDOW(dialog), _("Add new memo"));
965 gtk_window_set_transient_for(GTK_WINDOW(dialog), mainview_get_dialog_parent(mainview));
966 gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
967
968 g_signal_connect(G_OBJECT(dialog), "key_press_event", G_CALLBACK(newnodedlg_key_press_cb), dialog);
969
970 vbox = gtk_vbox_new(FALSE, 0);
971
972 hbox = gtk_hbox_new(TRUE, 0);
973
974 /* Text note toggle button */
975 rb1 = hildon_gtk_radio_button_new(HILDON_SIZE_FINGER_HEIGHT, NULL);
976 gtk_button_set_label(GTK_BUTTON(rb1), _("Rich text"));
977 gtk_button_set_image(GTK_BUTTON(rb1), gtk_image_new_from_file(PIXMAPDIR "/text.png"));
978 gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(rb1), TRUE, TRUE, 0);
979 nntb->rbt = rb1;
980
981 /* Sketch toggle button */
982 rb2 = hildon_gtk_radio_button_new_from_widget(HILDON_SIZE_FINGER_HEIGHT, GTK_RADIO_BUTTON(rb1));
983 gtk_button_set_label(GTK_BUTTON(rb2), _("Sketch"));
984 gtk_button_set_image(GTK_BUTTON(rb2), gtk_image_new_from_file(PIXMAPDIR "/sketch.png"));
985 gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(rb2), TRUE, TRUE, 0);
986 nntb->rbs = rb2;
987
988 /* Checklist toggle button */
989 rb3 = hildon_gtk_radio_button_new_from_widget(HILDON_SIZE_FINGER_HEIGHT, GTK_RADIO_BUTTON(rb1));
990 gtk_button_set_label(GTK_BUTTON(rb3), _("Checklist"));
991 gtk_button_set_image(GTK_BUTTON(rb3), gtk_image_new_from_file(PIXMAPDIR "/checklist.png"));
992 gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(rb3), TRUE, TRUE, 0);
993 nntb->rbc = rb3;
994
995 /* Set mode to 0 to get correct styling */
996 gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(rb1), FALSE);
997 gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(rb2), FALSE);
998 gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(rb3), FALSE);
999
1000 /* Remember "new note toggle buttons" list */
1001 gtk_object_set_data(GTK_OBJECT(dialog), "nntb", nntb);
1002
1003 if (typ == NODE_TEXT) {
1004 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rb1), TRUE);
1005 } else if (typ == NODE_SKETCH) {
1006 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rb2), TRUE);
1007 } else {
1008 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rb3), TRUE);
1009 }
1010
1011 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1012
1013 but_ok = gtk_dialog_add_button(GTK_DIALOG(dialog), _("Add"), GTK_RESPONSE_OK);
1014 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
1015 g_signal_connect(G_OBJECT(but_ok), "clicked", G_CALLBACK(callback_new_node_real), dialog);
1016
1017 gtk_object_set_data(GTK_OBJECT(dialog), "m", mainview);
1018
1019 hb = gtk_hbox_new(FALSE, 10);
1020 gtk_box_pack_start(GTK_BOX(hb), gtk_label_new(_("Name:")), FALSE, FALSE, 0);
1021 entry = hildon_entry_new(HILDON_SIZE_AUTO);
1022 gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
1023 gtk_object_set_user_data(GTK_OBJECT(dialog), entry);
1024 gtk_entry_set_text(GTK_ENTRY(entry), datetime_str);
1025 gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
1026 gtk_box_pack_start(GTK_BOX(hb), entry, TRUE, TRUE, 0);
1027
1028 /* Sketch widget, hidden by default */
1029 al = gtk_alignment_new(0.5, 0.5, 0, 0);
1030 SketchWidget *s = sketchwidget_new(SKETCHNODE_X, SKETCHNODE_Y, TRUE);
1031 gtk_object_set_data(GTK_OBJECT(dialog), "sk", s);
1032 gtk_object_set_data(GTK_OBJECT(dialog), "al", al);
1033 sketchwidget_set_brushsize(s, 2);
1034 sketchwidget_set_backstyle(s, SKETCHBACK_GRAPH);
1035 gtk_widget_set_size_request(sketchwidget_get_mainwidget(s), SKETCHNODE_X, SKETCHNODE_Y);
1036 gtk_container_add(GTK_CONTAINER(al), sketchwidget_get_mainwidget(s));
1037 gtk_box_pack_start(GTK_BOX(hb), al, FALSE, FALSE, 0);
1038
1039 /*but_sketch = hildon_button_new_with_text(
1040 HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH,
1041 HILDON_BUTTON_ARRANGEMENT_VERTICAL,
1042 _("Use sketch label"), NULL);
1043
1044 gtk_object_set_data(GTK_OBJECT(dialog), "draw_button", but_sketch);
1045 gtk_signal_connect(GTK_OBJECT(but_sketch), "clicked", G_CALLBACK(show_sketch_widget), dialog);
1046 gtk_box_pack_start(GTK_BOX(hb), but_sketch, FALSE, TRUE, 0);*/
1047 gtk_box_pack_start(GTK_BOX(vbox), hb, TRUE, FALSE, 0);
1048
1049 cb = hildon_check_button_new(HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
1050 gtk_button_set_label(GTK_BUTTON(cb), _("Add as child of selected memo"));
1051 hildon_check_button_set_active(HILDON_CHECK_BUTTON(cb), mainview->newnodedialog_createchild);
1052 gtk_box_pack_start(GTK_BOX(vbox), cb, FALSE, FALSE, 0);
1053
1054 gtk_object_set_data(GTK_OBJECT(dialog), "cb", cb);
1055
1056 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), vbox);
1057
1058 gtk_widget_grab_focus(entry);
1059
1060 gtk_widget_show_all(dialog);
1061
1062 /* Hide the sketch widget at first */
1063 gtk_widget_hide(al);
1064 gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
1065 }
1066
1067 void add_new_node(nodeData * node, MainView * mainview, gboolean ischild)
1068 {
1069 GtkTreeIter parentiter, newiter;
1070 GtkTreeModel *model;
1071 void *ptr = NULL;
1072
1073 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
1074
1075 if (gtk_tree_selection_get_selected(selection, &model, &parentiter))
1076 ptr = &parentiter;
1077
1078 GtkTreePath *path = NULL;
1079
1080 unsigned int parentnodeid = 0;
1081
1082 if (ptr != NULL)
1083 {
1084 path = gtk_tree_model_get_path(model, &parentiter);
1085
1086 if (ischild == FALSE)
1087 {
1088 gtk_tree_path_up(path);
1089
1090 if (gtk_tree_path_get_depth(path) == 0)
1091 {
1092 /* Selected node is a root node */
1093 ptr = NULL; /* New node can not have a Parent node */
1094 gtk_tree_path_down(path); /*restore path so expand() works */
1095 }
1096 else if (gtk_tree_path_get_depth(path) > 0)
1097 {
1098 /* Selected node is a child node */
1099 if (gtk_tree_model_get_iter(model, &parentiter, path))
1100 ptr = &parentiter;
1101 }
1102 }
1103 }
1104
1105 if (ptr != NULL)
1106 {
1107 nodeData *nd;
1108
1109 gtk_tree_model_get(model, ptr, NODE_DATA, &nd, -1);
1110 if (nd)
1111 parentnodeid = nd->sql3id;
1112 }
1113
1114 node->sql3id = 0;
1115 do
1116 {
1117 sqlite3_stmt *stmt = NULL;
1118 const char *dum;
1119 char tq[512];
1120
1121 /*
1122 * FIXME: ord
1123 */
1124 g_snprintf(tq, sizeof(tq), "INSERT INTO %s (parent, bodytype, name, nameblob, ord) VALUES (%d, %d, ?, ?, 0);", datatable_tmpname, parentnodeid, node->typ);
1125 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt, &dum);
1126
1127 if (rc)
1128 {
1129 maepad_warning("Error inserting (1): %s", sqlite3_errmsg(mainview->db));
1130 break;
1131 }
1132 if (node->name != NULL)
1133 sqlite3_bind_text(stmt, 1, node->name, strlen(node->name), SQLITE_TRANSIENT);
1134 else
1135 sqlite3_bind_text(stmt, 1, NULL, 0, SQLITE_TRANSIENT);
1136
1137 if (node->namepix != NULL)
1138 {
1139 gchar *namepixdata = NULL;
1140 gsize datalen = 0;
1141
1142 GError *err = NULL;
1143
1144 if (gdk_pixbuf_save_to_buffer(node->namepix, &namepixdata, &datalen, "png", &err, NULL) == FALSE)
1145 {
1146 namepixdata = NULL;
1147 datalen = 0;
1148 maepad_warning("Error saving name: %s", err->message);
1149 g_error_free(err);
1150 }
1151 sqlite3_bind_blob(stmt, 2, namepixdata, datalen, SQLITE_TRANSIENT);
1152 }
1153 else
1154 sqlite3_bind_blob(stmt, 2, NULL, 0, SQLITE_TRANSIENT);
1155
1156 rc = SQLITE_BUSY;
1157 while(rc == SQLITE_BUSY)
1158 {
1159 rc = sqlite3_step(stmt);
1160 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
1161 break;
1162 }
1163 sqlite3_finalize(stmt);
1164 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE)
1165 {
1166 maepad_warning("Error inserting (2): %s", sqlite3_errmsg(mainview->db));
1167 break;
1168 }
1169 node->sql3id = sqlite3_last_insert_rowid(mainview->db);
1170 }
1171 while(FALSE);
1172
1173 if (node->sql3id == 0)
1174 {
1175 if (node->name)
1176 g_free(node->name);
1177 if (node->namepix)
1178 g_object_unref(node->namepix);
1179 g_free(node);
1180 if (path)
1181 gtk_tree_path_free(path);
1182 show_banner(mainview, _("Error creating memo"));
1183 return;
1184 }
1185
1186 gtk_tree_store_append(GTK_TREE_STORE(model), &newiter, ptr);
1187
1188 gtk_tree_store_set(GTK_TREE_STORE(model), &newiter, NODE_NAME, node->name, NODE_PIXBUF, node->namepix, NODE_DATA, node, -1);
1189
1190 if (path)
1191 {
1192 mainview->loading=TRUE; /*only when we have a valid parent*/
1193 gtk_tree_view_expand_row(GTK_TREE_VIEW(mainview->treeview), path, FALSE);
1194 gtk_tree_path_free(path);
1195 }
1196
1197 gtk_tree_selection_select_iter(selection, &newiter);
1198
1199 mainview->loading=FALSE;
1200 }
1201
1202 void callback_new_node_real(GtkAction * action, gpointer data)
1203 {
1204 MainView *mainview;
1205
1206 GtkWidget *dialog = data;
1207 GtkWidget *entry = gtk_object_get_user_data(GTK_OBJECT(dialog));
1208
1209 mainview = gtk_object_get_data(GTK_OBJECT(dialog), "m");
1210 SketchWidget *s = gtk_object_get_data(GTK_OBJECT(dialog), "sk");
1211 GtkWidget *cb = gtk_object_get_data(GTK_OBJECT(dialog), "cb");
1212 newNodeToggleButtons *nntb = gtk_object_get_data(GTK_OBJECT(dialog), "nntb");
1213
1214 nodeType typ = NODE_TEXT;
1215 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(nntb->rbs))) {
1216 typ = NODE_SKETCH;
1217 } else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(nntb->rbc))) {
1218 typ = NODE_CHECKLIST;
1219 }
1220 g_free(nntb);
1221
1222 gchar *txt = NULL;
1223
1224 /*if (GTK_WIDGET_VISIBLE(entry))
1225 {*/
1226 txt = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
1227 if (strcmp(txt, "") == 0)
1228 {
1229 g_free(txt);
1230 return;
1231 }/*
1232 }
1233 else
1234 {
1235 GtkWidget *sdr = sketchwidget_get_drawingarea(s);
1236
1237 GdkPixmap *spix = sketchwidget_get_Pixmap(s);
1238
1239 pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE(spix), NULL, 0, 0, 0, 0, sdr->allocation.width, sdr->allocation.height);
1240 g_object_unref(spix);
1241 double w, h;
1242 GdkPixbuf *pixbuf2 = sketchwidget_trim_image(pixbuf, SKETCHNODE_X, SKETCHNODE_Y, &w,
1243 &h, TRUE);
1244 if (pixbuf2==NULL) return;
1245
1246 GdkPixbuf *pixbuf3 = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, SKETCHNODE_RX,
1247 SKETCHNODE_RY);
1248
1249 gdk_pixbuf_fill(pixbuf3, 0xffffffff);
1250
1251 if (w <= SKETCHNODE_RX && h <= SKETCHNODE_RY)
1252 {
1253 gdk_pixbuf_copy_area(pixbuf2, 0, 0, w, h, pixbuf3, 0, (SKETCHNODE_RY - h) / 2);
1254 }
1255 else
1256 {
1257 double neww, newh;
1258
1259 if (w > h)
1260 {
1261 neww = SKETCHNODE_RX;
1262 newh = (h / w) * SKETCHNODE_RX;
1263 }
1264 else
1265 {
1266 newh = SKETCHNODE_RY;
1267 neww = (w / h) * SKETCHNODE_RY;
1268 }
1269 if (newh > SKETCHNODE_RY)
1270 newh = SKETCHNODE_RY;
1271
1272 GdkPixbuf *tmpbuf = gdk_pixbuf_scale_simple(pixbuf2, neww, newh,
1273 GDK_INTERP_BILINEAR);
1274
1275 gdk_pixbuf_copy_area(tmpbuf, 0, 0, neww, newh, pixbuf3, 0, (SKETCHNODE_RY - newh) / 2);
1276
1277 gdk_pixbuf_unref(tmpbuf);
1278 }
1279
1280 pixbuf = pixbuf3;
1281 gdk_pixbuf_unref(pixbuf2);
1282 }*/
1283
1284 nodeData *node;
1285
1286 node = g_malloc(sizeof(nodeData));
1287 node->typ = typ;
1288 node->name = txt;
1289 node->namepix = NULL;
1290
1291 /*if (GTK_WIDGET_VISIBLE(entry))
1292 {
1293 node->name = txt;
1294 }
1295 else
1296 {
1297 node->namepix = pixbuf;
1298 }*/
1299
1300 node->lastMod = 0;
1301 node->flags = 0;
1302 node->sql3id = 0;
1303
1304 mainview->newnodedialog_createchild = hildon_check_button_get_active(HILDON_CHECK_BUTTON(cb));
1305 add_new_node(node, mainview, mainview->newnodedialog_createchild);
1306
1307 sketchwidget_destroy(s);
1308 gtk_widget_destroy(dialog);
1309 mainview->file_edited = TRUE;
1310 }
1311
1312 /*
1313 * delete node
1314 */
1315 void callback_file_delete_node(GtkAction * action, gpointer data)
1316 {
1317 MainView *mainview = (MainView *) data;
1318 g_assert(mainview != NULL && mainview->data != NULL);
1319
1320 if (getSelectedNode(mainview) == NULL) {
1321 show_banner(mainview, _("Select a memo first"));
1322 return;
1323 }
1324
1325 if (show_confirmation(mainview, _("Delete selected memo?"))) {
1326 mainview->can_show_node_view = FALSE;
1327 callback_delete_node_real(mainview);
1328 gtk_widget_hide(GTK_WIDGET(mainview->data->node_view));
1329 }
1330 }
1331
1332 /*
1333 * Callback for Rename Menuitem
1334 */
1335 void callback_file_rename_node(GtkAction * action, gpointer data)
1336 {
1337 MainView *mainview = (MainView*)data;
1338 g_assert(mainview != NULL && mainview->data != NULL);
1339
1340 /* Get the selected node */
1341 nodeData *sel_node = getSelectedNode(mainview);
1342 if (sel_node == NULL) {
1343 /* Do nothing, if no node has been selected */
1344 show_banner(mainview, _("Select a memo first"));
1345 return;
1346 }
1347
1348 if (sel_node->namepix != NULL) {
1349 /* the memo has a graphical label, cannot edit! */
1350 show_banner(mainview, _("Cannot rename memos with sketch name"));
1351 return;
1352 }
1353
1354 gchar* new_name = show_line_edit_dialog(mainview, _("Rename memo"), _("New name:"), _("Rename"), sel_node->name);
1355
1356 /* Only rename node when user accepted the new name */
1357 if (new_name != NULL) {
1358 callback_rename_node_real(mainview, new_name);
1359 g_free(new_name);
1360 }
1361 }
1362
1363 void callback_rename_node_real(MainView* mainview, gchar* new_name)
1364 {
1365 GtkTreeIter iter;
1366 GtkTreeModel *model;
1367 nodeData *nd = NULL;
1368
1369 /* Get the selected node */
1370 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
1371
1372 if (!gtk_tree_selection_get_selected(selection, &model, &iter)) {
1373 return;
1374 }
1375
1376 gtk_tree_model_get (model, &iter, NODE_DATA, &nd, -1);
1377
1378 if (nd == NULL) {
1379 return;
1380 }
1381
1382 /* Update the database */
1383 sqlite3_stmt *stmt = NULL;
1384
1385 char* sql = sqlite3_mprintf("UPDATE %s SET name='%q' WHERE nodeid=%d", datatable_tmpname, new_name, nd->sql3id);
1386
1387 int rc = sqlite3_prepare(mainview->db, sql, strlen(sql), &stmt, NULL);
1388 if (rc == SQLITE_OK) {
1389 rc = SQLITE_BUSY;
1390 while (rc == SQLITE_BUSY) {
1391 rc = sqlite3_step(stmt);
1392 if (rc == SQLITE_DONE) {
1393 /* Update in the database was successful - now update the rest */
1394
1395 /* Update the noteData */
1396 g_free(nd->name);
1397 nd->name = g_strdup(new_name);
1398
1399 /* Update the window title of node_view */
1400 gtk_window_set_title(GTK_WINDOW(mainview->data->node_view), nd->name);
1401
1402 /* Update the value in the tree store */
1403 gtk_tree_store_set (GTK_TREE_STORE(model), &iter, NODE_NAME, new_name, -1);
1404
1405 break;
1406 } else if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE) {
1407 maepad_warning("Error updating node: %s", sqlite3_errmsg(mainview->db));
1408 break;
1409 }
1410 }
1411 sqlite3_finalize(stmt);
1412 } else {
1413 maepad_warning("Error preparing DB update query: %s", sqlite3_errmsg(mainview->db));
1414 }
1415
1416 sqlite3_free(sql);
1417
1418 mainview->file_edited = TRUE;
1419 }
1420
1421 void callback_file_export_node(GtkAction * action, gpointer data)
1422 {
1423 MainView *mainview = (MainView *) data;
1424 g_assert(mainview != NULL && mainview->data != NULL);
1425
1426 nodeData *nd=getSelectedNode(mainview);
1427 if (nd == NULL)
1428 {
1429 show_banner(mainview, _("Select a memo first"));
1430 return;
1431 }
1432
1433 gchar *nodename=nd->name;
1434 if (nodename==NULL) nodename=_("saved memo");
1435
1436 if (nd->typ == NODE_TEXT)
1437 {
1438 /*
1439 GtkTextIter begin, end;
1440 gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER(mainview->buffer), &begin, &end);
1441 gchar *text = gtk_text_buffer_get_slice(GTK_TEXT_BUFFER(mainview->buffer), &begin, &end, TRUE);
1442 */
1443 GString *gstr=g_string_sized_new(4096);
1444 wp_text_buffer_save_document(mainview->buffer, (WPDocumentSaveCallback)(wp_savecallback), gstr);
1445 gint textlen=gstr->len;
1446 gchar *text=g_string_free(gstr, FALSE);
1447
1448 if (text==NULL || !strcmp(text, ""))
1449 {
1450 show_banner(mainview, _("Memo is empty"));
1451 }
1452 else
1453 {
1454 gchar *fn = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_SAVE, nodename, "html");
1455 if (fn!=NULL)
1456 {
1457 GnomeVFSResult vfs_result;
1458 GnomeVFSHandle *handle = NULL;
1459 GnomeVFSFileSize out_bytes;
1460 vfs_result = gnome_vfs_create(&handle, fn, GNOME_VFS_OPEN_WRITE, 0, 0600);
1461 if ( vfs_result != GNOME_VFS_OK ) {
1462 show_banner(mainview, _("Export failed"));
1463 }
1464 else
1465 {
1466 gnome_vfs_write(handle, text, textlen, &out_bytes);
1467 gnome_vfs_close(handle);
1468 if (out_bytes==strlen(text)) show_banner(mainview, _("Exported"));
1469 else show_banner(mainview, _("Export incomplete"));
1470 }
1471 g_free(fn);
1472 }
1473 }
1474 g_free(text);
1475 }
1476 else if (nd->typ == NODE_SKETCH)
1477 {
1478 GdkPixmap *skpix = sketchwidget_get_Pixmap(mainview->sk);
1479 GtkWidget *skdr = sketchwidget_get_drawingarea(mainview->sk);
1480 GdkPixbuf *pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE(skpix), NULL, 0, 0, 0, 0, skdr->allocation.width, skdr->allocation.height);
1481 if (pixbuf==NULL)
1482 {
1483 show_banner(mainview, _("Memo is empty"));
1484 }
1485 else
1486 {
1487 gchar *fn = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_SAVE, nodename, "png");
1488 if (fn!=NULL)
1489 {
1490 if (gdk_pixbuf_save(pixbuf, fn, "png", NULL, NULL)==FALSE)
1491 {
1492 show_banner(mainview, _("Export failed"));
1493 }
1494 else
1495 {
1496 show_banner(mainview, _("Exported"));
1497 }
1498 g_free(fn);
1499 }
1500 }
1501 g_object_unref(skpix);
1502 }
1503 else if (nd->typ == NODE_CHECKLIST)
1504 {
1505 show_banner(mainview, _("Export of checklists not possible yet"));
1506 }
1507 }
1508
1509 /*
1510 * callback from menu item
1511 * move selected node down (switch node with next sibling), don't change level of node
1512 */
1513 void callback_move_down_node(GtkAction * action, gpointer data)
1514 {
1515 GtkTreeIter iter;
1516 GtkTreeModel *model;
1517
1518 MainView *mainview = (MainView *) data;
1519 g_assert(mainview != NULL && mainview->data != NULL);
1520
1521 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
1522 gtk_tree_selection_get_selected(selection, &model, &iter);
1523
1524 GtkTreeIter old_iter = iter;/*save pointer to old iter, we will need it during swap nodes*/
1525
1526 if (gtk_tree_model_iter_next(model,&iter)==FALSE)/*get next node*/
1527 return;
1528
1529 GtkTreeStore *treeStore = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview)));
1530 gtk_tree_store_swap(treeStore,&iter,&old_iter);
1531
1532 mainview->file_edited = TRUE;/*we have made changes , if required show "save changes?" dialog in future*/
1533 }
1534
1535 /*
1536 * callback from menu item
1537 * move selected node down (switch node with prev sibling), don't change level of node
1538 */
1539 void callback_move_up_node(GtkAction * action, gpointer data)
1540 {
1541 GtkTreeIter iter;
1542 GtkTreeModel *model;
1543
1544 MainView *mainview = (MainView *) data;
1545 g_assert(mainview != NULL && mainview->data != NULL);
1546
1547 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
1548 gtk_tree_selection_get_selected(selection, &model, &iter);
1549
1550 GtkTreeIter old_iter=iter;/*save pointer to old iter, we will need it during swap nodes*/
1551
1552 if (tree_model_iter_prev(model,&iter)==FALSE)/*get previous node*/
1553 return;
1554
1555 GtkTreeStore *treeStore = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview)));
1556 gtk_tree_store_swap(treeStore,&old_iter,&iter);/*do move*/
1557
1558 mainview->file_edited = TRUE;/*we have made changes , if required show "save changes?" dialog in future*/
1559 }
1560
1561 /*
1562 * callback from menu item
1563 * we change level of actual node with direction to top
1564 */
1565 void callback_move_to_top_level_node(GtkAction * action, gpointer data)
1566 {
1567 GtkTreeIter iter,new_parent;
1568 GtkTreeIter *p_new_parent;
1569 GtkTreeIter parent;
1570 GtkTreeModel *model;
1571
1572 MainView *mainview = (MainView *) data;
1573 g_assert(mainview != NULL && mainview->data != NULL);
1574
1575 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
1576 gtk_tree_selection_get_selected(selection, &model, &iter);
1577
1578 /*at first we need actual parent of selected node*/
1579 if (gtk_tree_model_iter_parent(model,&parent,&iter)==FALSE)
1580 {
1581 /*if parent of selected node is ROOT we can't go higher*/
1582 return;
1583 }
1584 /*we need also new parent, it's parent of actual parent*/
1585 if (gtk_tree_model_iter_parent(model,&new_parent,&parent)==FALSE)
1586 {
1587 /*if our new parent is ROOT we got filled new_parent with invalid value,
1588 so we need set NULL value to p_new_parent (root item)*/
1589 p_new_parent=NULL;
1590 }
1591 else
1592 {
1593 p_new_parent=&new_parent;/*we only redirect pointer to treeiter*/
1594 }
1595
1596 saveCurrentData(mainview);/*we save changes in node befor move*/
1597
1598 /*this move function provide move item with all his children, be careful iter value will change!*/
1599 if (move_node(mainview,p_new_parent,&iter,&parent)==TRUE){
1600
1601 gint id_parent = get_node_id_on_tmp_db(model,p_new_parent);
1602 gint id_node = get_node_id_on_tmp_db(model,&iter);
1603 /*we need also update parent id of moved item*/
1604 char tq[512];
1605 g_snprintf (tq, sizeof(tq), "UPDATE %s SET parent=%d WHERE nodeid=%d",datatable_tmpname,id_parent ,id_node);
1606 exec_command_on_db(mainview,tq);
1607
1608 /*select new created iter*/
1609 gtk_tree_selection_select_iter(selection,&iter);
1610
1611 mainview->file_edited = TRUE;/*we have made changes , if required show "save changes?" dialog in future*/
1612 }
1613 }
1614
1615 /*
1616 * callback from menu item
1617 * we change level of actual node with direction to bottom
1618 * previous node will be parent of our actual node
1619 */
1620 void callback_move_to_bottom_level_node(GtkAction * action, gpointer data)
1621 {
1622 GtkTreeIter iter;
1623 GtkTreeModel *model;
1624
1625 MainView *mainview = (MainView *) data;
1626 g_assert(mainview != NULL && mainview->data != NULL);
1627
1628 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
1629 gtk_tree_selection_get_selected(selection, &model, &iter);
1630
1631 GtkTreeIter move_iter=iter;/*save pointer to old iter*/
1632
1633 /*we try to get previous node*/
1634 if (tree_model_iter_prev(model,&iter)==FALSE)
1635 return;/*if previous node on the same level doesn't exist we will exit*/
1636
1637 saveCurrentData(mainview);/*we save changes in node befor move*/
1638
1639 /*this move function provide move item with all his children, be careful move_iter value will change!*/
1640 if (move_node(mainview,&iter,&move_iter,NULL)==TRUE)
1641 {
1642 gint id_parent = get_node_id_on_tmp_db(model,&iter);
1643 gint id_node = get_node_id_on_tmp_db(model,&move_iter);
1644
1645 /*we need also update parent id of moved item*/
1646 char tq[512];
1647 g_snprintf (tq, sizeof(tq), "UPDATE %s SET parent=%d WHERE nodeid=%d",datatable_tmpname,id_parent ,id_node);
1648 exec_command_on_db(mainview,tq);
1649
1650 GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
1651 gtk_tree_view_expand_row(GTK_TREE_VIEW(mainview->treeview), path, FALSE);/*expand parent node*/
1652 gtk_tree_path_free(path);
1653
1654 /*select new created iter*/
1655 gtk_tree_selection_select_iter(selection,&move_iter);
1656
1657 mainview->file_edited = TRUE;/*we have made changes , if required show "save changes?" dialog in future*/
1658 }
1659 }
1660
1661 /*
1662 * move item_to_move to new_parent with his children, this function is designed for change level of node
1663 * we copy item_to_move with his children to new position (after item_befor if is not NULL) and then we
1664 * destroy old node with his children, so ! item_to_move is set with new iter, be careful on this!
1665 */
1666 gboolean move_node(MainView *mainview,GtkTreeIter *new_parent,GtkTreeIter *item_to_move,GtkTreeIter *item_befor)
1667 {
1668 GtkTreeModel *model;
1669
1670 model=gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview));
1671 GtkTreeStore *treeStore = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview)));
1672
1673 nodeData *node;
1674 gtk_tree_model_get(model, item_to_move, NODE_DATA, &node, -1);/*get data from actual iter*/
1675 if (node)
1676 {
1677 GtkTreeIter new_iter;/*create new iter*/
1678 gtk_tree_store_append(treeStore,&new_iter,new_parent);/*append new iter to new parent*/
1679
1680 if (item_befor!=NULL)
1681 gtk_tree_store_move_after(treeStore,&new_iter,item_befor);/*sometimes we need set position*/
1682
1683 gtk_tree_store_set(treeStore, &new_iter, NODE_NAME, node->name,NODE_PIXBUF, node->namepix, NODE_DATA, node, -1);/*set data from old iter*/
1684
1685 GtkTreeIter child;
1686 while (gtk_tree_model_iter_children(model, &child, item_to_move)==TRUE)/*move all childrens while some exits*/
1687 {
1688 if (move_node(mainview,&new_iter,&child,NULL)==FALSE)/*use recursion on children*/
1689 return FALSE;
1690 }
1691
1692 gtk_tree_store_set(treeStore, item_to_move, NODE_DATA, NULL, -1);
1693 gtk_tree_store_remove(treeStore, item_to_move);/*remove node, data need't remove, they are stored in new node*/
1694
1695 /*we need return new value of moved item, so we need assign new_iter to item_to_move*/
1696 /*this code is ugly : new_iter to path and back to item_to_move*/
1697 GtkTreePath *path=gtk_tree_model_get_path(model,&new_iter);
1698 gtk_tree_model_get_iter(model,item_to_move,path);
1699 gtk_tree_path_free(path);
1700 }
1701 else
1702 {
1703 fprintf(stderr,"Get data node failed!\n");
1704 return FALSE;
1705 }
1706
1707 return TRUE;
1708 }
1709
1710 /*
1711 * simple execute of sql command which is stored in sql_string[]
1712 */
1713 gboolean exec_command_on_db(MainView *mainview,char sql_string[])
1714 {
1715 sqlite3_stmt *stmt = NULL;
1716 const char* dum;
1717 gboolean db_query_result = FALSE;
1718
1719 int rc = sqlite3_prepare (mainview->db, sql_string, strlen(sql_string), &stmt, &dum);
1720
1721 if (rc) {
1722 maepad_warning("Error preparing DB update query: %s", sqlite3_errmsg(mainview->db));
1723 return FALSE;
1724 }
1725
1726 rc = SQLITE_BUSY;
1727 while (rc == SQLITE_BUSY) {
1728 rc = sqlite3_step (stmt);
1729 if (rc == SQLITE_DONE) {
1730 db_query_result = TRUE;
1731 break;
1732 }
1733 else if(rc == SQLITE_ERROR || rc== SQLITE_MISUSE) {
1734 maepad_warning("Error updating node: %s", sqlite3_errmsg(mainview->db));
1735 break;
1736 }
1737 sqlite3_finalize(stmt);
1738 }
1739 return TRUE;
1740 }
1741
1742 /*
1743 * it is used in gtk_tree_model_foreach function to update ord value for all nodes (it's usefull for move up, move down node)
1744 */
1745 gboolean foreach_func_update_ord (GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter, MainView *mainview)
1746 {
1747 nodeData *node;
1748 gtk_tree_model_get(model, iter, NODE_DATA, &node, -1);
1749 /*we need index of node on actual level*/
1750 gint index=get_branch_node_index(path);
1751
1752 /*prepare to execute update command,and exec it*/
1753 char sql_command[512];
1754 g_snprintf (sql_command, sizeof(sql_command), "UPDATE %s SET ord=\"%d\" WHERE nodeid=%d",datatable_tmpname, index, node->sql3id);
1755 exec_command_on_db(mainview,sql_command);
1756
1757 /*we don't want break gtk_tree_model_foreach function,until we call this func on each node - so we return always FALSE*/
1758 return FALSE;
1759 }
1760
1761 /*
1762 * return id number of iter (id number which is used to identify in sql database of nodes)
1763 */
1764 int get_node_id_on_tmp_db(GtkTreeModel *model,GtkTreeIter *iter)
1765 {
1766 if (iter==NULL)
1767 return 0;/*we got ROOT parent here*/
1768
1769 nodeData *node;
1770 gtk_tree_model_get(model, iter, NODE_DATA, &node, -1);
1771 return node->sql3id;
1772 }
1773
1774 /*
1775 * get index of node in current branch
1776 */
1777 gint get_branch_node_index(GtkTreePath *path)
1778 {
1779 int depth=gtk_tree_path_get_depth(path);
1780 gint *indicies = gtk_tree_path_get_indices(path);
1781
1782 return indicies[depth-1];
1783 }
1784
1785 /*
1786 * similiar with gtk_tree_model_iter_next (), but opposite
1787 */
1788 gboolean tree_model_iter_prev(GtkTreeModel *tree_model,GtkTreeIter *iter)
1789 {
1790 GtkTreePath *path = gtk_tree_model_get_path(tree_model, iter);
1791
1792 if (path==NULL){
1793 fprintf(stderr,"Error: path is null\n");
1794 return FALSE;
1795 }
1796
1797 if (gtk_tree_path_prev(path)==FALSE)
1798 return FALSE;
1799
1800 gtk_tree_model_get_iter(tree_model, iter,path);
1801
1802 return TRUE;
1803 }
1804
1805 gboolean ref2iter(GtkTreeModel * model, GtkTreeRowReference * ref, GtkTreeIter * iter)
1806 {
1807 gboolean res = FALSE;
1808 GtkTreePath *path = gtk_tree_row_reference_get_path(ref);
1809
1810 if (gtk_tree_model_get_iter(model, iter, path))
1811 {
1812 res = TRUE;
1813 }
1814 gtk_tree_path_free(path);
1815 return (res);
1816 }
1817
1818 GtkTreeRowReference *iter2ref(GtkTreeModel * model, GtkTreeIter * iter)
1819 {
1820 GtkTreeRowReference *ref;
1821
1822 GtkTreePath *path = gtk_tree_model_get_path(model, iter);
1823
1824 ref = gtk_tree_row_reference_new(model, path);
1825 gtk_tree_path_free(path);
1826 return (ref);
1827 }
1828
1829 void move_nodes_up(GtkTreeModel * model, GtkTreeRowReference * topnode, GtkTreeRowReference * newtop)
1830 {
1831 GtkTreeIter topiter;
1832
1833 if (ref2iter(model, topnode, &topiter) == FALSE)
1834 return;
1835
1836 GtkTreeIter child;
1837
1838 if (gtk_tree_model_iter_children(model, &child, &topiter))
1839 {
1840 GtkTreeRowReference *ref;
1841 GList *rr_list = NULL, *node;
1842
1843 do
1844 {
1845 ref = iter2ref(model, &child);
1846 rr_list = g_list_append(rr_list, ref);
1847 }
1848 while(gtk_tree_model_iter_next(model, &child));
1849
1850 /*
1851 * got a reflist for all children
1852 */
1853
1854 for(node = rr_list; node; node = node->next)
1855 {
1856 ref = (GtkTreeRowReference *) (node->data);
1857 if (ref2iter(model, ref, &child))
1858 {
1859 GtkTreeIter newtopiter, newiter;
1860 GtkTreeIter *newtopiterptr;
1861
1862 if (ref2iter(model, newtop, &newtopiter))
1863 newtopiterptr = &newtopiter;
1864 else
1865 newtopiterptr = NULL;
1866
1867 nodeData *node;
1868
1869 gtk_tree_model_get(model, &child, NODE_DATA, &node, -1);
1870
1871 gtk_tree_store_append(GTK_TREE_STORE(model), &newiter, newtopiterptr);
1872 gtk_tree_store_set(GTK_TREE_STORE(model), &newiter, NODE_NAME, node->name, NODE_PIXBUF, node->namepix, NODE_DATA, node, -1);
1873
1874 GtkTreeRowReference *newref = iter2ref(model, &newiter);
1875
1876 move_nodes_up(model, ref, newref);
1877 gtk_tree_row_reference_free(newref);
1878
1879 gtk_tree_store_remove(GTK_TREE_STORE(model), &child);
1880 }
1881 gtk_tree_row_reference_free(ref);
1882 }
1883
1884 g_list_free(rr_list);
1885 }
1886
1887 }
1888
1889 void callback_delete_node_real(MainView* mainview)
1890 {
1891 GtkTreeIter iter;
1892 GtkTreeModel *model;
1893
1894 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
1895
1896 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
1897 return;
1898
1899 nodeData *nd;
1900
1901 gtk_tree_model_get(model, &iter, NODE_DATA, &nd, -1);
1902 if (!nd)
1903 return;
1904
1905 mainview->file_edited = TRUE;
1906
1907 unsigned int sql3id = nd->sql3id;
1908
1909 if (nd->name)
1910 g_free(nd->name);
1911
1912 /*
1913 * g_free(nd->data);
1914 * if (nd->pix) g_object_unref(nd->pix);
1915 */
1916 g_free(nd);
1917
1918 GtkTreeRowReference *upref = NULL, *ref = NULL;
1919
1920 GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
1921
1922 ref = gtk_tree_row_reference_new(model, path);
1923 if (gtk_tree_path_up(path))
1924 upref = gtk_tree_row_reference_new(model, path);
1925 gtk_tree_path_free(path);
1926
1927 g_object_ref(model);
1928 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), NULL);
1929
1930 move_nodes_up(model, ref, upref);
1931
1932 if (ref2iter(model, ref, &iter))
1933 {
1934 char tq[512];
1935
1936 g_snprintf(tq, sizeof(tq), "SELECT parent FROM %s WHERE nodeid=%d", datatable_tmpname, sql3id);
1937 sqlite3_stmt *stmt = NULL;
1938 const char *dum;
1939 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt, &dum);
1940 unsigned int sql3parentid = 0;
1941
1942 if (rc)
1943 {
1944 maepad_warning("Error finding children for delete: %s", sqlite3_errmsg(mainview->db));
1945 }
1946 else
1947 {
1948 rc = SQLITE_BUSY;
1949 while(rc == SQLITE_BUSY || rc == SQLITE_ROW)
1950 {
1951 rc = sqlite3_step(stmt);
1952 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
1953 break;
1954 else if (rc == SQLITE_ROW)
1955 {
1956 sql3parentid = sqlite3_column_int(stmt, 0);
1957 break;
1958 }
1959 }
1960 sqlite3_finalize(stmt);
1961
1962 g_snprintf(tq, sizeof(tq), "UPDATE %s SET parent=%d WHERE parent=%d;", datatable_tmpname, sql3parentid, sql3id);
1963 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0) {
1964 maepad_warning("Error moving nodes up one level");
1965 } else
1966 {
1967 g_snprintf(tq, sizeof(tq), "DELETE FROM %s WHERE nodeid=%d;", datatable_tmpname, sql3id);
1968 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0) {
1969 maepad_warning("Error deleting node");
1970 }
1971
1972 /* Delete all checklist items that do not have
1973 * a node anymore (= orphaned checklist items) */
1974 g_snprintf(tq, sizeof(tq), "DELETE FROM %s WHERE nodeid NOT IN (SELECT nodeid FROM %s);", checklisttable_tmpname, datatable_tmpname);
1975 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0) {
1976 maepad_warning("Error deleting orphaned checklist items");
1977 }
1978 }
1979 }
1980 gtk_tree_store_remove(GTK_TREE_STORE(model), &iter);
1981 }
1982
1983 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), model);
1984 g_object_unref(model);
1985
1986 gtk_tree_row_reference_free(ref);
1987 gtk_tree_row_reference_free(upref);
1988
1989 gtk_tree_view_expand_all(GTK_TREE_VIEW(mainview->treeview));
1990
1991 }
1992
1993 void callback_edit_clear(GtkAction * action, gpointer data)
1994 {
1995 MainView *mainview = (MainView *) data;
1996 g_assert(mainview != NULL && mainview->data != NULL);
1997 nodeData *nd = getSelectedNode(mainview);
1998
1999 if (show_confirmation(mainview, _("Remove all contents of this memo?"))) {
2000 switch (nd->typ) {
2001 case NODE_TEXT:
2002 gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mainview->buffer), "", 0);
2003 break;
2004 case NODE_SKETCH:
2005 sketchwidget_clear(mainview->sk);
2006 break;
2007 case NODE_CHECKLIST:
2008 gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview))));
2009 break;
2010 default:
2011 g_assert_not_reached();
2012 }
2013 }
2014 }
2015
2016 /*
2017 * cut
2018 */
2019 void callback_edit_cut(GtkAction * action, gpointer data)
2020 {
2021 MainView *mainview = (MainView *) data;
2022 g_assert(mainview != NULL && mainview->data != NULL);
2023
2024 nodeData *nd = getSelectedNode(mainview);
2025
2026 if (nd->typ == NODE_TEXT)
2027 gtk_text_buffer_cut_clipboard(GTK_TEXT_BUFFER(mainview->buffer), mainview->clipboard, TRUE);
2028 else if (nd->typ == NODE_SKETCH)
2029 {
2030 if (sketchwidget_cut(mainview->sk, mainview->clipboard)==FALSE)
2031 show_banner(mainview, _("Error cutting"));
2032 }
2033 else if (nd->typ == NODE_CHECKLIST)
2034 show_banner(mainview, _("Unimplemented"));
2035
2036 }
2037
2038 /*
2039 * copy
2040 */
2041 void callback_edit_copy(GtkAction * action, gpointer data)
2042 {
2043 MainView *mainview = (MainView *) data;
2044 g_assert(mainview != NULL && mainview->data != NULL);
2045
2046 nodeData *nd = getSelectedNode(mainview);
2047
2048 if (nd->typ == NODE_TEXT)
2049 gtk_text_buffer_copy_clipboard(GTK_TEXT_BUFFER(mainview->buffer), mainview->clipboard);
2050 else if (nd->typ == NODE_SKETCH)
2051 {
2052 if (sketchwidget_copy(mainview->sk, mainview->clipboard)==FALSE)
2053 show_banner(mainview, _("Error copying"));
2054 }
2055 else if (nd->typ == NODE_CHECKLIST)
2056 {
2057 /* Copy all selected entries as multiline text (1 line per entry) */
2058 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
2059 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->listview));
2060
2061 gint selected_rows = gtk_tree_selection_count_selected_rows(selection);
2062 GList* l = gtk_tree_selection_get_selected_rows(selection, NULL);
2063
2064 GtkTreeIter iter;
2065 gchar *str_data;
2066
2067 gchar **entries = g_malloc0(sizeof(gchar*)*selected_rows+1);
2068 gint entries_idx = 0;
2069
2070 GList* cur = l;
2071 while(cur) {
2072 GtkTreePath *path = cur->data;
2073
2074 if (gtk_tree_model_get_iter(model, &iter, path)) {
2075 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, CHECKNODE_TEXT, &(entries[entries_idx++]), -1);
2076 }
2077 gtk_tree_path_free(path);
2078
2079 cur = cur->next;
2080 }
2081
2082 g_list_free(l);
2083 str_data = g_strjoinv("\n", entries);
2084 g_strfreev(entries);
2085 gtk_clipboard_set_text(mainview->clipboard, str_data, -1);
2086 g_free(str_data);
2087
2088 str_data = g_strdup_printf(_("Copied %d entries"), selected_rows);
2089 show_banner(mainview, str_data);
2090 g_free(str_data);
2091
2092 }
2093 }
2094
2095 /*
2096 * paste
2097 */
2098 void callback_edit_paste(GtkAction * action, gpointer data)
2099 {
2100 MainView *mainview = (MainView *) data;
2101 g_assert(mainview != NULL && mainview->data != NULL);
2102
2103 nodeData *nd = getSelectedNode(mainview);
2104
2105 if (nd->typ == NODE_TEXT)
2106 gtk_text_buffer_paste_clipboard(GTK_TEXT_BUFFER(mainview->buffer), mainview->clipboard, NULL, TRUE);
2107 else if (nd->typ == NODE_SKETCH)
2108 {
2109 if (sketchwidget_paste(mainview->sk, mainview->clipboard)==FALSE)
2110 show_banner(mainview, _("Error pasting"));
2111 }
2112 else if (nd->typ == NODE_CHECKLIST) {
2113 /* Paste string from clipboard as new item */
2114 callback_checklist_paste(mainview);
2115 checklist_select(mainview, TREEVIEW_SELECT_LAST);
2116 }
2117
2118 mainview->file_edited = TRUE;
2119 }
2120
2121 gint cb_popup(GtkWidget * widget, GdkEvent * event)
2122 {
2123 GtkMenu *menu;
2124 GdkEventButton *event_button;
2125
2126 /*
2127 * The "widget" is the menu that was supplied when
2128 * * g_signal_connect_swapped() was called.
2129 */
2130 menu = GTK_MENU(widget);
2131 event_button = (GdkEventButton *) event;
2132 if (event->type == GDK_BUTTON_PRESS && event_button->button == 3)
2133 {
2134 gtk_menu_popup(menu, NULL, NULL, NULL, NULL, event_button->button, event_button->time);
2135 return TRUE;
2136 }
2137 return FALSE;
2138 }
2139
2140
2141 /**
2142 * on_node_menu_show(GtkWidget*, gpointer)
2143 *
2144 * This is called when the longpress menu is shown in the main
2145 * window. In the Hildon UI mode that we are using, this does
2146 * not automatically select the touched node, so we need to set
2147 * the cursor here so that the functions in the menu operate on
2148 * the node that the user touched (i.e. the expected one).
2149 *
2150 * The value of mainview->node_list_longpress_path has been set
2151 * by callback_treeview_button_press on the buttn press event.
2152 **/
2153 void
2154 on_node_menu_show(GtkWidget* nodemenu, gpointer user_data)
2155 {
2156 MainView* mainview = (MainView*)user_data;
2157
2158 if (mainview->node_list_longpress_path != NULL) {
2159 /* Set the cursor, but don't open the node view */
2160 mainview->can_show_node_view = FALSE;
2161 gtk_tree_view_set_cursor(GTK_TREE_VIEW(mainview->treeview),
2162 mainview->node_list_longpress_path, NULL, FALSE);
2163
2164 /* Dispose the path (we don't need it anymore) */
2165 gtk_tree_path_free(mainview->node_list_longpress_path);
2166 mainview->node_list_longpress_path = NULL;
2167 }
2168 }
2169
2170 /*
2171 * close
2172 */
2173 gboolean closefile(MainView * mainview)
2174 {
2175 saveCurrentData(mainview);
2176
2177 if (mainview->file_edited)
2178 {
2179 HildonNote *hn = HILDON_NOTE(hildon_note_new_confirmation_add_buttons(GTK_WINDOW(mainview->data->main_view), _("Save changes?"), _("Yes"), CONFRESP_YES, _("No"), CONFRESP_NO, _("Cancel"), CONFRESP_CANCEL, NULL, NULL));
2180 gint answer = gtk_dialog_run(GTK_DIALOG(hn));
2181 gtk_widget_destroy(GTK_WIDGET(hn));
2182
2183 if (answer == CONFRESP_CANCEL)
2184 return (FALSE);
2185 else if (answer == CONFRESP_YES)
2186 {
2187 if (mainview->file_name == NULL)
2188 {
2189 mainview->file_name = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_SAVE, "maemopaddata", "db");
2190 }
2191 write_buffer_to_file(mainview);
2192 }
2193 }
2194
2195 if (mainview->db)
2196 sqlite3_close(mainview->db);
2197 mainview->db = NULL;
2198 return (TRUE);
2199 }
2200
2201 gboolean callback_file_close(GtkAction * action, gpointer data)
2202 {
2203
2204 MainView *mainview = (MainView *) data;
2205 g_assert(mainview != NULL && mainview->data != NULL);
2206 if (closefile(mainview) == FALSE)
2207 return(FALSE);
2208
2209 gtk_main_quit();
2210 return(TRUE);
2211 }
2212
2213 void callback_file_new_node(GtkAction * action, gpointer data)
2214 {
2215 MainView *mainview = (MainView *) data;
2216 g_assert(mainview != NULL && mainview->data != NULL);
2217
2218 nodeType typ = NODE_SKETCH;
2219
2220 nodeData *nd = getSelectedNode(mainview);
2221
2222 if (nd != NULL)
2223 typ = nd->typ;
2224
2225 new_node_dialog(typ, mainview);
2226 }
2227
2228 /*
2229 * new
2230 */
2231 void callback_file_new(GtkAction * action, gpointer data)
2232 {
2233 MainView *mainview = (MainView *) data;
2234 g_assert(mainview != NULL && mainview->data != NULL);
2235
2236 gchar *filename = NULL;
2237
2238 filename = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_SAVE, "memos", "db");
2239 if (filename == NULL) {
2240 return;
2241 }
2242
2243 if (closefile(mainview) == FALSE) {
2244 return;
2245 }
2246
2247 new_file(mainview);
2248
2249 do
2250 {
2251 busy_enter(mainview);
2252
2253 int rc;
2254
2255 rc = sqlite3_open(filename, &mainview->db);
2256 if (rc)
2257 {
2258 show_banner(mainview, _("Cannot create database"));
2259 maepad_warning("Can't create database %s: %s", filename, sqlite3_errmsg(mainview->db));
2260 break;
2261 }
2262
2263 sqlite3_exec(mainview->db, "PRAGMA synchronous = OFF;", NULL, NULL, NULL);
2264
2265 char tq[512];
2266
2267 g_snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", misctable_name, misctable);
2268 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2269
2270 g_snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", datatable_name, datatable);
2271 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
2272 {
2273 maepad_warning("Cannot create data table");
2274 show_banner(mainview, _("Error creating data table"));
2275 break;
2276 }
2277
2278 g_snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", checklisttable_name, checklisttable);
2279 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
2280 {
2281 maepad_warning("Cannot create checklist table");
2282 show_banner(mainview, _("Error creating checklist table"));
2283 break;
2284 }
2285
2286 if (mainview->db)
2287 sqlite3_close(mainview->db);
2288 mainview->db = NULL;
2289
2290 mainview->file_name = filename;
2291 mainview->file_edited = FALSE;
2292 read_file_to_buffer(mainview);
2293
2294 /*add a starter memo*/
2295 nodeData *node;
2296 node = g_malloc(sizeof(nodeData));
2297 node->typ = NODE_SKETCH;
2298 node->name = _("My first memo");
2299 node->namepix = NULL;
2300 node->lastMod = 0;
2301 node->flags = 0;
2302 node->sql3id = 0;
2303 add_new_node(node, mainview, TRUE);
2304 /*gtk_paned_set_position(GTK_PANED(mainview->hpaned), 180);*/
2305 write_buffer_to_file(mainview);
2306
2307 }while(FALSE);
2308 busy_reset(mainview);
2309 }
2310
2311 gboolean reset_ctree(GtkTreeModel * model, GtkTreePath * path, GtkTreeIter * iter, gpointer data)
2312 {
2313 nodeData *node;
2314
2315 gtk_tree_model_get(model, iter, NODE_DATA, &node, -1);
2316 if (node)
2317 {
2318 if (node->name)
2319 g_free(node->name);
2320 if (node->namepix)
2321 g_object_unref(node->namepix);
2322 g_free(node);
2323
2324 gtk_tree_store_set(GTK_TREE_STORE(model), iter, NODE_DATA, NULL, -1);
2325 }
2326 return (FALSE);
2327 }
2328
2329 void new_file(MainView * mainview)
2330 {
2331 busy_enter(mainview);
2332 /*
2333 * clear buffer, filename and free buffer text
2334 */
2335 gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mainview->buffer), "", -1);
2336 mainview->file_name = NULL;
2337 mainview->file_edited = FALSE;
2338 mainview->newnodedialog_createchild = TRUE;
2339
2340 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview));
2341
2342 g_object_ref(model);
2343 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), NULL);
2344
2345 gtk_tree_model_foreach(model, (GtkTreeModelForeachFunc) reset_ctree, (gpointer) mainview);
2346
2347 /*
2348 * crashing bastard
2349 * gtk_tree_store_clear(GTK_TREE_STORE(model));
2350 */
2351 GtkTreePath *path = gtk_tree_path_new_from_indices(0, -1);
2352 GtkTreeIter iter;
2353
2354 if (gtk_tree_model_get_iter(model, &iter, path))
2355 {
2356 do
2357 {
2358 gtk_tree_store_remove(GTK_TREE_STORE(model), &iter);
2359 }
2360 while(gtk_tree_store_iter_is_valid(GTK_TREE_STORE(model), &iter));
2361 }
2362 gtk_tree_path_free(path);
2363
2364 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), model);
2365 g_object_unref(model);
2366
2367 busy_leave(mainview);
2368 }
2369
2370 /*
2371 * open
2372 */
2373 void callback_file_open(GtkAction * action, gpointer data)
2374 {
2375 gchar *filename = NULL;
2376 MainView *mainview = (MainView *) data;
2377 g_assert(mainview != NULL && mainview->data != NULL);
2378
2379 filename = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_OPEN, NULL, NULL);
2380 if (filename == NULL) {
2381 return;
2382 }
2383
2384 if (closefile(mainview) == FALSE) {
2385 return;
2386 }
2387
2388 open_file(filename, mainview);
2389 g_free(filename);
2390 }
2391
2392 gboolean open_file(gchar * filename, MainView * mainview)
2393 {
2394 gboolean ret=FALSE;
2395
2396 /* Don't open nodes when opening a file */
2397 mainview->can_show_node_view = FALSE;
2398
2399 busy_enter(mainview);
2400
2401 while(filename != NULL)
2402 {
2403 struct stat s;
2404
2405 if (stat(filename, &s) == -1) break;
2406
2407 mainview->file_name = g_strdup(filename);
2408 gboolean res = read_file_to_buffer(mainview);
2409
2410 if (res == FALSE)
2411 {
2412 g_free(mainview->file_name);
2413 mainview->file_name = NULL;
2414 break;
2415 }
2416 mainview->file_edited = FALSE;
2417 ret=TRUE;
2418 break;
2419 }
2420
2421 busy_leave(mainview);
2422 return(ret);
2423 }
2424
2425 void callback_about_link(GtkAboutDialog *about, const gchar *link, gpointer data)
2426 {
2427 MainView *mainview = (MainView *) data;
2428 g_assert(mainview != NULL && mainview->data != NULL);
2429 osso_rpc_run_with_defaults(mainview->data->osso, "osso_browser", OSSO_BROWSER_OPEN_NEW_WINDOW_REQ, NULL,
2430 DBUS_TYPE_STRING, link, DBUS_TYPE_INVALID);
2431 }
2432
2433 void callback_about(GtkAction * action, gpointer data)
2434 {
2435 MainView* mainview = (MainView *)data;
2436 he_about_dialog_present(mainview_get_dialog_parent(mainview),
2437 NULL /* auto-detect app name */,
2438 "maepad",
2439 VERSION,
2440 _("A node-based memory pad for Maemo"),
2441 _("(c) 2010 Thomas Perl"),
2442 "http://thpinfo.com/2010/maepad/",
2443 "https://garage.maemo.org/tracker/?group_id=1291",
2444 "http://thpinfo.com/2010/maepad/donate");
2445 }
2446
2447 /*
2448 * save
2449 */
2450 void callback_file_save(GtkAction * action, gpointer data)
2451 {
2452 gchar *filename = NULL;
2453 MainView *mainview = (MainView *) data;
2454 g_assert(mainview != NULL && mainview->data != NULL);
2455
2456 /*
2457 * check is we had a new file
2458 */
2459 if (mainview->file_name != NULL)
2460 {
2461 write_buffer_to_file(mainview);
2462 }
2463 else
2464 {
2465 filename = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_SAVE, "maemopaddata", "db");
2466 /*
2467 * if we got a file name from chooser -> save file
2468 */
2469 if (filename != NULL)
2470 {
2471 mainview->file_name = filename;
2472 write_buffer_to_file(mainview);
2473 mainview->file_edited = FALSE;
2474 }
2475 }
2476 }
2477
2478 void callback_shapemenu(GtkAction * action, GtkWidget * wid)
2479 {
2480 gint style = GPOINTER_TO_INT(gtk_object_get_user_data(GTK_OBJECT(wid)));
2481 MainView* mainview = gtk_object_get_data(GTK_OBJECT(wid), "m");
2482 g_assert(mainview != NULL);
2483
2484 if (style >= 0 && style < SKETCHSHAPE_COUNT) {
2485 /* We use the sketch widget's enum for available styles */
2486 sketchwidget_set_shape(mainview->sk, style);
2487
2488 /* Draw the correct indicator for the current shape */
2489 GtkWidget* pix = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(wid), "i"));
2490 g_assert(pix != NULL);
2491 gtk_widget_show(pix);
2492 gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(mainview->shape_tb), pix);
2493 } else {
2494 /* Fail. We shouldn't get here at all! */
2495 g_error("Invalid style ID from shape menu: %d", style);
2496 }
2497 }
2498
2499
2500
2501 void callback_eraser(GtkAction * action, MainView * mainview)
2502 {
2503 g_assert(mainview != NULL && mainview->data != NULL);
2504
2505 if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(mainview->eraser_tb))) {
2506 /* Eraser on: Set pen color to white */
2507 GdkColor white = { 0, 0xFFFF, 0xFFFF, 0xFFFF };
2508 sketchwidget_set_brushcolor(mainview->sk, white);
2509 } else {
2510 /* Eraser off: Set default color again (or black) */
2511 GdkColor black = {0, 0, 0, 0};
2512 if (mainview->current_color == NULL) {
2513 mainview->current_color = gdk_color_copy(&black);
2514 }
2515 sketchwidget_set_brushcolor(mainview->sk, *(mainview->current_color));
2516 }
2517 }
2518
2519 void callback_menu(GtkAction * action, GtkWidget * menu)
2520 {
2521 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
2522 }
2523
2524 void callback_brushsizetb(GtkAction * action, MainView *mainview)
2525 {
2526 g_assert(mainview != NULL && mainview->data != NULL);
2527 callback_menu(NULL, mainview->brushsizemenu);
2528 }
2529
2530 void callback_brushsize(GtkAction * action, GtkWidget * wid)
2531 {
2532 int bsize = (int)gtk_object_get_user_data(GTK_OBJECT(wid));
2533 MainView *mainview = gtk_object_get_data(GTK_OBJECT(wid), "m");
2534
2535 g_assert(mainview != NULL && mainview->data != NULL);
2536
2537 sketchwidget_set_brushsize(mainview->sk, bsize);
2538
2539 GtkWidget *pix = gtk_object_get_data(GTK_OBJECT(wid), "i");
2540
2541 gtk_widget_show(pix);
2542 gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(mainview->brushsize_tb), pix);
2543 }
2544
2545 void callback_sketchlines(GtkAction * action, GtkWidget * wid)
2546 {
2547 int style = (int)gtk_object_get_user_data(GTK_OBJECT(wid));
2548 MainView *mainview = gtk_object_get_data(GTK_OBJECT(wid), "m");
2549
2550 g_assert(mainview != NULL);
2551
2552 nodeData *nd = getSelectedNode(mainview);
2553 gboolean doit = FALSE;
2554
2555 if (nd != NULL && nd->typ == NODE_SKETCH)
2556 {
2557 nd->flags &= ~NODEFLAG_SKETCHLINES;
2558 nd->flags &= ~NODEFLAG_SKETCHGRAPH;
2559 /* sketchwidget_set_edited(mainview->sk, TRUE);*/ /*we call this on openfile, so this messes things up*/
2560 doit = TRUE;
2561 }
2562
2563 if (style == 0)
2564 {
2565 sketchwidget_set_backstyle(mainview->sk, SKETCHBACK_NONE);
2566 }
2567 else if (style == 1)
2568 {
2569 sketchwidget_set_backstyle(mainview->sk, SKETCHBACK_LINES);
2570 if (doit == TRUE)
2571 nd->flags |= NODEFLAG_SKETCHLINES;
2572 }
2573 else if (style == 2)
2574 {
2575 sketchwidget_set_backstyle(mainview->sk, SKETCHBACK_GRAPH);
2576 if (doit == TRUE)
2577 nd->flags |= NODEFLAG_SKETCHGRAPH;
2578 }
2579
2580 GtkWidget *pix = gtk_object_get_data(GTK_OBJECT(wid), "i");
2581
2582 gtk_widget_show(pix);
2583 gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(mainview->sketchlines_tb), pix);
2584 }
2585
2586 void callback_color(GtkAction* action, MainView* mainview)
2587 {
2588 g_assert(mainview != NULL && mainview->data != NULL);
2589
2590 nodeData *nd = getSelectedNode(mainview);
2591 if (nd == NULL) return;
2592
2593 HeSimpleColorDialog* dialog = HE_SIMPLE_COLOR_DIALOG(he_simple_color_dialog_new());
2594 gtk_window_set_transient_for(GTK_WINDOW(dialog), mainview_get_dialog_parent(mainview));
2595
2596 if (mainview->current_color) {
2597 he_simple_color_dialog_set_color(dialog, mainview->current_color);
2598 }
2599
2600 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
2601 gtk_widget_destroy(GTK_WIDGET(dialog));
2602 return;
2603 }
2604
2605 gdk_color_free(mainview->current_color);
2606 mainview->current_color = he_simple_color_dialog_get_color(dialog);
2607
2608 gtk_widget_destroy(GTK_WIDGET(dialog));
2609
2610 switch (nd->typ) {
2611 case NODE_SKETCH:
2612 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->eraser_tb), FALSE);
2613 sketchwidget_set_brushcolor(mainview->sk, *(mainview->current_color));
2614 break;
2615 case NODE_CHECKLIST:
2616 { /* Put in a separate block to allow new local variables */
2617 GtkTreeModel* model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
2618 GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->listview));
2619 GList* selected = gtk_tree_selection_get_selected_rows(selection, NULL);
2620
2621 gchar* color_string = g_strdup_printf("#%02x%02x%02x",
2622 mainview->current_color->red >> 8,
2623 mainview->current_color->green >> 8,
2624 mainview->current_color->blue >> 8);
2625
2626 GList* cur = selected;
2627 while (cur != NULL) {
2628 GtkTreePath* path = cur->data;
2629 GtkTreeIter iter;
2630 if (gtk_tree_model_get_iter(model, &iter, path)) {
2631 gtk_list_store_set(GTK_LIST_STORE(model), &iter, CHECKNODE_COLOR, color_string, -1);
2632 }
2633 gtk_tree_path_free(path);
2634 cur = cur->next;
2635 }
2636
2637 g_list_free(selected);
2638 g_free(color_string);
2639 }
2640 break;
2641 default:
2642 g_assert_not_reached();
2643 }
2644 }
2645
2646 void callback_color_invoke(GtkAction * action, gpointer data)
2647 {
2648 MainView *mainview = (MainView *) data;
2649 g_assert(mainview != NULL && mainview->data != NULL);
2650 gtk_button_clicked(GTK_BUTTON(mainview->colorbutton_tb));
2651 }
2652
2653
2654
2655 void callback_pressure(GtkAction * action, MainView *mainview)
2656 {
2657 g_assert(mainview != NULL && mainview->data != NULL);
2658
2659 nodeData *nd = getSelectedNode(mainview);
2660
2661 if (nd == NULL)
2662 return;
2663 if (nd->typ != NODE_SKETCH)
2664 return;
2665
2666 /* pressure sensitivity disabled for now...
2667 mainview->sk->pressuresensitivity=gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(mainview->tools_pressure));*/
2668 }
2669
2670
2671 void callback_wordwrap(GtkWidget* widget, gpointer user_data)
2672 {
2673 MainView* mainview = (MainView*)user_data;
2674 nodeData* nd = getSelectedNode(mainview);
2675 GtkWrapMode wrap_mode;
2676
2677 if (nd == NULL || nd->typ != NODE_TEXT) {
2678 return;
2679 }
2680
2681 if (hildon_check_button_get_active(HILDON_CHECK_BUTTON(mainview->menu_button_wordwrap))) {
2682 nd->flags |= NODEFLAG_WORDWRAP;
2683 wrap_mode = GTK_WRAP_WORD_CHAR;
2684 } else {
2685 nd->flags &= ~NODEFLAG_WORDWRAP;
2686 wrap_mode = GTK_WRAP_NONE;
2687 }
2688
2689 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(mainview->textview), wrap_mode);
2690 }
2691
2692
2693 void callback_font(GtkAction * action, gpointer data)
2694 {
2695 MainView *mainview = (MainView *) data;
2696 g_assert(mainview != NULL && mainview->data != NULL);
2697
2698 nodeData *nd = getSelectedNode(mainview);
2699
2700 if (nd == NULL)
2701 return;
2702 if (nd->typ != NODE_TEXT)
2703 return;
2704
2705 HildonFontSelectionDialog *dialog = HILDON_FONT_SELECTION_DIALOG(hildon_font_selection_dialog_new(NULL, NULL));
2706
2707 gboolean gotsel=wp_text_buffer_has_selection(mainview->buffer);
2708 /*gotsel=FALSE;*/
2709
2710 WPTextBufferFormat fmt;
2711 wp_text_buffer_get_attributes(mainview->buffer, &fmt, gotsel);
2712
2713 gint ri=0;
2714 if (fmt.text_position==TEXT_POSITION_SUPERSCRIPT) ri=1;
2715 else if (fmt.text_position==TEXT_POSITION_SUBSCRIPT) ri=-1;
2716
2717 g_object_set(G_OBJECT(dialog),
2718 "family-set", fmt.cs.font,
2719 "family", wp_get_font_name(fmt.font),
2720 "size-set", fmt.cs.font_size,
2721 "size", wp_font_size[fmt.font_size],
2722 "color-set", fmt.cs.color,
2723 "color", &fmt.color,
2724 "bold-set", fmt.cs.bold,
2725 "bold", fmt.bold,
2726 "italic-set", fmt.cs.italic,
2727 "italic", fmt.italic,
2728 "underline-set", fmt.cs.underline,
2729 "underline", fmt.underline,
2730 "strikethrough-set", fmt.cs.strikethrough,
2731 "strikethrough", fmt.strikethrough,
2732 "position-set", fmt.cs.text_position,
2733 "position", ri,
2734 NULL);
2735
2736 gtk_widget_show_all(GTK_WIDGET(dialog));
2737 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
2738 {
2739 gboolean bold, italic, underline, strikethrough;
2740 gchar *family = NULL;
2741 gint size, position;
2742 GdkColor *color=NULL;
2743 gboolean set_family, set_size, set_bold, set_italic, set_underline, set_strikethrough, set_color, set_position;
2744
2745 g_object_get(G_OBJECT(dialog), "family", &family, "size", &size, "bold", &bold, "italic", &italic,
2746 "underline", &underline, "strikethrough", &strikethrough,
2747 "family-set", &set_family, "size-set", &set_size, "bold-set", &set_bold, "italic-set", &set_italic,
2748 "underline-set", &set_underline, "strikethrough-set", &set_strikethrough,
2749 "color", &color, "color-set", &set_color, "position", &position, "position-set", &set_position,
2750 NULL);
2751
2752 wp_text_buffer_get_attributes(mainview->buffer, &fmt, FALSE);
2753 fmt.cs.font=fmt.cs.font_size=fmt.cs.strikethrough=fmt.cs.color=fmt.cs.bold=fmt.cs.italic=fmt.cs.underline=fmt.cs.text_position=0;
2754
2755 if (set_family) { fmt.font=wp_get_font_index(family, 1); fmt.cs.font=1; }
2756 if (set_size) { fmt.font_size=wp_get_font_size_index(size, 16); fmt.cs.font_size=1; }
2757
2758 if (set_strikethrough)
2759 {
2760 fmt.cs.strikethrough=1;
2761 fmt.strikethrough=strikethrough;
2762 }
2763
2764 if (set_color)
2765 {
2766 /*
2767 GLIB WARNING ** GLib-GObject - IA__g_object_set_valist: object class `GtkTextTag' has no property named `'
2768 */
2769 fmt.cs.color=1;
2770 fmt.color.pixel=color->pixel;
2771 fmt.color.red=color->red;
2772 fmt.color.green=color->green;
2773 fmt.color.blue=color->blue;
2774 }
2775
2776 if (set_position)
2777 {
2778 if (position==1) ri=TEXT_POSITION_SUPERSCRIPT;
2779 else if (position==-1) ri=TEXT_POSITION_SUBSCRIPT;
2780 else ri=TEXT_POSITION_NORMAL;
2781
2782 fmt.cs.text_position=1;
2783 fmt.text_position=ri;
2784 }
2785
2786 if (set_bold)
2787 {
2788 fmt.cs.bold=1;
2789 fmt.bold=bold;
2790 }
2791 if (set_italic)
2792 {
2793 fmt.cs.italic=1;
2794 fmt.italic=italic;
2795 }
2796 if (set_underline)
2797 {
2798 fmt.cs.underline=1;
2799 fmt.underline=underline;
2800 }
2801
2802 wp_text_buffer_set_format(mainview->buffer, &fmt);
2803 }
2804
2805 gtk_widget_destroy(GTK_WIDGET(dialog));
2806 }
2807
2808 void callback_fontstyle(GtkAction * action, GtkWidget * wid)
2809 {
2810 MainView *mainview = gtk_object_get_data(GTK_OBJECT(wid), "m");
2811 g_assert(mainview != NULL && mainview->data != NULL);
2812
2813 nodeData *nd = getSelectedNode(mainview);
2814
2815 if (nd == NULL)
2816 return;
2817 if (nd->typ == NODE_TEXT)
2818 {
2819 gboolean act=gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(wid));
2820
2821 gint style = (gint)gtk_object_get_data(GTK_OBJECT(wid), "s");
2822 wp_text_buffer_set_attribute(mainview->buffer, style, (gpointer)act);
2823 }
2824 else if (nd->typ == NODE_CHECKLIST)
2825 {
2826 gboolean act=gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(wid));
2827 gint style = (gint)gtk_object_get_data(GTK_OBJECT(wid), "s");
2828 if (style!=WPT_BOLD && style!=WPT_STRIKE && style!=WPT_LEFT) return;
2829
2830 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
2831 GList* l=gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->listview)), NULL);
2832
2833 gint styletoset_weight=PANGO_WEIGHT_NORMAL;
2834 gboolean styletoset_strike=FALSE;
2835 gboolean checkit=FALSE;
2836
2837 if (style==WPT_BOLD && act==TRUE) styletoset_weight=PANGO_WEIGHT_BOLD;
2838 else if (style==WPT_STRIKE && act==TRUE) styletoset_strike=TRUE;
2839 else if (style==WPT_LEFT && act==TRUE) checkit=TRUE;
2840
2841 GList* cur=l;
2842 while(cur)
2843 {
2844 GtkTreePath *path=cur->data;
2845
2846 GtkTreeIter iter;
2847 if (gtk_tree_model_get_iter(model, &iter, path))
2848 {
2849 if (style==WPT_BOLD) gtk_list_store_set(GTK_LIST_STORE(model), &iter, CHECKNODE_BOLD, styletoset_weight, -1);
2850 else if (style==WPT_STRIKE) gtk_list_store_set(GTK_LIST_STORE(model), &iter, CHECKNODE_STRIKE, styletoset_strike, -1);
2851 else if (style==WPT_LEFT) {
2852 gtk_list_store_set(GTK_LIST_STORE(model), &iter, CHECKNODE_CHECKED, checkit, -1);
2853 if (checkit) {
2854 gtk_list_store_set(GTK_LIST_STORE(model), &iter, CHECKNODE_ICON_NAME, "widgets_tickmark_list", -1);
2855 } else {
2856 gtk_list_store_set(GTK_LIST_STORE(model), &iter, CHECKNODE_ICON_NAME, NULL, -1);
2857 }
2858 }
2859 }
2860 gtk_tree_path_free(path);
2861 cur=cur->next;
2862 }
2863
2864 g_list_free(l);
2865 mainview->checklist_edited = TRUE;
2866 }
2867 }
2868
2869 void
2870 callback_sharing(GtkWidget* widget, gpointer user_data)
2871 {
2872 MainView* mainview = (MainView*)user_data;
2873 nodeData* nd = getSelectedNode(mainview);
2874 gchar* filename = g_strdup("/tmp/untitled.png");
2875 gchar* uri = NULL;
2876
2877 if (nd == NULL || nd->typ != NODE_SKETCH) {
2878 show_banner(mainview, _("Only sketches can be shared"));
2879 return;
2880 }
2881
2882 if (nd->name != NULL) {
2883 g_free(filename);
2884 filename = g_strdup_printf("/tmp/%s.png", nd->name);
2885 }
2886
2887 busy_enter(mainview);
2888 GdkPixmap* skpix = sketchwidget_get_Pixmap(mainview->sk);
2889 GtkWidget* skdr = sketchwidget_get_drawingarea(mainview->sk);
2890 GdkPixbuf* pixbuf = gdk_pixbuf_get_from_drawable(NULL,
2891 GDK_DRAWABLE(skpix), NULL, 0, 0, 0, 0,
2892 skdr->allocation.width, skdr->allocation.height);
2893
2894 if (pixbuf == NULL) {
2895 show_banner(mainview, _("Memo is empty"));
2896 goto cleanup;
2897 }
2898
2899 if (!gdk_pixbuf_save(pixbuf, filename, "png", NULL, NULL)) {
2900 show_banner(mainview, _("File export failed"));
2901 goto cleanup;
2902 }
2903
2904 uri = g_strdup_printf("file://%s", filename);
2905
2906 sharing_dialog_with_file(mainview->data->osso,
2907 mainview_get_dialog_parent(mainview),
2908 uri);
2909
2910 cleanup:
2911 g_object_unref(skpix);
2912 g_free(filename);
2913 g_free(uri);
2914 busy_leave(mainview);
2915 }
2916
2917 void
2918 callback_remove_checked(GtkWidget* widget, gpointer user_data)
2919 {
2920 MainView* mainview = (MainView*)user_data;
2921 nodeData* nd = getSelectedNode(mainview);
2922 GtkTreeIter iter;
2923 GtkTreeModel* model = NULL;
2924 GList* checked_items = NULL;
2925 gchar* question = NULL;
2926 gint count = 0;
2927
2928 if (nd == NULL || nd->typ != NODE_CHECKLIST) {
2929 return;
2930 }
2931
2932 /* Get a list of checked items */
2933 model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
2934 if (!gtk_tree_model_get_iter_first(model, &iter)) {
2935 return;
2936 }
2937
2938 busy_enter(mainview);
2939 do {
2940 gboolean checked = FALSE;
2941 gtk_tree_model_get(model, &iter, CHECKNODE_CHECKED, &checked, -1);
2942
2943 if (checked) {
2944 GtkTreePath* path = gtk_tree_model_get_path(model, &iter);
2945
2946 checked_items = g_list_append(checked_items,
2947 gtk_tree_row_reference_new(model, path));
2948 count++;
2949
2950 gtk_tree_path_free(path);
2951 }
2952 } while (gtk_tree_model_iter_next(model, &iter));
2953 busy_leave(mainview);
2954
2955 if (checked_items == NULL) {
2956 show_banner(mainview, _("No checked items in checklist"));
2957 return;
2958 }
2959
2960 question = g_strdup_printf(N_("Remove %d checked item?", "Remove %d checked items?", count), count);
2961 if (show_confirmation(mainview, question)) {
2962 /* Remove the checklist items from the list */
2963 checklist_remove_rowrefs(mainview, checked_items, TRUE);
2964 } else {
2965 /* Free the allocated row references + list */
2966 GList* cur = checked_items;
2967 while (cur != NULL) {
2968 GtkTreeRowReference* rowref = cur->data;
2969 gtk_tree_row_reference_free(rowref);
2970 cur = cur->next;
2971 }
2972 g_list_free(checked_items);
2973 }
2974 g_free(question);
2975 }
2976
2977 void callback_textbuffer_move(WPTextBuffer *textbuffer, MainView *mainview)
2978 {
2979 g_assert(mainview != NULL && mainview->data != NULL);
2980
2981 /*
2982 gboolean gotsel=wp_text_buffer_has_selection(mainview->buffer);
2983
2984 _toggle_tool_button_set_inconsistent(GTK_TOGGLE_TOOL_BUTTON(mainview->bold_tb), gotsel);
2985 _toggle_tool_button_set_inconsistent(GTK_TOGGLE_TOOL_BUTTON(mainview->italic_tb), gotsel);
2986 _toggle_tool_button_set_inconsistent(GTK_TOGGLE_TOOL_BUTTON(mainview->underline_tb), gotsel);
2987 _toggle_tool_button_set_inconsistent(GTK_TOGGLE_TOOL_BUTTON(mainview->bullet_tb), gotsel);
2988 */
2989 WPTextBufferFormat fmt;
2990 wp_text_buffer_get_attributes(mainview->buffer, &fmt, FALSE/*gotsel*/);
2991
2992 g_signal_handlers_block_by_func(mainview->bold_tb, callback_fontstyle, mainview->bold_tb);
2993 g_signal_handlers_block_by_func(mainview->italic_tb, callback_fontstyle, mainview->italic_tb);
2994 g_signal_handlers_block_by_func(mainview->underline_tb, callback_fontstyle, mainview->underline_tb);
2995 g_signal_handlers_block_by_func(mainview->bullet_tb, callback_fontstyle, mainview->bullet_tb);
2996
2997 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->bold_tb), fmt.bold);
2998 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->italic_tb), fmt.italic);
2999 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->underline_tb), fmt.underline);
3000 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->bullet_tb), fmt.bullet);
3001
3002 g_signal_handlers_unblock_by_func(mainview->bold_tb, callback_fontstyle, mainview->bold_tb);
3003 g_signal_handlers_unblock_by_func(mainview->italic_tb, callback_fontstyle, mainview->italic_tb);
3004 g_signal_handlers_unblock_by_func(mainview->underline_tb, callback_fontstyle, mainview->underline_tb);
3005 g_signal_handlers_unblock_by_func(mainview->bullet_tb, callback_fontstyle, mainview->bullet_tb);
3006 }
3007
3008 gint wp_savecallback(const gchar *buffer, GString * gstr)
3009 {
3010 gstr=g_string_append(gstr, buffer);
3011 return(0);
3012 }
3013
3014 void callback_undo(GtkAction * action, MainView * mainview)
3015 {
3016 g_assert(mainview != NULL && mainview->data != NULL);
3017
3018 nodeData *nd = getSelectedNode(mainview);
3019
3020 if (nd == NULL) return;
3021
3022 if (nd->typ == NODE_SKETCH) sketchwidget_undo(mainview->sk);
3023 else if (nd->typ == NODE_TEXT) wp_text_buffer_undo(mainview->buffer);
3024 }
3025
3026 void callback_redo(GtkAction * action, MainView * mainview)
3027 {
3028 g_assert(mainview != NULL && mainview->data != NULL);
3029
3030 nodeData *nd = getSelectedNode(mainview);
3031
3032 if (nd == NULL) return;
3033
3034 if (nd->typ == NODE_SKETCH) sketchwidget_redo(mainview->sk);
3035 else if (nd->typ == NODE_TEXT) wp_text_buffer_redo(mainview->buffer);
3036 }
3037
3038 void callback_undotoggle(gpointer widget, gboolean st, MainView * mainview)
3039 {
3040 g_assert(mainview != NULL && mainview->data != NULL);
3041
3042 gtk_widget_set_sensitive(GTK_WIDGET(mainview->undo_tb), st);
3043 }
3044
3045 void callback_redotoggle(gpointer widget, gboolean st, MainView * mainview)
3046 {
3047 g_assert(mainview != NULL && mainview->data != NULL);
3048
3049 gtk_widget_set_sensitive(GTK_WIDGET(mainview->redo_tb), st);
3050 }
3051
3052 gboolean close_cb(GtkWidget * widget, GdkEventAny * event, MainView * mainview)
3053 {
3054 callback_file_close(NULL, mainview);
3055 return (TRUE);
3056 }
3057
3058 void
3059 mainview_click_on_current_node(MainView* mainview)
3060 {
3061 GtkTreeSelection* selection = NULL;
3062 GtkTreeModel* model = NULL;
3063 GtkTreeIter iter;
3064
3065 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
3066 if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
3067 GtkTreePath* path = gtk_tree_model_get_path(model, &iter);
3068
3069 mainview->can_show_node_view = TRUE;
3070 gtk_tree_view_set_cursor(GTK_TREE_VIEW(mainview->treeview),
3071 path, NULL, FALSE);
3072
3073 gtk_tree_path_free(path);
3074 }
3075 }
3076
3077 gboolean
3078 on_main_view_key_press(GtkWidget* widget, GdkEventKey* event, gpointer user_data)
3079 {
3080 MainView* mainview = (MainView*)user_data;
3081 gboolean result = FALSE;
3082
3083 switch (event->keyval) {
3084 case GDK_KP_Enter:
3085 case GDK_Return:
3086 case GDK_l:
3087 case GDK_L:
3088 /* Open selected memo in node view */
3089 mainview_click_on_current_node(mainview);
3090 result = TRUE;
3091 break;
3092 case GDK_w:
3093 case GDK_W:
3094 /* Save changes to file ("write buffer") */
3095 callback_file_save(NULL, mainview);
3096 result = TRUE;
3097 break;
3098 case GDK_BackSpace:
3099 /* Delete selected node (with confirmation) */
3100 callback_file_delete_node(NULL, mainview);
3101 result = TRUE;
3102 break;
3103 case GDK_o:
3104 case GDK_O:
3105 /* Add new memo to list */
3106 callback_file_new_node(NULL, mainview);
3107 result = TRUE;
3108 break;
3109 case GDK_r:
3110 case GDK_R:
3111 /* Replace (edit) name of selected memo */
3112 callback_file_rename_node(NULL, mainview);
3113 result = TRUE;
3114 break;
3115 case GDK_g:
3116 if (mainview->main_view_prev_keyval == GDK_g) {
3117 /* Goto (=select) first memo */
3118 mainview->can_show_node_view = FALSE;
3119 nodelist_select(mainview, TREEVIEW_SELECT_FIRST);
3120
3121 /* Don't remember this key for the next keypress */
3122 mainview->main_view_prev_keyval_reset = TRUE;
3123
3124 result = TRUE;
3125 }
3126 break;
3127 case GDK_G:
3128 /* Goto (=select) last memo */
3129 mainview->can_show_node_view = FALSE;
3130 nodelist_select(mainview, TREEVIEW_SELECT_LAST);
3131 result = TRUE;
3132 break;
3133 case GDK_j:
3134 case GDK_J:
3135 case GDK_Down:
3136 /* Goto (=select) next memo */
3137 mainview->can_show_node_view = FALSE;
3138 nodelist_select(mainview, TREEVIEW_SELECT_NEXT);
3139 result = TRUE;
3140 break;
3141 case GDK_k:
3142 case GDK_K:
3143 case GDK_Up:
3144 /* Goto (=select) previous memo */
3145 mainview->can_show_node_view = FALSE;
3146 nodelist_select(mainview, TREEVIEW_SELECT_PREVIOUS);
3147 result = TRUE;
3148 break;
3149 default:
3150 /* do nothing */
3151 break;
3152 }
3153
3154 return result;
3155 }
3156
3157 gboolean
3158 on_node_view_key_press(GtkWidget* widget, GdkEventKey* event, gpointer user_data)
3159 {
3160 MainView* mainview = (MainView*)user_data;
3161 nodeData* nd = getSelectedNode(mainview);
3162 gboolean result = FALSE;
3163
3164 if (nd == NULL) {
3165 return FALSE;
3166 }
3167
3168 switch (event->keyval) {
3169 case GDK_BackSpace:
3170 if (event->state & GDK_SHIFT_MASK) {
3171 /* Remove current memo (with confirmation) */
3172 callback_file_delete_node(NULL, mainview);
3173 result = TRUE;
3174 } else if (nd->typ == NODE_CHECKLIST) {
3175 /* Remove current item (with confirmation) */
3176 callback_checklist_delete(NULL, mainview);
3177 result = TRUE;
3178 } else if (nd->typ == NODE_SKETCH) {
3179 /* Undo last sketch action */
3180 callback_undo(NULL, mainview);
3181 result = TRUE;
3182 }
3183 break;
3184 case GDK_space:
3185 if (nd->typ == NODE_CHECKLIST) {
3186 /* Toggle check of current item */
3187 maepad_toggle_gtk_toggle_tool_button(mainview->check_tb);
3188 result = TRUE;
3189 } else if (nd->typ == NODE_SKETCH) {
3190 /* Toggle eraser tool */
3191 maepad_toggle_gtk_toggle_tool_button(mainview->eraser_tb);
3192 result = TRUE;
3193 }
3194 break;
3195 case GDK_f:
3196 case GDK_F:
3197 if (nd->typ != NODE_TEXT) {
3198 /* Toggle fullscreen mode */
3199 callback_fullscreen(NULL, mainview);
3200 result = TRUE;
3201 }
3202 break;
3203 case GDK_h:
3204 case GDK_H:
3205 if (nd->typ != NODE_TEXT) {
3206 /* Hide node view, go to main view ("left") */
3207 gtk_widget_hide(GTK_WIDGET(mainview->data->node_view));
3208 result = TRUE;
3209 }
3210 break;
3211 case GDK_o:
3212 case GDK_O:
3213 if (nd->typ == NODE_CHECKLIST) {
3214 /* Insert new checklist item */
3215 callback_checklist_add(NULL, mainview);
3216 result = TRUE;
3217 }
3218 break;
3219 case GDK_d:
3220 if (nd->typ == NODE_CHECKLIST) {
3221 if (mainview->node_view_prev_keyval == GDK_d) {
3222 /* Yank selected items, then remove them silently */
3223 callback_edit_copy(NULL, mainview);
3224 callback_checklist_delete_real(mainview);
3225 show_banner(mainview, _("Item yanked to clipboard"));
3226
3227 /* Don't remember this key for the next keypress */
3228 mainview->node_view_prev_keyval_reset = TRUE;
3229
3230 result = TRUE;
3231 }
3232 }
3233 break;
3234 case GDK_y:
3235 if (nd->typ == NODE_CHECKLIST) {
3236 if (mainview->node_view_prev_keyval == GDK_y) {
3237 /* Non-destructive yanking of items */
3238 callback_edit_copy(NULL, mainview);
3239 show_banner(mainview, _("Item yanked to clipboard"));
3240
3241 /* Don't remember this key for the next keypress */
3242 mainview->node_view_prev_keyval_reset = TRUE;
3243
3244 result = TRUE;
3245 }
3246 }
3247 break;
3248 case GDK_p:
3249 case GDK_P:
3250 if (nd->typ == NODE_CHECKLIST) {
3251 /* Paste text in clipboard as items */
3252 callback_edit_paste(NULL, mainview);
3253 result = TRUE;
3254 }
3255 break;
3256 case GDK_g:
3257 if (nd->typ == NODE_CHECKLIST) {
3258 if (mainview->node_view_prev_keyval == GDK_g) {
3259 /* Goto (=select) first item */
3260 checklist_select(mainview, TREEVIEW_SELECT_FIRST);
3261
3262 /* Don't remember this key for the next keypress */
3263 mainview->node_view_prev_keyval_reset = TRUE;
3264
3265 result = TRUE;
3266 }
3267 }
3268 break;
3269 case GDK_G:
3270 if (nd->typ == NODE_CHECKLIST) {
3271 /* Goto (=select) last item */
3272 checklist_select(mainview, TREEVIEW_SELECT_LAST);
3273 result = TRUE;
3274 }
3275 break;
3276 case GDK_j:
3277 case GDK_J:
3278 case GDK_Down:
3279 if (nd->typ == NODE_CHECKLIST) {
3280 /* Goto (=select) next item */
3281 checklist_select(mainview, TREEVIEW_SELECT_NEXT);
3282 result = TRUE;
3283 } else if (nd->typ == NODE_SKETCH) {
3284 /* Undo last sketch operation */
3285 callback_undo(NULL, mainview);
3286 result = TRUE;
3287 }
3288 break;
3289 case GDK_k:
3290 case GDK_K:
3291 case GDK_Up:
3292 if (nd->typ == NODE_CHECKLIST) {
3293 /* Goto (=select) previous item */
3294 checklist_select(mainview, TREEVIEW_SELECT_PREVIOUS);
3295 result = TRUE;
3296 } else if (nd->typ == NODE_SKETCH) {
3297 /* Redo last sketch operation */
3298 callback_redo(NULL, mainview);
3299 result = TRUE;
3300 }
3301 break;
3302 case GDK_a:
3303 case GDK_A:
3304 if (nd->typ == NODE_CHECKLIST) {
3305 /* Append text to current node */
3306 checklist_edit_selected(mainview, LINE_EDIT_MODE_APPEND);
3307 result = TRUE;
3308 }
3309 break;
3310 case GDK_r:
3311 case GDK_R:
3312 case GDK_KP_Enter:
3313 case GDK_Return:
3314 if (nd->typ == NODE_CHECKLIST) {
3315 /* Replace (edit) text of current node */
3316 checklist_edit_selected(mainview, LINE_EDIT_MODE_DEFAULT);
3317 result = TRUE;
3318 }
3319 break;
3320 case GDK_i:
3321 case GDK_I:
3322 if (nd->typ == NODE_CHECKLIST) {
3323 /* Prepend (insert) text to current node */
3324 checklist_edit_selected(mainview, LINE_EDIT_MODE_PREPEND);
3325 result = TRUE;
3326 }
3327 break;
3328 default:
3329 /* do nothing */
3330 break;
3331 }
3332
3333 return result;
3334 }
3335
3336 gboolean
3337 on_main_view_key_release(GtkWidget* widget, GdkEventKey* event, gpointer user_data)
3338 {
3339 MainView* mainview = (MainView*)user_data;
3340
3341 if (mainview->main_view_prev_keyval_reset) {
3342 /* Forget last-pressed key value */
3343 mainview->main_view_prev_keyval = GDK_VoidSymbol;
3344 mainview->main_view_prev_keyval_reset = FALSE;
3345 } else {
3346 /* Remember last keyval for double-press bindings */
3347 mainview->main_view_prev_keyval = event->keyval;
3348 }
3349
3350 return FALSE;
3351 }
3352
3353 gboolean
3354 on_node_view_key_release(GtkWidget* widget, GdkEventKey* event, gpointer user_data)
3355 {
3356 MainView* mainview = (MainView*)user_data;
3357
3358 if (mainview->node_view_prev_keyval_reset) {
3359 /* Forget last-pressed key value */
3360 mainview->node_view_prev_keyval = GDK_VoidSymbol;
3361 mainview->node_view_prev_keyval_reset = FALSE;
3362 } else {
3363 /* Remember last keyval for double-press bindings */
3364 mainview->node_view_prev_keyval = event->keyval;
3365 }
3366
3367 return FALSE;
3368 }
3369
3370 gboolean
3371 on_checklist_longpress_timeout(gpointer user_data)
3372 {
3373 MainView* mainview = (MainView*)user_data;
3374 callback_checklist_edit(NULL, mainview);
3375 mainview->checklist_longpress_source_id = 0;
3376 return FALSE;
3377 }
3378
3379 gboolean
3380 on_checklist_button_press(GtkWidget* widget, GdkEventButton* event, gpointer user_data)
3381 {
3382 MainView* mainview = (MainView*)user_data;
3383 GtkTreePath* path;
3384 GtkTreeViewColumn* column;
3385 GtkTreeSelection* selection;
3386
3387 if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget),
3388 event->x,
3389 event->y,
3390 &path,
3391 &column,
3392 NULL,
3393 NULL)) {
3394 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
3395
3396 if (gtk_tree_selection_path_is_selected(selection, path)) {
3397 if (column == mainview->checklist_column_check) {
3398 /* Check column touched - toggle checklist item */
3399 maepad_toggle_gtk_toggle_tool_button(mainview->check_tb);
3400 } else if (column == mainview->checklist_column_text) {
3401 mainview->checklist_longpress_source_id = g_timeout_add(
3402 CHECKLIST_LONGPRESS_EDIT_DELAY,
3403 on_checklist_longpress_timeout,
3404 mainview);
3405 }
3406 return TRUE;
3407 }
3408
3409 gtk_tree_path_free(path);
3410 }
3411
3412 return FALSE;
3413 }
3414
3415 void
3416 checklist_abort_longpress(MainView* mainview)
3417 {
3418 /* Abort the longpress action on the checklist */
3419 if (mainview->checklist_longpress_source_id != 0) {
3420 g_source_remove(mainview->checklist_longpress_source_id);
3421 mainview->checklist_longpress_source_id = 0;
3422 }
3423 }
3424
3425 gboolean
3426 on_checklist_button_release(GtkWidget* widget, GdkEventButton* event, gpointer user_data)
3427 {
3428 MainView* mainview = (MainView*)user_data;
3429 checklist_abort_longpress(mainview);
3430 return FALSE;
3431 }
3432
3433 gboolean
3434 on_checklist_start_panning(HildonPannableArea* area, gpointer user_data)
3435 {
3436 MainView* mainview = (MainView*)user_data;
3437 checklist_abort_longpress(mainview);
3438 return FALSE;
3439 }
3440
3441 void callback_fullscreen(GtkToolButton* tool_button, gpointer user_data)
3442 {
3443 MainView* mainview = (MainView*)user_data;
3444 gtk_window_fullscreen(GTK_WINDOW(mainview->data->node_view));
3445 }
3446
3447 void
3448 callback_sketch_button_toggled(HildonCheckButton* button, gpointer user_data)
3449 {
3450 MainView* mainview = (MainView*)user_data;
3451 gboolean active = hildon_check_button_get_active(button);
3452
3453 if (GTK_WIDGET(button) == GTK_WIDGET(mainview->menu_button_square)) {
3454 sketchwidget_set_shift(mainview->sk, active);
3455 } else if (GTK_WIDGET(button) == GTK_WIDGET(mainview->menu_button_filled)) {
3456 sketchwidget_set_fillmode(mainview->sk, active);
3457 }
3458 }
3459
3460 void callback_buffer_modified(GtkAction * action, gpointer data)
3461 {
3462 MainView *mainview = (MainView *) data;
3463 g_assert(mainview != NULL && mainview->data != NULL);
3464
3465 mainview->file_edited = TRUE;
3466 }
3467
3468 GtkTreeRowReference *read_sqlite3_data(MainView * mainview, unsigned int parentid, GtkTreeRowReference * parenttree, unsigned int selected, GtkTreeStore * model)
3469 {
3470 GtkTreeRowReference *resref = NULL;
3471
3472 char q[256];
3473
3474 g_snprintf(q, sizeof(q), "SELECT nodeid, bodytype, name, nameblob, lastmodified, flags FROM %s WHERE parent=%d ORDER BY ord", datatable_tmpname, parentid);
3475
3476 sqlite3_stmt *stmt = NULL;
3477 const char *dum;
3478 int rc = sqlite3_prepare(mainview->db, q, strlen(q), &stmt, &dum);
3479
3480 if (rc)
3481 {
3482 maepad_warning("Error reading SQLite3 data: %s", sqlite3_errmsg(mainview->db));
3483 return (NULL);
3484 }
3485
3486 rc = SQLITE_BUSY;
3487 while(rc == SQLITE_BUSY || rc == SQLITE_ROW)
3488 {
3489 rc = sqlite3_step(stmt);
3490 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
3491 break;
3492 else if (rc == SQLITE_ROW)
3493 {
3494 int nodeid = sqlite3_column_int(stmt, 0);
3495 int typ = sqlite3_column_int(stmt, 1);
3496 const unsigned char *name = sqlite3_column_text(stmt, 2);
3497 const unsigned char *nameblob = sqlite3_column_text(stmt, 3);
3498 int lastmod = sqlite3_column_int(stmt, 4);
3499 int flags = sqlite3_column_int(stmt, 5);
3500
3501 if ((typ != NODE_TEXT && typ != NODE_SKETCH && typ != NODE_CHECKLIST) || (name == NULL && nameblob == NULL)) {
3502 maepad_warning("Unknown node type in database: %d (skipping)", typ);
3503 continue;
3504 }
3505
3506 nodeData *node = g_malloc(sizeof(nodeData));
3507
3508 node->sql3id = nodeid;
3509 node->typ = typ;
3510 node->flags = flags;
3511 node->name = NULL;
3512 node->namepix = NULL;
3513 if (name != NULL) {
3514 node->name = g_strdup((char *)name);
3515 } else {
3516 node->name = g_strdup(_("Unnamed memo"));
3517 }
3518 /*if (nameblob != NULL)
3519 {
3520 int blobsize = sqlite3_column_bytes(stmt, 3);
3521
3522 GdkPixbufLoader *pl = gdk_pixbuf_loader_new_with_type("png", NULL);
3523 GError *err = NULL;
3524
3525 gdk_pixbuf_loader_write(pl, (guchar *) nameblob, blobsize, &err);
3526 if (err != NULL)
3527 {
3528 fprintf(stderr, "Error loading nodename! %s\n", err->message);
3529 g_error_free(err);
3530 err = NULL;
3531 }
3532 gdk_pixbuf_loader_close(pl, NULL);
3533 GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf(pl);
3534
3535 if (GDK_IS_PIXBUF(pixbuf))
3536 node->namepix = pixbuf;
3537 }*/
3538 node->lastMod = lastmod;
3539
3540 GtkTreeIter parentiter, newiter;
3541 void *par = NULL;
3542
3543 if (parenttree != NULL)
3544 {
3545 GtkTreePath *pa = gtk_tree_row_reference_get_path(parenttree);
3546
3547 gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &parentiter, pa);
3548 gtk_tree_path_free(pa);
3549 par = &parentiter;
3550 }
3551
3552 gtk_tree_store_append(model, &newiter, par);
3553 gtk_tree_store_set(model, &newiter, NODE_NAME, node->name, NODE_PIXBUF, node->namepix, NODE_DATA, node, -1);
3554
3555 GtkTreePath *pa = gtk_tree_model_get_path(GTK_TREE_MODEL(model), &newiter);
3556
3557 GtkTreeRowReference *newref = gtk_tree_row_reference_new(GTK_TREE_MODEL(model), pa);
3558
3559 if (selected == nodeid)
3560 resref = newref;
3561
3562 gtk_tree_path_free(pa);
3563 GtkTreeRowReference *r = read_sqlite3_data(mainview, nodeid, newref, selected,
3564 model);
3565
3566 if (resref != newref)
3567 gtk_tree_row_reference_free(newref);
3568
3569 if (r != NULL)
3570 {
3571 if (resref == NULL)
3572 resref = r;
3573 else
3574 gtk_tree_row_reference_free(r); /*safeguard */
3575 }
3576 }
3577 }
3578
3579 if (stmt)
3580 sqlite3_finalize(stmt);
3581
3582 return (resref); /*ref to supposed-to-be-selected treeitem */
3583 }
3584
3585 /*
3586 * read file
3587 */
3588 gboolean read_file_to_buffer(MainView * mainview)
3589 {
3590 char tq[512];
3591
3592 g_assert(mainview != NULL);
3593 gboolean res = FALSE;
3594
3595 gchar *filename = mainview->file_name;
3596
3597 new_file(mainview);
3598 mainview->file_name = filename;
3599 mainview->loading=TRUE;
3600
3601 maepad_message("Reading database file: %s", filename);
3602
3603 int rc;
3604 sqlite3_stmt *stmt = NULL;
3605
3606 rc = sqlite3_open(filename, &mainview->db);
3607 do
3608 {
3609 if (rc)
3610 {
3611 maepad_warning("Cannot open database %s: %s", filename, sqlite3_errmsg(mainview->db));
3612 break;
3613 }
3614
3615 sqlite3_exec(mainview->db, "PRAGMA synchronous = OFF;", NULL, NULL, NULL);
3616
3617 char *q = "SELECT skey, sval FROM settings";
3618 const char *dum;
3619
3620 rc = sqlite3_prepare(mainview->db, q, strlen(q), &stmt, &dum);
3621 if (rc)
3622 {
3623 maepad_warning("Error reading settings: %s", sqlite3_errmsg(mainview->db));
3624 break;
3625 }
3626
3627 unsigned int selectedCard = 0;
3628 unsigned int curDataVersion = 0;
3629 unsigned int curChecklistVersion = 0;
3630
3631 rc = SQLITE_BUSY;
3632 while(rc == SQLITE_BUSY || rc == SQLITE_ROW)
3633 {
3634 rc = sqlite3_step(stmt);
3635 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
3636 break;
3637 else if (rc == SQLITE_ROW)
3638 {
3639 const gchar* col_key = (const gchar*)sqlite3_column_text(stmt, 0);
3640 const gchar* col_val = (const gchar*)sqlite3_column_text(stmt, 1);
3641 if (!strcmp(col_key, "selectedNode"))
3642 {
3643 gint tmp = atoi((char *)col_val);
3644
3645 if (tmp > 0)
3646 selectedCard = tmp;
3647 }
3648 if (!strcmp(col_key, "dataVersion"))
3649 {
3650 gint tmp = atoi((char *)col_val);
3651
3652 if (tmp > 0)
3653 curDataVersion = tmp;
3654 }
3655 if (!strcmp(col_key, "checklistVersion"))
3656 {
3657 gint tmp = atoi((char *)col_val);
3658
3659 if (tmp > 0)
3660 curChecklistVersion = tmp;
3661 }
3662 if (!strcmp(col_key, "newNodeDlgCreateChild"))
3663 {
3664 gint tmp = atoi((char *)col_val);
3665
3666 mainview->newnodedialog_createchild = TRUE;
3667 if (tmp == 0)
3668 mainview->newnodedialog_createchild = FALSE;
3669 }
3670 if (!strcmp(col_key, "brushSize"))
3671 {
3672 gint tmp = atoi((char *)col_val);
3673 if (tmp>0) sk_set_brushsize(mainview, tmp);
3674 }
3675 if (!strcmp(col_key, "brushColor"))
3676 {
3677 unsigned long tmp = atol((char *)col_val);
3678 GdkColor c2;
3679
3680 c2.red = ((tmp & 0xFF0000) >> 16) << 8;
3681 c2.green = ((tmp & 0xFF00) >> 8) << 8;
3682 c2.blue = (tmp & 0xFF) << 8;
3683 sketchwidget_set_brushcolor(mainview->sk, c2);
3684
3685 if (mainview->current_color != NULL) {
3686 gdk_color_free(mainview->current_color);
3687 }
3688 mainview->current_color = gdk_color_copy(&c2);
3689 }
3690
3691 }
3692 }
3693 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE)
3694 {
3695 maepad_warning("Error reading data: %s", sqlite3_errmsg(mainview->db));
3696 break;
3697 }
3698
3699 if (stmt) {
3700 sqlite3_finalize(stmt);
3701 stmt = NULL;
3702 }
3703
3704 gboolean resback = FALSE;
3705
3706 while(curDataVersion < datatableversion)
3707 {
3708 if (curDataVersion == 0)
3709 {
3710 g_snprintf(tq, sizeof(tq), "DROP TABLE %s", datatable_backupname);
3711 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3712
3713 g_snprintf(tq, sizeof(tq), "ALTER TABLE %s RENAME TO %s", datatable_name, datatable_backupname);
3714 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0) {
3715 maepad_warning("Error backing up table %s to %s", datatable_name, datatable_backupname);
3716 break;
3717 }
3718 resback = TRUE;
3719
3720 g_snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", datatable_name, datatable);
3721 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0) {
3722 maepad_warning("Error creating table: %s", datatable_name);
3723 break;
3724 }
3725 g_snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT nodeid, parent, bodytype, name, body, nameblob, bodyblob, lastmodified, ord, 0 FROM %s", datatable_name, datatable_backupname);
3726 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0) {
3727 maepad_warning("Error copying data from %s to %s", datatable_name, datatable_backupname);
3728 break;
3729 }
3730
3731 g_snprintf(tq, sizeof(tq), "DROP TABLE %s", datatable_backupname);
3732 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3733
3734 curDataVersion = datatableversion;
3735 }
3736 break;
3737 }
3738
3739 if (curDataVersion != datatableversion)
3740 {
3741 maepad_warning("Data table version mismatch: %d <=> %d", curDataVersion, datatableversion);
3742
3743 if (resback == TRUE)
3744 {
3745 g_snprintf(tq, sizeof(tq), "DROP TABLE %s", datatable_name);
3746 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3747 g_snprintf(tq, sizeof(tq), "ALTER TABLE %s RENAME TO %s", datatable_backupname, datatable_name);
3748 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3749 }
3750
3751 break;
3752 }
3753
3754
3755 while(curChecklistVersion < checklisttableversion)
3756 {
3757 if (curChecklistVersion == 0) /*no checklisttable at all*/
3758 {
3759 g_snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", checklisttable_name, checklisttable);
3760 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0) {
3761 maepad_warning("Error creating checklist table during schema upgrade");
3762 break;
3763 }
3764 curChecklistVersion = checklisttableversion;
3765 }
3766 break;
3767 }
3768
3769
3770 GtkTreeStore *model = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview)));
3771
3772 g_object_ref(model);
3773 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), NULL);
3774
3775 do
3776 {
3777 char tq[512];
3778
3779 g_snprintf(tq, sizeof(tq), "CREATE%s TABLE %s%s", TEMPTABLE_KEYWORD, datatable_tmpname, datatable);
3780 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0) {
3781 maepad_warning("Error creating temp table: %s", datatable_tmpname);
3782 break;
3783 }
3784 g_snprintf(tq, sizeof(tq), "CREATE INDEX %s_index ON %s %s", datatable_tmpname, datatable_tmpname, dataindex);
3785 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0) {
3786 maepad_warning("Error creating temp index for %s", datatable_tmpname);
3787 break;
3788 }
3789 g_snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", datatable_tmpname, datatable_name);
3790 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0) {
3791 maepad_warning("Error copying data from %s to %s", datatable_name, datatable_tmpname);
3792 break;
3793 }
3794
3795 g_snprintf(tq, sizeof(tq), "CREATE%s TABLE %s%s", TEMPTABLE_KEYWORD, checklisttable_tmpname, checklisttable);
3796 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0) {
3797 maepad_warning("Error creating temp table: %s", checklisttable_tmpname);
3798 break;
3799 }
3800 g_snprintf(tq, sizeof(tq), "CREATE INDEX %s_index ON %s %s", checklisttable_tmpname, checklisttable_tmpname, checklistindex);
3801 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0) {
3802 maepad_warning("Error creating temp index for %s", checklisttable_tmpname);
3803 break;
3804 }
3805 g_snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", checklisttable_tmpname, checklisttable_name);
3806 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0) {
3807 maepad_warning("Error copying data from %s to %s", checklisttable_name, checklisttable_tmpname);
3808 break;
3809 }
3810 }
3811 while(FALSE);
3812
3813 GtkTreeRowReference *selectedRef = read_sqlite3_data(mainview, 0, NULL, selectedCard, model);
3814
3815 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), GTK_TREE_MODEL(model));
3816 g_object_unref(model);
3817 gtk_tree_view_expand_all(GTK_TREE_VIEW(mainview->treeview));
3818
3819 if (selectedRef != NULL)
3820 {
3821 GtkTreeIter seliter;
3822
3823 if (ref2iter(GTK_TREE_MODEL(model), selectedRef, &seliter) == TRUE)
3824 {
3825 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
3826 gtk_tree_selection_select_iter(selection, &seliter);
3827 }
3828
3829 gtk_tree_row_reference_free(selectedRef);
3830 }
3831 res = TRUE;
3832 }
3833 while(FALSE);
3834
3835 if (stmt) {
3836 sqlite3_finalize(stmt);
3837 }
3838
3839
3840 mainview->loading=FALSE;
3841
3842 return (res);
3843 }
3844
3845 /*
3846 * write to file
3847 */
3848 void write_buffer_to_file(MainView * mainview)
3849 {
3850 maepad_message("Writing database to file: %s", mainview->file_name);
3851 saveCurrentData(mainview);
3852
3853 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview));
3854 /*update ord value in database for all nodes*/
3855 gtk_tree_model_foreach(GTK_TREE_MODEL(model),(GtkTreeModelForeachFunc) foreach_func_update_ord,mainview);
3856
3857 busy_enter(mainview);
3858
3859 char tq[512];
3860
3861 g_snprintf(tq, sizeof(tq), "DROP TABLE %s", misctable_name);
3862 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3863
3864 g_snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", misctable_name, misctable);
3865 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3866
3867 gint nndcc = 1;
3868
3869 if (mainview->newnodedialog_createchild == FALSE)
3870 nndcc = 0;
3871 g_snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('newNodeDlgCreateChild', '%d');", misctable_name, nndcc);
3872 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3873
3874 nodeData *node = getSelectedNode(mainview);
3875
3876 if (node)
3877 {
3878 g_snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('selectedNode', '%d');", misctable_name, node->sql3id);
3879 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3880 }
3881
3882 guint bsize = sketchwidget_get_brushsize(mainview->sk);
3883 g_snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('brushSize', '%d');", misctable_name, bsize);
3884 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3885
3886 if (mainview->current_color == NULL) {
3887 GdkColor color = {0, 0, 0, 0};
3888 mainview->current_color = gdk_color_copy(&color);
3889 }
3890 unsigned long bcol = ((mainview->current_color->red >> 8) << 16) |
3891 ((mainview->current_color->green >> 8) << 8) |
3892 ((mainview->current_color->blue) >> 8);
3893
3894 g_snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('brushColor', '%lu');", misctable_name, bcol);
3895 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3896
3897 g_snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('dataVersion', '%d');", misctable_name, datatableversion);
3898 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3899
3900 g_snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('checklistVersion', '%d');", misctable_name, checklisttableversion);
3901 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3902
3903 g_snprintf(tq, sizeof(tq), "DROP TABLE %s", datatable_backupname);
3904 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3905 g_snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", datatable_backupname, datatable);
3906 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3907 {
3908 maepad_warning("Error creating backup table: %s", datatable_backupname);
3909 show_banner(mainview, _("Error creating backup table"));
3910
3911 busy_leave(mainview);
3912 return;
3913 }
3914 g_snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", datatable_backupname, datatable_name);
3915 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3916 {
3917 maepad_warning("Error backing up table %s to %s", datatable_name, datatable_backupname);
3918 show_banner(mainview, _("Error creating backup table"));
3919
3920 busy_leave(mainview);
3921 return;
3922 }
3923 g_snprintf(tq, sizeof(tq), "DELETE FROM %s", datatable_name);
3924 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3925
3926 g_snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", datatable_name, datatable_tmpname);
3927 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3928 {
3929 maepad_warning("Error saving table %s to %s", datatable_tmpname, datatable_name);
3930 show_banner(mainview, _("Error saving table"));
3931
3932 g_snprintf(tq, sizeof(tq), "DELETE FROM %s", datatable_name);
3933 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3934
3935 g_snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", datatable_name, datatable_backupname);
3936 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0) {
3937 maepad_warning("Error restoring backup. Data lost :(");
3938 }
3939
3940 busy_leave(mainview);
3941 return;
3942 }
3943
3944 g_snprintf(tq, sizeof(tq), "DROP TABLE %s", datatable_backupname);
3945 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3946
3947 /*checklist*/
3948 g_snprintf(tq, sizeof(tq), "DROP TABLE %s", checklisttable_backupname);
3949 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3950 g_snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", checklisttable_backupname, checklisttable);
3951 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3952 {
3953 maepad_warning("Error creating backup table: %s", checklisttable_backupname);
3954 show_banner(mainview, _("Error creating checklist backup table"));
3955
3956 busy_leave(mainview);
3957 return;
3958 }
3959
3960 g_snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", checklisttable_backupname, checklisttable_name);
3961 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3962 {
3963 maepad_warning("Error backing up table %s to %s", checklisttable_name, checklisttable_backupname);
3964 show_banner(mainview, _("Error creating checklist backup table"));
3965
3966 busy_leave(mainview);
3967 return;
3968 }
3969 g_snprintf(tq, sizeof(tq), "DELETE FROM %s", checklisttable_name);
3970 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3971
3972 g_snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", checklisttable_name, checklisttable_tmpname);
3973 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3974 {
3975 maepad_warning("Error saving table %s to %s", checklisttable_tmpname, checklisttable_name);
3976 show_banner(mainview, _("Error saving checklist table"));
3977
3978 g_snprintf(tq, sizeof(tq), "DELETE FROM %s", checklisttable_name);
3979 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3980
3981 g_snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", checklisttable_name, checklisttable_backupname);
3982 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0) {
3983 maepad_warning("Error restoring backup. Data lost :(");
3984 }
3985 busy_leave(mainview);
3986 return;
3987 }
3988
3989 g_snprintf(tq, sizeof(tq), "DROP TABLE %s", checklisttable_backupname);
3990 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3991
3992 mainview->file_edited = FALSE;
3993 busy_leave(mainview);
3994 show_banner(mainview, _("Changes saved"));
3995 }
3996
3997 void callback_checklist_change(GtkTreeSelection *selection, MainView *mainview)
3998 {
3999 g_assert(mainview != NULL && mainview->data != NULL);
4000
4001 g_signal_handlers_block_by_func(mainview->bold_tb, callback_fontstyle, mainview->bold_tb);
4002 g_signal_handlers_block_by_func(mainview->strikethru_tb, callback_fontstyle, mainview->strikethru_tb);
4003 g_signal_handlers_block_by_func(mainview->check_tb, callback_fontstyle, mainview->check_tb);
4004
4005 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->bold_tb), FALSE);
4006 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->strikethru_tb), FALSE);
4007 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->check_tb), FALSE);
4008
4009 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
4010 GList* l=gtk_tree_selection_get_selected_rows(selection, NULL);
4011
4012 gboolean gotit=FALSE;
4013
4014 GList* cur=l;
4015 while(cur)
4016 {
4017 GtkTreePath *path=cur->data;
4018
4019 if (!gotit)
4020 {
4021 GtkTreeIter iter;
4022 if (gtk_tree_model_get_iter(model, &iter, path))
4023 {
4024 gint styletoset_weight;
4025 gboolean styletoset_strike;
4026 gboolean ischecked;
4027
4028 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, CHECKNODE_BOLD, &styletoset_weight, CHECKNODE_STRIKE, &styletoset_strike, CHECKNODE_CHECKED, &ischecked, -1);
4029 if (styletoset_weight==PANGO_WEIGHT_BOLD) gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->bold_tb), TRUE);
4030 if (styletoset_strike==TRUE) gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->strikethru_tb), TRUE);
4031 if (ischecked==TRUE) gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->check_tb), TRUE);
4032 gotit=TRUE;
4033 }
4034 }
4035 gtk_tree_path_free(path);
4036 cur=cur->next;
4037 }
4038
4039 g_list_free(l);
4040
4041 g_signal_handlers_unblock_by_func(mainview->bold_tb, callback_fontstyle, mainview->bold_tb);
4042 g_signal_handlers_unblock_by_func(mainview->strikethru_tb, callback_fontstyle, mainview->strikethru_tb);
4043 g_signal_handlers_unblock_by_func(mainview->check_tb, callback_fontstyle, mainview->check_tb);
4044 }
4045
4046 void callback_checklist_paste(MainView *mainview)
4047 {
4048 g_assert(mainview != NULL && mainview->data != NULL);
4049 gchar **entries;
4050 gint length, i;
4051
4052 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
4053 GtkTreeIter toplevel;
4054 gchar *pasted_text = gtk_clipboard_wait_for_text(mainview->clipboard);
4055
4056 entries = g_strsplit(pasted_text, "\n", 0);
4057 length = g_strv_length(entries);
4058
4059 for (i=0; i<length; i++) {
4060 gtk_list_store_append(GTK_LIST_STORE(model), &toplevel);
4061 gtk_list_store_set(GTK_LIST_STORE(model), &toplevel, CHECKNODE_CHECKED, FALSE, CHECKNODE_TEXT, entries[i], -1);
4062 }
4063
4064 mainview->checklist_edited = TRUE;
4065 g_free(pasted_text);
4066 g_strfreev(entries);
4067 }
4068
4069 void callback_checklist_add(GtkAction *action, MainView *mainview)
4070 {
4071 g_assert(mainview != NULL && mainview->data != NULL);
4072
4073 gchar* text = show_line_edit_dialog(mainview, _("Add new checklist item"), _("Name:"), _("Add"), "");
4074
4075 if (text != NULL) {
4076 GtkTreeModel* model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
4077 GtkTreeIter toplevel;
4078 gtk_list_store_append(GTK_LIST_STORE(model), &toplevel);
4079
4080 gtk_list_store_set(GTK_LIST_STORE(model),
4081 &toplevel,
4082 CHECKNODE_CHECKED, FALSE,
4083 CHECKNODE_TEXT, text,
4084 -1);
4085
4086 GtkTreePath *path = gtk_tree_model_get_path(model, &toplevel);
4087 if (path) {
4088 gtk_tree_view_set_cursor(GTK_TREE_VIEW(mainview->listview), path, mainview->checklist_column_text, FALSE);
4089 gtk_tree_path_free(path);
4090 }
4091
4092 mainview->checklist_edited = TRUE;
4093 }
4094 }
4095
4096 void
4097 checklist_edit_selected(MainView* mainview, LineEditMode mode)
4098 {
4099 GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->listview));
4100
4101 if (gtk_tree_selection_count_selected_rows(selection) == 0) {
4102 show_banner(mainview, _("Select items first"));
4103 return;
4104 }
4105
4106 GtkTreeModel* model;
4107 GtkTreeIter iter;
4108
4109 if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
4110 gchar* old_text = NULL;
4111 gtk_tree_model_get(model, &iter, CHECKNODE_TEXT, &old_text, -1);
4112
4113 gchar* new_text = show_line_edit_dialog_full(mainview, _("Edit checklist item"), _("New name:"), _("Save"), old_text, mode);
4114
4115 if (new_text != NULL) {
4116 gtk_list_store_set(GTK_LIST_STORE(model), &iter, CHECKNODE_TEXT, new_text, -1);
4117 mainview->checklist_edited = TRUE;
4118 g_free(new_text);
4119 }
4120
4121 g_free(old_text);
4122 }
4123 }
4124
4125 void callback_checklist_edit(GtkAction *action, MainView *mainview)
4126 {
4127 g_assert(mainview != NULL && mainview->data != NULL);
4128 checklist_edit_selected(mainview, LINE_EDIT_MODE_DEFAULT);
4129 }
4130
4131 void callback_checklist_delete(GtkAction *action, MainView *mainview)
4132 {
4133 g_assert(mainview != NULL && mainview->data != NULL);
4134
4135 if (gtk_tree_selection_count_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->listview)))==0) {
4136 show_banner(mainview, _("Select items first"));
4137 return;
4138 }
4139
4140 if (show_confirmation(mainview, _("Delete selected checklist item?"))) {
4141 callback_checklist_delete_real(mainview);
4142 }
4143 }
4144
4145 void callback_checklist_delete_real(MainView* mainview)
4146 {
4147 GtkTreeModel *model=gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
4148 GList* l=gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->listview)), NULL);
4149
4150 /* Select the item after the selection */
4151 checklist_select(mainview, TREEVIEW_SELECT_NEXT);
4152
4153 GList* rowrefs=NULL;
4154 GList* cur=l;
4155 while(cur)
4156 {
4157 GtkTreePath *path=cur->data;
4158
4159 GtkTreeIter iter;
4160 if (gtk_tree_model_get_iter(model, &iter, path))
4161 {
4162 GtkTreeRowReference *rowref = gtk_tree_row_reference_new(model, path);
4163 rowrefs=g_list_append(rowrefs, rowref);
4164 }
4165 gtk_tree_path_free(path);
4166 cur=cur->next;
4167 }
4168 g_list_free(l);
4169 checklist_remove_rowrefs(mainview, rowrefs, FALSE);
4170 }
4171
4172 void
4173 checklist_remove_rowrefs(MainView* mainview, GList* rowrefs, gboolean show_result)
4174 {
4175 GtkTreeModel* model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
4176 GList* cur = rowrefs;
4177 gint count = 0;
4178
4179 busy_enter(mainview);
4180
4181 while (cur) {
4182 GtkTreeRowReference* rowref = cur->data;
4183 GtkTreePath* path = gtk_tree_row_reference_get_path(rowref);
4184 if (path != NULL) {
4185 GtkTreeIter iter;
4186 if (gtk_tree_model_get_iter(model, &iter, path)) {
4187 gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
4188 count++;
4189 }
4190 gtk_tree_path_free(path);
4191 }
4192 gtk_tree_row_reference_free(rowref);
4193 cur = cur->next;
4194 }
4195 g_list_free(rowrefs);
4196
4197 busy_leave(mainview);
4198
4199 if (count && show_result) {
4200 gchar* message = g_strdup_printf(N_("%d item removed", "%d items removed", count), count);
4201 show_banner(mainview, message);
4202 g_free(message);
4203 }
4204
4205 mainview->checklist_edited = TRUE;
4206 }
4207
4208 /* Private callback for show_confirmation() - handle keyboard input */
4209 gboolean
4210 on_confirmation_key_press_event(GtkWidget* widget, GdkEventKey* event, gpointer user_data)
4211 {
4212 GtkDialog* dialog = GTK_DIALOG(widget);
4213
4214 switch (event->keyval) {
4215 /* Positive response - Enter, Return or y */
4216 case GDK_KP_Enter:
4217 case GDK_Return:
4218 case GDK_y:
4219 case GDK_Y:
4220 gtk_dialog_response(dialog, GTK_RESPONSE_OK);
4221 return TRUE;
4222
4223 /* Negative response - Backspace, Escape or n */
4224 case GDK_BackSpace:
4225 case GDK_Escape:
4226 case GDK_n:
4227 case GDK_N:
4228 gtk_dialog_response(dialog, GTK_RESPONSE_CANCEL);
4229 return TRUE;
4230
4231 /* Don't handle the rest of the keys */
4232 default:
4233 return FALSE;
4234 }
4235 }
4236
4237
4238 /* Ask the user for confirmation of a specific action */
4239 gboolean
4240 show_confirmation(MainView* mainview, gchar* question)
4241 {
4242 GtkDialog* dialog = GTK_DIALOG(hildon_note_new_confirmation(
4243 GTK_WINDOW(mainview->data->main_view), question));
4244 gtk_window_set_transient_for(GTK_WINDOW(dialog), mainview_get_dialog_parent(mainview));
4245 g_signal_connect(G_OBJECT(dialog), "key-press-event",
4246 G_CALLBACK(on_confirmation_key_press_event), NULL);
4247
4248 gint response = gtk_dialog_run(dialog);
4249 gtk_widget_destroy(GTK_WIDGET(dialog));
4250
4251 return (response == GTK_RESPONSE_OK);
4252 }
4253
4254 /* Show a information banner to the user (non-modal) */
4255 void
4256 show_banner(MainView* mainview, const gchar* text)
4257 {
4258 hildon_banner_show_information(GTK_WIDGET(mainview_get_dialog_parent(mainview)), NULL, text);
4259 }
4260
4261 typedef struct {
4262 GtkWidget* dialog;
4263 gboolean can_close_window;
4264 } LineEditDialogData;
4265
4266 /* Helper function to close line edit dialog on Backspace */
4267 gboolean
4268 line_edit_dialog_key_press(GtkWidget* w, GdkEventKey* event, gpointer user_data)
4269 {
4270 LineEditDialogData* dialogdata = (LineEditDialogData*)user_data;
4271 GtkEntry* entry = GTK_ENTRY(w);
4272
4273 if (event->keyval == GDK_BackSpace &&
4274 dialogdata->can_close_window &&
4275 strcmp(gtk_entry_get_text(entry), "") == 0) {
4276 gtk_dialog_response(GTK_DIALOG(dialogdata->dialog), GTK_RESPONSE_CANCEL);
4277 return TRUE;
4278 }
4279
4280 return FALSE;
4281 }
4282
4283 /* Let the user enter or edit a line of text */
4284 gchar*
4285 show_line_edit_dialog_full(MainView* mainview, const gchar* title,
4286 const gchar* label_text, const gchar* action, const gchar* text,
4287 LineEditMode mode)
4288 {
4289 GtkWidget* edit_dialog;
4290 GtkWidget* label;
4291 GtkWidget* entry;
4292 GtkWidget* hbox;
4293 gchar* result = NULL;
4294 LineEditDialogData dialogdata;
4295
4296 edit_dialog = GTK_WIDGET(gtk_dialog_new());
4297 gtk_window_set_title(GTK_WINDOW(edit_dialog), title);
4298 gtk_window_set_transient_for(GTK_WINDOW(edit_dialog), mainview_get_dialog_parent(mainview));
4299
4300 label = GTK_WIDGET(gtk_label_new(label_text));
4301
4302 entry = hildon_entry_new(HILDON_SIZE_AUTO);
4303 gtk_entry_set_text(GTK_ENTRY(entry), text);
4304 gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
4305 switch (mode) {
4306 case LINE_EDIT_MODE_DEFAULT:
4307 gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
4308 break;
4309 case LINE_EDIT_MODE_APPEND:
4310 gtk_editable_select_region(GTK_EDITABLE(entry), -1, -1);
4311 break;
4312 case LINE_EDIT_MODE_PREPEND:
4313 gtk_editable_select_region(GTK_EDITABLE(entry), 0, 0);
4314 break;
4315 default:
4316 break;
4317 }
4318
4319 gtk_dialog_add_button(GTK_DIALOG(edit_dialog), action, GTK_RESPONSE_OK);
4320 gtk_dialog_set_default_response(GTK_DIALOG(edit_dialog), GTK_RESPONSE_OK);
4321
4322 dialogdata.dialog = edit_dialog;
4323 dialogdata.can_close_window = (strcmp(text, "") == 0);
4324 g_signal_connect(G_OBJECT(entry), "key-press-event", G_CALLBACK(line_edit_dialog_key_press), &dialogdata);
4325
4326 hbox = GTK_WIDGET(gtk_hbox_new(FALSE, 10));
4327
4328 gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(edit_dialog))), GTK_WIDGET(hbox));
4329 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
4330 gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
4331
4332 gtk_widget_show_all(GTK_WIDGET(hbox));
4333
4334 while (TRUE) {
4335 if (gtk_dialog_run(GTK_DIALOG(edit_dialog)) == GTK_RESPONSE_OK) {
4336 result = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
4337 if (strcmp(result, "") != 0) {
4338 break;
4339 } else {
4340 show_banner(mainview, _("Please enter a non-empty text"));
4341 g_free(result);
4342 result = NULL;
4343 }
4344 } else {
4345 result = NULL;
4346 break;
4347 }
4348 }
4349
4350 gtk_widget_destroy(GTK_WIDGET(edit_dialog));
4351 return result;
4352 }
4353
4354 void
4355 treeview_scroll_to_selection(MainView* mainview, TreeViewType type)
4356 {
4357 GtkTreeView* treeview = NULL;
4358 HildonPannableArea* pannable_area = NULL;
4359 GtkTreeModel* model = NULL;
4360 GtkTreeSelection* selection = NULL;
4361 GtkTreePath* path = NULL;
4362 GtkTreeIter iter;
4363 GdkRectangle rect;
4364 gint y;
4365
4366 switch (type) {
4367 case TREEVIEW_MAINVIEW:
4368 treeview = GTK_TREE_VIEW(mainview->treeview);
4369 pannable_area = HILDON_PANNABLE_AREA(mainview->scrolledtree);
4370 break;
4371 case TREEVIEW_CHECKLIST:
4372 treeview = GTK_TREE_VIEW(mainview->listview);
4373 pannable_area = HILDON_PANNABLE_AREA(mainview->listscroll);
4374 break;
4375 default:
4376 g_assert_not_reached();
4377 break;
4378 }
4379
4380 /* Let the view scroll so that the selected item is visible */
4381 selection = gtk_tree_view_get_selection(treeview);
4382 if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
4383 path = gtk_tree_model_get_path(model, &iter);
4384
4385 gtk_tree_view_get_background_area(treeview, path, NULL, &rect);
4386 gtk_tree_view_convert_bin_window_to_tree_coords(treeview,
4387 0, rect.y, NULL, &y);
4388 hildon_pannable_area_scroll_to(pannable_area, -1, y);
4389
4390 gtk_tree_path_free(path);
4391 }
4392 }
4393
4394 gboolean
4395 checklist_scroll_to_selection(gpointer user_data)
4396 {
4397 MainView* mainview = (MainView*)user_data;
4398 treeview_scroll_to_selection(mainview, TREEVIEW_CHECKLIST);
4399 return FALSE;
4400 }
4401
4402 gboolean
4403 nodelist_scroll_to_selection(gpointer user_data)
4404 {
4405 MainView* mainview = (MainView*)user_data;
4406 treeview_scroll_to_selection(mainview, TREEVIEW_MAINVIEW);
4407 return FALSE;
4408 }
4409
4410 void
4411 checklist_select(MainView* mainview, TreeviewSelectType type)
4412 {
4413 GtkTreeModel* model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
4414 GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->listview));
4415 GtkTreeIter iter;
4416 GtkTreeIter last;
4417 GtkTreePath* path;
4418
4419 switch (type) {
4420 case TREEVIEW_SELECT_FIRST:
4421 if (gtk_tree_model_get_iter_first(model, &iter)) {
4422 path = gtk_tree_model_get_path(model, &iter);
4423 gtk_tree_selection_select_path(selection, path);
4424 gtk_tree_path_free(path);
4425 }
4426 break;
4427 case TREEVIEW_SELECT_LAST:
4428 if (gtk_tree_model_get_iter_first(model, &iter)) {
4429 do {
4430 last = iter;
4431 } while (gtk_tree_model_iter_next(model, &iter));
4432 path = gtk_tree_model_get_path(model, &last);
4433 gtk_tree_selection_select_path(selection, path);
4434 gtk_tree_path_free(path);
4435 }
4436 break;
4437 case TREEVIEW_SELECT_PREVIOUS:
4438 if (gtk_tree_selection_get_selected(selection, NULL, &iter)) {
4439 path = gtk_tree_model_get_path(model, &iter);
4440 if (gtk_tree_path_prev(path)) {
4441 gtk_tree_selection_select_path(selection, path);
4442 }
4443 gtk_tree_path_free(path);
4444 }
4445 break;
4446 case TREEVIEW_SELECT_NEXT:
4447 if (gtk_tree_selection_get_selected(selection, NULL, &iter)) {
4448 path = gtk_tree_model_get_path(model, &iter);
4449 gtk_tree_path_next(path);
4450 gtk_tree_selection_select_path(selection, path);
4451 gtk_tree_path_free(path);
4452 }
4453 break;
4454 default:
4455 g_assert_not_reached();
4456 break;
4457 }
4458
4459 checklist_scroll_to_selection(mainview);
4460
4461 /**
4462 * This is a workaround: The HildonPannableArea does not seem to
4463 * scroll to the right position (especially when going to the first
4464 * or last item in the list), so we simply scroll again after 500ms.
4465 **/
4466 g_timeout_add(500, checklist_scroll_to_selection, mainview);
4467 }
4468
4469 void
4470 nodelist_select(MainView* mainview, TreeviewSelectType type)
4471 {
4472 GtkTreeView* treeview = GTK_TREE_VIEW(mainview->treeview);
4473 GtkTreeModel* model = gtk_tree_view_get_model(treeview);
4474 GtkTreeSelection* selection = gtk_tree_view_get_selection(treeview);
4475 GtkTreeIter iter;
4476 GtkTreeIter last;
4477 GtkTreeIter child;
4478 GtkTreePath* path;
4479
4480 switch (type) {
4481 case TREEVIEW_SELECT_FIRST:
4482 if (gtk_tree_model_get_iter_first(model, &iter)) {
4483 path = gtk_tree_model_get_path(model, &iter);
4484 gtk_tree_selection_select_path(selection, path);
4485 gtk_tree_path_free(path);
4486 }
4487 break;
4488 case TREEVIEW_SELECT_LAST:
4489 if (gtk_tree_model_get_iter_first(model, &iter)) {
4490 do {
4491 last = iter;
4492 if (gtk_tree_model_iter_children(model, &child, &last)) {
4493 do {
4494 last = child;
4495 } while (gtk_tree_model_iter_next(model, &child));
4496 }
4497 } while (gtk_tree_model_iter_next(model, &iter));
4498 path = gtk_tree_model_get_path(model, &last);
4499 gtk_tree_selection_select_path(selection, path);
4500 gtk_tree_path_free(path);
4501 }
4502 break;
4503 case TREEVIEW_SELECT_PREVIOUS:
4504 if (gtk_tree_selection_get_selected(selection, NULL, &iter)) {
4505 path = gtk_tree_model_get_path(model, &iter);
4506 if (gtk_tree_path_prev(path)) {
4507 gtk_tree_selection_select_path(selection, path);
4508 } else if (gtk_tree_path_up(path)) {
4509 gtk_tree_selection_select_path(selection, path);
4510 }
4511 gtk_tree_path_free(path);
4512 }
4513 break;
4514 case TREEVIEW_SELECT_NEXT:
4515 if (gtk_tree_selection_get_selected(selection, NULL, &iter)) {
4516 path = gtk_tree_model_get_path(model, &iter);
4517 gtk_tree_path_down(path);
4518 while (!gtk_tree_model_get_iter(model, &iter, path)) {
4519 /* Child item does not exist - bubble up to next item */
4520 gtk_tree_path_up(path);
4521 gtk_tree_path_next(path);
4522
4523 if (gtk_tree_path_get_depth(path) == 0) {
4524 /* avoid infinite loops */
4525 break;
4526 }
4527 }
4528
4529 if (gtk_tree_model_get_iter(model, &iter, path)) {
4530 gtk_tree_selection_select_path(selection, path);
4531 }
4532
4533 gtk_tree_path_free(path);
4534 }
4535 break;
4536 default:
4537 g_assert_not_reached();
4538 break;
4539 }
4540
4541 nodelist_scroll_to_selection(mainview);
4542
4543 /**
4544 * This is a workaround: The HildonPannableArea does not seem to
4545 * scroll to the right position (especially when going to the first
4546 * or last item in the list), so we simply scroll again after 500ms.
4547 **/
4548 g_timeout_add(500, nodelist_scroll_to_selection, mainview);
4549 }
4550
MaePad - A node-based memory pad for Maemo