?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
added minimal RTF support
[maemopadplus.git] / src / ui / callbacks.c
blobb264af3b8870a7ac63aa298b35fa9508baccd205
1 /*
2 * This file is part of maemopad+
3 *
4 *
5 * This software is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public License
7 * as published by the Free Software Foundation; either version 2.1 of
8 * the License, or (at your option) any later version.
9 *
10 * This software is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this software; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
18 * 02110-1301 USA
19 *
20 */
21
22 #include <ui/callbacks.h>
23 #include <ui/interface.h>
24 #include <gtk/gtk.h>
25 #include <gdk/gdkkeysyms.h>
26 #include <libintl.h>
27
28 /*
29 * strlen needed from string.h
30 */
31 #include <string.h>
32 #include <sys/types.h>
33 #include <sys/stat.h>
34 #include <unistd.h>
35 #include <stdlib.h>
36 #include <hildon-widgets/hildon-banner.h>
37 #include <hildon-widgets/hildon-note.h>
38 #include <hildon-widgets/hildon-font-selection-dialog.h>
39 #include <libgnomevfs/gnome-vfs.h>
40 #include <osso-browser-interface.h>
41
42 #include <config.h>
43
44 /*
45 * Privates:
46 */
47 gboolean read_file_to_buffer(MainView * mainview);
48 void write_buffer_to_file(MainView * mainview);
49 void new_node_dialog(nodeType typ, MainView * mainview);
50
51 /*
52 st==0: turn off/zero refcount
53 st==1: turn on/increase ref
54 st==2: decrease refcount and turn off if necessary
55 */
56 void setBusy(MainView *mainview, gchar st)
57 {
58 if (st==0) mainview->busyrefcount=0;
59 else if (st==1) mainview->busyrefcount++;
60 else if (st==2 && mainview->busyrefcount>0) mainview->busyrefcount--;
61 gdk_window_set_cursor(GTK_WIDGET(mainview->data->main_view)->window, (mainview->busyrefcount>0)?mainview->cursorBusy:NULL);
62 }
63
64 gboolean isBusy(MainView *mainview)
65 {
66 if (mainview->busyrefcount>0) return(TRUE);
67 return(FALSE);
68 }
69
70 void prepareUIforNodeChange(MainView * mainview, nodeType typ)
71 {
72 if (typ == NODE_TEXT)
73 {
74 gtk_widget_show(GTK_WIDGET(mainview->font_tb));
75 gtk_widget_show(GTK_WIDGET(mainview->bold_tb));
76 gtk_widget_show(GTK_WIDGET(mainview->italic_tb));
77 gtk_widget_show(GTK_WIDGET(mainview->underline_tb));
78 gtk_widget_show(mainview->tools_font);
79 gtk_widget_show(mainview->tools_wordwrap);
80 }
81 else
82 {
83 gtk_widget_hide(GTK_WIDGET(mainview->font_tb));
84 gtk_widget_hide(GTK_WIDGET(mainview->bold_tb));
85 gtk_widget_hide(GTK_WIDGET(mainview->italic_tb));
86 gtk_widget_hide(GTK_WIDGET(mainview->underline_tb));
87 gtk_widget_hide(mainview->tools_font);
88 gtk_widget_hide(mainview->tools_wordwrap);
89 }
90
91 if (typ == NODE_SKETCH)
92 {
93 gtk_widget_show(GTK_WIDGET(mainview->colorbutton_tb));
94 gtk_widget_show(GTK_WIDGET(mainview->eraser_tb));
95 gtk_widget_show(GTK_WIDGET(mainview->brushsize_tb));
96 gtk_widget_show(GTK_WIDGET(mainview->sketchlines_tb));
97 gtk_widget_show(GTK_WIDGET(mainview->shape_tb));
98 gtk_widget_show(GTK_WIDGET(mainview->undo_tb));
99 gtk_widget_show(GTK_WIDGET(mainview->redo_tb));
100 gtk_widget_show(mainview->tools_color);
101 gtk_widget_show(mainview->tools_brushsize);
102 gtk_widget_show(mainview->tools_pagestyle);
103 gtk_widget_show(mainview->tools_shape);
104 }
105 else
106 {
107 gtk_widget_hide(GTK_WIDGET(mainview->colorbutton_tb));
108 gtk_widget_hide(GTK_WIDGET(mainview->eraser_tb));
109 gtk_widget_hide(GTK_WIDGET(mainview->brushsize_tb));
110 gtk_widget_hide(GTK_WIDGET(mainview->sketchlines_tb));
111 gtk_widget_hide(GTK_WIDGET(mainview->shape_tb));
112 gtk_widget_hide(GTK_WIDGET(mainview->undo_tb));
113 gtk_widget_hide(GTK_WIDGET(mainview->redo_tb));
114 gtk_widget_hide(mainview->tools_color);
115 gtk_widget_hide(mainview->tools_brushsize);
116 gtk_widget_hide(mainview->tools_pagestyle);
117 gtk_widget_hide(mainview->tools_shape);
118 }
119
120 if (typ == NODE_TEXT)
121 {
122 gtk_widget_hide(sketchwidget_get_mainwidget(mainview->sk));
123 gtk_widget_show(GTK_WIDGET(mainview->scrolledwindow));
124 gtk_widget_show(mainview->tools_item);
125 }
126 else if (typ == NODE_SKETCH)
127 {
128 gtk_widget_hide(GTK_WIDGET(mainview->scrolledwindow));
129 gtk_widget_show(sketchwidget_get_mainwidget(mainview->sk));
130 gtk_widget_show(mainview->tools_item);
131 }
132 else
133 {
134 gtk_widget_hide(GTK_WIDGET(mainview->scrolledwindow));
135 gtk_widget_hide(sketchwidget_get_mainwidget(mainview->sk));
136 gtk_widget_hide(mainview->tools_item);
137 }
138 }
139
140 nodeData *getSelectedNode(MainView * mainview)
141 {
142 GtkTreeIter iter;
143 GtkTreeModel *model;
144
145 nodeData *nd;
146
147 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
148
149 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
150 return (NULL);
151
152 gtk_tree_model_get(model, &iter, NODE_DATA, &nd, -1);
153
154 return (nd);
155 }
156
157 void saveCurrentData(MainView * mainview)
158 {
159 nodeData *selnode = getSelectedNode(mainview);
160 saveDataToNode(mainview, selnode);
161 }
162
163 void saveDataToNode(MainView * mainview, nodeData *selnode)
164 {
165 if (selnode == NULL)
166 return;
167
168 if ((selnode->typ == NODE_SKETCH && sketchwidget_get_edited(mainview->sk) == FALSE)/* || (selnode->typ == NODE_TEXT && gtk_text_buffer_get_modified(GTK_TEXT_BUFFER(mainview->buffer)) == FALSE)*/)
169 {
170 fprintf(stderr, "node not edited, not saving\n");
171 return;
172 }
173
174 mainview->file_edited = TRUE;
175
176 setBusy(mainview, 1);
177 fprintf(stderr, "savecurrentdata!\n");
178
179 gboolean goterr = TRUE;
180 gchar *textdata = NULL;
181 GdkPixbuf *pixbuf = NULL;
182 gchar *sketchdata = NULL;
183 gsize datalen = 0;
184 char tq[512];
185
186 if (selnode->typ == NODE_TEXT)
187 {
188 GtkTextIter start, end;
189
190 gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(mainview->buffer), &start, &end);
191 /* textdata = gtk_text_buffer_get_slice(GTK_TEXT_BUFFER(mainview->buffer), &start, &end, TRUE);*/
192 textdata = gtk_text_buffer_serialize_rich_text(GTK_TEXT_BUFFER(mainview->buffer), &start, &end, &datalen);
193
194 /* 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);*/
195 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);
196 }
197 else if (selnode->typ == NODE_SKETCH)
198 {
199 GError *err = NULL;
200 GdkPixmap *skpix = sketchwidget_get_Pixmap(mainview->sk);
201 GtkWidget *skdr = sketchwidget_get_drawingarea(mainview->sk);
202
203 pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE(skpix), NULL, 0, 0, 0, 0, skdr->allocation.width, skdr->allocation.height);
204 if (pixbuf == NULL)
205 {
206 fprintf(stderr, "Error saving: pixbuf is null\n");
207 }
208 else
209 {
210 double w, h;
211 GdkPixbuf *pixbuf2 = sketchwidget_trim_image(pixbuf, skdr->allocation.width, skdr->allocation.height, &w, &h, FALSE);
212
213 if (pixbuf2!=NULL)
214 {
215 if (gdk_pixbuf_save_to_buffer(pixbuf2, &sketchdata, &datalen, "png", &err, NULL) == FALSE)
216 {
217 sketchdata = NULL;
218 datalen = 0;
219 fprintf(stderr, "Error saving sketch! %s\n", err->message);
220 g_error_free(err);
221 }
222 gdk_pixbuf_unref(pixbuf2);
223 }
224 }
225 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);
226 fprintf(stderr, "datalen:%d\n", datalen);
227 if (skpix && G_IS_OBJECT(skpix)) g_object_unref(skpix);
228 }
229
230 /*
231 * fprintf(stderr, "query is *%s*\n", tq);
232 */
233
234 do
235 {
236 sqlite3_stmt *stmt = NULL;
237 const char *dum;
238 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt, &dum);
239
240 if (rc)
241 {
242 fprintf(stderr, "Error updating: %s\n", sqlite3_errmsg(mainview->db));
243 break;
244 }
245 if (selnode->typ == NODE_TEXT)
246 sqlite3_bind_text(stmt, 1, textdata, datalen, /*strlen(textdata),*/ SQLITE_TRANSIENT);
247 else if (selnode->typ == NODE_SKETCH)
248 sqlite3_bind_blob(stmt, 1, sketchdata, datalen, SQLITE_TRANSIENT);
249
250 rc = SQLITE_BUSY;
251 while(rc == SQLITE_BUSY)
252 {
253 rc = sqlite3_step(stmt);
254 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
255 break;
256 }
257 sqlite3_finalize(stmt);
258 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE)
259 {
260 fprintf(stderr, "Error saving node: %s\n", sqlite3_errmsg(mainview->db));
261 }
262 else
263 {
264 if (selnode->typ == NODE_TEXT)
265 gtk_text_buffer_set_modified(GTK_TEXT_BUFFER(mainview->buffer), FALSE);
266 else if (selnode->typ == NODE_SKETCH)
267 sketchwidget_set_edited(mainview->sk, FALSE);
268 goterr = FALSE;
269 }
270 }
271 while(FALSE);
272
273 if (textdata)
274 g_free(textdata);
275 if (sketchdata)
276 g_free(sketchdata);
277 if (goterr == TRUE)
278 {
279 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Error saving memo"));
280 }
281 setBusy(mainview, 2);
282 }
283
284 void callback_treeview_celldatafunc(GtkTreeViewColumn * tree_column, GtkCellRenderer * cell, GtkTreeModel * tree_model, GtkTreeIter * iter, gpointer data)
285 {
286 MainView *mainview = NULL;
287 mainview = ( MainView * ) data;
288 g_assert(mainview != NULL && mainview->data != NULL );
289
290 nodeData *nd;
291
292 gtk_tree_model_get(tree_model, iter, NODE_DATA, &nd, -1);
293 if (nd == NULL)
294 return;
295
296 if (nd->namepix == NULL)
297 {
298 g_object_set(cell, "visible", FALSE, NULL);
299 }
300 else
301 {
302 g_object_set(cell, "visible", TRUE, NULL);
303 g_object_set(cell, "width", SKETCHNODE_RX, NULL);
304 g_object_set(cell, "height", SKETCHNODE_RY, NULL);
305 }
306 }
307
308 gboolean callback_treeview_testcollapse(GtkTreeView * treeview, GtkTreeIter * arg1, GtkTreePath * arg2, gpointer user_data)
309 {
310 return (TRUE);
311 }
312
313 void callback_treeview_change(GtkTreeSelection * selection, gpointer data)
314 {
315 MainView *mainview = NULL;
316
317 mainview = (MainView *) data;
318 g_assert(mainview != NULL && mainview->data != NULL);
319
320 nodeData *nd = getSelectedNode(mainview);
321
322 /*
323 if (nd==NULL)
324 fprintf(stderr, "changed called but no selectednode\n");
325 else
326 fprintf(stderr, "changed called, selectednode is %d\n", nd->sql3id);
327 */
328 #ifdef NEW_SEL_LOGIC
329 guint tm=time(NULL);
330 if (mainview->cansel_time>0 && mainview->cansel_time+1.0<tm) mainview->cansel_node=NULL;
331
332 if (nd==NULL)
333 {
334 if (mainview->cansel_node!=NULL)
335 {
336 fprintf(stderr, "[SELLOGIC] saving %d to unselect all nodes\n", (mainview->cansel_node)->sql3id);
337 saveDataToNode(mainview, (mainview->cansel_node));
338 mainview->cansel_node=NULL;
339 }
340 return;
341 }
342
343 if (mainview->cansel_node!=NULL)
344 {
345 if (nd->sql3id == (mainview->cansel_node)->sql3id)
346 {
347 mainview->cansel_node=NULL;
348 fprintf(stderr, "[SELLOGIC] doubly selected %d, doing nothing\n", nd->sql3id);
349 return;
350 }
351 else
352 {
353 fprintf(stderr, "[SELLOGIC] saving %d to load new node\n", (mainview->cansel_node)->sql3id);
354 saveDataToNode(mainview, (mainview->cansel_node));
355 mainview->cansel_node=NULL;
356 }
357 }
358 #endif
359
360 if (nd == NULL) return;
361
362 setBusy(mainview, 1);
363
364 gboolean goterr = TRUE;
365 char *textdata = NULL;
366 char *blob = NULL;
367 int blobsize = 0, textsize = 0;
368
369 char tq[512];
370
371 snprintf(tq, sizeof(tq), "SELECT bodytype, body, bodyblob, flags FROM %s WHERE nodeid=%d", datatable_tmpname, nd->sql3id);
372 sqlite3_stmt *stmt = NULL;
373 const char *dum;
374 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt, &dum);
375
376 if (rc)
377 {
378 fprintf(stderr, "Error reading (1) %s\n", sqlite3_errmsg(mainview->db));
379 }
380 else
381 {
382 rc = SQLITE_BUSY;
383 while(rc == SQLITE_BUSY || rc == SQLITE_ROW)
384 {
385 rc = sqlite3_step(stmt);
386 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
387 break;
388 else if (rc == SQLITE_ROW)
389 {
390 nd->typ = sqlite3_column_int(stmt, 0);
391 nd->flags = sqlite3_column_int(stmt, 3);
392
393 prepareUIforNodeChange(mainview, nd->typ);
394 if (nd->typ == NODE_TEXT)
395 {
396 gboolean file_edited_backup = mainview->file_edited;
397
398 blobsize = sqlite3_column_bytes(stmt, 2);
399 blob = (char *)sqlite3_column_blob(stmt, 2);
400
401 textdata = (char *)sqlite3_column_text(stmt, 1);
402 textsize = sqlite3_column_bytes(stmt, 1);
403
404 gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mainview->buffer), "", -1);
405
406 gboolean richtext=FALSE;
407
408 if (blob != NULL)
409 {
410 GError *err = NULL;
411 GtkTextIter iter;
412 gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER(mainview->buffer), &iter);
413 gtk_text_buffer_deserialize_rich_text(GTK_TEXT_BUFFER(mainview->buffer), &iter, blob, blobsize, TRUE, &err);
414 if (err != NULL)
415 {
416 fprintf(stderr, "Error loading text memo! %s\n", err->message);
417 g_error_free(err);
418 }
419 else
420 {
421 richtext=TRUE;
422 }
423 }
424 if (richtext==FALSE && !(textdata == NULL || g_utf8_validate(textdata, textsize, NULL) == FALSE))
425 {
426 gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mainview->buffer), textdata, textsize);
427 }
428
429 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->tools_wordwrap), ((nd->flags & NODEFLAG_WORDWRAP) > 0)?TRUE:FALSE);
430 callback_wordwrap(NULL, mainview); /*FIXME:ugly (do we need this? gotta test) */
431
432 gtk_text_buffer_set_modified(GTK_TEXT_BUFFER(mainview->buffer), FALSE);
433
434 if (file_edited_backup==FALSE) mainview->file_edited=FALSE; /*textview changed event toggles this*/
435 goterr = FALSE;
436 }
437 else if (nd->typ == NODE_SKETCH)
438 {
439 sketchwidget_wipe_undo(mainview->sk);
440 sketchwidget_set_fillmode(mainview->sk, FALSE);
441 sketchwidget_set_shift(mainview->sk, FALSE);
442 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->shapemenuitems[1]), TRUE);
443 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->shapemenuitems[0]), TRUE);
444
445 blobsize = sqlite3_column_bytes(stmt, 2);
446 blob = (char *)sqlite3_column_blob(stmt, 2);
447 gboolean clear = TRUE;
448
449 if (blob == NULL)
450 goterr = FALSE;
451 if (blob != NULL)
452 {
453 fprintf(stderr, "blobsize:%d\n", blobsize);
454 GdkPixbufLoader *pl = gdk_pixbuf_loader_new_with_type("png", NULL);
455 GError *err = NULL;
456
457 gdk_pixbuf_loader_write(pl, (guchar *) blob, blobsize, &err);
458 if (err != NULL)
459 {
460 fprintf(stderr, "Error loading sketch! %s\n", err->message);
461 g_error_free(err);
462 err = NULL;
463 }
464 gdk_pixbuf_loader_close(pl, NULL);
465 GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf(pl);
466
467 if (GDK_IS_PIXBUF(pixbuf))
468 {
469 GtkWidget *skdr = sketchwidget_get_drawingarea(mainview->sk);
470 GtkPixmap *skpix = (GtkPixmap *) sketchwidget_get_Pixmap(mainview->sk);
471
472 int w=gdk_pixbuf_get_width(pixbuf);
473 int h=gdk_pixbuf_get_height(pixbuf);
474 if (w!=skdr->allocation.width || h!=skdr->allocation.height)
475 {
476 if (w>skdr->allocation.width) w=skdr->allocation.width;
477 if (h>skdr->allocation.height) h=skdr->allocation.height;
478 sketchwidget_clear_real(mainview->sk);
479 }
480 gdk_draw_pixbuf(GDK_DRAWABLE(skpix), NULL, pixbuf, 0, 0, 0, 0, w, h, GDK_RGB_DITHER_NONE, 0, 0);
481
482 clear = FALSE;
483 goterr = FALSE;
484
485 if (skpix && G_IS_OBJECT(skpix)) g_object_unref(skpix);
486 }
487 else
488 {
489 fprintf(stderr, "error loading pixbuf\n");
490 }
491 g_object_unref(pl);
492 }
493 if (clear == TRUE)
494 {
495 fprintf(stderr, "clearing pix area\n");
496 sketchwidget_clear_real(mainview->sk);
497 }
498 gtk_widget_queue_draw(sketchwidget_get_drawingarea(mainview->sk));
499 }
500
501 if ((nd->flags & NODEFLAG_SKETCHLINES) > 0)
502 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->sketchlinesmenuitems[1]), TRUE);
503 else if ((nd->flags & NODEFLAG_SKETCHGRAPH) > 0)
504 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->sketchlinesmenuitems[2]), TRUE);
505 else
506 {
507 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->sketchlinesmenuitems[0]), TRUE);
508 callback_sketchlines(NULL, mainview->sketchlinesmenuitems[0]); /*FIXME:ugly */
509 }
510
511 break;
512 }
513 }
514 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE)
515 fprintf(stderr, "Error reading (2) %s\n", sqlite3_errmsg(mainview->db));
516
517 sqlite3_finalize(stmt);
518 }
519
520 setBusy(mainview, 2);
521
522 if (goterr == TRUE)
523 {
524 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Error loading memo"));
525 }
526 }
527
528 gboolean treeview_canselect(GtkTreeSelection * selection, GtkTreeModel * model, GtkTreePath * path, gboolean path_currently_selected, gpointer userdata)
529 {
530 MainView *mainview = NULL;
531
532 mainview = (MainView *) userdata;
533 g_assert(mainview != NULL && mainview->data != NULL);
534
535 if (mainview->loading==FALSE)
536 {
537 #ifndef EXPANDING_ROWS
538 if (path_currently_selected)
539 return (FALSE);
540 #endif
541 }
542 #ifndef NEW_SEL_LOGIC
543 saveCurrentData(mainview);
544 #else
545 if (path_currently_selected)
546 {
547 GtkTreeIter iter;
548 gtk_tree_model_get_iter(model, &iter, path);
549
550 gtk_tree_model_get(model, &iter, NODE_DATA, &(mainview->cansel_node), -1);
551 mainview->cansel_time=time(NULL);
552 /* fprintf(stderr, "[SELLOGIC] canselect called for node %d\n", nd->sql3id);*/
553 }
554 #endif
555
556 return (TRUE);
557 }
558
559 gboolean newnodedlg_key_press_cb(GtkWidget * widget, GdkEventKey * event, GtkWidget * dlg)
560 {
561 SketchWidget *s = gtk_object_get_data(GTK_OBJECT(dlg), "sk");
562
563 switch (event->keyval)
564 {
565 case GDK_F7:
566 sketchwidget_redo(s);
567 return TRUE;
568 case GDK_F8:
569 sketchwidget_undo(s);
570 return TRUE;
571 return TRUE;
572 }
573 return FALSE;
574 }
575
576 void new_node_dialog(nodeType typ, MainView * mainview)
577 {
578 GtkWidget *dialog, *label, *entry, *but_ok, *but_cancel, *vbox, *hbox, *al, *cb, *rb1, *rb2;
579
580 dialog = gtk_dialog_new();
581
582 g_signal_connect(G_OBJECT(dialog), "key_press_event", G_CALLBACK(newnodedlg_key_press_cb), dialog);
583
584 GtkWidget *notebook = gtk_notebook_new();
585
586 vbox = gtk_vbox_new(FALSE, 0);
587 gtk_container_border_width(GTK_CONTAINER(vbox), 15);
588
589 hbox = gtk_hbox_new(FALSE, 0);
590
591 rb1=gtk_radio_button_new_with_label(NULL, _("Text memo"));
592 gtk_box_pack_start(GTK_BOX(hbox), rb1, FALSE, FALSE, 0);
593 gtk_object_set_data(GTK_OBJECT(dialog), "rbt", rb1);
594
595 rb2=gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(rb1)), _("Sketch memo"));
596 gtk_box_pack_start(GTK_BOX(hbox), rb2, FALSE, FALSE, 0);
597 gtk_object_set_data(GTK_OBJECT(dialog), "rbs", rb2);
598
599 if (typ==NODE_TEXT) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rb1), TRUE);
600 else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rb2), TRUE);
601
602 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox);
603
604 label = gtk_label_new(_("Text name"));
605 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, label);
606 label = gtk_label_new(_("Please name the memo:"));
607 entry = gtk_entry_new_with_max_length(64);
608 gtk_entry_set_text(GTK_ENTRY(entry), _("New memo"));
609 gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
610
611 gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
612 gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0);
613
614 vbox = gtk_vbox_new(FALSE, 0);
615 gtk_container_border_width(GTK_CONTAINER(vbox), 15);
616 label = gtk_label_new(_("Sketch name"));
617 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, label);
618
619 label = gtk_label_new(_("Please name the memo:"));
620
621 al = gtk_alignment_new(0.5, 0.5, 0, 0);
622
623 SketchWidget *s = sketchwidget_new(SKETCHNODE_X, SKETCHNODE_Y, TRUE);
624
625 sketchwidget_set_brushsize(s, 2);
626 sketchwidget_set_backstyle(s, SKETCHBACK_GRAPH);
627
628 gtk_widget_set_size_request(sketchwidget_get_mainwidget(s), SKETCHNODE_X, SKETCHNODE_Y);
629 gtk_container_add(GTK_CONTAINER(al), sketchwidget_get_mainwidget(s));
630
631 gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
632 gtk_box_pack_start(GTK_BOX(vbox), al, FALSE, FALSE, 0);
633
634 but_ok = gtk_button_new_with_label(_("Create"));
635 but_cancel = gtk_button_new_with_label(_("Cancel"));
636 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), but_ok);
637 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), but_cancel);
638
639 gtk_object_set_user_data(GTK_OBJECT(dialog), entry);
640 gtk_object_set_data(GTK_OBJECT(dialog), "m", mainview);
641 gtk_object_set_data(GTK_OBJECT(dialog), "sk", s);
642 gtk_object_set_data(GTK_OBJECT(dialog), "n", notebook);
643
644 nodeType *tmp = g_malloc(sizeof(nodeType)); /*FIXME memleak:not freed on widget_destroy */
645 *tmp = typ;
646 gtk_object_set_data(GTK_OBJECT(dialog), "t", tmp);
647
648 gtk_signal_connect_object(GTK_OBJECT(but_cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), dialog);
649 g_signal_connect(G_OBJECT(but_ok), "clicked", G_CALLBACK(callback_new_node_real), dialog);
650
651 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), notebook);
652
653 cb = gtk_check_button_new_with_label("Create as childnode");
654 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cb), mainview->newnodedialog_createchild);
655 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), cb);
656 gtk_object_set_data(GTK_OBJECT(dialog), "cb", cb);
657
658 gtk_widget_grab_focus(entry);
659
660 gtk_widget_show_all(dialog);
661 gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
662 }
663
664 void add_new_node(nodeData * node, MainView * mainview, gboolean ischild)
665 {
666 GtkTreeIter parentiter, newiter;
667 GtkTreeModel *model;
668 void *ptr = NULL;
669
670 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
671
672 if (gtk_tree_selection_get_selected(selection, &model, &parentiter))
673 ptr = &parentiter;
674
675 GtkTreePath *path = NULL;
676
677 unsigned int parentnodeid = 0;
678
679 if (ptr != NULL)
680 {
681 path = gtk_tree_model_get_path(model, &parentiter);
682
683 if (ischild == FALSE)
684 {
685 gboolean tmp = gtk_tree_path_up(path);
686
687 if (gtk_tree_path_get_depth(path) > 0)
688 {
689 if (gtk_tree_model_get_iter(model, &parentiter, path))
690 ptr = &parentiter;
691 }
692 else if (tmp == TRUE)
693 {
694 gtk_tree_path_down(path); /*restore path so expand() works */
695 }
696 }
697 }
698
699 if (ptr != NULL)
700 {
701 nodeData *nd;
702
703 gtk_tree_model_get(model, ptr, NODE_DATA, &nd, -1);
704 if (nd)
705 parentnodeid = nd->sql3id;
706 }
707
708 node->sql3id = 0;
709 do
710 {
711 sqlite3_stmt *stmt = NULL;
712 const char *dum;
713 char tq[512];
714
715 /*
716 * FIXME: ord
717 */
718 snprintf(tq, sizeof(tq), "INSERT INTO %s (parent, bodytype, name, nameblob, ord) VALUES (%d, %d, ?, ?, 0);", datatable_tmpname, parentnodeid, node->typ);
719 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt, &dum);
720
721 if (rc)
722 {
723 fprintf(stderr, "Error inserting(1): %s\n", sqlite3_errmsg(mainview->db));
724 break;
725 }
726 if (node->name != NULL)
727 sqlite3_bind_text(stmt, 1, node->name, strlen(node->name), SQLITE_TRANSIENT);
728 else
729 sqlite3_bind_text(stmt, 1, NULL, 0, SQLITE_TRANSIENT);
730
731 if (node->namepix != NULL)
732 {
733 gchar *namepixdata = NULL;
734 gsize datalen = 0;
735
736 GError *err = NULL;
737
738 if (gdk_pixbuf_save_to_buffer(node->namepix, &namepixdata, &datalen, "png", &err, NULL) == FALSE)
739 {
740 namepixdata = NULL;
741 datalen = 0;
742 fprintf(stderr, "Error saving name! %s\n", err->message);
743 g_error_free(err);
744 }
745 sqlite3_bind_blob(stmt, 2, namepixdata, datalen, SQLITE_TRANSIENT);
746 }
747 else
748 sqlite3_bind_blob(stmt, 2, NULL, 0, SQLITE_TRANSIENT);
749
750 rc = SQLITE_BUSY;
751 while(rc == SQLITE_BUSY)
752 {
753 rc = sqlite3_step(stmt);
754 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
755 break;
756 }
757 sqlite3_finalize(stmt);
758 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE)
759 {
760 fprintf(stderr, "Error inserting(2): %s\n", sqlite3_errmsg(mainview->db));
761 break;
762 }
763 node->sql3id = sqlite3_last_insert_rowid(mainview->db);
764 }
765 while(FALSE);
766
767 if (node->sql3id == 0)
768 {
769 if (node->name)
770 g_free(node->name);
771 if (node->namepix)
772 g_object_unref(node->namepix);
773 g_free(node);
774 if (path)
775 gtk_tree_path_free(path);
776 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, "Error creating node");
777 return;
778 }
779
780 fprintf(stderr, "new node id is %d\n", node->sql3id);
781
782
783 gtk_tree_store_append(GTK_TREE_STORE(model), &newiter, ptr);
784
785 gtk_tree_store_set(GTK_TREE_STORE(model), &newiter, NODE_NAME, node->name, NODE_PIXBUF, node->namepix, NODE_DATA, node, -1);
786
787 if (path)
788 {
789 mainview->loading=TRUE; /*only when we have a valid parent*/
790 gtk_tree_view_expand_row(GTK_TREE_VIEW(mainview->treeview), path, FALSE);
791 gtk_tree_path_free(path);
792 }
793
794 gtk_tree_selection_select_iter(selection, &newiter);
795
796 mainview->loading=FALSE;
797 }
798
799 void callback_new_node_real(GtkAction * action, gpointer data)
800 {
801 MainView *mainview;
802
803 GtkWidget *dialog = data;
804 GtkWidget *entry = gtk_object_get_user_data(GTK_OBJECT(dialog));
805
806 mainview = gtk_object_get_data(GTK_OBJECT(dialog), "m");
807 SketchWidget *s = gtk_object_get_data(GTK_OBJECT(dialog), "sk");
808 GtkWidget *notebook = gtk_object_get_data(GTK_OBJECT(dialog), "n");
809 GtkWidget *cb = gtk_object_get_data(GTK_OBJECT(dialog), "cb");
810 /* nodeType *typ = gtk_object_get_data(GTK_OBJECT(dialog), "t");*/
811
812 nodeType typ = NODE_TEXT;
813
814 /* GtkWidget *rbt = gtk_object_get_data(GTK_OBJECT(dialog), "rbt");*/
815 GtkWidget *rbs = gtk_object_get_data(GTK_OBJECT(dialog), "rbs");
816 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(rbs))) typ=NODE_SKETCH;
817
818
819 gint t = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
820
821 gchar *txt = NULL;
822 GdkPixbuf *pixbuf = NULL;
823
824 if (t == 0)
825 {
826 txt = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
827 if (strcmp(txt, "") == 0)
828 {
829 g_free(txt);
830 return;
831 }
832 }
833 else
834 {
835 GtkWidget *sdr = sketchwidget_get_drawingarea(s);
836
837 GdkPixmap *spix = sketchwidget_get_Pixmap(s);
838
839 pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE(spix), NULL, 0, 0, 0, 0, sdr->allocation.width, sdr->allocation.height);
840 g_object_unref(spix);
841 double w, h;
842 GdkPixbuf *pixbuf2 = sketchwidget_trim_image(pixbuf, SKETCHNODE_X, SKETCHNODE_Y, &w,
843 &h, TRUE);
844 if (pixbuf2==NULL) return;
845
846 GdkPixbuf *pixbuf3 = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, SKETCHNODE_RX,
847 SKETCHNODE_RY);
848
849 gdk_pixbuf_fill(pixbuf3, 0xffffffff);
850
851 if (w <= SKETCHNODE_RX && h <= SKETCHNODE_RY)
852 {
853 gdk_pixbuf_copy_area(pixbuf2, 0, 0, w, h, pixbuf3, 0, (SKETCHNODE_RY - h) / 2);
854 }
855 else
856 {
857 double neww, newh;
858
859 if (w > h)
860 {
861 neww = SKETCHNODE_RX;
862 newh = (h / w) * SKETCHNODE_RX;
863 }
864 else
865 {
866 newh = SKETCHNODE_RY;
867 neww = (w / h) * SKETCHNODE_RY;
868 }
869 if (newh > SKETCHNODE_RY)
870 newh = SKETCHNODE_RY; /*FIXME: newh exceeds SKETCHNODE_RY sometimes */
871
872 GdkPixbuf *tmpbuf = gdk_pixbuf_scale_simple(pixbuf2, neww, newh,
873 GDK_INTERP_BILINEAR);
874
875 gdk_pixbuf_copy_area(tmpbuf, 0, 0, neww, newh, pixbuf3, 0, (SKETCHNODE_RY - newh) / 2);
876
877 gdk_pixbuf_unref(tmpbuf);
878 }
879
880 pixbuf = pixbuf3;
881 gdk_pixbuf_unref(pixbuf2);
882 }
883
884 nodeData *node;
885
886 node = g_malloc(sizeof(nodeData));
887 node->typ = typ;
888 /* node->typ = *typ;
889 g_free(typ);*/
890 node->name = NULL;
891 node->namepix = NULL;
892
893 if (t == 0)
894 {
895 node->name = txt;
896 }
897 else if (t == 1)
898 {
899 node->namepix = pixbuf;
900 }
901
902 node->lastMod = 0;
903 node->flags = 0;
904 node->sql3id = 0;
905
906 mainview->newnodedialog_createchild = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cb));
907 add_new_node(node, mainview, mainview->newnodedialog_createchild);
908
909 sketchwidget_destroy(s);
910 gtk_widget_destroy(dialog);
911 mainview->file_edited = TRUE;
912 }
913
914 /*
915 * delete node
916 */
917 void callback_file_delete_node(GtkAction * action, gpointer data)
918 {
919 MainView *mainview = NULL;
920
921 mainview = (MainView *) data;
922 g_assert(mainview != NULL && mainview->data != NULL);
923
924 if (getSelectedNode(mainview) == NULL)
925 {
926 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Select a node first"));
927 return;
928 }
929
930 GtkWidget *dialog, *label, *but_ok, *but_cancel;
931
932 dialog = gtk_dialog_new();
933
934 label = gtk_label_new(_("Are you sure?"));
935
936 but_ok = gtk_button_new_with_label(_("Yes, Delete"));
937 but_cancel = gtk_button_new_with_label(_("Cancel"));
938
939 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), but_ok);
940 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), but_cancel);
941
942 gtk_object_set_user_data(GTK_OBJECT(dialog), mainview);
943
944 gtk_signal_connect_object(GTK_OBJECT(but_cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), dialog);
945 g_signal_connect(G_OBJECT(but_ok), "clicked", G_CALLBACK(callback_delete_node_real), dialog);
946
947 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
948
949 gtk_widget_show_all(dialog);
950 gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
951 }
952
953 void callback_file_expand_collapse_node(GtkAction * action, gpointer data)
954 {
955 MainView *mainview = NULL;
956
957 mainview = (MainView *) data;
958 g_assert(mainview != NULL && mainview->data != NULL);
959
960 GtkTreeIter iter;
961 GtkTreeModel *model;
962
963 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
964
965 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
966 {
967 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Select a node first"));
968 return;
969 }
970
971 GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
972 if (gtk_tree_view_row_expanded(GTK_TREE_VIEW(mainview->treeview), path)==FALSE)
973 {
974 gtk_tree_view_expand_row(GTK_TREE_VIEW(mainview->treeview), path, FALSE);
975 }
976 else
977 {
978 gtk_tree_view_collapse_row(GTK_TREE_VIEW(mainview->treeview), path);
979 }
980
981 gtk_tree_path_free(path);
982 }
983
984 void callback_file_export_node(GtkAction * action, gpointer data)
985 {
986 MainView *mainview = NULL;
987
988 mainview = (MainView *) data;
989 g_assert(mainview != NULL && mainview->data != NULL);
990
991 nodeData *nd=getSelectedNode(mainview);
992 if (nd == NULL)
993 {
994 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Select a node first"));
995 return;
996 }
997
998 gchar *nodename=nd->name;
999 if (nodename==NULL) nodename="saved node";
1000
1001 if (nd->typ == NODE_TEXT)
1002 {
1003 GtkTextIter begin, end;
1004 gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER(mainview->buffer), &begin, &end);
1005 gchar *text = gtk_text_buffer_get_slice(GTK_TEXT_BUFFER(mainview->buffer), &begin, &end, TRUE);
1006 if (text==NULL || !strcmp(text, ""))
1007 {
1008 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Node is empty"));
1009 }
1010 else
1011 {
1012 gchar *fn = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_SAVE, nodename, "txt");
1013 if (fn!=NULL)
1014 {
1015 GnomeVFSResult vfs_result;
1016 GnomeVFSHandle *handle = NULL;
1017 GnomeVFSFileSize out_bytes;
1018 vfs_result = gnome_vfs_create(&handle, fn, GNOME_VFS_OPEN_WRITE, 0, 0600);
1019 if ( vfs_result != GNOME_VFS_OK ) {
1020 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Export failed"));
1021 }
1022 else
1023 {
1024 gnome_vfs_write(handle, text, strlen(text), &out_bytes);
1025 gnome_vfs_close(handle);
1026 if (out_bytes==strlen(text)) hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Exported"));
1027 else hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Export incomplete"));
1028 }
1029 g_free(fn);
1030 }
1031 }
1032 g_free(text);
1033 }
1034 else if (nd->typ == NODE_SKETCH)
1035 {
1036 GdkPixmap *skpix = sketchwidget_get_Pixmap(mainview->sk);
1037 GtkWidget *skdr = sketchwidget_get_drawingarea(mainview->sk);
1038 GdkPixbuf *pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE(skpix), NULL, 0, 0, 0, 0, skdr->allocation.width, skdr->allocation.height);
1039 if (pixbuf==NULL)
1040 {
1041 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Node is empty"));
1042 }
1043 else
1044 {
1045 gchar *fn = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_SAVE, nodename, "png");
1046 if (fn!=NULL)
1047 {
1048 if (gdk_pixbuf_save(pixbuf, fn, "png", NULL, NULL)==FALSE)
1049 {
1050 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Export failed"));
1051 }
1052 else
1053 {
1054 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Exported"));
1055 }
1056 g_free(fn);
1057 }
1058 }
1059 g_object_unref(skpix);
1060 }
1061 }
1062
1063 gboolean ref2iter(GtkTreeModel * model, GtkTreeRowReference * ref, GtkTreeIter * iter)
1064 {
1065 gboolean res = FALSE;
1066 GtkTreePath *path = gtk_tree_row_reference_get_path(ref);
1067
1068 if (gtk_tree_model_get_iter(model, iter, path))
1069 {
1070 res = TRUE;
1071 }
1072 gtk_tree_path_free(path);
1073 return (res);
1074 }
1075
1076 GtkTreeRowReference *iter2ref(GtkTreeModel * model, GtkTreeIter * iter)
1077 {
1078 GtkTreeRowReference *ref;
1079
1080 GtkTreePath *path = gtk_tree_model_get_path(model, iter);
1081
1082 ref = gtk_tree_row_reference_new(model, path);
1083 gtk_tree_path_free(path);
1084 return (ref);
1085 }
1086
1087 void move_nodes_up(GtkTreeModel * model, GtkTreeRowReference * topnode, GtkTreeRowReference * newtop)
1088 {
1089 GtkTreeIter topiter;
1090
1091 fprintf(stderr, "here2\n");
1092
1093 if (ref2iter(model, topnode, &topiter) == FALSE)
1094 return;
1095
1096 fprintf(stderr, "here3\n");
1097
1098 GtkTreeIter child;
1099
1100 if (gtk_tree_model_iter_children(model, &child, &topiter))
1101 {
1102 fprintf(stderr, "here4\n");
1103 GtkTreeRowReference *ref;
1104 GList *rr_list = NULL, *node;
1105
1106 do
1107 {
1108 ref = iter2ref(model, &child);
1109 rr_list = g_list_append(rr_list, ref);
1110 }
1111 while(gtk_tree_model_iter_next(model, &child));
1112
1113 /*
1114 * got a reflist for all children
1115 */
1116
1117 fprintf(stderr, "here5\n");
1118 for(node = rr_list; node; node = node->next)
1119 {
1120 ref = (GtkTreeRowReference *) (node->data);
1121 if (ref2iter(model, ref, &child))
1122 {
1123 GtkTreeIter newtopiter, newiter;
1124 GtkTreeIter *newtopiterptr;
1125
1126 if (ref2iter(model, newtop, &newtopiter))
1127 newtopiterptr = &newtopiter;
1128 else
1129 newtopiterptr = NULL;
1130
1131 nodeData *node;
1132
1133 gtk_tree_model_get(model, &child, NODE_DATA, &node, -1);
1134
1135 gtk_tree_store_append(GTK_TREE_STORE(model), &newiter, newtopiterptr);
1136 gtk_tree_store_set(GTK_TREE_STORE(model), &newiter, NODE_NAME, node->name, NODE_PIXBUF, node->namepix, NODE_DATA, node, -1);
1137
1138 GtkTreeRowReference *newref = iter2ref(model, &newiter);
1139
1140 move_nodes_up(model, ref, newref);
1141 gtk_tree_row_reference_free(newref);
1142
1143 gtk_tree_store_remove(GTK_TREE_STORE(model), &child);
1144 }
1145 gtk_tree_row_reference_free(ref);
1146 }
1147 fprintf(stderr, "here6\n");
1148
1149 g_list_free(rr_list);
1150 }
1151
1152 fprintf(stderr, "here7\n");
1153
1154 }
1155
1156 void callback_delete_node_real(GtkAction * action, gpointer data)
1157 {
1158 MainView *mainview;
1159
1160 GtkWidget *dialog = data;
1161
1162 mainview = gtk_object_get_user_data(GTK_OBJECT(dialog));
1163
1164 GtkTreeIter iter;
1165 GtkTreeModel *model;
1166
1167 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
1168
1169 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
1170 return;
1171
1172 nodeData *nd;
1173
1174 gtk_tree_model_get(model, &iter, NODE_DATA, &nd, -1);
1175 if (!nd)
1176 return;
1177
1178 mainview->file_edited = TRUE;
1179
1180 unsigned int sql3id = nd->sql3id;
1181
1182 if (nd->name)
1183 g_free(nd->name);
1184
1185 /*
1186 * g_free(nd->data);
1187 * if (nd->pix) g_object_unref(nd->pix);
1188 */
1189 g_free(nd);
1190
1191 fprintf(stderr, "here1\n");
1192 GtkTreeRowReference *upref = NULL, *ref = NULL;
1193
1194 GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
1195
1196 ref = gtk_tree_row_reference_new(model, path);
1197 if (gtk_tree_path_up(path))
1198 upref = gtk_tree_row_reference_new(model, path);
1199 gtk_tree_path_free(path);
1200
1201 g_object_ref(model);
1202 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), NULL);
1203
1204 fprintf(stderr, "here! 1\n");
1205 move_nodes_up(model, ref, upref);
1206
1207 fprintf(stderr, "here! 2\n");
1208 if (ref2iter(model, ref, &iter))
1209 {
1210 char tq[512];
1211
1212 snprintf(tq, sizeof(tq), "SELECT parent FROM %s WHERE nodeid=%d", datatable_tmpname, sql3id);
1213 sqlite3_stmt *stmt = NULL;
1214 const char *dum;
1215 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt, &dum);
1216 unsigned int sql3parentid = 0;
1217
1218 if (rc)
1219 {
1220 fprintf(stderr, "Error %s\n", sqlite3_errmsg(mainview->db));
1221 }
1222 else
1223 {
1224 rc = SQLITE_BUSY;
1225 while(rc == SQLITE_BUSY || rc == SQLITE_ROW)
1226 {
1227 rc = sqlite3_step(stmt);
1228 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
1229 break;
1230 else if (rc == SQLITE_ROW)
1231 {
1232 sql3parentid = sqlite3_column_int(stmt, 0);
1233 break;
1234 }
1235 }
1236 sqlite3_finalize(stmt);
1237
1238 snprintf(tq, sizeof(tq), "UPDATE %s SET parent=%d WHERE parent=%d;", datatable_tmpname, sql3parentid, sql3id);
1239 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
1240 fprintf(stderr, "ERROR moving nodes up!\n");
1241 else
1242 {
1243 snprintf(tq, sizeof(tq), "DELETE FROM %s WHERE nodeid=%d;", datatable_tmpname, sql3id);
1244 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
1245 fprintf(stderr, "ERROR deleting node!\n");
1246 }
1247 }
1248 gtk_tree_store_remove(GTK_TREE_STORE(model), &iter);
1249 }
1250
1251 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), model);
1252 g_object_unref(model);
1253
1254 fprintf(stderr, "here! 3\n");
1255 gtk_tree_row_reference_free(ref);
1256 gtk_tree_row_reference_free(upref);
1257
1258 gtk_tree_view_expand_all(GTK_TREE_VIEW(mainview->treeview));
1259
1260 fprintf(stderr, "here10\n");
1261 gtk_widget_destroy(dialog);
1262 }
1263
1264 void callback_edit_clear(GtkAction * action, gpointer data)
1265 {
1266 MainView *mainview = NULL;
1267
1268 mainview = (MainView *) data;
1269 g_assert(mainview != NULL && mainview->data != NULL);
1270
1271 nodeData *nd = getSelectedNode(mainview);
1272
1273 if (nd->typ == NODE_TEXT) gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mainview->buffer), "", 0);
1274 else if (nd->typ == NODE_SKETCH) sketchwidget_clear(mainview->sk);
1275 }
1276
1277 /*
1278 * cut
1279 */
1280 void callback_edit_cut(GtkAction * action, gpointer data)
1281 {
1282 MainView *mainview = NULL;
1283
1284 mainview = (MainView *) data;
1285 g_assert(mainview != NULL && mainview->data != NULL);
1286
1287 nodeData *nd = getSelectedNode(mainview);
1288
1289 if (nd->typ == NODE_TEXT)
1290 gtk_text_buffer_cut_clipboard(GTK_TEXT_BUFFER(mainview->buffer), mainview->clipboard, TRUE);
1291 else if (nd->typ == NODE_SKETCH)
1292 if (sketchwidget_cut(mainview->sk, mainview->clipboard)==FALSE)
1293 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Error cutting"));
1294 }
1295
1296 /*
1297 * copy
1298 */
1299 void callback_edit_copy(GtkAction * action, gpointer data)
1300 {
1301 /*
1302 * connect pointer to our MainView struct
1303 */
1304 MainView *mainview = NULL;
1305
1306 mainview = (MainView *) data;
1307 g_assert(mainview != NULL && mainview->data != NULL);
1308
1309 nodeData *nd = getSelectedNode(mainview);
1310
1311 if (nd->typ == NODE_TEXT)
1312 gtk_text_buffer_copy_clipboard(GTK_TEXT_BUFFER(mainview->buffer), mainview->clipboard);
1313 else if (nd->typ == NODE_SKETCH)
1314 if (sketchwidget_copy(mainview->sk, mainview->clipboard)==FALSE)
1315 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Error copying"));
1316 }
1317
1318 /*
1319 * paste
1320 */
1321 void callback_edit_paste(GtkAction * action, gpointer data)
1322 {
1323 /*
1324 * connect pointer to our MainView struct
1325 */
1326 MainView *mainview = NULL;
1327
1328 mainview = (MainView *) data;
1329 g_assert(mainview != NULL && mainview->data != NULL);
1330
1331 nodeData *nd = getSelectedNode(mainview);
1332
1333 if (nd->typ == NODE_TEXT)
1334 gtk_text_buffer_paste_clipboard(GTK_TEXT_BUFFER(mainview->buffer), mainview->clipboard, NULL, TRUE);
1335 else if (nd->typ == NODE_SKETCH)
1336 if (sketchwidget_paste(mainview->sk, mainview->clipboard)==FALSE)
1337 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Error pasting"));
1338
1339 mainview->file_edited = TRUE;
1340 }
1341
1342 gint cb_popup(GtkWidget * widget, GdkEvent * event)
1343 {
1344 GtkMenu *menu;
1345 GdkEventButton *event_button;
1346
1347 /*
1348 * The "widget" is the menu that was supplied when
1349 * * g_signal_connect_swapped() was called.
1350 */
1351 menu = GTK_MENU(widget);
1352 event_button = (GdkEventButton *) event;
1353 if (event->type == GDK_BUTTON_PRESS && event_button->button == 3)
1354 {
1355 gtk_menu_popup(menu, NULL, NULL, NULL, NULL, event_button->button, event_button->time);
1356 return TRUE;
1357 }
1358 return FALSE;
1359 }
1360
1361 /*
1362 * close
1363 */
1364 gboolean closefile(MainView * mainview)
1365 {
1366 saveCurrentData(mainview);
1367
1368 if (mainview->file_edited)
1369 {
1370 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));
1371 gint answer = gtk_dialog_run(GTK_DIALOG(hn));
1372 gtk_widget_destroy(GTK_WIDGET(hn));
1373
1374 if (answer == CONFRESP_CANCEL)
1375 return (FALSE);
1376 else if (answer == CONFRESP_YES)
1377 {
1378 if (mainview->file_name == NULL)
1379 {
1380 mainview->file_name = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_SAVE, "maemopaddata", "db");
1381 }
1382 write_buffer_to_file(mainview);
1383 }
1384 }
1385
1386 if (mainview->db)
1387 sqlite3_close(mainview->db);
1388 mainview->db = NULL;
1389 return (TRUE);
1390 }
1391
1392 gboolean callback_file_close(GtkAction * action, gpointer data)
1393 {
1394
1395 MainView *mainview = NULL;
1396
1397 mainview = (MainView *) data;
1398 g_assert(mainview != NULL && mainview->data != NULL);
1399 if (closefile(mainview) == FALSE)
1400 return(FALSE);
1401
1402 gtk_main_quit();
1403 return(TRUE);
1404 }
1405
1406 void callback_file_new_node(GtkAction * action, gpointer data)
1407 {
1408 MainView *mainview = NULL;
1409
1410 mainview = (MainView *) data;
1411 g_assert(mainview != NULL && mainview->data != NULL);
1412
1413 nodeType typ = NODE_SKETCH;
1414
1415 nodeData *nd = getSelectedNode(mainview);
1416
1417 if (nd != NULL)
1418 typ = nd->typ;
1419
1420 new_node_dialog(typ, mainview);
1421 }
1422
1423 /*
1424 * new
1425 */
1426 void callback_file_new(GtkAction * action, gpointer data)
1427 {
1428 MainView *mainview = NULL;
1429
1430 mainview = (MainView *) data;
1431 g_assert(mainview != NULL && mainview->data != NULL);
1432
1433 gchar *filename = NULL;
1434
1435 if (closefile(mainview) == FALSE)
1436 return;
1437
1438 filename = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_SAVE, "memos", "db");
1439 if (filename == NULL)
1440 return;
1441
1442 new_file(mainview);
1443
1444 do
1445 {
1446 setBusy(mainview, 1);
1447
1448 int rc;
1449
1450 rc = sqlite3_open(filename, &mainview->db);
1451 if (rc)
1452 {
1453 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Error 1"));
1454 fprintf(stderr, "Can't create database %s: %s\n", filename, sqlite3_errmsg(mainview->db));
1455 break;
1456 }
1457 char tq[512];
1458
1459 snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", misctable_name, misctable);
1460 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
1461
1462 snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", datatable_name, datatable);
1463 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
1464 {
1465 fprintf(stderr, "ERROR creating data table\n");
1466 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Error 2"));
1467 break;
1468 }
1469
1470 if (mainview->db)
1471 sqlite3_close(mainview->db);
1472 mainview->db = NULL;
1473
1474 mainview->file_name = filename;
1475 mainview->file_edited = FALSE;
1476 read_file_to_buffer(mainview);
1477
1478 /*add a starter memo*/
1479 nodeData *node;
1480 node = g_malloc(sizeof(nodeData));
1481 node->typ = NODE_SKETCH;
1482 node->name = _("My first memo");
1483 node->namepix = NULL;
1484 node->lastMod = 0;
1485 node->flags = 0;
1486 node->sql3id = 0;
1487 add_new_node(node, mainview, TRUE);
1488 gtk_paned_set_position(GTK_PANED(mainview->hpaned), 180);
1489 mainview->viewflags = 3;
1490 callback_setview(mainview, 1);
1491 write_buffer_to_file(mainview);
1492
1493 }while(FALSE);
1494 setBusy(mainview, 0);
1495 }
1496
1497 gboolean reset_ctree(GtkTreeModel * model, GtkTreePath * path, GtkTreeIter * iter, gpointer data)
1498 {
1499 nodeData *node;
1500
1501 gtk_tree_model_get(model, iter, NODE_DATA, &node, -1);
1502 if (node)
1503 {
1504 if (node->name)
1505 g_free(node->name);
1506 if (node->namepix)
1507 g_object_unref(node->namepix);
1508 g_free(node);
1509
1510 gtk_tree_store_set(GTK_TREE_STORE(model), iter, NODE_DATA, NULL, -1);
1511 }
1512 return (FALSE);
1513 }
1514
1515 void new_file(MainView * mainview)
1516 {
1517 setBusy(mainview, 1);
1518 /*
1519 * clear buffer, filename and free buffer text
1520 */
1521 gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mainview->buffer), "", -1);
1522 mainview->file_name = NULL;
1523 mainview->file_edited = FALSE;
1524 mainview->newnodedialog_createchild = TRUE;
1525
1526 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview));
1527
1528 g_object_ref(model);
1529 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), NULL);
1530
1531 gtk_tree_model_foreach(model, (GtkTreeModelForeachFunc) reset_ctree, (gpointer) mainview);
1532
1533 /*
1534 * crashing bastard
1535 * gtk_tree_store_clear(GTK_TREE_STORE(model));
1536 */
1537 GtkTreePath *path = gtk_tree_path_new_from_indices(0, -1);
1538 GtkTreeIter iter;
1539
1540 if (gtk_tree_model_get_iter(model, &iter, path))
1541 {
1542 do
1543 {
1544 gtk_tree_store_remove(GTK_TREE_STORE(model), &iter);
1545 }
1546 while(gtk_tree_store_iter_is_valid(GTK_TREE_STORE(model), &iter));
1547 }
1548 gtk_tree_path_free(path);
1549
1550 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), model);
1551 g_object_unref(model);
1552
1553 prepareUIforNodeChange(mainview, NODE_UNKNOWN);
1554 setBusy(mainview, 2);
1555 }
1556
1557 /*
1558 * open
1559 */
1560 void callback_file_open(GtkAction * action, gpointer data)
1561 {
1562 gchar *filename = NULL;
1563 MainView *mainview = NULL;
1564
1565 mainview = (MainView *) data;
1566 g_assert(mainview != NULL && mainview->data != NULL);
1567
1568 if (closefile(mainview) == FALSE)
1569 return;
1570
1571 /*
1572 * open new file
1573 */
1574 filename = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_OPEN, NULL, NULL);
1575
1576 /*
1577 * if we got a file name from chooser -> open file
1578 */
1579 open_file(filename, mainview);
1580 g_free(filename);
1581 }
1582
1583 gboolean open_file(gchar * filename, MainView * mainview)
1584 {
1585 gboolean ret=FALSE;
1586
1587 setBusy(mainview, 1);
1588
1589 while(filename != NULL)
1590 {
1591 struct stat s;
1592
1593 if (stat(filename, &s) == -1) break;
1594
1595 mainview->file_name = g_strdup(filename);
1596 gboolean res = read_file_to_buffer(mainview);
1597
1598 if (res == FALSE)
1599 {
1600 g_free(mainview->file_name);
1601 mainview->file_name = NULL;
1602 break;
1603 }
1604 mainview->file_edited = FALSE;
1605 ret=TRUE;
1606 break;
1607 }
1608
1609 setBusy(mainview, 2);
1610 return(ret);
1611 }
1612
1613 void callback_about_link(GtkAction * action, gpointer data)
1614 {
1615 MainView *mainview = NULL;
1616
1617 mainview = (MainView *) data;
1618 g_assert(mainview != NULL && mainview->data != NULL);
1619
1620 osso_rpc_run_with_defaults(mainview->data->osso, "osso_browser", OSSO_BROWSER_OPEN_NEW_WINDOW_REQ, NULL,
1621 DBUS_TYPE_STRING, "http://garage.maemo.org/projects/maemopadplus/", DBUS_TYPE_INVALID);
1622 }
1623
1624 void callback_about(GtkAction * action, gpointer data)
1625 {
1626 #if 1
1627 MainView *mainview = NULL;
1628 mainview = (MainView *) data;
1629
1630 GtkWidget *w, *d;
1631
1632 d = gtk_dialog_new();
1633 gtk_container_border_width(GTK_CONTAINER(d), 15);
1634
1635 char tmp[32];
1636
1637 snprintf(tmp, sizeof(tmp), "Maemopad+ %s", VERSION);
1638 w = gtk_button_new_with_label(tmp);
1639 g_object_set(w, "relief", GTK_RELIEF_NONE, NULL);
1640 g_object_set(w, "focus-on-click", FALSE, NULL);
1641 g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(callback_about_link), mainview);
1642 gtk_container_add (GTK_CONTAINER(GTK_DIALOG(d)->vbox), w);
1643
1644 w = gtk_label_new("\nLicense: LGPL\nAuthor: Kemal 'disq' Hadimli <disqkk@gmail.com>\n");
1645 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(d)->vbox), w);
1646
1647 w = gtk_button_new_with_label(_("Close"));
1648 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(d)->action_area), w);
1649 gtk_signal_connect_object(GTK_OBJECT(w), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), d);
1650
1651 gtk_widget_show_all(d);
1652 gtk_window_set_modal(GTK_WINDOW(d), TRUE);
1653
1654 #else
1655
1656 MainView *mainview=(MainView *)data;
1657 const char *authors[]={"Kemal 'disq' Hadimli <disqkk@gmail.com>", NULL};
1658 gtk_show_about_dialog(GTK_WINDOW(mainview->data->main_view), "name", "Maemopad+", "authors", authors, "copyright", "\xc2\xa9 2006 Kemal 'disq' Hadimli <disqkk@gmail.com>", "license", "GPL", "version", VERSION, "website", "http://garage.maemo.org/projects/maemopadplus/", "comments", "Based on Nokia's MaemoPad", NULL);
1659
1660 #endif
1661 }
1662
1663 /*
1664 * save
1665 */
1666 void callback_file_save(GtkAction * action, gpointer data)
1667 {
1668 gchar *filename = NULL;
1669 MainView *mainview = NULL;
1670
1671 mainview = (MainView *) data;
1672 g_assert(mainview != NULL && mainview->data != NULL);
1673
1674 /*
1675 * check is we had a new file
1676 */
1677 if (mainview->file_name != NULL)
1678 {
1679 write_buffer_to_file(mainview);
1680 }
1681 else
1682 {
1683 filename = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_SAVE, "maemopaddata", "db");
1684 /*
1685 * if we got a file name from chooser -> save file
1686 */
1687 if (filename != NULL)
1688 {
1689 mainview->file_name = filename;
1690 write_buffer_to_file(mainview);
1691 mainview->file_edited = FALSE;
1692 }
1693 }
1694 }
1695
1696 void callback_shapemenu(GtkAction * action, GtkWidget * wid)
1697 {
1698 int style = (int)gtk_object_get_user_data(GTK_OBJECT(wid));
1699 MainView *mainview = gtk_object_get_data(GTK_OBJECT(wid), "m");
1700
1701 g_assert(mainview != NULL);
1702
1703 if (style==0) sketchwidget_set_shape(mainview->sk, SKETCHSHAPE_FREEHAND);
1704 else if (style==1) sketchwidget_set_shape(mainview->sk, SKETCHSHAPE_LINE);
1705 else if (style==2) sketchwidget_set_shape(mainview->sk, SKETCHSHAPE_RECT);
1706 else if (style==3) sketchwidget_set_shape(mainview->sk, SKETCHSHAPE_ELLIPSE);
1707 }
1708
1709
1710
1711 void callback_eraser(GtkAction * action, MainView * mainview)
1712 {
1713 g_assert(mainview != NULL && mainview->data != NULL);
1714
1715 if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(mainview->eraser_tb)) == TRUE)
1716 {
1717 GdkColor c2;
1718
1719 c2.red = 65535;
1720 c2.green = 65535;
1721 c2.blue = 65535;
1722
1723 sketchwidget_set_brushcolor(mainview->sk, c2);
1724 mainview->brushsize_backup = sketchwidget_get_brushsize(mainview->sk);
1725 guint ers=(mainview->brushsize_backup*4)+4;
1726 sk_set_brushsize(mainview, ers);
1727 sketchwidget_set_brushsize(mainview->sk, ers); /*fixme:to override max brush size, not pretty*/
1728 }
1729 else
1730 {
1731 GdkColor *col = hildon_color_button_get_color(HILDON_COLOR_BUTTON(mainview->colorbutton));
1732
1733 GdkColor c2;
1734
1735 c2.red = col->red;
1736 c2.green = col->green;
1737 c2.blue = col->blue;
1738
1739 sketchwidget_set_brushcolor(mainview->sk, c2);
1740 sk_set_brushsize(mainview, mainview->brushsize_backup);
1741 }
1742 }
1743
1744 void callback_toggletree(GtkAction * action, MainView * mainview)
1745 {
1746 g_assert(mainview != NULL && mainview->data != NULL);
1747
1748 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->viewmenuitems[0]), gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(mainview->toggletree_tb)));
1749
1750 if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(mainview->toggletree_tb))==TRUE)
1751 mainview->viewflags |= 1;
1752 else
1753 mainview->viewflags &= ~1;
1754
1755 callback_setview(mainview, 0);
1756 }
1757
1758 void callback_menu(GtkAction * action, GtkWidget * menu)
1759 {
1760 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
1761 }
1762
1763 void callback_brushsizetb(GtkAction * action, MainView *mainview)
1764 {
1765 g_assert(mainview != NULL && mainview->data != NULL);
1766
1767 if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(mainview->eraser_tb)) == TRUE)
1768 {
1769 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->eraser_tb), FALSE);
1770 }
1771 else
1772 {
1773 callback_menu(NULL, mainview->brushsizemenu);
1774 }
1775 }
1776
1777 void callback_brushsize(GtkAction * action, GtkWidget * wid)
1778 {
1779 int bsize = (int)gtk_object_get_user_data(GTK_OBJECT(wid));
1780 MainView *mainview = gtk_object_get_data(GTK_OBJECT(wid), "m");
1781
1782 g_assert(mainview != NULL && mainview->data != NULL);
1783
1784 sketchwidget_set_brushsize(mainview->sk, bsize);
1785
1786 GtkWidget *pix = gtk_object_get_data(GTK_OBJECT(wid), "i");
1787
1788 gtk_widget_show(pix);
1789 gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(mainview->brushsize_tb), pix);
1790 }
1791
1792 void callback_sketchlines(GtkAction * action, GtkWidget * wid)
1793 {
1794 int style = (int)gtk_object_get_user_data(GTK_OBJECT(wid));
1795 MainView *mainview = gtk_object_get_data(GTK_OBJECT(wid), "m");
1796
1797 g_assert(mainview != NULL);
1798
1799 nodeData *nd = getSelectedNode(mainview);
1800 gboolean doit = FALSE;
1801
1802 if (nd != NULL && nd->typ == NODE_SKETCH)
1803 {
1804 nd->flags &= ~NODEFLAG_SKETCHLINES;
1805 nd->flags &= ~NODEFLAG_SKETCHGRAPH;
1806 /* sketchwidget_set_edited(mainview->sk, TRUE);*/ /*we call this on openfile, so this messes things up*/
1807 doit = TRUE;
1808 }
1809
1810 if (style == 0)
1811 {
1812 sketchwidget_set_backstyle(mainview->sk, SKETCHBACK_NONE);
1813 }
1814 else if (style == 1)
1815 {
1816 sketchwidget_set_backstyle(mainview->sk, SKETCHBACK_LINES);
1817 if (doit == TRUE)
1818 nd->flags |= NODEFLAG_SKETCHLINES;
1819 }
1820 else if (style == 2)
1821 {
1822 sketchwidget_set_backstyle(mainview->sk, SKETCHBACK_GRAPH);
1823 if (doit == TRUE)
1824 nd->flags |= NODEFLAG_SKETCHGRAPH;
1825 }
1826
1827 GtkWidget *pix = gtk_object_get_data(GTK_OBJECT(wid), "i");
1828
1829 gtk_widget_show(pix);
1830 gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(mainview->sketchlines_tb), pix);
1831 }
1832
1833 void callback_color(HildonColorButton * colorButton, MainView * mainview)
1834 {
1835 g_assert(mainview != NULL && mainview->data != NULL);
1836
1837 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->eraser_tb), FALSE);
1838
1839 GdkColor *col = hildon_color_button_get_color(colorButton);
1840
1841 GdkColor c2;
1842
1843 c2.red = col->red;
1844 c2.green = col->green;
1845 c2.blue = col->blue;
1846
1847 sketchwidget_set_brushcolor(mainview->sk, c2);
1848 }
1849
1850 void callback_color_invoke(GtkAction * action, gpointer data)
1851 {
1852 MainView *mainview = NULL;
1853
1854 mainview = (MainView *) data;
1855 g_assert(mainview != NULL && mainview->data != NULL);
1856
1857 HildonColorButton *hc = HILDON_COLOR_BUTTON(mainview->colorbutton);
1858
1859 gtk_button_clicked(GTK_BUTTON(&hc->button));
1860 }
1861
1862
1863 void callback_wordwrap(GtkAction * action, MainView *mainview)
1864 {
1865 g_assert(mainview != NULL && mainview->data != NULL);
1866
1867 nodeData *nd = getSelectedNode(mainview);
1868
1869 if (nd == NULL)
1870 return;
1871 if (nd->typ == NODE_SKETCH)
1872 return;
1873
1874 gboolean act=gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(mainview->tools_wordwrap));
1875 if (act==TRUE) nd->flags |= NODEFLAG_WORDWRAP;
1876 else nd->flags &= ~NODEFLAG_WORDWRAP;
1877
1878 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(mainview->textview), (act==TRUE)?GTK_WRAP_WORD:GTK_WRAP_NONE);
1879 }
1880
1881
1882 void callback_font(GtkAction * action, gpointer data)
1883 {
1884 MainView *mainview = NULL;
1885
1886 mainview = (MainView *) data;
1887 g_assert(mainview != NULL && mainview->data != NULL);
1888
1889 nodeData *nd = getSelectedNode(mainview);
1890
1891 if (nd == NULL)
1892 return;
1893 if (nd->typ == NODE_SKETCH)
1894 return;
1895
1896 /*
1897 PangoFontDescription *new_font = interface_font_chooser(mainview);
1898
1899 if (new_font != NULL)
1900 {
1901 gtk_widget_modify_font(mainview->textview, new_font);
1902 }
1903 */
1904 HildonFontSelectionDialog *dialog = HILDON_FONT_SELECTION_DIALOG(hildon_font_selection_dialog_new(NULL, NULL));
1905
1906 GtkTextAttributes *attrs = gtk_text_view_get_default_attributes(GTK_TEXT_VIEW(mainview->textview));
1907
1908 GtkTextIter iter, iter2;
1909 if (gtk_text_buffer_get_selection_bounds(mainview->buffer, &iter, &iter2)==FALSE) /*no selection*/
1910 {
1911 if (gtk_text_iter_is_end(&iter)) gtk_text_iter_backward_char(&iter);
1912 gtk_text_iter_get_attributes(&iter, attrs);
1913 }
1914
1915 gint ri=0;
1916 if (attrs->appearance.rise>0 /*==SUPERSCRIPT_RISE*/) ri=1;
1917 else if (attrs->appearance.rise<0 /*==SUBSCRIPT_LOW*/) ri=-1;
1918
1919 g_object_set(G_OBJECT(dialog),
1920 "family", pango_font_description_get_family(attrs->font),
1921 "size", (gint)(pango_font_description_get_size(attrs->font) / PANGO_SCALE),
1922 /* "color", attrs->appearance.fg_color,*/
1923 "bold", pango_font_description_get_weight(attrs->font)==PANGO_WEIGHT_BOLD,
1924 "italic", pango_font_description_get_style(attrs->font)==PANGO_STYLE_ITALIC,
1925 "underline", attrs->appearance.underline,
1926 "strikethrough", attrs->appearance.strikethrough,
1927 "position", ri,
1928 NULL);
1929 /*
1930 if (attrs->appearance!=NULL && attrs->appearance.fg_color)
1931 {
1932 g_object_set(G_OBJECT(dialog), "color", attrs->appearance.fg_color, NULL);
1933 }
1934 */
1935 gtk_widget_show_all(GTK_WIDGET(dialog));
1936 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
1937 {
1938 gboolean bold, italic, underline, strikethrough;
1939 gchar *family = NULL;
1940 gint size, position;
1941 GdkColor color;
1942 gboolean set_family, set_size, set_bold, set_italic, set_underline, set_strikethrough, set_color, set_position;
1943
1944 g_object_get(G_OBJECT(dialog), "family", &family, "size", &size, "bold", &bold, "italic", &italic,
1945 "underline", &underline, "strikethrough", &strikethrough,
1946 "family-set", &set_family, "size-set", &set_size, "bold-set", &set_bold, "italic-set", &set_italic,
1947 "underline-set", &set_underline, "strikethrough-set", &set_strikethrough,
1948 "color", &color, "color-set", &set_color, "position", &position, "position-set", &set_position,
1949 NULL);
1950
1951 GtkTextTag *tag;
1952 PangoFontDescription *font = pango_font_description_new();
1953 gboolean set_font=FALSE;
1954
1955 if (set_family) pango_font_description_set_family(font, family);
1956 if (set_size) pango_font_description_set_size(font, size * PANGO_SCALE);
1957 set_font=set_family || set_size;
1958 /*
1959 if (set_bold)
1960 {
1961 if (bold) pango_font_description_set_weight(font, PANGO_WEIGHT_BOLD);
1962 else pango_font_description_set_weight(font, PANGO_WEIGHT_NORMAL);
1963 }
1964 if (set_italic)
1965 {
1966 if (italic) pango_font_description_set_style(font, PANGO_STYLE_ITALIC);
1967 else pango_font_description_set_style(font, PANGO_STYLE_NORMAL);
1968 }
1969
1970 if (set_underline)
1971 {
1972 if (underline) gtk_text_buffer_apply_tag(mainview->buffer, mainview->tag_underline, &iter, &iter2);
1973 else gtk_text_buffer_remove_tag(mainview->buffer, mainview->tag_underline, &iter, &iter2);
1974 }
1975 */
1976
1977 if (set_strikethrough)
1978 {
1979 tag = gtk_text_buffer_create_tag(mainview->buffer, NULL, "strikethrough", strikethrough, NULL);
1980 gtk_text_buffer_apply_tag(mainview->buffer, tag, &iter, &iter2);
1981 }
1982
1983 if (set_color)
1984 {
1985 /*
1986 GLIB WARNING ** GLib-GObject - IA__g_object_set_valist: object class `GtkTextTag' has no property named `'
1987 */
1988 tag = gtk_text_buffer_create_tag(mainview->buffer, NULL, "foreground-gdk", color, NULL);
1989 gtk_text_buffer_apply_tag(mainview->buffer, tag, &iter, &iter2);
1990 }
1991
1992 if (set_position)
1993 {
1994 if (position==1) ri=SUPERSCRIPT_RISE;
1995 else if (position==-1) ri=SUBSCRIPT_LOW;
1996 else ri=0;
1997
1998 tag = gtk_text_buffer_create_tag(mainview->buffer, NULL, "rise", ri, NULL);
1999 gtk_text_buffer_apply_tag(mainview->buffer, tag, &iter, &iter2);
2000 }
2001
2002 if (set_font)
2003 {
2004 tag = gtk_text_buffer_create_tag(mainview->buffer, NULL, "font-desc", font, NULL);
2005 gtk_text_buffer_apply_tag(mainview->buffer, tag, &iter, &iter2);
2006 }
2007
2008 if (set_bold)
2009 {
2010 if (bold)
2011 {
2012 gtk_text_buffer_remove_tag(mainview->buffer, mainview->tag_nobold, &iter, &iter2);
2013 gtk_text_buffer_apply_tag(mainview->buffer, mainview->tag_bold, &iter, &iter2);
2014 }
2015 else
2016 {
2017 gtk_text_buffer_remove_tag(mainview->buffer, mainview->tag_bold, &iter, &iter2);
2018 gtk_text_buffer_apply_tag(mainview->buffer, mainview->tag_nobold, &iter, &iter2);
2019 }
2020 }
2021 if (set_italic)
2022 {
2023 if (italic)
2024 {
2025 gtk_text_buffer_remove_tag(mainview->buffer, mainview->tag_noitalic, &iter, &iter2);
2026 gtk_text_buffer_apply_tag(mainview->buffer, mainview->tag_italic, &iter, &iter2);
2027 }
2028 else
2029 {
2030 gtk_text_buffer_remove_tag(mainview->buffer, mainview->tag_italic, &iter, &iter2);
2031 gtk_text_buffer_apply_tag(mainview->buffer, mainview->tag_noitalic, &iter, &iter2);
2032 }
2033 }
2034 if (set_underline)
2035 {
2036 if (underline)
2037 {
2038 gtk_text_buffer_remove_tag(mainview->buffer, mainview->tag_nounderline, &iter, &iter2);
2039 gtk_text_buffer_apply_tag(mainview->buffer, mainview->tag_underline, &iter, &iter2);
2040 }
2041 else
2042 {
2043 gtk_text_buffer_remove_tag(mainview->buffer, mainview->tag_underline, &iter, &iter2);
2044 gtk_text_buffer_apply_tag(mainview->buffer, mainview->tag_nounderline, &iter, &iter2);
2045 }
2046 }
2047 /*
2048 if (set_family)
2049 {
2050 tag = gtk_text_buffer_create_tag (mainview->buffer, NULL, "family", family, NULL);
2051 gtk_text_buffer_apply_tag(mainview->buffer, tag, &iter, &iter2);
2052 }
2053 if (set_size)
2054 {
2055 tag = gtk_text_buffer_create_tag (mainview->buffer, NULL, "size-points", size, NULL);
2056 gtk_text_buffer_apply_tag(mainview->buffer, tag, &iter, &iter2);
2057 }
2058 if (set_strikethrough)
2059 {
2060 tag = gtk_text_buffer_create_tag (mainview->buffer, NULL, "strikethrough", strikethrough, NULL);
2061 gtk_text_buffer_apply_tag(mainview->buffer, tag, &iter, &iter2);
2062 }
2063 */
2064 }
2065
2066 gtk_widget_destroy(GTK_WIDGET(dialog));
2067 }
2068
2069 void callback_fontstyle(GtkAction * action, GtkWidget * wid)
2070 {
2071 MainView *mainview = gtk_object_get_data(GTK_OBJECT(wid), "m");
2072 g_assert(mainview != NULL && mainview->data != NULL);
2073
2074 nodeData *nd = getSelectedNode(mainview);
2075
2076 if (nd == NULL)
2077 return;
2078 if (nd->typ == NODE_SKETCH)
2079 return;
2080
2081 gboolean act=gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(wid));
2082
2083 char *tag = gtk_object_get_data(GTK_OBJECT(wid), "s");
2084
2085 #if 0
2086 fprintf(stderr, "toggled: %s\n", tag);
2087 #endif
2088
2089 GtkTextIter start, end;
2090 gtk_text_buffer_get_selection_bounds (mainview->buffer, &start, &end);
2091
2092 char tmp[64];
2093 snprintf(tmp, 64, "no%s", tag);
2094
2095 if (act)
2096 {
2097 gtk_text_buffer_remove_tag_by_name(mainview->buffer, tmp, &start, &end);
2098 gtk_text_buffer_apply_tag_by_name(mainview->buffer, tag, &start, &end);
2099 }
2100 else
2101 {
2102 gtk_text_buffer_remove_tag_by_name(mainview->buffer, tag, &start, &end);
2103 gtk_text_buffer_apply_tag_by_name(mainview->buffer, tmp, &start, &end);
2104 }
2105 }
2106
2107
2108 void callback_textbuffer_move(GtkTextBuffer *textbuffer, GtkTextIter *arg1, GtkTextMark *arg2, MainView *mainview)
2109 {
2110 g_assert(mainview != NULL && mainview->data != NULL);
2111 callback_recalc_stylebuttons(mainview);
2112 }
2113
2114 void callback_recalc_stylebuttons(MainView *mainview)
2115 {
2116 GtkTextIter iter, iter2;
2117 if (gtk_text_buffer_get_selection_bounds(mainview->buffer, &iter, &iter2)==TRUE)
2118 {
2119 /*we have a selection*/
2120 return;
2121 }
2122
2123 /* this is probably slower
2124 GtkTextMark *mark;
2125 GtkTextIter iter;
2126
2127 mark=gtk_text_buffer_get_selection_bound(mainview->buffer);
2128 gtk_text_buffer_get_iter_at_mark(mainview->buffer, &iter, mark);
2129 gint i1=gtk_text_iter_get_offset(&iter);
2130
2131 mark=gtk_text_buffer_get_insert(mainview->buffer);
2132 gtk_text_buffer_get_iter_at_mark(mainview->buffer, &iter, mark);
2133 gint i2=gtk_text_iter_get_offset(&iter);
2134
2135 if (i1!=i2)
2136 {
2137 return;
2138 }
2139 */
2140 if (mainview->textbuffer_ignore_next_mark>0)
2141 {
2142 #if 0
2143 fprintf(stderr, "ignored\n");
2144 #endif
2145 mainview->textbuffer_ignore_next_mark--;
2146 return;
2147 }
2148
2149 #if 0
2150 fprintf(stderr, "mark\n");
2151 #endif
2152
2153 if (gtk_text_iter_is_end(&iter)) gtk_text_iter_backward_char(&iter);
2154
2155 GtkTextAttributes *attrs = gtk_text_view_get_default_attributes(GTK_TEXT_VIEW(mainview->textview));
2156 gtk_text_iter_get_attributes(&iter, attrs);
2157
2158 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->bold_tb), pango_font_description_get_weight(attrs->font)==PANGO_WEIGHT_BOLD);
2159 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->italic_tb), pango_font_description_get_style(attrs->font)==PANGO_STYLE_ITALIC);
2160 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->underline_tb), attrs->appearance.underline==PANGO_UNDERLINE_SINGLE);
2161
2162 gtk_text_attributes_unref(attrs);
2163 }
2164
2165 void callback_textbuffer_inserttext(GtkTextBuffer *buffer, GtkTextIter *pos, const gchar *text, gint length, MainView *mainview)
2166 {
2167 mainview->textbuffer_ignore_next_mark=2;
2168
2169 #if 0
2170 fprintf(stderr, "length=%d\n", length);
2171 #endif
2172
2173 GtkTextIter *iter2 = gtk_text_iter_copy(pos);
2174 gtk_text_iter_backward_chars(iter2, length);
2175
2176 if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(mainview->bold_tb)))
2177 {
2178 gtk_text_buffer_remove_tag(mainview->buffer, mainview->tag_nobold, pos, iter2);
2179 gtk_text_buffer_apply_tag(mainview->buffer, mainview->tag_bold, pos, iter2);
2180 }
2181 else
2182 {
2183 gtk_text_buffer_remove_tag(mainview->buffer, mainview->tag_bold, pos, iter2);
2184 gtk_text_buffer_apply_tag(mainview->buffer, mainview->tag_nobold, pos, iter2);
2185 }
2186
2187 if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(mainview->italic_tb)))
2188 {
2189 gtk_text_buffer_remove_tag(mainview->buffer, mainview->tag_noitalic, pos, iter2);
2190 gtk_text_buffer_apply_tag(mainview->buffer, mainview->tag_italic, pos, iter2);
2191 }
2192 else
2193 {
2194 gtk_text_buffer_remove_tag(mainview->buffer, mainview->tag_italic, pos, iter2);
2195 gtk_text_buffer_apply_tag(mainview->buffer, mainview->tag_noitalic, pos, iter2);
2196 }
2197
2198 if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(mainview->underline_tb)))
2199 {
2200 gtk_text_buffer_remove_tag(mainview->buffer, mainview->tag_nounderline, pos, iter2);
2201 gtk_text_buffer_apply_tag(mainview->buffer, mainview->tag_underline, pos, iter2);
2202 }
2203 else
2204 {
2205 gtk_text_buffer_remove_tag(mainview->buffer, mainview->tag_underline, pos, iter2);
2206 gtk_text_buffer_apply_tag(mainview->buffer, mainview->tag_nounderline, pos, iter2);
2207 }
2208
2209 gtk_text_iter_free(iter2);
2210 }
2211
2212
2213 void callback_undo(GtkAction * action, MainView * mainview)
2214 {
2215 g_assert(mainview != NULL && mainview->data != NULL);
2216
2217 nodeData *nd = getSelectedNode(mainview);
2218
2219 if (nd == NULL || nd->typ != NODE_SKETCH)
2220 return;
2221
2222 sketchwidget_undo(mainview->sk);
2223 }
2224
2225 void callback_redo(GtkAction * action, MainView * mainview)
2226 {
2227 g_assert(mainview != NULL && mainview->data != NULL);
2228
2229 nodeData *nd = getSelectedNode(mainview);
2230
2231 if (nd == NULL || nd->typ != NODE_SKETCH)
2232 return;
2233
2234 sketchwidget_redo(mainview->sk);
2235 }
2236
2237 void callback_undotoggle(SketchWidget * sk, gboolean st, MainView * mainview)
2238 {
2239 g_assert(mainview != NULL && mainview->data != NULL);
2240
2241 gtk_widget_set_sensitive(GTK_WIDGET(mainview->undo_tb), st);
2242 }
2243
2244 void callback_redotoggle(SketchWidget * sk, gboolean st, MainView * mainview)
2245 {
2246 g_assert(mainview != NULL && mainview->data != NULL);
2247
2248 gtk_widget_set_sensitive(GTK_WIDGET(mainview->redo_tb), st);
2249 }
2250
2251 void callback_finger(SketchWidget * sk, gint x, gint y, gdouble pressure, MainView * mainview)
2252 {
2253 g_assert(mainview != NULL && mainview->data != NULL);
2254
2255 if ((mainview->viewflags & 2) == 0) mainview->viewflags |= 2;
2256 else mainview->viewflags &= ~2;
2257 callback_setview(mainview, 1);
2258 }
2259
2260 gboolean close_cb(GtkWidget * widget, GdkEventAny * event, MainView * mainview)
2261 {
2262 callback_file_close(NULL, mainview);
2263 return (TRUE);
2264 }
2265
2266 gboolean key_press_cb(GtkWidget * widget, GdkEventKey * event, MainView * mainview)
2267 {
2268 switch (event->keyval)
2269 {
2270
2271 /*
2272 * case GDK_Up:
2273 * gtk_infoprint(GTK_WINDOW(app), "Navigation Key Up");
2274 * return TRUE;
2275 *
2276 * case GDK_Down:
2277 * gtk_infoprint(GTK_WINDOW(app), "Navigation Key Down");
2278 * return TRUE;
2279 *
2280 * case GDK_Left:
2281 * gtk_infoprint(GTK_WINDOW(app), "Navigation Key Left");
2282 * return TRUE;
2283 *
2284 * case GDK_Right:
2285 * gtk_infoprint(GTK_WINDOW(app), "Navigation Key Right");
2286 * return TRUE;
2287 *
2288 * case GDK_Return:
2289 * gtk_infoprint(GTK_WINDOW(app), "Navigation Key select");
2290 * return TRUE;
2291 */
2292 /*code below messes up when you have a textview*/
2293 /*
2294 case GDK_Left:
2295 case GDK_Right:
2296 {
2297 gtk_widget_child_focus(widget, event->keyval==GDK_Left?GTK_DIR_TAB_BACKWARD:GTK_DIR_TAB_FORWARD);
2298 return TRUE;
2299 }
2300 */
2301 case GDK_Left:
2302 {
2303 nodeData *selnode = getSelectedNode(mainview);
2304 if (selnode!=NULL && selnode->typ==NODE_SKETCH)
2305 {
2306 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Squared shapes ON"));
2307 sketchwidget_set_shift(mainview->sk, TRUE);
2308 return TRUE;
2309 }
2310 return FALSE;
2311 }
2312 case GDK_Right:
2313 {
2314 nodeData *selnode = getSelectedNode(mainview);
2315 if (selnode!=NULL && selnode->typ==NODE_SKETCH)
2316 {
2317 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Squared shapes OFF"));
2318 sketchwidget_set_shift(mainview->sk, FALSE);
2319 return TRUE;
2320 }
2321 return FALSE;
2322 }
2323 case GDK_Down:
2324 {
2325 nodeData *selnode = getSelectedNode(mainview);
2326 if (selnode!=NULL && selnode->typ==NODE_SKETCH)
2327 {
2328 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Filled shapes OFF"));
2329 sketchwidget_set_fillmode(mainview->sk, FALSE);
2330 return TRUE;
2331 }
2332 return FALSE;
2333 }
2334 case GDK_Up:
2335 {
2336 nodeData *selnode = getSelectedNode(mainview);
2337 if (selnode!=NULL && selnode->typ==NODE_SKETCH)
2338 {
2339 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Filled shapes ON"));
2340 sketchwidget_set_fillmode(mainview->sk, TRUE);
2341 return TRUE;
2342 }
2343 return FALSE;
2344 }
2345 case GDK_F6:
2346 {
2347 if ((mainview->viewflags & 4) == 0) mainview->viewflags |= 4;
2348 else mainview->viewflags &= ~4;
2349 callback_setview(mainview, 1);
2350 return TRUE;
2351 }
2352 case GDK_F7:
2353 {
2354 nodeData *selnode = getSelectedNode(mainview);
2355 if (selnode!=NULL && selnode->typ==NODE_SKETCH)
2356 {
2357 callback_redo(NULL, mainview);
2358 return TRUE;
2359 }
2360 return FALSE;
2361 }
2362 case GDK_F8:
2363 {
2364 nodeData *selnode = getSelectedNode(mainview);
2365 if (selnode!=NULL && selnode->typ==NODE_SKETCH)
2366 {
2367 callback_undo(NULL, mainview);
2368 return TRUE;
2369 }
2370 return FALSE;
2371 }
2372 case GDK_Escape:
2373 {
2374 if ((mainview->viewflags & 1) == 0) mainview->viewflags |= 1;
2375 else mainview->viewflags &= ~1;
2376 callback_setview(mainview, 1);
2377
2378 return TRUE;
2379 }
2380 case GDK_Return:
2381 {
2382 if ((mainview->viewflags & 2) == 0) mainview->viewflags |= 2;
2383 else mainview->viewflags &= ~2;
2384 callback_setview(mainview, 1);
2385 return TRUE;
2386 }
2387
2388 }
2389
2390 return FALSE;
2391 }
2392
2393 void callback_viewmenu(GtkAction * action, GtkWidget * wid)
2394 {
2395 int flag = (int)gtk_object_get_user_data(GTK_OBJECT(wid));
2396 MainView *mainview = gtk_object_get_data(GTK_OBJECT(wid), "m");
2397
2398 g_assert(mainview != NULL);
2399
2400 if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(wid))) mainview->viewflags |= flag;
2401 else mainview->viewflags &= ~flag;
2402
2403 if (flag==1)
2404 {
2405 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->toggletree_tb), gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(wid)));
2406 return;
2407 }
2408
2409 callback_setview(mainview, 0);
2410 }
2411
2412
2413 void callback_setview(MainView *mainview, int setmenu)
2414 {
2415 if (setmenu>0)
2416 {
2417 if ((mainview->viewflags&4)>0)
2418 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->viewmenuitems[2]), TRUE);
2419 else
2420 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->viewmenuitems[2]), FALSE);
2421
2422 if ((mainview->viewflags&2)>0)
2423 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->viewmenuitems[1]), TRUE);
2424 else
2425 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->viewmenuitems[1]), FALSE);
2426
2427 if ((mainview->viewflags&1)>0)
2428 {
2429 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->viewmenuitems[0]), TRUE);
2430 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->toggletree_tb), TRUE);
2431 }
2432 else
2433 {
2434 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->viewmenuitems[0]), FALSE);
2435 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->toggletree_tb), FALSE);
2436 }
2437
2438 return;
2439 }
2440
2441 setBusy(mainview, 1);
2442
2443 if ((mainview->viewflags&4)>0)
2444 gtk_window_fullscreen(GTK_WINDOW(mainview->data->main_view));
2445 else
2446 gtk_window_unfullscreen(GTK_WINDOW(mainview->data->main_view));
2447
2448 if ((mainview->viewflags&2)>0)
2449 gtk_widget_show(mainview->toolbar);
2450 else
2451 gtk_widget_hide(mainview->toolbar);
2452
2453 if ((mainview->viewflags&1)>0)
2454 gtk_widget_show(mainview->scrolledtree);
2455 else
2456 gtk_widget_hide(mainview->scrolledtree);
2457
2458 if (mainview->viewflags==4)
2459 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sketchwidget_get_mainwidget(mainview->sk)), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
2460 else
2461 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sketchwidget_get_mainwidget(mainview->sk)), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2462
2463 setBusy(mainview, 2);
2464 }
2465
2466 /*
2467 * buffer edited
2468 */
2469 void callback_buffer_modified(GtkAction * action, gpointer data)
2470 {
2471 /*
2472 * connect pointer to our MainView struct
2473 */
2474 MainView *mainview = NULL;
2475
2476 mainview = (MainView *) data;
2477 g_assert(mainview != NULL && mainview->data != NULL);
2478
2479 /*
2480 * change state
2481 */
2482 mainview->file_edited = TRUE;
2483 }
2484
2485 /*
2486 * Callback for exit D-BUS event
2487 */
2488 void exit_event_handler(gboolean die_now, gpointer data)
2489 {
2490 MainView *mainview = NULL;
2491
2492 mainview = (MainView *) data;
2493 g_assert(mainview != NULL && mainview->data != NULL);
2494
2495 if (!die_now)
2496 {
2497 if (callback_file_close(NULL, mainview)==FALSE) gtk_main_quit(); /*make sure we call gtk_main_quit*/
2498 }
2499 else
2500 {
2501 gtk_main_quit();
2502 }
2503 /*
2504 * application_exit(mainview->data);
2505 */
2506 }
2507
2508 /*
2509 * Callback for hardware D-BUS events
2510 */
2511 void hw_event_handler(osso_hw_state_t * state, gpointer data)
2512 {
2513 MainView *mainview = NULL;
2514
2515 mainview = (MainView *) data;
2516 g_assert(mainview != NULL && mainview->data != NULL);
2517
2518 /*
2519 * if (state->shutdown_ind)
2520 * {
2521 * gtk_infoprint(GTK_WINDOW(mainview->data->app),
2522 * "Shutdown event!");
2523 * }
2524 * if (state->memory_low_ind)
2525 * {
2526 * gtk_infoprint(GTK_WINDOW(mainview->data->app),
2527 * "Memory low event!");
2528 * }
2529 */
2530 if (state->save_unsaved_data_ind)
2531 {
2532 fprintf(stderr, "Saving unsaved data!\n");
2533 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, "Saving unsaved data!");
2534 callback_file_save(NULL, mainview);
2535 }
2536
2537 /*
2538 * if (state->system_inactivity_ind)
2539 * {
2540 * gtk_infoprint(GTK_WINDOW(mainview->data->app),
2541 * "Minimize application inactivity event!");
2542 * }
2543 */
2544 }
2545
2546 GtkTreeRowReference *read_sqlite3_data(MainView * mainview, unsigned int parentid, GtkTreeRowReference * parenttree, unsigned int selected, GtkTreeStore * model)
2547 {
2548 GtkTreeRowReference *resref = NULL;
2549
2550 char q[256];
2551
2552 snprintf(q, sizeof(q), "SELECT nodeid, bodytype, name, nameblob, lastmodified, flags FROM %s WHERE parent=%d ORDER BY ord", datatable_tmpname, parentid);
2553
2554 sqlite3_stmt *stmt = NULL;
2555 const char *dum;
2556 int rc = sqlite3_prepare(mainview->db, q, strlen(q), &stmt, &dum);
2557
2558 if (rc)
2559 {
2560 fprintf(stderr, "Error %s\n", sqlite3_errmsg(mainview->db));
2561 return (NULL);
2562 }
2563
2564 rc = SQLITE_BUSY;
2565 while(rc == SQLITE_BUSY || rc == SQLITE_ROW)
2566 {
2567 rc = sqlite3_step(stmt);
2568 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
2569 break;
2570 else if (rc == SQLITE_ROW)
2571 {
2572 int nodeid = sqlite3_column_int(stmt, 0);
2573 int typ = sqlite3_column_int(stmt, 1);
2574 const unsigned char *name = sqlite3_column_text(stmt, 2);
2575 const unsigned char *nameblob = sqlite3_column_text(stmt, 3);
2576 int lastmod = sqlite3_column_int(stmt, 4);
2577 int flags = sqlite3_column_int(stmt, 5);
2578
2579 /*
2580 * fprintf(stderr, "CARD=%s TYPE=%d\n", name, typ);
2581 */
2582 if ((typ != NODE_TEXT && typ != NODE_SKETCH) || (name == NULL && nameblob == NULL))
2583 {
2584
2585 /*
2586 * fprintf(stderr, "invalid card, skipping\n");
2587 */
2588 continue;
2589 }
2590
2591 nodeData *node = g_malloc(sizeof(nodeData));
2592
2593 node->sql3id = nodeid;
2594 node->typ = typ;
2595 node->flags = flags;
2596 node->name = NULL;
2597 node->namepix = NULL;
2598 if (name != NULL)
2599 node->name = g_strdup((char *)name);
2600 if (nameblob != NULL)
2601 {
2602 int blobsize = sqlite3_column_bytes(stmt, 3);
2603
2604 GdkPixbufLoader *pl = gdk_pixbuf_loader_new_with_type("png", NULL);
2605 GError *err = NULL;
2606
2607 gdk_pixbuf_loader_write(pl, (guchar *) nameblob, blobsize, &err);
2608 if (err != NULL)
2609 {
2610 fprintf(stderr, "Error loading nodename! %s\n", err->message);
2611 g_error_free(err);
2612 err = NULL;
2613 }
2614 gdk_pixbuf_loader_close(pl, NULL);
2615 GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf(pl);
2616
2617 if (GDK_IS_PIXBUF(pixbuf))
2618 node->namepix = pixbuf;
2619 }
2620 node->lastMod = lastmod;
2621
2622 GtkTreeIter parentiter, newiter;
2623 void *par = NULL;
2624
2625 if (parenttree != NULL)
2626 {
2627 GtkTreePath *pa = gtk_tree_row_reference_get_path(parenttree);
2628
2629 gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &parentiter, pa);
2630 gtk_tree_path_free(pa);
2631 par = &parentiter;
2632 }
2633
2634 gtk_tree_store_append(model, &newiter, par);
2635 gtk_tree_store_set(model, &newiter, NODE_NAME, node->name, NODE_PIXBUF, node->namepix, NODE_DATA, node, -1);
2636
2637 GtkTreePath *pa = gtk_tree_model_get_path(GTK_TREE_MODEL(model), &newiter);
2638
2639 GtkTreeRowReference *newref = gtk_tree_row_reference_new(GTK_TREE_MODEL(model), pa);
2640
2641 if (selected == nodeid)
2642 resref = newref;
2643
2644 gtk_tree_path_free(pa);
2645 GtkTreeRowReference *r = read_sqlite3_data(mainview, nodeid, newref, selected,
2646 model);
2647
2648 if (resref != newref)
2649 gtk_tree_row_reference_free(newref);
2650
2651 if (r != NULL)
2652 {
2653 if (resref == NULL)
2654 resref = r;
2655 else
2656 gtk_tree_row_reference_free(r); /*safeguard */
2657 }
2658 }
2659 }
2660
2661 if (stmt)
2662 sqlite3_finalize(stmt);
2663
2664 return (resref); /*ref to supposed-to-be-selected treeitem */
2665 }
2666
2667 /*
2668 * read file
2669 */
2670 gboolean read_file_to_buffer(MainView * mainview)
2671 {
2672 char tq[512];
2673
2674 g_assert(mainview != NULL);
2675 gboolean res = FALSE;
2676
2677 gchar *filename = mainview->file_name;
2678
2679 new_file(mainview);
2680 mainview->file_name = filename;
2681 mainview->loading=TRUE;
2682
2683 fprintf(stderr, "read:*%s*\n", filename);
2684
2685 int rc;
2686 sqlite3_stmt *stmt = NULL;
2687
2688 rc = sqlite3_open(filename, &mainview->db);
2689 do
2690 {
2691 if (rc)
2692 {
2693 fprintf(stderr, "Can't open database %s: %s\n", filename, sqlite3_errmsg(mainview->db));
2694 break;
2695 }
2696
2697 char *q = "SELECT skey, sval FROM settings";
2698 const char *dum;
2699
2700 rc = sqlite3_prepare(mainview->db, q, strlen(q), &stmt, &dum);
2701 if (rc)
2702 {
2703 fprintf(stderr, "Error %s\n", sqlite3_errmsg(mainview->db));
2704 break;
2705 }
2706
2707 unsigned int selectedCard = 0;
2708
2709 /*
2710 * fprintf(stderr, "start config\n");
2711 */
2712 unsigned int curDataVersion = 0;
2713
2714 rc = SQLITE_BUSY;
2715 while(rc == SQLITE_BUSY || rc == SQLITE_ROW)
2716 {
2717 rc = sqlite3_step(stmt);
2718 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
2719 break;
2720 else if (rc == SQLITE_ROW)
2721 {
2722 const unsigned char *col_key = sqlite3_column_text(stmt, 0);
2723 const unsigned char *col_val = sqlite3_column_text(stmt, 1);
2724
2725 /*
2726 * fprintf(stderr, "%s=%s\n", col_key, col_val);
2727 */
2728 if (!strcmp(col_key, "leftPanedPos"))
2729 {
2730 gint panedPos = atoi((char *)col_val);
2731
2732 if (panedPos > 0)
2733 gtk_paned_set_position(GTK_PANED(mainview->hpaned), panedPos);
2734 }
2735 if (!strcmp(col_key, "selectedNode"))
2736 {
2737 gint tmp = atoi((char *)col_val);
2738
2739 if (tmp > 0)
2740 selectedCard = tmp;
2741 }
2742 if (!strcmp(col_key, "dataVersion"))
2743 {
2744 gint tmp = atoi((char *)col_val);
2745
2746 if (tmp > 0)
2747 curDataVersion = tmp;
2748 }
2749 if (!strcmp(col_key, "newNodeDlgCreateChild"))
2750 {
2751 gint tmp = atoi((char *)col_val);
2752
2753 mainview->newnodedialog_createchild = TRUE;
2754 if (tmp == 0)
2755 mainview->newnodedialog_createchild = FALSE;
2756 }
2757 if (!strcmp(col_key, "fullScreen"))
2758 {
2759 gint tmp = atoi((char *)col_val);
2760 if (tmp<0 || tmp>4) tmp=0;
2761 if (tmp==0) tmp=4;
2762 else tmp--;
2763 if (tmp==0) tmp=3;
2764 else if (tmp==1) tmp=2;
2765 else if (tmp==2) tmp=7;
2766 else if (tmp==3) tmp=6;
2767 else if (tmp==4) tmp=4;
2768 mainview->viewflags=tmp;
2769 callback_setview(mainview, TRUE);
2770 }
2771 if (!strcmp(col_key, "viewFlags"))
2772 {
2773 gint tmp = atoi((char *)col_val);
2774 if (tmp<0) tmp=3;
2775 mainview->viewflags=tmp;
2776 callback_setview(mainview, TRUE);
2777 }
2778 if (!strcmp(col_key, "brushSize"))
2779 {
2780 gint tmp = atoi((char *)col_val);
2781 if (tmp>0) sk_set_brushsize(mainview, tmp);
2782 }
2783 if (!strcmp(col_key, "brushColor"))
2784 {
2785 unsigned long tmp = atol((char *)col_val);
2786 GdkColor c2;
2787
2788 c2.red = ((tmp & 0xFF0000) >> 16) << 8;
2789 c2.green = ((tmp & 0xFF00) >> 8) << 8;
2790 c2.blue = (tmp & 0xFF) << 8;
2791 /* fprintf(stderr, "READ BRUSHCOLOR is %ul (%d,%d,%d)\n", tmp, c2.red, c2.green, c2.blue);*/
2792
2793 sketchwidget_set_brushcolor(mainview->sk, c2);
2794 hildon_color_button_set_color(HILDON_COLOR_BUTTON(mainview->colorbutton), &c2);
2795 }
2796
2797 }
2798 }
2799 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE)
2800 {
2801 fprintf(stderr, "Error2 %s\n", sqlite3_errmsg(mainview->db));
2802 break;
2803 }
2804
2805 /*
2806 * fprintf(stderr, "end config\n");
2807 */
2808 if (stmt)
2809 sqlite3_finalize(stmt);
2810
2811 gboolean resback = FALSE;
2812
2813 while(curDataVersion < datatableversion)
2814 {
2815 if (curDataVersion == 0)
2816 {
2817 snprintf(tq, sizeof(tq), "DROP TABLE %s", datatable_backupname);
2818 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2819
2820 snprintf(tq, sizeof(tq), "ALTER TABLE %s RENAME TO %s", datatable_name, datatable_backupname);
2821 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
2822 {
2823 fprintf(stderr, "ERROR backing up table!\n");
2824 break;
2825 }
2826 resback = TRUE;
2827
2828 snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", datatable_name, datatable);
2829 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
2830 {
2831 fprintf(stderr, "ERROR creating table!\n");
2832 break;
2833 }
2834 snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT nodeid, parent, bodytype, name, body, nameblob, bodyblob, lastmodified, ord, 0 FROM %s", datatable_name, datatable_backupname);
2835 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
2836 {
2837 fprintf(stderr, "ERROR copying data!\n");
2838 break;
2839 }
2840
2841 snprintf(tq, sizeof(tq), "DROP TABLE %s", datatable_backupname);
2842 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2843
2844 curDataVersion = datatableversion;
2845 }
2846 }
2847 if (curDataVersion != datatableversion)
2848 {
2849 fprintf(stderr, "Data version mismatch\n");
2850
2851 if (resback == TRUE)
2852 {
2853 snprintf(tq, sizeof(tq), "DROP TABLE %s", datatable_name);
2854 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2855 snprintf(tq, sizeof(tq), "ALTER TABLE %s RENAME TO %s", datatable_backupname, datatable_name);
2856 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2857 }
2858
2859 break;
2860 }
2861
2862 GtkTreeStore *model = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview)));
2863
2864 g_object_ref(model);
2865 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), NULL);
2866
2867 do
2868 {
2869 char tq[512];
2870
2871 snprintf(tq, sizeof(tq), "CREATE%s TABLE %s%s", TEMPTABLE_KEYWORD, datatable_tmpname, datatable);
2872 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
2873 {
2874 fprintf(stderr, "ERROR creating temp table!\n");
2875 break;
2876 }
2877 snprintf(tq, sizeof(tq), "CREATE INDEX %s_index ON %s %s", datatable_tmpname, datatable_tmpname, dataindex);
2878 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
2879 {
2880 fprintf(stderr, "ERROR creating temp index!\n");
2881 break;
2882 }
2883 snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", datatable_tmpname, datatable_name);
2884 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
2885 {
2886 fprintf(stderr, "ERROR copying data to temp table!\n");
2887 break;
2888 }
2889 }
2890 while(FALSE);
2891
2892 GtkTreeRowReference *selectedRef = read_sqlite3_data(mainview, 0, NULL, selectedCard, model);
2893
2894 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), GTK_TREE_MODEL(model));
2895 g_object_unref(model);
2896 gtk_tree_view_expand_all(GTK_TREE_VIEW(mainview->treeview));
2897
2898 if (selectedRef != NULL)
2899 {
2900 GtkTreeIter seliter;
2901
2902 if (ref2iter(GTK_TREE_MODEL(model), selectedRef, &seliter) == TRUE)
2903 {
2904 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
2905 gtk_tree_selection_select_iter(selection, &seliter);
2906 }
2907
2908 gtk_tree_row_reference_free(selectedRef);
2909 }
2910 res = TRUE;
2911 }
2912 while(FALSE);
2913
2914 if (stmt)
2915 sqlite3_finalize(stmt);
2916
2917
2918 mainview->loading=FALSE;
2919
2920 return (res);
2921 }
2922
2923 /*
2924 * write to file
2925 */
2926 void write_buffer_to_file(MainView * mainview)
2927 {
2928 fprintf(stderr, "write:*%s*\n", mainview->file_name);
2929 saveCurrentData(mainview);
2930
2931 setBusy(mainview, 1);
2932
2933 char tq[512];
2934
2935 snprintf(tq, sizeof(tq), "DROP TABLE %s", misctable_name);
2936 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2937
2938 snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", misctable_name, misctable);
2939 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2940
2941 gint panedPos = gtk_paned_get_position(GTK_PANED(mainview->hpaned));
2942
2943 snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('leftPanedPos', '%d');", misctable_name, panedPos);
2944 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2945
2946 gint nndcc = 1;
2947
2948 if (mainview->newnodedialog_createchild == FALSE)
2949 nndcc = 0;
2950 snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('newNodeDlgCreateChild', '%d');", misctable_name, nndcc);
2951 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2952
2953 snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('viewFlags', '%d');", misctable_name, mainview->viewflags);
2954 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2955
2956 nodeData *node = getSelectedNode(mainview);
2957
2958 if (node)
2959 {
2960 snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('selectedNode', '%d');", misctable_name, node->sql3id);
2961 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2962 }
2963
2964 guint bsize;
2965 if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(mainview->eraser_tb)) == TRUE)
2966 {
2967 bsize=mainview->brushsize_backup;
2968 }
2969 else
2970 {
2971 bsize=sketchwidget_get_brushsize(mainview->sk);
2972 }
2973 snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('brushSize', '%d');", misctable_name, bsize);
2974 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2975
2976 GdkColor *col = hildon_color_button_get_color(HILDON_COLOR_BUTTON(mainview->colorbutton));
2977 unsigned long bcol=((col->red >> 8) << 16) | ((col->green >> 8) << 8) | (col->blue >> 8);
2978 /* fprintf(stderr, "BRUSHCOLOR is %d (%d,%d,%d)\n", bcol, col->red, col->green, col->blue);*/
2979 snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('brushColor', '%lu');", misctable_name, bcol);
2980 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2981
2982 snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('dataVersion', '%d');", misctable_name, datatableversion);
2983 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2984
2985 snprintf(tq, sizeof(tq), "DROP TABLE %s", datatable_backupname);
2986 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2987 snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", datatable_backupname, datatable);
2988 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
2989 {
2990 fprintf(stderr, "ERROR creating backup table!\n");
2991 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, "Error 1");
2992 return;
2993 }
2994 snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", datatable_backupname, datatable_name);
2995 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
2996 {
2997 fprintf(stderr, "ERROR backing up table!\n");
2998 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, "Error 2");
2999 return;
3000 }
3001 snprintf(tq, sizeof(tq), "DELETE FROM %s", datatable_name);
3002 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3003
3004 snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", datatable_name, datatable_tmpname);
3005 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3006 {
3007 fprintf(stderr, "ERROR saving table!\n");
3008 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, "Error 3");
3009
3010 snprintf(tq, sizeof(tq), "DELETE FROM %s", datatable_name);
3011 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3012
3013 snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", datatable_name, datatable_backupname);
3014 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3015 {
3016 fprintf(stderr, "ERROR restoring backup! data lost!\n");
3017 }
3018 setBusy(mainview, 2);
3019 return;
3020 }
3021
3022 snprintf(tq, sizeof(tq), "DROP TABLE %s", datatable_backupname);
3023 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3024
3025 mainview->file_edited = FALSE;
3026 setBusy(mainview, 2);
3027 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), GTK_STOCK_SAVE, _("Saved"));
3028 }
Tree-based notes, sketches and checklists for Maemo