?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use stock about dialog + link handler; add garage project members to
[maemopadplus.git] / src / ui / callbacks.c
blobc9dc368f0a59d47688cbb928b2d25309853d62e5
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 <stdio.h>
37 #include <config.h>
38
39 #if HILDON == 1
40 #include <hildon/hildon-banner.h>
41 #include <hildon/hildon-note.h>
42 #include <hildon/hildon-font-selection-dialog.h>
43 #include <tablet-browser-interface.h>
44 #else
45 #include <hildon-widgets/hildon-banner.h>
46 #include <hildon-widgets/hildon-note.h>
47 #include <hildon-widgets/hildon-font-selection-dialog.h>
48 #include <osso-browser-interface.h>
49 #endif
50 #include <libgnomevfs/gnome-vfs.h>
51
52
53 /*
54 * Privates:
55 */
56 gboolean read_file_to_buffer(MainView * mainview);
57 void write_buffer_to_file(MainView * mainview);
58 void new_node_dialog(nodeType typ, MainView * mainview);
59 gboolean foreach_func_update_ord (GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter, MainView *mainview);
60 void move_nodes_up(GtkTreeModel * model, GtkTreeRowReference * topnode, GtkTreeRowReference * newtop);
61 GtkTreeRowReference *iter2ref(GtkTreeModel * model, GtkTreeIter * iter);
62 gboolean exec_command_on_db(MainView *mainview,char sql_string[]);
63 int get_node_id_on_tmp_db(GtkTreeModel *model,GtkTreeIter *iter);
64 gint get_branch_node_index(GtkTreePath *path);
65 gboolean move_node(MainView *mainview,GtkTreeIter *new_parent,GtkTreeIter *item_to_move,GtkTreeIter *item_befor);
66 gboolean tree_model_iter_prev(GtkTreeModel *tree_model,GtkTreeIter *iter);
67
68 /*
69 st==0: turn off/zero refcount
70 st==1: turn on/increase ref
71 st==2: decrease refcount and turn off if necessary
72 */
73 void setBusy(MainView *mainview, gchar st)
74 {
75 if (st==0) mainview->busyrefcount=0;
76 else if (st==1) mainview->busyrefcount++;
77 else if (st==2 && mainview->busyrefcount>0) mainview->busyrefcount--;
78 gdk_window_set_cursor(GTK_WIDGET(mainview->data->main_view)->window, (mainview->busyrefcount>0)?mainview->cursorBusy:NULL);
79 }
80
81 gboolean isBusy(MainView *mainview)
82 {
83 if (mainview->busyrefcount>0) return(TRUE);
84 return(FALSE);
85 }
86
87 void prepareUIforNodeChange(MainView * mainview, nodeType typ)
88 {
89 gtk_widget_set_sensitive(GTK_WIDGET(mainview->undo_tb), TRUE);
90 gtk_widget_set_sensitive(GTK_WIDGET(mainview->redo_tb), TRUE);
91
92 if (typ == NODE_TEXT)
93 {
94 gtk_widget_show(GTK_WIDGET(mainview->font_tb));
95 gtk_widget_show(GTK_WIDGET(mainview->bold_tb));
96 gtk_widget_show(GTK_WIDGET(mainview->italic_tb));
97 gtk_widget_show(GTK_WIDGET(mainview->underline_tb));
98 gtk_widget_show(GTK_WIDGET(mainview->bullet_tb));
99 gtk_widget_show(mainview->tools_font);
100 gtk_widget_show(mainview->tools_wordwrap);
101 }
102 else
103 {
104 gtk_widget_hide(GTK_WIDGET(mainview->font_tb));
105 gtk_widget_hide(GTK_WIDGET(mainview->bold_tb));
106 gtk_widget_hide(GTK_WIDGET(mainview->italic_tb));
107 gtk_widget_hide(GTK_WIDGET(mainview->underline_tb));
108 gtk_widget_hide(GTK_WIDGET(mainview->bullet_tb));
109 gtk_widget_hide(mainview->tools_font);
110 gtk_widget_hide(mainview->tools_wordwrap);
111 }
112
113 if (typ == NODE_SKETCH)
114 {
115 /* gtk_widget_show(GTK_WIDGET(mainview->colorbutton_tb));*/
116 gtk_widget_show(GTK_WIDGET(mainview->eraser_tb));
117 gtk_widget_show(GTK_WIDGET(mainview->brushsize_tb));
118 gtk_widget_show(GTK_WIDGET(mainview->sketchlines_tb));
119 gtk_widget_show(GTK_WIDGET(mainview->shape_tb));
120 gtk_widget_show(mainview->tools_color);
121 gtk_widget_show(mainview->tools_brushsize);
122 gtk_widget_show(mainview->tools_pagestyle);
123 gtk_widget_show(mainview->tools_shape);
124 gtk_widget_show(mainview->tools_pressure);
125 }
126 else
127 {
128 /* gtk_widget_hide(GTK_WIDGET(mainview->colorbutton_tb));*/
129 gtk_widget_hide(GTK_WIDGET(mainview->eraser_tb));
130 gtk_widget_hide(GTK_WIDGET(mainview->brushsize_tb));
131 gtk_widget_hide(GTK_WIDGET(mainview->sketchlines_tb));
132 gtk_widget_hide(GTK_WIDGET(mainview->shape_tb));
133 gtk_widget_hide(mainview->tools_color);
134 gtk_widget_hide(mainview->tools_brushsize);
135 gtk_widget_hide(mainview->tools_pagestyle);
136 gtk_widget_hide(mainview->tools_shape);
137 gtk_widget_hide(mainview->tools_pressure);
138 }
139
140 if (typ == NODE_CHECKLIST)
141 {
142 gtk_widget_show(GTK_WIDGET(mainview->bold_tb));
143 gtk_widget_show(GTK_WIDGET(mainview->strikethru_tb));
144 gtk_widget_show(GTK_WIDGET(mainview->check_tb));
145 gtk_widget_show(GTK_WIDGET(mainview->checkadd_tb));
146 gtk_widget_show(GTK_WIDGET(mainview->checkdel_tb));
147 gtk_widget_hide(GTK_WIDGET(mainview->undo_tb));
148 gtk_widget_hide(GTK_WIDGET(mainview->redo_tb));
149 }
150 else
151 {
152 gtk_widget_hide(GTK_WIDGET(mainview->strikethru_tb));
153 gtk_widget_hide(GTK_WIDGET(mainview->check_tb));
154 gtk_widget_hide(GTK_WIDGET(mainview->checkadd_tb));
155 gtk_widget_hide(GTK_WIDGET(mainview->checkdel_tb));
156 gtk_widget_show(GTK_WIDGET(mainview->undo_tb));
157 gtk_widget_show(GTK_WIDGET(mainview->redo_tb));
158 }
159
160 if (typ == NODE_TEXT)
161 {
162 gtk_widget_hide(GTK_WIDGET(mainview->colorbutton_tb));
163 gtk_widget_hide(sketchwidget_get_mainwidget(mainview->sk));
164 gtk_widget_hide(mainview->listscroll);
165 gtk_widget_show(GTK_WIDGET(mainview->scrolledwindow));
166 gtk_widget_show(mainview->tools_item);
167 }
168 else if (typ == NODE_SKETCH)
169 {
170 gtk_widget_show(GTK_WIDGET(mainview->colorbutton_tb));
171 gtk_widget_hide(GTK_WIDGET(mainview->scrolledwindow));
172 gtk_widget_hide(mainview->listscroll);
173 gtk_widget_show(sketchwidget_get_mainwidget(mainview->sk));
174 gtk_widget_show(mainview->tools_item);
175 }
176 else if (typ == NODE_CHECKLIST)
177 {
178 gtk_widget_show(GTK_WIDGET(mainview->colorbutton_tb));
179 gtk_widget_hide(GTK_WIDGET(mainview->scrolledwindow));
180 gtk_widget_hide(sketchwidget_get_mainwidget(mainview->sk));
181 gtk_widget_hide(mainview->tools_item);
182 gtk_widget_show(mainview->listscroll);
183 }
184 else
185 {
186 gtk_widget_hide(GTK_WIDGET(mainview->colorbutton_tb));
187 gtk_widget_hide(GTK_WIDGET(mainview->scrolledwindow));
188 gtk_widget_hide(sketchwidget_get_mainwidget(mainview->sk));
189 gtk_widget_hide(mainview->tools_item);
190 gtk_widget_hide(mainview->listscroll);
191 }
192 }
193
194 nodeData *getSelectedNode(MainView * mainview)
195 {
196 GtkTreeIter iter;
197 GtkTreeModel *model;
198
199 nodeData *nd;
200
201 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
202
203 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
204 return (NULL);
205
206 gtk_tree_model_get(model, &iter, NODE_DATA, &nd, -1);
207
208 return (nd);
209 }
210
211 void saveCurrentData(MainView * mainview)
212 {
213 nodeData *selnode = getSelectedNode(mainview);
214 saveDataToNode(mainview, selnode);
215 }
216
217 void saveDataToNode(MainView * mainview, nodeData *selnode)
218 {
219 if (selnode == NULL)
220 return;
221
222 if (
223 (selnode->typ == NODE_SKETCH && sketchwidget_get_edited(mainview->sk) == FALSE) ||
224 (selnode->typ == NODE_TEXT && wp_text_buffer_is_modified(mainview->buffer)==FALSE) ||
225 (selnode->typ == NODE_CHECKLIST && gtk_object_get_data(GTK_OBJECT(mainview->listview), "edited")==FALSE)
226 )
227 {
228 fprintf(stderr, "node not edited, not saving\n");
229 return;
230 }
231
232 mainview->file_edited = TRUE;
233
234 setBusy(mainview, 1);
235 fprintf(stderr, "savecurrentdata!\n");
236
237 gboolean goterr = TRUE;
238 gchar *textdata = NULL;
239 GdkPixbuf *pixbuf = NULL;
240 gchar *sketchdata = NULL;
241 gsize datalen = 0;
242 char tq[512];
243
244 if (selnode->typ == NODE_TEXT)
245 {
246 #if 0
247 GtkTextIter start, end;
248 gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(mainview->buffer), &start, &end);
249 textdata = gtk_text_buffer_serialize_rich_text(GTK_TEXT_BUFFER(mainview->buffer), &start, &end, &datalen);
250 #endif
251
252 GString *gstr=g_string_sized_new(4096);
253 wp_text_buffer_save_document(mainview->buffer, (WPDocumentSaveCallback)(wp_savecallback), gstr);
254
255 datalen=gstr->len;
256 textdata=g_string_free(gstr, FALSE);
257 /*fprintf(stderr, "*%s*\n", textdata);*/
258
259 /* 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);*/
260 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);
261 }
262 else if (selnode->typ == NODE_SKETCH)
263 {
264 GError *err = NULL;
265 GdkPixmap *skpix = sketchwidget_get_Pixmap(mainview->sk);
266 GtkWidget *skdr = sketchwidget_get_drawingarea(mainview->sk);
267
268 pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE(skpix), NULL, 0, 0, 0, 0, skdr->allocation.width, skdr->allocation.height);
269 if (pixbuf == NULL)
270 {
271 fprintf(stderr, "Error saving: pixbuf is null\n");
272 }
273 else
274 {
275 double w, h;
276 GdkPixbuf *pixbuf2 = sketchwidget_trim_image(pixbuf, skdr->allocation.width, skdr->allocation.height, &w, &h, FALSE);
277
278 if (pixbuf2!=NULL)
279 {
280 if (gdk_pixbuf_save_to_buffer(pixbuf2, &sketchdata, &datalen, "png", &err, NULL) == FALSE)
281 {
282 sketchdata = NULL;
283 datalen = 0;
284 fprintf(stderr, "Error saving sketch! %s\n", err->message);
285 g_error_free(err);
286 }
287 gdk_pixbuf_unref(pixbuf2);
288 }
289 }
290 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);
291 fprintf(stderr, "datalen:%d\n", datalen);
292 if (skpix && G_IS_OBJECT(skpix)) g_object_unref(skpix);
293 }
294 else if (selnode->typ == NODE_CHECKLIST)
295 {
296 snprintf(tq, sizeof(tq), "UPDATE %s SET bodytype=%d, body=NULL, bodyblob=NULL, flags=%d WHERE nodeid=%d", datatable_tmpname, selnode->typ, selnode->flags, selnode->sql3id);
297 }
298
299 /*fprintf(stderr, "query is *%s*\n", tq); */
300
301 do
302 {
303 sqlite3_stmt *stmt = NULL;
304 const char *dum;
305 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt, &dum);
306
307 if (rc)
308 {
309 fprintf(stderr, "Error updating: %s\n", sqlite3_errmsg(mainview->db));
310 break;
311 }
312 if (selnode->typ == NODE_TEXT)
313 sqlite3_bind_text(stmt, 1, textdata, datalen, /*strlen(textdata),*/ SQLITE_TRANSIENT);
314 else if (selnode->typ == NODE_SKETCH)
315 sqlite3_bind_blob(stmt, 1, sketchdata, datalen, SQLITE_TRANSIENT);
316
317 rc = SQLITE_BUSY;
318 while(rc == SQLITE_BUSY)
319 {
320 rc = sqlite3_step(stmt);
321 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
322 break;
323 }
324 sqlite3_finalize(stmt);
325
326 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE)
327 {
328 fprintf(stderr, "Error saving node: %s\n", sqlite3_errmsg(mainview->db));
329 }
330 else
331 {
332 if (selnode->typ == NODE_TEXT)
333 gtk_text_buffer_set_modified(GTK_TEXT_BUFFER(mainview->buffer), FALSE);
334 else if (selnode->typ == NODE_SKETCH)
335 sketchwidget_set_edited(mainview->sk, FALSE);
336 else if (selnode->typ == NODE_CHECKLIST)
337 gtk_object_set_data(GTK_OBJECT(mainview->listview), "edited", FALSE);
338 goterr = FALSE;
339 }
340 }while(FALSE);
341
342 while(goterr==FALSE && selnode->typ == NODE_CHECKLIST)
343 {
344 GtkTreeModel *model=gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
345
346 char tq[512];
347 snprintf(tq, sizeof(tq), "DELETE FROM %s WHERE nodeid=%d", checklisttable_tmpname, selnode->sql3id);
348 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
349
350 GtkTreeIter iter;
351 if (gtk_tree_model_get_iter_first(model, &iter)==FALSE) break;
352
353 do
354 {
355 gint styletoset_weight;
356 gboolean styletoset_strike;
357 gboolean ischecked;
358 gchar *text;
359 gchar *color;
360 unsigned long col=0;
361
362 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, CHECKNODE_BOLD, &styletoset_weight, CHECKNODE_STRIKE, &styletoset_strike, CHECKNODE_CHECKED, &ischecked, CHECKNODE_TEXT, &text, CHECKNODE_COLOR, &color, -1);
363
364 GdkColor tmpcol;
365 if (color!=NULL && strcmp(color, "(null)")!=0 && gdk_color_parse(color, &tmpcol))
366 {
367 col=((tmpcol.red>>8)<<16)|((tmpcol.green>>8)<<8)|(tmpcol.blue>>8);
368 /* fprintf(stderr, "calculated color for node is *%lu*\n", col);*/
369 }
370
371 gint style=0;
372 if (ischecked) style|=CHECKSTYLE_CHECKED;
373 if (styletoset_weight==PANGO_WEIGHT_BOLD) style|=CHECKSTYLE_BOLD;
374 if (styletoset_strike) style|=CHECKSTYLE_STRIKE;
375
376 snprintf(tq, sizeof(tq), "INSERT INTO %s (nodeid, name, style, color, ord) VALUES(%d, ?, %d, %lu, 0)", checklisttable_tmpname, selnode->sql3id, style, col);
377 sqlite3_stmt *stmt = NULL;
378 const char *dum;
379 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt, &dum);
380
381 if (rc)
382 {
383 goterr=TRUE;
384 fprintf(stderr, "Error while saving checklist: %s\n", sqlite3_errmsg(mainview->db));
385 break;
386 }
387 sqlite3_bind_text(stmt, 1, text, strlen(text), SQLITE_TRANSIENT);
388
389 rc = SQLITE_BUSY;
390 while(rc == SQLITE_BUSY)
391 {
392 rc = sqlite3_step(stmt);
393 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
394 break;
395 }
396 sqlite3_finalize(stmt);
397
398 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE)
399 {
400 goterr=TRUE;
401 fprintf(stderr, "Error while saving checklist (2): %s\n", sqlite3_errmsg(mainview->db));
402 }
403
404 g_free(color);
405 g_free(text);
406
407 }while(gtk_tree_model_iter_next(model, &iter)==TRUE);
408
409 break;
410 }
411
412 if (textdata)
413 g_free(textdata);
414 if (sketchdata)
415 g_free(sketchdata);
416 if (goterr == TRUE)
417 {
418 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Error saving memo"));
419 }
420 setBusy(mainview, 2);
421 }
422
423 void callback_treeview_celldatafunc(GtkTreeViewColumn * tree_column, GtkCellRenderer * cell, GtkTreeModel * tree_model, GtkTreeIter * iter, gpointer data)
424 {
425 MainView *mainview = ( MainView * ) data;
426 g_assert(mainview != NULL && mainview->data != NULL );
427
428 nodeData *nd;
429
430 gtk_tree_model_get(tree_model, iter, NODE_DATA, &nd, -1);
431 if (nd == NULL)
432 return;
433
434 if (nd->namepix == NULL)
435 {
436 g_object_set(cell, "visible", FALSE, NULL);
437 }
438 else
439 {
440 g_object_set(cell, "visible", TRUE, NULL);
441 g_object_set(cell, "width", SKETCHNODE_RX, NULL);
442 g_object_set(cell, "height", SKETCHNODE_RY, NULL);
443 }
444 }
445
446
447 gboolean callback_treeview_testcollapse(GtkTreeView * treeview, GtkTreeIter * arg1, GtkTreePath * arg2, gpointer user_data)
448 {
449 return (TRUE);
450 }
451
452 void callback_treeview_change(GtkTreeSelection * selection, gpointer data)
453 {
454 MainView *mainview = (MainView *) data;
455 g_assert(mainview != NULL && mainview->data != NULL);
456
457 nodeData *nd = getSelectedNode(mainview);
458
459 /*
460 if (nd==NULL)
461 fprintf(stderr, "changed called but no selectednode\n");
462 else
463 fprintf(stderr, "changed called, selectednode is %d\n", nd->sql3id);
464 */
465 #ifdef NEW_SEL_LOGIC
466 guint tm=time(NULL);
467 if (mainview->cansel_time>0 && mainview->cansel_time+1.0<tm) mainview->cansel_node=NULL;
468
469 if (nd==NULL)
470 {
471 if (mainview->cansel_node!=NULL)
472 {
473 fprintf(stderr, "[SELLOGIC] saving %d to unselect all nodes\n", (mainview->cansel_node)->sql3id);
474 saveDataToNode(mainview, (mainview->cansel_node));
475 mainview->cansel_node=NULL;
476 }
477 return;
478 }
479
480 if (mainview->cansel_node!=NULL)
481 {
482 if (nd->sql3id == (mainview->cansel_node)->sql3id)
483 {
484 mainview->cansel_node=NULL;
485 fprintf(stderr, "[SELLOGIC] doubly selected %d, doing nothing\n", nd->sql3id);
486 return;
487 }
488 else
489 {
490 fprintf(stderr, "[SELLOGIC] saving %d to load new node\n", (mainview->cansel_node)->sql3id);
491 saveDataToNode(mainview, (mainview->cansel_node));
492 mainview->cansel_node=NULL;
493 }
494 }
495 #endif
496
497 if (nd == NULL) return;
498
499 setBusy(mainview, 1);
500
501 gboolean goterr = TRUE;
502 char *textdata = NULL;
503 char *blob = NULL;
504 int blobsize = 0, textsize = 0;
505
506 char tq[512];
507
508 snprintf(tq, sizeof(tq), "SELECT bodytype, body, bodyblob, flags FROM %s WHERE nodeid=%d", datatable_tmpname, nd->sql3id);
509 sqlite3_stmt *stmt = NULL;
510 const char *dum;
511 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt, &dum);
512
513 if (rc)
514 {
515 fprintf(stderr, "Error reading (1) %s\n", sqlite3_errmsg(mainview->db));
516 }
517 else
518 {
519 rc = SQLITE_BUSY;
520 while(rc == SQLITE_BUSY || rc == SQLITE_ROW)
521 {
522 rc = sqlite3_step(stmt);
523 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
524 break;
525 else if (rc == SQLITE_ROW)
526 {
527 nd->typ = sqlite3_column_int(stmt, 0);
528 nd->flags = sqlite3_column_int(stmt, 3);
529
530 prepareUIforNodeChange(mainview, nd->typ);
531 if (nd->typ == NODE_TEXT)
532 {
533 gboolean file_edited_backup = mainview->file_edited;
534
535 blobsize = sqlite3_column_bytes(stmt, 2);
536 blob = (char *)sqlite3_column_blob(stmt, 2);
537
538 textdata = (char *)sqlite3_column_text(stmt, 1);
539 textsize = sqlite3_column_bytes(stmt, 1);
540
541 /* gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mainview->buffer), "", -1);*/
542 wp_text_buffer_reset_buffer(mainview->buffer, TRUE);
543
544 gboolean richtext=FALSE;
545
546 if (blob != NULL)
547 {
548 #if 0
549 gboolean oldway=FALSE;
550 if (blobsize>8)
551 {
552 char tst[8];
553 strncpy(tst, blob, 8);
554 tst[8]=0;
555 if (strcmp(tst, "RICHTEXT")==0) oldway=TRUE;
556 }
557 if (oldway)
558 {
559 GError *err = NULL;
560 GtkTextIter iter;
561 gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER(mainview->buffer), &iter);
562 gtk_text_buffer_deserialize_rich_text(GTK_TEXT_BUFFER(mainview->buffer), &iter, blob, blobsize, TRUE, &err);
563 if (err != NULL)
564 {
565 fprintf(stderr, "Error loading text memo with richtext parser! %s\n", err->message);
566 g_error_free(err);
567 }
568 else
569 {
570 richtext=TRUE;
571 }
572 }
573 #endif
574
575 if (richtext==FALSE)
576 {
577 wp_text_buffer_load_document_begin(mainview->buffer, TRUE);
578 wp_text_buffer_load_document_write(mainview->buffer, blob, blobsize);
579 wp_text_buffer_load_document_end(mainview->buffer);
580 richtext=TRUE;
581 }
582 }
583 if (richtext==FALSE && !(textdata == NULL || g_utf8_validate(textdata, textsize, NULL) == FALSE))
584 {
585 /* gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mainview->buffer), textdata, textsize);*/
586 wp_text_buffer_load_document_begin(mainview->buffer, FALSE);
587 wp_text_buffer_load_document_write(mainview->buffer, textdata, textsize);
588 wp_text_buffer_load_document_end(mainview->buffer);
589 }
590
591 wp_text_buffer_enable_rich_text(mainview->buffer, TRUE);
592 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->tools_wordwrap), ((nd->flags & NODEFLAG_WORDWRAP) > 0)?TRUE:FALSE);
593 callback_wordwrap(NULL, mainview); /*FIXME:ugly (do we need this? gotta test) */
594
595 gtk_text_buffer_set_modified(GTK_TEXT_BUFFER(mainview->buffer), FALSE); /*we probably don't need this*/
596
597 callback_undotoggle((gpointer)mainview->buffer, FALSE, mainview); /*we need these*/
598 callback_redotoggle((gpointer)mainview->buffer, FALSE, mainview);
599
600 if (file_edited_backup==FALSE) mainview->file_edited=FALSE; /*textview changed event toggles this?*/
601 goterr = FALSE;
602 }
603 else if (nd->typ == NODE_SKETCH)
604 {
605 sketchwidget_wipe_undo(mainview->sk);
606 sketchwidget_set_fillmode(mainview->sk, FALSE);
607 sketchwidget_set_shift(mainview->sk, FALSE);
608 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->shapemenuitems[1]), TRUE);
609 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->shapemenuitems[0]), TRUE);
610
611 blobsize = sqlite3_column_bytes(stmt, 2);
612 blob = (char *)sqlite3_column_blob(stmt, 2);
613 gboolean clear = TRUE;
614
615 if (blob == NULL)
616 goterr = FALSE;
617 if (blob != NULL)
618 {
619 fprintf(stderr, "blobsize:%d\n", blobsize);
620 GdkPixbufLoader *pl = gdk_pixbuf_loader_new_with_type("png", NULL);
621 GError *err = NULL;
622
623 gdk_pixbuf_loader_write(pl, (guchar *) blob, blobsize, &err);
624 if (err != NULL)
625 {
626 fprintf(stderr, "Error loading sketch! %s\n", err->message);
627 g_error_free(err);
628 err = NULL;
629 }
630 gdk_pixbuf_loader_close(pl, NULL);
631 GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf(pl);
632
633 if (GDK_IS_PIXBUF(pixbuf))
634 {
635 GtkWidget *skdr = sketchwidget_get_drawingarea(mainview->sk);
636 GtkPixmap *skpix = (GtkPixmap *) sketchwidget_get_Pixmap(mainview->sk);
637
638 int w=gdk_pixbuf_get_width(pixbuf);
639 int h=gdk_pixbuf_get_height(pixbuf);
640 if (w!=skdr->allocation.width || h!=skdr->allocation.height)
641 {
642 if (w>skdr->allocation.width) w=skdr->allocation.width;
643 if (h>skdr->allocation.height) h=skdr->allocation.height;
644 sketchwidget_clear_real(mainview->sk);
645 }
646 gdk_draw_pixbuf(GDK_DRAWABLE(skpix), NULL, pixbuf, 0, 0, 0, 0, w, h, GDK_RGB_DITHER_NONE, 0, 0);
647
648 clear = FALSE;
649 goterr = FALSE;
650
651 if (skpix && G_IS_OBJECT(skpix)) g_object_unref(skpix);
652 }
653 else
654 {
655 fprintf(stderr, "error loading pixbuf\n");
656 }
657 g_object_unref(pl);
658 }
659 if (clear == TRUE)
660 {
661 fprintf(stderr, "clearing pix area\n");
662 sketchwidget_clear_real(mainview->sk);
663 }
664 gtk_widget_queue_draw(sketchwidget_get_drawingarea(mainview->sk));
665 }
666 else if (nd->typ == NODE_CHECKLIST)
667 {
668 gtk_object_set_data(GTK_OBJECT(mainview->listview), "edited", FALSE);
669 GtkTreeModel *model=gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
670 g_object_ref(model);
671 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->listview), NULL);
672 gtk_list_store_clear(GTK_LIST_STORE(model));
673
674 snprintf(tq, sizeof(tq), "SELECT name, style, color FROM %s WHERE nodeid=%d ORDER BY ord, idx", checklisttable_tmpname, nd->sql3id);
675 sqlite3_stmt *stmt2 = NULL;
676 const char *dum;
677 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt2, &dum);
678 if (rc)
679 {
680 fprintf(stderr, "Error reading checklist (1) %s\n", sqlite3_errmsg(mainview->db));
681 }
682 else
683 {
684 goterr=FALSE;
685 rc = SQLITE_BUSY;
686 while(rc == SQLITE_BUSY || rc == SQLITE_ROW)
687 {
688 rc = sqlite3_step(stmt2);
689 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
690 break;
691 else if (rc == SQLITE_ROW)
692 {
693 char *textdata = (char *)sqlite3_column_text(stmt2, 0);
694 int style = sqlite3_column_int(stmt2, 1);
695 unsigned long col = sqlite3_column_int(stmt2, 2);
696
697 GtkTreeIter toplevel;
698 gtk_list_store_append(GTK_LIST_STORE(model), &toplevel);
699 gtk_list_store_set(GTK_LIST_STORE(model), &toplevel, CHECKNODE_TEXT, textdata, CHECKNODE_CHECKED, FALSE, -1);
700 if ((style & CHECKSTYLE_CHECKED)>0) gtk_list_store_set(GTK_LIST_STORE(model), &toplevel, CHECKNODE_CHECKED, TRUE, -1);
701 if ((style & CHECKSTYLE_BOLD)>0) gtk_list_store_set(GTK_LIST_STORE(model), &toplevel, CHECKNODE_BOLD, PANGO_WEIGHT_BOLD, -1);
702 if ((style & CHECKSTYLE_STRIKE)>0) gtk_list_store_set(GTK_LIST_STORE(model), &toplevel, CHECKNODE_STRIKE, TRUE, -1);
703
704 if (col>0)
705 {
706 char tmp[10];
707 snprintf(tmp, sizeof(tmp), "#%02x%02x%02x", ((col & 0xFF0000) >> 16), ((col & 0xFF00) >> 8), (col & 0xFF));
708 /* fprintf(stderr, "read color for node is *%s*\n", tmp);*/
709 gtk_list_store_set(GTK_LIST_STORE(model), &toplevel, CHECKNODE_COLOR, tmp, -1);
710 }
711
712 }
713 }
714 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE)
715 {
716 fprintf(stderr, "Error reading checklist (2) %s\n", sqlite3_errmsg(mainview->db));
717 goterr=TRUE;
718 }
719
720 sqlite3_finalize(stmt2);
721 }
722
723 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->listview), model);
724 g_object_unref(model);
725 }
726
727 if ((nd->flags & NODEFLAG_SKETCHLINES) > 0)
728 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->sketchlinesmenuitems[1]), TRUE);
729 else if ((nd->flags & NODEFLAG_SKETCHGRAPH) > 0)
730 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->sketchlinesmenuitems[2]), TRUE);
731 else
732 {
733 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->sketchlinesmenuitems[0]), TRUE);
734 callback_sketchlines(NULL, mainview->sketchlinesmenuitems[0]); /*FIXME:ugly */
735 }
736 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->tools_pressure), TRUE);
737
738 break;
739 }
740 }
741 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE)
742 fprintf(stderr, "Error reading (2) %s\n", sqlite3_errmsg(mainview->db));
743
744 sqlite3_finalize(stmt);
745 }
746
747 setBusy(mainview, 2);
748
749 if (goterr == TRUE)
750 {
751 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Error loading memo"));
752 }
753 }
754
755 gboolean treeview_canselect(GtkTreeSelection * selection, GtkTreeModel * model, GtkTreePath * path, gboolean path_currently_selected, gpointer userdata)
756 {
757 MainView *mainview = (MainView *) userdata;
758 g_assert(mainview != NULL && mainview->data != NULL);
759
760 if (mainview->loading==FALSE)
761 {
762 #ifndef EXPANDING_ROWS
763 if (path_currently_selected)
764 return (FALSE);
765 #endif
766 }
767 #ifndef NEW_SEL_LOGIC
768 saveCurrentData(mainview);
769 #else
770 if (path_currently_selected)
771 {
772 GtkTreeIter iter;
773 gtk_tree_model_get_iter(model, &iter, path);
774
775 gtk_tree_model_get(model, &iter, NODE_DATA, &(mainview->cansel_node), -1);
776 mainview->cansel_time=time(NULL);
777 /* fprintf(stderr, "[SELLOGIC] canselect called for node %d\n", nd->sql3id);*/
778 }
779 #endif
780
781 return (TRUE);
782 }
783
784 gboolean newnodedlg_key_press_cb(GtkWidget * widget, GdkEventKey * event, GtkWidget * dlg)
785 {
786 SketchWidget *s = gtk_object_get_data(GTK_OBJECT(dlg), "sk");
787
788 switch (event->keyval)
789 {
790 case GDK_F7:
791 sketchwidget_redo(s);
792 return TRUE;
793 case GDK_F8:
794 sketchwidget_undo(s);
795 return TRUE;
796 return TRUE;
797 }
798 return FALSE;
799 }
800
801 void new_node_dialog(nodeType typ, MainView * mainview)
802 {
803 GtkWidget *dialog, *label, *entry, *but_ok, *but_cancel, *vbox, *hbox, *al, *cb, *rb1, *rb2, *rb3;
804
805 dialog = gtk_dialog_new();
806
807 g_signal_connect(G_OBJECT(dialog), "key_press_event", G_CALLBACK(newnodedlg_key_press_cb), dialog);
808
809 GtkWidget *notebook = gtk_notebook_new();
810
811 vbox = gtk_vbox_new(FALSE, 0);
812 gtk_container_border_width(GTK_CONTAINER(vbox), 15);
813
814 hbox = gtk_hbox_new(FALSE, 0);
815
816 rb1=gtk_radio_button_new_with_label(NULL, _("Text memo"));
817 gtk_box_pack_start(GTK_BOX(hbox), rb1, FALSE, FALSE, 0);
818 gtk_object_set_data(GTK_OBJECT(dialog), "rbt", rb1); /*FIXME: not pretty*/
819
820 rb2=gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(rb1)), _("Sketch memo"));
821 gtk_box_pack_start(GTK_BOX(hbox), rb2, FALSE, FALSE, 0);
822 gtk_object_set_data(GTK_OBJECT(dialog), "rbs", rb2); /*FIXME: not pretty*/
823
824 rb3=gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(rb1)), _("Checklist"));
825 gtk_box_pack_start(GTK_BOX(hbox), rb3, FALSE, FALSE, 0);
826 gtk_object_set_data(GTK_OBJECT(dialog), "rbc", rb3); /*FIXME: not pretty*/
827
828 if (typ==NODE_TEXT) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rb1), TRUE);
829 else if (typ==NODE_SKETCH) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rb2), TRUE);
830 else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rb3), TRUE);
831
832 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox);
833
834 label = gtk_label_new(_("Text name"));
835 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, label);
836 label = gtk_label_new(_("Please name the memo:"));
837 entry = gtk_entry_new_with_max_length(64);
838 gtk_entry_set_text(GTK_ENTRY(entry), _("New memo"));
839 gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
840
841 gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
842 gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0);
843
844 vbox = gtk_vbox_new(FALSE, 0);
845 gtk_container_border_width(GTK_CONTAINER(vbox), 15);
846 label = gtk_label_new(_("Sketch name"));
847 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, label);
848
849 label = gtk_label_new(_("Please name the memo:"));
850
851 al = gtk_alignment_new(0.5, 0.5, 0, 0);
852
853 SketchWidget *s = sketchwidget_new(SKETCHNODE_X, SKETCHNODE_Y, TRUE);
854
855 sketchwidget_set_brushsize(s, 2);
856 sketchwidget_set_backstyle(s, SKETCHBACK_GRAPH);
857
858 gtk_widget_set_size_request(sketchwidget_get_mainwidget(s), SKETCHNODE_X, SKETCHNODE_Y);
859 gtk_container_add(GTK_CONTAINER(al), sketchwidget_get_mainwidget(s));
860
861 gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
862 gtk_box_pack_start(GTK_BOX(vbox), al, FALSE, FALSE, 0);
863
864 but_ok = gtk_button_new_with_label(_("Create"));
865 but_cancel = gtk_button_new_with_label(_("Cancel"));
866 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), but_ok);
867 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), but_cancel);
868
869 gtk_object_set_user_data(GTK_OBJECT(dialog), entry);
870 gtk_object_set_data(GTK_OBJECT(dialog), "m", mainview);
871 gtk_object_set_data(GTK_OBJECT(dialog), "sk", s);
872 gtk_object_set_data(GTK_OBJECT(dialog), "n", notebook);
873
874 nodeType *tmp = g_malloc(sizeof(nodeType)); /*FIXME memleak:not freed on widget_destroy */
875 *tmp = typ;
876 gtk_object_set_data(GTK_OBJECT(dialog), "t", tmp);
877
878 gtk_signal_connect_object(GTK_OBJECT(but_cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), dialog);
879 g_signal_connect(G_OBJECT(but_ok), "clicked", G_CALLBACK(callback_new_node_real), dialog);
880
881 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), notebook);
882
883 cb = gtk_check_button_new_with_label(_("Create as childnode"));
884 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cb), mainview->newnodedialog_createchild);
885 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), cb);
886 gtk_object_set_data(GTK_OBJECT(dialog), "cb", cb);
887
888 gtk_widget_grab_focus(entry);
889
890 gtk_widget_show_all(dialog);
891 gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
892 }
893
894 void add_new_node(nodeData * node, MainView * mainview, gboolean ischild)
895 {
896 GtkTreeIter parentiter, newiter;
897 GtkTreeModel *model;
898 void *ptr = NULL;
899
900 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
901
902 if (gtk_tree_selection_get_selected(selection, &model, &parentiter))
903 ptr = &parentiter;
904
905 GtkTreePath *path = NULL;
906
907 unsigned int parentnodeid = 0;
908
909 if (ptr != NULL)
910 {
911 path = gtk_tree_model_get_path(model, &parentiter);
912
913 if (ischild == FALSE)
914 {
915 gtk_tree_path_up(path);
916
917 if (gtk_tree_path_get_depth(path) == 0)
918 {
919 /* Selected node is a root node */
920 ptr = NULL; /* New node can not have a Parent node */
921 gtk_tree_path_down(path); /*restore path so expand() works */
922 }
923 else if (gtk_tree_path_get_depth(path) > 0)
924 {
925 /* Selected node is a child node */
926 if (gtk_tree_model_get_iter(model, &parentiter, path))
927 ptr = &parentiter;
928 }
929 }
930 }
931
932 if (ptr != NULL)
933 {
934 nodeData *nd;
935
936 gtk_tree_model_get(model, ptr, NODE_DATA, &nd, -1);
937 if (nd)
938 parentnodeid = nd->sql3id;
939 }
940
941 node->sql3id = 0;
942 do
943 {
944 sqlite3_stmt *stmt = NULL;
945 const char *dum;
946 char tq[512];
947
948 /*
949 * FIXME: ord
950 */
951 snprintf(tq, sizeof(tq), "INSERT INTO %s (parent, bodytype, name, nameblob, ord) VALUES (%d, %d, ?, ?, 0);", datatable_tmpname, parentnodeid, node->typ);
952 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt, &dum);
953
954 if (rc)
955 {
956 fprintf(stderr, "Error inserting(1): %s\n", sqlite3_errmsg(mainview->db));
957 break;
958 }
959 if (node->name != NULL)
960 sqlite3_bind_text(stmt, 1, node->name, strlen(node->name), SQLITE_TRANSIENT);
961 else
962 sqlite3_bind_text(stmt, 1, NULL, 0, SQLITE_TRANSIENT);
963
964 if (node->namepix != NULL)
965 {
966 gchar *namepixdata = NULL;
967 gsize datalen = 0;
968
969 GError *err = NULL;
970
971 if (gdk_pixbuf_save_to_buffer(node->namepix, &namepixdata, &datalen, "png", &err, NULL) == FALSE)
972 {
973 namepixdata = NULL;
974 datalen = 0;
975 fprintf(stderr, "Error saving name! %s\n", err->message);
976 g_error_free(err);
977 }
978 sqlite3_bind_blob(stmt, 2, namepixdata, datalen, SQLITE_TRANSIENT);
979 }
980 else
981 sqlite3_bind_blob(stmt, 2, NULL, 0, SQLITE_TRANSIENT);
982
983 rc = SQLITE_BUSY;
984 while(rc == SQLITE_BUSY)
985 {
986 rc = sqlite3_step(stmt);
987 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
988 break;
989 }
990 sqlite3_finalize(stmt);
991 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE)
992 {
993 fprintf(stderr, "Error inserting(2): %s\n", sqlite3_errmsg(mainview->db));
994 break;
995 }
996 node->sql3id = sqlite3_last_insert_rowid(mainview->db);
997 }
998 while(FALSE);
999
1000 if (node->sql3id == 0)
1001 {
1002 if (node->name)
1003 g_free(node->name);
1004 if (node->namepix)
1005 g_object_unref(node->namepix);
1006 g_free(node);
1007 if (path)
1008 gtk_tree_path_free(path);
1009 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, "Error creating node");
1010 return;
1011 }
1012
1013 gtk_tree_store_append(GTK_TREE_STORE(model), &newiter, ptr);
1014
1015 gtk_tree_store_set(GTK_TREE_STORE(model), &newiter, NODE_NAME, node->name, NODE_PIXBUF, node->namepix, NODE_DATA, node, -1);
1016
1017 if (path)
1018 {
1019 mainview->loading=TRUE; /*only when we have a valid parent*/
1020 gtk_tree_view_expand_row(GTK_TREE_VIEW(mainview->treeview), path, FALSE);
1021 gtk_tree_path_free(path);
1022 }
1023
1024 gtk_tree_selection_select_iter(selection, &newiter);
1025
1026 mainview->loading=FALSE;
1027 }
1028
1029 void callback_new_node_real(GtkAction * action, gpointer data)
1030 {
1031 MainView *mainview;
1032
1033 GtkWidget *dialog = data;
1034 GtkWidget *entry = gtk_object_get_user_data(GTK_OBJECT(dialog));
1035
1036 mainview = gtk_object_get_data(GTK_OBJECT(dialog), "m");
1037 SketchWidget *s = gtk_object_get_data(GTK_OBJECT(dialog), "sk");
1038 GtkWidget *notebook = gtk_object_get_data(GTK_OBJECT(dialog), "n");
1039 GtkWidget *cb = gtk_object_get_data(GTK_OBJECT(dialog), "cb");
1040 /* nodeType *typ = gtk_object_get_data(GTK_OBJECT(dialog), "t");*/
1041
1042 nodeType typ = NODE_TEXT;
1043
1044 /* GtkWidget *rbt = gtk_object_get_data(GTK_OBJECT(dialog), "rbt");*/
1045 GtkWidget *rbs = gtk_object_get_data(GTK_OBJECT(dialog), "rbs");
1046 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(rbs))) typ=NODE_SKETCH;
1047
1048 GtkWidget *rbc = gtk_object_get_data(GTK_OBJECT(dialog), "rbc");
1049 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(rbc))) typ=NODE_CHECKLIST;
1050
1051 gint t = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
1052
1053 gchar *txt = NULL;
1054 GdkPixbuf *pixbuf = NULL;
1055
1056 if (t == 0)
1057 {
1058 txt = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
1059 if (strcmp(txt, "") == 0)
1060 {
1061 g_free(txt);
1062 return;
1063 }
1064 }
1065 else
1066 {
1067 GtkWidget *sdr = sketchwidget_get_drawingarea(s);
1068
1069 GdkPixmap *spix = sketchwidget_get_Pixmap(s);
1070
1071 pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE(spix), NULL, 0, 0, 0, 0, sdr->allocation.width, sdr->allocation.height);
1072 g_object_unref(spix);
1073 double w, h;
1074 GdkPixbuf *pixbuf2 = sketchwidget_trim_image(pixbuf, SKETCHNODE_X, SKETCHNODE_Y, &w,
1075 &h, TRUE);
1076 if (pixbuf2==NULL) return;
1077
1078 GdkPixbuf *pixbuf3 = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, SKETCHNODE_RX,
1079 SKETCHNODE_RY);
1080
1081 gdk_pixbuf_fill(pixbuf3, 0xffffffff);
1082
1083 if (w <= SKETCHNODE_RX && h <= SKETCHNODE_RY)
1084 {
1085 gdk_pixbuf_copy_area(pixbuf2, 0, 0, w, h, pixbuf3, 0, (SKETCHNODE_RY - h) / 2);
1086 }
1087 else
1088 {
1089 double neww, newh;
1090
1091 if (w > h)
1092 {
1093 neww = SKETCHNODE_RX;
1094 newh = (h / w) * SKETCHNODE_RX;
1095 }
1096 else
1097 {
1098 newh = SKETCHNODE_RY;
1099 neww = (w / h) * SKETCHNODE_RY;
1100 }
1101 if (newh > SKETCHNODE_RY)
1102 newh = SKETCHNODE_RY; /*FIXME: newh exceeds SKETCHNODE_RY sometimes */
1103
1104 GdkPixbuf *tmpbuf = gdk_pixbuf_scale_simple(pixbuf2, neww, newh,
1105 GDK_INTERP_BILINEAR);
1106
1107 gdk_pixbuf_copy_area(tmpbuf, 0, 0, neww, newh, pixbuf3, 0, (SKETCHNODE_RY - newh) / 2);
1108
1109 gdk_pixbuf_unref(tmpbuf);
1110 }
1111
1112 pixbuf = pixbuf3;
1113 gdk_pixbuf_unref(pixbuf2);
1114 }
1115
1116 nodeData *node;
1117
1118 node = g_malloc(sizeof(nodeData));
1119 node->typ = typ;
1120 /* node->typ = *typ;
1121 g_free(typ);*/
1122 node->name = NULL;
1123 node->namepix = NULL;
1124
1125 if (t == 0)
1126 {
1127 node->name = txt;
1128 }
1129 else if (t == 1)
1130 {
1131 node->namepix = pixbuf;
1132 }
1133
1134 node->lastMod = 0;
1135 node->flags = 0;
1136 node->sql3id = 0;
1137
1138 mainview->newnodedialog_createchild = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cb));
1139 add_new_node(node, mainview, mainview->newnodedialog_createchild);
1140
1141 sketchwidget_destroy(s);
1142 gtk_widget_destroy(dialog);
1143 mainview->file_edited = TRUE;
1144 }
1145
1146 /*
1147 * delete node
1148 */
1149 void callback_file_delete_node(GtkAction * action, gpointer data)
1150 {
1151 MainView *mainview = (MainView *) data;
1152 g_assert(mainview != NULL && mainview->data != NULL);
1153
1154 if (getSelectedNode(mainview) == NULL)
1155 {
1156 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Select a node first"));
1157 return;
1158 }
1159
1160 GtkWidget *dialog, *label, *but_ok, *but_cancel;
1161
1162 dialog = gtk_dialog_new();
1163
1164 label = gtk_label_new(_("Delete current memo?"));
1165
1166 but_ok = gtk_button_new_with_label(_("Yes, Delete"));
1167 but_cancel = gtk_button_new_with_label(_("Cancel"));
1168
1169 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), but_ok);
1170 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), but_cancel);
1171
1172 gtk_object_set_user_data(GTK_OBJECT(dialog), mainview);
1173
1174 gtk_signal_connect_object(GTK_OBJECT(but_cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), dialog);
1175 g_signal_connect(G_OBJECT(but_ok), "clicked", G_CALLBACK(callback_delete_node_real), dialog);
1176
1177 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
1178
1179 gtk_widget_show_all(dialog);
1180 gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
1181 }
1182
1183 /*
1184 * Callback for Rename Menuitem
1185 */
1186 void callback_file_rename_node(GtkAction * action, gpointer data)
1187 {
1188 MainView *mainview = (MainView *) data;
1189 g_assert(mainview != NULL && mainview->data != NULL);
1190
1191 /* Get the selected node */
1192 nodeData *sel_node = getSelectedNode(mainview);
1193 if (!sel_node)
1194 {
1195 /* Do nothing, if no node has been selected */
1196 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Select a node first"));
1197 return;
1198 }
1199
1200 /* Create dialog box */
1201 GtkWidget *dialog, *label, *entry, *but_ok, *but_cancel;
1202
1203 dialog = gtk_dialog_new();
1204
1205 label = gtk_label_new(_("New Memo name:"));
1206
1207 entry = gtk_entry_new_with_max_length(64);
1208 gtk_entry_set_text (GTK_ENTRY(entry), "Type here");
1209 gtk_editable_select_region (GTK_EDITABLE(entry), 0, -1);
1210
1211 but_ok = gtk_button_new_with_label(_("OK"));
1212 but_cancel = gtk_button_new_with_label(_("Cancel"));
1213
1214 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), but_ok);
1215 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), but_cancel);
1216
1217 g_object_set_data(G_OBJECT(dialog), "m", mainview);
1218 g_object_set_data(G_OBJECT(dialog), "e", entry);
1219
1220 gtk_signal_connect_object(GTK_OBJECT(but_cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), dialog);
1221 g_signal_connect(G_OBJECT(but_ok), "clicked", G_CALLBACK(callback_rename_node_real), dialog);
1222
1223 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
1224 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), entry);
1225
1226 gtk_box_set_spacing (GTK_DIALOG(dialog)->vbox, 10);
1227
1228 gtk_widget_show_all(dialog);
1229 gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
1230 }
1231
1232 /*
1233 * Callback for Rename Dialog
1234 */
1235 void callback_rename_node_real (GtkAction *action, gpointer data)
1236 {
1237 MainView *mainview;
1238 GtkWidget *entry;
1239 GtkTreeIter iter;
1240 GtkTreeModel *model;
1241 nodeData *nd = NULL;
1242
1243 GtkWidget *dialog = data;
1244
1245 mainview = g_object_get_data (G_OBJECT(dialog), "m");
1246 entry = g_object_get_data (G_OBJECT(dialog), "e");
1247
1248 /* Checking whether the entry is empty */
1249 gchar *new_node_name = gtk_entry_get_text (GTK_ENTRY(entry));
1250 if (strcmp (new_node_name, "") == 0) {
1251 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Name can not be empty"));
1252 return;
1253 }
1254
1255 /* Get the selected node */
1256 GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(mainview->treeview));
1257
1258 if (!gtk_tree_selection_get_selected (selection, &model, &iter))
1259 return;
1260
1261 gtk_tree_model_get (model, &iter, NODE_DATA, &nd, -1);
1262 if (!nd)
1263 return;
1264
1265 /* If we reach here, all checkings are done */
1266 /* Update the database */
1267 char tq[512];
1268 unsigned int sql3id = nd->sql3id;
1269 sqlite3_stmt *stmt = NULL;
1270 const char* dum;
1271 gboolean db_query_result = FALSE;
1272
1273 do {
1274 snprintf (tq, sizeof(tq), "UPDATE %s SET name=\"%s\" WHERE nodeid=%d",
1275 datatable_tmpname, new_node_name, sql3id);
1276 int rc = sqlite3_prepare (mainview->db, tq, strlen(tq), &stmt, &dum);
1277
1278 if (rc) {
1279 fprintf (stderr, "Error preparing db update query: %s\n", sqlite3_errmsg(mainview->db));
1280 break;
1281 }
1282 rc = SQLITE_BUSY;
1283 while (rc == SQLITE_BUSY) {
1284 rc = sqlite3_step (stmt);
1285 if (rc == SQLITE_DONE) {
1286 db_query_result = TRUE;
1287 break;
1288 }
1289 else if(rc == SQLITE_ERROR || rc== SQLITE_MISUSE) {
1290 fprintf (stderr, "Error updating node: %s\n", sqlite3_errmsg(mainview->db));
1291 break;
1292 }
1293 sqlite3_finalize(stmt);
1294 }
1295 } while (FALSE);
1296
1297 /* Update the tree */
1298 if (db_query_result)
1299 gtk_tree_store_set (GTK_TREE_STORE(model), &iter, NODE_NAME, new_node_name, -1);
1300
1301 mainview->file_edited = TRUE;
1302
1303 /* Destroy the dialog */
1304 gtk_widget_destroy (dialog);
1305 }
1306
1307 void callback_file_expand_collapse_node(GtkAction * action, gpointer data)
1308 {
1309 MainView *mainview = (MainView *) data;
1310 g_assert(mainview != NULL && mainview->data != NULL);
1311
1312 GtkTreeIter iter;
1313 GtkTreeModel *model;
1314
1315 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
1316
1317 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
1318 {
1319 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Select a node first"));
1320 return;
1321 }
1322
1323 GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
1324 if (gtk_tree_view_row_expanded(GTK_TREE_VIEW(mainview->treeview), path)==FALSE)
1325 {
1326 gtk_tree_view_expand_row(GTK_TREE_VIEW(mainview->treeview), path, FALSE);
1327 }
1328 else
1329 {
1330 gtk_tree_view_collapse_row(GTK_TREE_VIEW(mainview->treeview), path);
1331 }
1332
1333 gtk_tree_path_free(path);
1334 }
1335
1336 void callback_file_export_node(GtkAction * action, gpointer data)
1337 {
1338 MainView *mainview = (MainView *) data;
1339 g_assert(mainview != NULL && mainview->data != NULL);
1340
1341 nodeData *nd=getSelectedNode(mainview);
1342 if (nd == NULL)
1343 {
1344 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Select a memo first"));
1345 return;
1346 }
1347
1348 gchar *nodename=nd->name;
1349 if (nodename==NULL) nodename=_("saved memo");
1350
1351 if (nd->typ == NODE_TEXT)
1352 {
1353 /*
1354 GtkTextIter begin, end;
1355 gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER(mainview->buffer), &begin, &end);
1356 gchar *text = gtk_text_buffer_get_slice(GTK_TEXT_BUFFER(mainview->buffer), &begin, &end, TRUE);
1357 */
1358 GString *gstr=g_string_sized_new(4096);
1359 wp_text_buffer_save_document(mainview->buffer, (WPDocumentSaveCallback)(wp_savecallback), gstr);
1360 gint textlen=gstr->len;
1361 gchar *text=g_string_free(gstr, FALSE);
1362
1363 if (text==NULL || !strcmp(text, ""))
1364 {
1365 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Memo is empty"));
1366 }
1367 else
1368 {
1369 gchar *fn = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_SAVE, nodename, "html");
1370 if (fn!=NULL)
1371 {
1372 GnomeVFSResult vfs_result;
1373 GnomeVFSHandle *handle = NULL;
1374 GnomeVFSFileSize out_bytes;
1375 vfs_result = gnome_vfs_create(&handle, fn, GNOME_VFS_OPEN_WRITE, 0, 0600);
1376 if ( vfs_result != GNOME_VFS_OK ) {
1377 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Export failed"));
1378 }
1379 else
1380 {
1381 gnome_vfs_write(handle, text, textlen, &out_bytes);
1382 gnome_vfs_close(handle);
1383 if (out_bytes==strlen(text)) hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Exported"));
1384 else hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Export incomplete"));
1385 }
1386 g_free(fn);
1387 }
1388 }
1389 g_free(text);
1390 }
1391 else if (nd->typ == NODE_SKETCH)
1392 {
1393 GdkPixmap *skpix = sketchwidget_get_Pixmap(mainview->sk);
1394 GtkWidget *skdr = sketchwidget_get_drawingarea(mainview->sk);
1395 GdkPixbuf *pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE(skpix), NULL, 0, 0, 0, 0, skdr->allocation.width, skdr->allocation.height);
1396 if (pixbuf==NULL)
1397 {
1398 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Memo is empty"));
1399 }
1400 else
1401 {
1402 gchar *fn = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_SAVE, nodename, "png");
1403 if (fn!=NULL)
1404 {
1405 if (gdk_pixbuf_save(pixbuf, fn, "png", NULL, NULL)==FALSE)
1406 {
1407 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Export failed"));
1408 }
1409 else
1410 {
1411 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Exported"));
1412 }
1413 g_free(fn);
1414 }
1415 }
1416 g_object_unref(skpix);
1417 }
1418 else if (nd->typ == NODE_CHECKLIST)
1419 {
1420 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Unimplemented"));
1421 }
1422 }
1423
1424 /*
1425 * callback from menu item
1426 * move selected node down (switch node with next sibling), don't change level of node
1427 */
1428 void callback_move_down_node(GtkAction * action, gpointer data)
1429 {
1430 GtkTreeIter iter;
1431 GtkTreeModel *model;
1432
1433 MainView *mainview = (MainView *) data;
1434 g_assert(mainview != NULL && mainview->data != NULL);
1435
1436 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
1437 gtk_tree_selection_get_selected(selection, &model, &iter);
1438
1439 GtkTreeIter old_iter = iter;/*save pointer to old iter, we will need it during swap nodes*/
1440
1441 if (gtk_tree_model_iter_next(model,&iter)==FALSE)/*get next node*/
1442 return;
1443
1444 GtkTreeStore *treeStore = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview)));
1445 gtk_tree_store_swap(treeStore,&iter,&old_iter);
1446
1447 mainview->file_edited = TRUE;/*we have made changes , if required show "save changes?" dialog in future*/
1448 }
1449
1450 /*
1451 * callback from menu item
1452 * move selected node down (switch node with prev sibling), don't change level of node
1453 */
1454 void callback_move_up_node(GtkAction * action, gpointer data)
1455 {
1456 GtkTreeIter iter;
1457 GtkTreeModel *model;
1458
1459 MainView *mainview = (MainView *) data;
1460 g_assert(mainview != NULL && mainview->data != NULL);
1461
1462 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
1463 gtk_tree_selection_get_selected(selection, &model, &iter);
1464
1465 GtkTreeIter old_iter=iter;/*save pointer to old iter, we will need it during swap nodes*/
1466
1467 if (tree_model_iter_prev(model,&iter)==FALSE)/*get previous node*/
1468 return;
1469
1470 GtkTreeStore *treeStore = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview)));
1471 gtk_tree_store_swap(treeStore,&old_iter,&iter);/*do move*/
1472
1473 mainview->file_edited = TRUE;/*we have made changes , if required show "save changes?" dialog in future*/
1474 }
1475
1476 /*
1477 * callback from menu item
1478 * we change level of actual node with direction to top
1479 */
1480 void callback_move_to_top_level_node(GtkAction * action, gpointer data)
1481 {
1482 GtkTreeIter iter,new_parent;
1483 GtkTreeIter *p_new_parent;
1484 GtkTreeIter parent;
1485 GtkTreeModel *model;
1486
1487 MainView *mainview = (MainView *) data;
1488 g_assert(mainview != NULL && mainview->data != NULL);
1489
1490 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
1491 gtk_tree_selection_get_selected(selection, &model, &iter);
1492
1493 /*at first we need actual parent of selected node*/
1494 if (gtk_tree_model_iter_parent(model,&parent,&iter)==FALSE)
1495 {
1496 /*if parent of selected node is ROOT we can't go higher*/
1497 return;
1498 }
1499 /*we need also new parent, it's parent of actual parent*/
1500 if (gtk_tree_model_iter_parent(model,&new_parent,&parent)==FALSE)
1501 {
1502 /*if our new parent is ROOT we got filled new_parent with invalid value,
1503 so we need set NULL value to p_new_parent (root item)*/
1504 p_new_parent=NULL;
1505 }
1506 else
1507 {
1508 p_new_parent=&new_parent;/*we only redirect pointer to treeiter*/
1509 }
1510
1511 saveCurrentData(mainview);/*we save changes in node befor move*/
1512
1513 /*this move function provide move item with all his children, be careful iter value will change!*/
1514 if (move_node(mainview,p_new_parent,&iter,&parent)==TRUE){
1515
1516 gint id_parent = get_node_id_on_tmp_db(model,p_new_parent);
1517 gint id_node = get_node_id_on_tmp_db(model,&iter);
1518 /*we need also update parent id of moved item*/
1519 char tq[512];
1520 snprintf (tq, sizeof(tq), "UPDATE %s SET parent=%d WHERE nodeid=%d",datatable_tmpname,id_parent ,id_node);
1521 exec_command_on_db(mainview,tq);
1522
1523 /*select new created iter*/
1524 gtk_tree_selection_select_iter(selection,&iter);
1525
1526 mainview->file_edited = TRUE;/*we have made changes , if required show "save changes?" dialog in future*/
1527 }
1528 }
1529
1530 /*
1531 * callback from menu item
1532 * we change level of actual node with direction to bottom
1533 * previous node will be parent of our actual node
1534 */
1535 void callback_move_to_bottom_level_node(GtkAction * action, gpointer data)
1536 {
1537 GtkTreeIter iter;
1538 GtkTreeModel *model;
1539
1540 MainView *mainview = (MainView *) data;
1541 g_assert(mainview != NULL && mainview->data != NULL);
1542
1543 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
1544 gtk_tree_selection_get_selected(selection, &model, &iter);
1545
1546 GtkTreeIter move_iter=iter;/*save pointer to old iter*/
1547
1548 /*we try to get previous node*/
1549 if (tree_model_iter_prev(model,&iter)==FALSE)
1550 return;/*if previous node on the same level doesn't exist we will exit*/
1551
1552 saveCurrentData(mainview);/*we save changes in node befor move*/
1553
1554 /*this move function provide move item with all his children, be careful move_iter value will change!*/
1555 if (move_node(mainview,&iter,&move_iter,NULL)==TRUE)
1556 {
1557 gint id_parent = get_node_id_on_tmp_db(model,&iter);
1558 gint id_node = get_node_id_on_tmp_db(model,&move_iter);
1559
1560 /*we need also update parent id of moved item*/
1561 char tq[512];
1562 snprintf (tq, sizeof(tq), "UPDATE %s SET parent=%d WHERE nodeid=%d",datatable_tmpname,id_parent ,id_node);
1563 exec_command_on_db(mainview,tq);
1564
1565 GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
1566 gtk_tree_view_expand_row(GTK_TREE_VIEW(mainview->treeview), path, FALSE);/*expand parent node*/
1567 gtk_tree_path_free(path);
1568
1569 /*select new created iter*/
1570 gtk_tree_selection_select_iter(selection,&move_iter);
1571
1572 mainview->file_edited = TRUE;/*we have made changes , if required show "save changes?" dialog in future*/
1573 }
1574 }
1575
1576 /*
1577 * move item_to_move to new_parent with his children, this function is designed for change level of node
1578 * we copy item_to_move with his children to new position (after item_befor if is not NULL) and then we
1579 * destroy old node with his children, so ! item_to_move is set with new iter, be careful on this!
1580 */
1581 gboolean move_node(MainView *mainview,GtkTreeIter *new_parent,GtkTreeIter *item_to_move,GtkTreeIter *item_befor)
1582 {
1583 GtkTreeModel *model;
1584
1585 model=gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview));
1586 GtkTreeStore *treeStore = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview)));
1587
1588 nodeData *node;
1589 gtk_tree_model_get(model, item_to_move, NODE_DATA, &node, -1);/*get data from actual iter*/
1590 if (node)
1591 {
1592 GtkTreeIter new_iter;/*create new iter*/
1593 gtk_tree_store_append(treeStore,&new_iter,new_parent);/*append new iter to new parent*/
1594
1595 if (item_befor!=NULL)
1596 gtk_tree_store_move_after(treeStore,&new_iter,item_befor);/*sometimes we need set position*/
1597
1598 gtk_tree_store_set(treeStore, &new_iter, NODE_NAME, node->name,NODE_PIXBUF, node->namepix, NODE_DATA, node, -1);/*set data from old iter*/
1599
1600 GtkTreeIter child;
1601 while (gtk_tree_model_iter_children(model, &child, item_to_move)==TRUE)/*move all childrens while some exits*/
1602 {
1603 if (move_node(mainview,&new_iter,&child,NULL)==FALSE)/*use recursion on children*/
1604 return FALSE;
1605 }
1606
1607 gtk_tree_store_set(treeStore, item_to_move, NODE_DATA, NULL, -1);
1608 gtk_tree_store_remove(treeStore, item_to_move);/*remove node, data need't remove, they are stored in new node*/
1609
1610 /*we need return new value of moved item, so we need assign new_iter to item_to_move*/
1611 /*this code is ugly : new_iter to path and back to item_to_move*/
1612 GtkTreePath *path=gtk_tree_model_get_path(model,&new_iter);
1613 gtk_tree_model_get_iter(model,item_to_move,path);
1614 gtk_tree_path_free(path);
1615 }
1616 else
1617 {
1618 fprintf(stderr,"Get data node failed!\n");
1619 return FALSE;
1620 }
1621
1622 return TRUE;
1623 }
1624
1625 /*
1626 * simple execute of sql command which is stored in sql_string[]
1627 */
1628 gboolean exec_command_on_db(MainView *mainview,char sql_string[])
1629 {
1630 sqlite3_stmt *stmt = NULL;
1631 const char* dum;
1632 gboolean db_query_result = FALSE;
1633
1634 int rc = sqlite3_prepare (mainview->db, sql_string, strlen(sql_string), &stmt, &dum);
1635
1636 if (rc) {
1637 fprintf (stderr, "Error preparing db update query: %s\n", sqlite3_errmsg(mainview->db));
1638 return FALSE;
1639 }
1640
1641 rc = SQLITE_BUSY;
1642 while (rc == SQLITE_BUSY) {
1643 rc = sqlite3_step (stmt);
1644 if (rc == SQLITE_DONE) {
1645 db_query_result = TRUE;
1646 break;
1647 }
1648 else if(rc == SQLITE_ERROR || rc== SQLITE_MISUSE) {
1649 fprintf (stderr, "Error updating node: %s\n", sqlite3_errmsg(mainview->db));
1650 break;
1651 }
1652 sqlite3_finalize(stmt);
1653 }
1654 return TRUE;
1655 }
1656
1657 /*
1658 * it is used in gtk_tree_model_foreach function to update ord value for all nodes (it's usefull for move up, move down node)
1659 */
1660 gboolean foreach_func_update_ord (GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter, MainView *mainview)
1661 {
1662 nodeData *node;
1663 gtk_tree_model_get(model, iter, NODE_DATA, &node, -1);
1664 /*we need index of node on actual level*/
1665 gint index=get_branch_node_index(path);
1666
1667 /*prepare to execute update command,and exec it*/
1668 char sql_command[512];
1669 snprintf (sql_command, sizeof(sql_command), "UPDATE %s SET ord=\"%d\" WHERE nodeid=%d",datatable_tmpname, index, node->sql3id);
1670 exec_command_on_db(mainview,sql_command);
1671
1672 /*we don't want break gtk_tree_model_foreach function,until we call this func on each node - so we return always FALSE*/
1673 return FALSE;
1674 }
1675
1676 /*
1677 * return id number of iter (id number which is used to identify in sql database of nodes)
1678 */
1679 int get_node_id_on_tmp_db(GtkTreeModel *model,GtkTreeIter *iter)
1680 {
1681 if (iter==NULL)
1682 return 0;/*we got ROOT parent here*/
1683
1684 nodeData *node;
1685 gtk_tree_model_get(model, iter, NODE_DATA, &node, -1);
1686 return node->sql3id;
1687 }
1688
1689 /*
1690 * get index of node in current branch
1691 */
1692 gint get_branch_node_index(GtkTreePath *path)
1693 {
1694 int depth=gtk_tree_path_get_depth(path);
1695 gint *indicies = gtk_tree_path_get_indices(path);
1696
1697 return indicies[depth-1];
1698 }
1699
1700 /*
1701 * similiar with gtk_tree_model_iter_next (), but opposite
1702 */
1703 gboolean tree_model_iter_prev(GtkTreeModel *tree_model,GtkTreeIter *iter)
1704 {
1705 GtkTreePath *path = gtk_tree_model_get_path(tree_model, iter);
1706
1707 if (path==NULL){
1708 fprintf(stderr,"Error: path is null\n");
1709 return FALSE;
1710 }
1711
1712 if (gtk_tree_path_prev(path)==FALSE)
1713 return FALSE;
1714
1715 gtk_tree_model_get_iter(tree_model, iter,path);
1716
1717 return TRUE;
1718 }
1719
1720 gboolean ref2iter(GtkTreeModel * model, GtkTreeRowReference * ref, GtkTreeIter * iter)
1721 {
1722 gboolean res = FALSE;
1723 GtkTreePath *path = gtk_tree_row_reference_get_path(ref);
1724
1725 if (gtk_tree_model_get_iter(model, iter, path))
1726 {
1727 res = TRUE;
1728 }
1729 gtk_tree_path_free(path);
1730 return (res);
1731 }
1732
1733 GtkTreeRowReference *iter2ref(GtkTreeModel * model, GtkTreeIter * iter)
1734 {
1735 GtkTreeRowReference *ref;
1736
1737 GtkTreePath *path = gtk_tree_model_get_path(model, iter);
1738
1739 ref = gtk_tree_row_reference_new(model, path);
1740 gtk_tree_path_free(path);
1741 return (ref);
1742 }
1743
1744 void move_nodes_up(GtkTreeModel * model, GtkTreeRowReference * topnode, GtkTreeRowReference * newtop)
1745 {
1746 GtkTreeIter topiter;
1747
1748 fprintf(stderr, "here2\n");
1749
1750 if (ref2iter(model, topnode, &topiter) == FALSE)
1751 return;
1752
1753 fprintf(stderr, "here3\n");
1754
1755 GtkTreeIter child;
1756
1757 if (gtk_tree_model_iter_children(model, &child, &topiter))
1758 {
1759 fprintf(stderr, "here4\n");
1760 GtkTreeRowReference *ref;
1761 GList *rr_list = NULL, *node;
1762
1763 do
1764 {
1765 ref = iter2ref(model, &child);
1766 rr_list = g_list_append(rr_list, ref);
1767 }
1768 while(gtk_tree_model_iter_next(model, &child));
1769
1770 /*
1771 * got a reflist for all children
1772 */
1773
1774 fprintf(stderr, "here5\n");
1775 for(node = rr_list; node; node = node->next)
1776 {
1777 ref = (GtkTreeRowReference *) (node->data);
1778 if (ref2iter(model, ref, &child))
1779 {
1780 GtkTreeIter newtopiter, newiter;
1781 GtkTreeIter *newtopiterptr;
1782
1783 if (ref2iter(model, newtop, &newtopiter))
1784 newtopiterptr = &newtopiter;
1785 else
1786 newtopiterptr = NULL;
1787
1788 nodeData *node;
1789
1790 gtk_tree_model_get(model, &child, NODE_DATA, &node, -1);
1791
1792 gtk_tree_store_append(GTK_TREE_STORE(model), &newiter, newtopiterptr);
1793 gtk_tree_store_set(GTK_TREE_STORE(model), &newiter, NODE_NAME, node->name, NODE_PIXBUF, node->namepix, NODE_DATA, node, -1);
1794
1795 GtkTreeRowReference *newref = iter2ref(model, &newiter);
1796
1797 move_nodes_up(model, ref, newref);
1798 gtk_tree_row_reference_free(newref);
1799
1800 gtk_tree_store_remove(GTK_TREE_STORE(model), &child);
1801 }
1802 gtk_tree_row_reference_free(ref);
1803 }
1804 fprintf(stderr, "here6\n");
1805
1806 g_list_free(rr_list);
1807 }
1808
1809 fprintf(stderr, "here7\n");
1810
1811 }
1812
1813 void callback_delete_node_real(GtkAction * action, gpointer data)
1814 {
1815 MainView *mainview;
1816
1817 GtkWidget *dialog = data;
1818
1819 mainview = gtk_object_get_user_data(GTK_OBJECT(dialog));
1820
1821 GtkTreeIter iter;
1822 GtkTreeModel *model;
1823
1824 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
1825
1826 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
1827 return;
1828
1829 nodeData *nd;
1830
1831 gtk_tree_model_get(model, &iter, NODE_DATA, &nd, -1);
1832 if (!nd)
1833 return;
1834
1835 mainview->file_edited = TRUE;
1836
1837 unsigned int sql3id = nd->sql3id;
1838
1839 if (nd->name)
1840 g_free(nd->name);
1841
1842 /*
1843 * g_free(nd->data);
1844 * if (nd->pix) g_object_unref(nd->pix);
1845 */
1846 g_free(nd);
1847
1848 fprintf(stderr, "here1\n");
1849 GtkTreeRowReference *upref = NULL, *ref = NULL;
1850
1851 GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
1852
1853 ref = gtk_tree_row_reference_new(model, path);
1854 if (gtk_tree_path_up(path))
1855 upref = gtk_tree_row_reference_new(model, path);
1856 gtk_tree_path_free(path);
1857
1858 g_object_ref(model);
1859 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), NULL);
1860
1861 fprintf(stderr, "here! 1\n");
1862 move_nodes_up(model, ref, upref);
1863
1864 fprintf(stderr, "here! 2\n");
1865 if (ref2iter(model, ref, &iter))
1866 {
1867 char tq[512];
1868
1869 snprintf(tq, sizeof(tq), "SELECT parent FROM %s WHERE nodeid=%d", datatable_tmpname, sql3id);
1870 sqlite3_stmt *stmt = NULL;
1871 const char *dum;
1872 int rc = sqlite3_prepare(mainview->db, tq, strlen(tq), &stmt, &dum);
1873 unsigned int sql3parentid = 0;
1874
1875 if (rc)
1876 {
1877 fprintf(stderr, "Error %s\n", sqlite3_errmsg(mainview->db));
1878 }
1879 else
1880 {
1881 rc = SQLITE_BUSY;
1882 while(rc == SQLITE_BUSY || rc == SQLITE_ROW)
1883 {
1884 rc = sqlite3_step(stmt);
1885 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
1886 break;
1887 else if (rc == SQLITE_ROW)
1888 {
1889 sql3parentid = sqlite3_column_int(stmt, 0);
1890 break;
1891 }
1892 }
1893 sqlite3_finalize(stmt);
1894
1895 snprintf(tq, sizeof(tq), "UPDATE %s SET parent=%d WHERE parent=%d;", datatable_tmpname, sql3parentid, sql3id);
1896 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
1897 fprintf(stderr, "ERROR moving nodes up!\n");
1898 else
1899 {
1900 snprintf(tq, sizeof(tq), "DELETE FROM %s WHERE nodeid=%d;", datatable_tmpname, sql3id);
1901 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
1902 fprintf(stderr, "ERROR deleting node!\n");
1903 }
1904 }
1905 gtk_tree_store_remove(GTK_TREE_STORE(model), &iter);
1906 }
1907
1908 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), model);
1909 g_object_unref(model);
1910
1911 fprintf(stderr, "here! 3\n");
1912 gtk_tree_row_reference_free(ref);
1913 gtk_tree_row_reference_free(upref);
1914
1915 gtk_tree_view_expand_all(GTK_TREE_VIEW(mainview->treeview));
1916
1917 fprintf(stderr, "here10\n");
1918 gtk_widget_destroy(dialog);
1919 }
1920
1921 void callback_edit_clear(GtkAction * action, gpointer data)
1922 {
1923 MainView *mainview = (MainView *) data;
1924 g_assert(mainview != NULL && mainview->data != NULL);
1925
1926 nodeData *nd = getSelectedNode(mainview);
1927
1928 if (nd->typ == NODE_TEXT) gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mainview->buffer), "", 0);
1929 else if (nd->typ == NODE_SKETCH) sketchwidget_clear(mainview->sk);
1930 else if (nd->typ == NODE_CHECKLIST) gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview))));
1931 }
1932
1933 /*
1934 * cut
1935 */
1936 void callback_edit_cut(GtkAction * action, gpointer data)
1937 {
1938 MainView *mainview = (MainView *) data;
1939 g_assert(mainview != NULL && mainview->data != NULL);
1940
1941 nodeData *nd = getSelectedNode(mainview);
1942
1943 if (nd->typ == NODE_TEXT)
1944 gtk_text_buffer_cut_clipboard(GTK_TEXT_BUFFER(mainview->buffer), mainview->clipboard, TRUE);
1945 else if (nd->typ == NODE_SKETCH)
1946 {
1947 if (sketchwidget_cut(mainview->sk, mainview->clipboard)==FALSE)
1948 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Error cutting"));
1949 }
1950 else if (nd->typ == NODE_CHECKLIST)
1951 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Unimplemented"));
1952
1953 }
1954
1955 /*
1956 * copy
1957 */
1958 void callback_edit_copy(GtkAction * action, gpointer data)
1959 {
1960 MainView *mainview = (MainView *) data;
1961 g_assert(mainview != NULL && mainview->data != NULL);
1962
1963 nodeData *nd = getSelectedNode(mainview);
1964
1965 if (nd->typ == NODE_TEXT)
1966 gtk_text_buffer_copy_clipboard(GTK_TEXT_BUFFER(mainview->buffer), mainview->clipboard);
1967 else if (nd->typ == NODE_SKETCH)
1968 {
1969 if (sketchwidget_copy(mainview->sk, mainview->clipboard)==FALSE)
1970 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Error copying"));
1971 }
1972 else if (nd->typ == NODE_CHECKLIST)
1973 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Unimplemented"));
1974 }
1975
1976 /*
1977 * paste
1978 */
1979 void callback_edit_paste(GtkAction * action, gpointer data)
1980 {
1981 MainView *mainview = (MainView *) data;
1982 g_assert(mainview != NULL && mainview->data != NULL);
1983
1984 nodeData *nd = getSelectedNode(mainview);
1985
1986 if (nd->typ == NODE_TEXT)
1987 gtk_text_buffer_paste_clipboard(GTK_TEXT_BUFFER(mainview->buffer), mainview->clipboard, NULL, TRUE);
1988 else if (nd->typ == NODE_SKETCH)
1989 {
1990 if (sketchwidget_paste(mainview->sk, mainview->clipboard)==FALSE)
1991 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Error pasting"));
1992 }
1993 else if (nd->typ == NODE_CHECKLIST)
1994 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Unimplemented"));
1995
1996 mainview->file_edited = TRUE;
1997 }
1998
1999 gint cb_popup(GtkWidget * widget, GdkEvent * event)
2000 {
2001 GtkMenu *menu;
2002 GdkEventButton *event_button;
2003
2004 /*
2005 * The "widget" is the menu that was supplied when
2006 * * g_signal_connect_swapped() was called.
2007 */
2008 menu = GTK_MENU(widget);
2009 event_button = (GdkEventButton *) event;
2010 if (event->type == GDK_BUTTON_PRESS && event_button->button == 3)
2011 {
2012 gtk_menu_popup(menu, NULL, NULL, NULL, NULL, event_button->button, event_button->time);
2013 return TRUE;
2014 }
2015 return FALSE;
2016 }
2017
2018 /*
2019 * close
2020 */
2021 gboolean closefile(MainView * mainview)
2022 {
2023 saveCurrentData(mainview);
2024
2025 if (mainview->file_edited)
2026 {
2027 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));
2028 gint answer = gtk_dialog_run(GTK_DIALOG(hn));
2029 gtk_widget_destroy(GTK_WIDGET(hn));
2030
2031 if (answer == CONFRESP_CANCEL)
2032 return (FALSE);
2033 else if (answer == CONFRESP_YES)
2034 {
2035 if (mainview->file_name == NULL)
2036 {
2037 mainview->file_name = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_SAVE, "maemopaddata", "db");
2038 }
2039 write_buffer_to_file(mainview);
2040 }
2041 }
2042
2043 if (mainview->db)
2044 sqlite3_close(mainview->db);
2045 mainview->db = NULL;
2046 return (TRUE);
2047 }
2048
2049 gboolean callback_file_close(GtkAction * action, gpointer data)
2050 {
2051
2052 MainView *mainview = (MainView *) data;
2053 g_assert(mainview != NULL && mainview->data != NULL);
2054 if (closefile(mainview) == FALSE)
2055 return(FALSE);
2056
2057 gtk_main_quit();
2058 return(TRUE);
2059 }
2060
2061 void callback_file_new_node(GtkAction * action, gpointer data)
2062 {
2063 MainView *mainview = (MainView *) data;
2064 g_assert(mainview != NULL && mainview->data != NULL);
2065
2066 nodeType typ = NODE_SKETCH;
2067
2068 nodeData *nd = getSelectedNode(mainview);
2069
2070 if (nd != NULL)
2071 typ = nd->typ;
2072
2073 new_node_dialog(typ, mainview);
2074 }
2075
2076 /*
2077 * new
2078 */
2079 void callback_file_new(GtkAction * action, gpointer data)
2080 {
2081 MainView *mainview = (MainView *) data;
2082 g_assert(mainview != NULL && mainview->data != NULL);
2083
2084 gchar *filename = NULL;
2085
2086 if (closefile(mainview) == FALSE)
2087 return;
2088
2089 filename = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_SAVE, "memos", "db");
2090 if (filename == NULL)
2091 return;
2092
2093 new_file(mainview);
2094
2095 do
2096 {
2097 setBusy(mainview, 1);
2098
2099 int rc;
2100
2101 rc = sqlite3_open(filename, &mainview->db);
2102 if (rc)
2103 {
2104 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Error 1"));
2105 fprintf(stderr, "Can't create database %s: %s\n", filename, sqlite3_errmsg(mainview->db));
2106 break;
2107 }
2108
2109 sqlite3_exec(mainview->db, "PRAGMA synchronous = OFF;", NULL, NULL, NULL);
2110
2111 char tq[512];
2112
2113 snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", misctable_name, misctable);
2114 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
2115
2116 snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", datatable_name, datatable);
2117 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
2118 {
2119 fprintf(stderr, "ERROR creating data table\n");
2120 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Error 2"));
2121 break;
2122 }
2123
2124 snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", checklisttable_name, checklisttable);
2125 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
2126 {
2127 fprintf(stderr, "ERROR creating checklist table\n");
2128 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Error 3"));
2129 break;
2130 }
2131
2132 if (mainview->db)
2133 sqlite3_close(mainview->db);
2134 mainview->db = NULL;
2135
2136 mainview->file_name = filename;
2137 mainview->file_edited = FALSE;
2138 read_file_to_buffer(mainview);
2139
2140 /*add a starter memo*/
2141 nodeData *node;
2142 node = g_malloc(sizeof(nodeData));
2143 node->typ = NODE_SKETCH;
2144 node->name = _("My first memo");
2145 node->namepix = NULL;
2146 node->lastMod = 0;
2147 node->flags = 0;
2148 node->sql3id = 0;
2149 add_new_node(node, mainview, TRUE);
2150 gtk_paned_set_position(GTK_PANED(mainview->hpaned), 180);
2151 mainview->viewflags = 3;
2152 callback_setview(mainview, 1);
2153 write_buffer_to_file(mainview);
2154
2155 }while(FALSE);
2156 setBusy(mainview, 0);
2157 }
2158
2159 gboolean reset_ctree(GtkTreeModel * model, GtkTreePath * path, GtkTreeIter * iter, gpointer data)
2160 {
2161 nodeData *node;
2162
2163 gtk_tree_model_get(model, iter, NODE_DATA, &node, -1);
2164 if (node)
2165 {
2166 if (node->name)
2167 g_free(node->name);
2168 if (node->namepix)
2169 g_object_unref(node->namepix);
2170 g_free(node);
2171
2172 gtk_tree_store_set(GTK_TREE_STORE(model), iter, NODE_DATA, NULL, -1);
2173 }
2174 return (FALSE);
2175 }
2176
2177 void new_file(MainView * mainview)
2178 {
2179 setBusy(mainview, 1);
2180 /*
2181 * clear buffer, filename and free buffer text
2182 */
2183 gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mainview->buffer), "", -1);
2184 mainview->file_name = NULL;
2185 mainview->file_edited = FALSE;
2186 mainview->newnodedialog_createchild = TRUE;
2187
2188 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview));
2189
2190 g_object_ref(model);
2191 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), NULL);
2192
2193 gtk_tree_model_foreach(model, (GtkTreeModelForeachFunc) reset_ctree, (gpointer) mainview);
2194
2195 /*
2196 * crashing bastard
2197 * gtk_tree_store_clear(GTK_TREE_STORE(model));
2198 */
2199 GtkTreePath *path = gtk_tree_path_new_from_indices(0, -1);
2200 GtkTreeIter iter;
2201
2202 if (gtk_tree_model_get_iter(model, &iter, path))
2203 {
2204 do
2205 {
2206 gtk_tree_store_remove(GTK_TREE_STORE(model), &iter);
2207 }
2208 while(gtk_tree_store_iter_is_valid(GTK_TREE_STORE(model), &iter));
2209 }
2210 gtk_tree_path_free(path);
2211
2212 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), model);
2213 g_object_unref(model);
2214
2215 prepareUIforNodeChange(mainview, NODE_UNKNOWN);
2216 setBusy(mainview, 2);
2217 }
2218
2219 /*
2220 * open
2221 */
2222 void callback_file_open(GtkAction * action, gpointer data)
2223 {
2224 gchar *filename = NULL;
2225 MainView *mainview = (MainView *) data;
2226 g_assert(mainview != NULL && mainview->data != NULL);
2227
2228 if (closefile(mainview) == FALSE)
2229 return;
2230
2231 /*
2232 * open new file
2233 */
2234 filename = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_OPEN, NULL, NULL);
2235
2236 /*
2237 * if we got a file name from chooser -> open file
2238 */
2239 open_file(filename, mainview);
2240 g_free(filename);
2241 }
2242
2243 gboolean open_file(gchar * filename, MainView * mainview)
2244 {
2245 gboolean ret=FALSE;
2246
2247 setBusy(mainview, 1);
2248
2249 while(filename != NULL)
2250 {
2251 struct stat s;
2252
2253 if (stat(filename, &s) == -1) break;
2254
2255 mainview->file_name = g_strdup(filename);
2256 gboolean res = read_file_to_buffer(mainview);
2257
2258 if (res == FALSE)
2259 {
2260 g_free(mainview->file_name);
2261 mainview->file_name = NULL;
2262 break;
2263 }
2264 mainview->file_edited = FALSE;
2265 ret=TRUE;
2266 break;
2267 }
2268
2269 setBusy(mainview, 2);
2270 return(ret);
2271 }
2272
2273 void callback_about_link(GtkAboutDialog *about, const gchar *link, gpointer data)
2274 {
2275 MainView *mainview = (MainView *) data;
2276 g_assert(mainview != NULL && mainview->data != NULL);
2277 osso_rpc_run_with_defaults(mainview->data->osso, "osso_browser", OSSO_BROWSER_OPEN_NEW_WINDOW_REQ, NULL,
2278 DBUS_TYPE_STRING, link, DBUS_TYPE_INVALID);
2279 }
2280
2281 void callback_about(GtkAction * action, gpointer data)
2282 {
2283 MainView *mainview=(MainView *)data;
2284
2285 const char *authors[] = {
2286 "Kemal Hadimli",
2287 "Thomas Perl",
2288 "Anil Kumar",
2289 "Michal Seben",
2290 "Marko Vertainen",
2291 NULL
2292 };
2293
2294 gtk_about_dialog_set_url_hook(callback_about_link, mainview, NULL);
2295
2296 gtk_show_about_dialog(GTK_WINDOW(mainview->data->main_view),
2297 "name", "Maemopad+",
2298 "authors", authors,
2299 "copyright", "(c) 2006-2008 Kemal Hadimli and the Maemopad+ Team",
2300 "license", "GNU LGPL version 2.1 or later\n\nSee http://www.gnu.org/licenses/lgpl.html",
2301 "version", VERSION,
2302 "website", "http://maemopadplus.garage.maemo.org/",
2303 NULL);
2304
2305 }
2306
2307 /*
2308 * save
2309 */
2310 void callback_file_save(GtkAction * action, gpointer data)
2311 {
2312 gchar *filename = NULL;
2313 MainView *mainview = (MainView *) data;
2314 g_assert(mainview != NULL && mainview->data != NULL);
2315
2316 /*
2317 * check is we had a new file
2318 */
2319 if (mainview->file_name != NULL)
2320 {
2321 write_buffer_to_file(mainview);
2322 }
2323 else
2324 {
2325 filename = interface_file_chooser(mainview, GTK_FILE_CHOOSER_ACTION_SAVE, "maemopaddata", "db");
2326 /*
2327 * if we got a file name from chooser -> save file
2328 */
2329 if (filename != NULL)
2330 {
2331 mainview->file_name = filename;
2332 write_buffer_to_file(mainview);
2333 mainview->file_edited = FALSE;
2334 }
2335 }
2336 }
2337
2338 void callback_shapemenu(GtkAction * action, GtkWidget * wid)
2339 {
2340 int style = (int)gtk_object_get_user_data(GTK_OBJECT(wid));
2341 MainView *mainview = gtk_object_get_data(GTK_OBJECT(wid), "m");
2342
2343 g_assert(mainview != NULL);
2344
2345 if (style==0) sketchwidget_set_shape(mainview->sk, SKETCHSHAPE_FREEHAND);
2346 else if (style==1) sketchwidget_set_shape(mainview->sk, SKETCHSHAPE_LINE);
2347 else if (style==2) sketchwidget_set_shape(mainview->sk, SKETCHSHAPE_RECT);
2348 else if (style==3) sketchwidget_set_shape(mainview->sk, SKETCHSHAPE_ELLIPSE);
2349 }
2350
2351
2352
2353 void callback_eraser(GtkAction * action, MainView * mainview)
2354 {
2355 g_assert(mainview != NULL && mainview->data != NULL);
2356
2357 if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(mainview->eraser_tb)) == TRUE)
2358 {
2359 GdkColor c2;
2360
2361 c2.red = 65535;
2362 c2.green = 65535;
2363 c2.blue = 65535;
2364
2365 mainview->sk->pressuresensitivity=FALSE;
2366
2367 sketchwidget_set_brushcolor(mainview->sk, c2);
2368 mainview->brushsize_backup = sketchwidget_get_brushsize(mainview->sk);
2369 guint ers=(mainview->brushsize_backup*4)+4;
2370 sk_set_brushsize(mainview, ers);
2371 sketchwidget_set_brushsize(mainview->sk, ers); /*fixme:to override max brush size, not pretty*/
2372 }
2373 else
2374 {
2375 GdkColor c2;
2376
2377 #if HILDON == 1
2378 hildon_color_button_get_color(HILDON_COLOR_BUTTON(mainview->colorbutton), &c2);
2379 #else
2380 GdkColor *col = hildon_color_button_get_color(HILDON_COLOR_BUTTON(mainview->colorbutton));
2381 c2.red = col->red;
2382 c2.green = col->green;
2383 c2.blue = col->blue;
2384 #endif
2385
2386 mainview->sk->pressuresensitivity=gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(mainview->tools_pressure));
2387
2388 sketchwidget_set_brushcolor(mainview->sk, c2);
2389 sk_set_brushsize(mainview, mainview->brushsize_backup);
2390 }
2391 }
2392
2393 void callback_toggletree(GtkAction * action, MainView * mainview)
2394 {
2395 g_assert(mainview != NULL && mainview->data != NULL);
2396
2397 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)));
2398
2399 if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(mainview->toggletree_tb))==TRUE)
2400 mainview->viewflags |= 1;
2401 else
2402 mainview->viewflags &= ~1;
2403
2404 callback_setview(mainview, 0);
2405 }
2406
2407 void callback_menu(GtkAction * action, GtkWidget * menu)
2408 {
2409 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
2410 }
2411
2412 void callback_brushsizetb(GtkAction * action, MainView *mainview)
2413 {
2414 g_assert(mainview != NULL && mainview->data != NULL);
2415
2416 if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(mainview->eraser_tb)) == TRUE)
2417 {
2418 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->eraser_tb), FALSE);
2419 }
2420 else
2421 {
2422 callback_menu(NULL, mainview->brushsizemenu);
2423 }
2424 }
2425
2426 void callback_brushsize(GtkAction * action, GtkWidget * wid)
2427 {
2428 int bsize = (int)gtk_object_get_user_data(GTK_OBJECT(wid));
2429 MainView *mainview = gtk_object_get_data(GTK_OBJECT(wid), "m");
2430
2431 g_assert(mainview != NULL && mainview->data != NULL);
2432
2433 sketchwidget_set_brushsize(mainview->sk, bsize);
2434
2435 GtkWidget *pix = gtk_object_get_data(GTK_OBJECT(wid), "i");
2436
2437 gtk_widget_show(pix);
2438 gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(mainview->brushsize_tb), pix);
2439 }
2440
2441 void callback_sketchlines(GtkAction * action, GtkWidget * wid)
2442 {
2443 int style = (int)gtk_object_get_user_data(GTK_OBJECT(wid));
2444 MainView *mainview = gtk_object_get_data(GTK_OBJECT(wid), "m");
2445
2446 g_assert(mainview != NULL);
2447
2448 nodeData *nd = getSelectedNode(mainview);
2449 gboolean doit = FALSE;
2450
2451 if (nd != NULL && nd->typ == NODE_SKETCH)
2452 {
2453 nd->flags &= ~NODEFLAG_SKETCHLINES;
2454 nd->flags &= ~NODEFLAG_SKETCHGRAPH;
2455 /* sketchwidget_set_edited(mainview->sk, TRUE);*/ /*we call this on openfile, so this messes things up*/
2456 doit = TRUE;
2457 }
2458
2459 if (style == 0)
2460 {
2461 sketchwidget_set_backstyle(mainview->sk, SKETCHBACK_NONE);
2462 }
2463 else if (style == 1)
2464 {
2465 sketchwidget_set_backstyle(mainview->sk, SKETCHBACK_LINES);
2466 if (doit == TRUE)
2467 nd->flags |= NODEFLAG_SKETCHLINES;
2468 }
2469 else if (style == 2)
2470 {
2471 sketchwidget_set_backstyle(mainview->sk, SKETCHBACK_GRAPH);
2472 if (doit == TRUE)
2473 nd->flags |= NODEFLAG_SKETCHGRAPH;
2474 }
2475
2476 GtkWidget *pix = gtk_object_get_data(GTK_OBJECT(wid), "i");
2477
2478 gtk_widget_show(pix);
2479 gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(mainview->sketchlines_tb), pix);
2480 }
2481
2482 void callback_color(HildonColorButton * colorButton, MainView * mainview)
2483 {
2484 g_assert(mainview != NULL && mainview->data != NULL);
2485
2486 nodeData *nd = getSelectedNode(mainview);
2487 if (nd == NULL) return;
2488
2489 GdkColor c2;
2490 #if HILDON == 1
2491 hildon_color_button_get_color(colorButton, &c2);
2492 #else
2493 GdkColor *col = hildon_color_button_get_color(colorButton);
2494 c2.red = col->red;
2495 c2.green = col->green;
2496 c2.blue = col->blue;
2497 #endif
2498
2499 if (nd->typ == NODE_SKETCH)
2500 {
2501 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->eraser_tb), FALSE);
2502 sketchwidget_set_brushcolor(mainview->sk, c2);
2503 }
2504 else if (nd->typ == NODE_CHECKLIST)
2505 {
2506 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
2507 GList* l=gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->listview)), NULL);
2508
2509 char tmp[10];
2510 snprintf(tmp, sizeof(tmp), "#%02x%02x%02x", c2.red>>8, c2.green>>8, c2.blue>>8);
2511
2512 GList* cur=l;
2513 while(cur)
2514 {
2515 GtkTreePath *path=cur->data;
2516
2517 GtkTreeIter iter;
2518 if (gtk_tree_model_get_iter(model, &iter, path))
2519 {
2520 gtk_list_store_set(GTK_LIST_STORE(model), &iter, CHECKNODE_COLOR, tmp, -1);
2521 }
2522 gtk_tree_path_free(path);
2523 cur=cur->next;
2524 }
2525 g_list_free(l);
2526 }
2527 }
2528
2529 void callback_color_invoke(GtkAction * action, gpointer data)
2530 {
2531 MainView *mainview = (MainView *) data;
2532 g_assert(mainview != NULL && mainview->data != NULL);
2533
2534 #if HILDON == 1
2535 gtk_button_clicked(GTK_BUTTON(mainview->colorbutton));
2536 #else
2537 HildonColorButton *hc = HILDON_COLOR_BUTTON(mainview->colorbutton);
2538 gtk_button_clicked(GTK_BUTTON(&hc->button));
2539 #endif
2540 }
2541
2542
2543
2544 void callback_pressure(GtkAction * action, MainView *mainview)
2545 {
2546 g_assert(mainview != NULL && mainview->data != NULL);
2547
2548 nodeData *nd = getSelectedNode(mainview);
2549
2550 if (nd == NULL)
2551 return;
2552 if (nd->typ != NODE_SKETCH)
2553 return;
2554
2555 mainview->sk->pressuresensitivity=gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(mainview->tools_pressure));
2556 }
2557
2558
2559 void callback_wordwrap(GtkAction * action, MainView *mainview)
2560 {
2561 g_assert(mainview != NULL && mainview->data != NULL);
2562
2563 nodeData *nd = getSelectedNode(mainview);
2564
2565 if (nd == NULL)
2566 return;
2567 if (nd->typ != NODE_TEXT)
2568 return;
2569
2570 gboolean act=gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(mainview->tools_wordwrap));
2571 if (act==TRUE) nd->flags |= NODEFLAG_WORDWRAP;
2572 else nd->flags &= ~NODEFLAG_WORDWRAP;
2573
2574 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(mainview->textview), (act==TRUE)?GTK_WRAP_WORD:GTK_WRAP_NONE);
2575 }
2576
2577
2578 void callback_font(GtkAction * action, gpointer data)
2579 {
2580 MainView *mainview = (MainView *) data;
2581 g_assert(mainview != NULL && mainview->data != NULL);
2582
2583 nodeData *nd = getSelectedNode(mainview);
2584
2585 if (nd == NULL)
2586 return;
2587 if (nd->typ != NODE_TEXT)
2588 return;
2589
2590 HildonFontSelectionDialog *dialog = HILDON_FONT_SELECTION_DIALOG(hildon_font_selection_dialog_new(NULL, NULL));
2591
2592 gboolean gotsel=wp_text_buffer_has_selection(mainview->buffer);
2593 /*gotsel=FALSE;*/
2594
2595 WPTextBufferFormat fmt;
2596 wp_text_buffer_get_attributes(mainview->buffer, &fmt, gotsel);
2597
2598 gint ri=0;
2599 if (fmt.text_position==TEXT_POSITION_SUPERSCRIPT) ri=1;
2600 else if (fmt.text_position==TEXT_POSITION_SUBSCRIPT) ri=-1;
2601
2602 g_object_set(G_OBJECT(dialog),
2603 "family-set", fmt.cs.font,
2604 "family", wp_get_font_name(fmt.font),
2605 "size-set", fmt.cs.font_size,
2606 "size", wp_font_size[fmt.font_size],
2607 "color-set", fmt.cs.color,
2608 "color", &fmt.color,
2609 "bold-set", fmt.cs.bold,
2610 "bold", fmt.bold,
2611 "italic-set", fmt.cs.italic,
2612 "italic", fmt.italic,
2613 "underline-set", fmt.cs.underline,
2614 "underline", fmt.underline,
2615 "strikethrough-set", fmt.cs.strikethrough,
2616 "strikethrough", fmt.strikethrough,
2617 "position-set", fmt.cs.text_position,
2618 "position", ri,
2619 NULL);
2620
2621 gtk_widget_show_all(GTK_WIDGET(dialog));
2622 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
2623 {
2624 gboolean bold, italic, underline, strikethrough;
2625 gchar *family = NULL;
2626 gint size, position;
2627 GdkColor *color=NULL;
2628 gboolean set_family, set_size, set_bold, set_italic, set_underline, set_strikethrough, set_color, set_position;
2629
2630 g_object_get(G_OBJECT(dialog), "family", &family, "size", &size, "bold", &bold, "italic", &italic,
2631 "underline", &underline, "strikethrough", &strikethrough,
2632 "family-set", &set_family, "size-set", &set_size, "bold-set", &set_bold, "italic-set", &set_italic,
2633 "underline-set", &set_underline, "strikethrough-set", &set_strikethrough,
2634 "color", &color, "color-set", &set_color, "position", &position, "position-set", &set_position,
2635 NULL);
2636
2637 wp_text_buffer_get_attributes(mainview->buffer, &fmt, FALSE);
2638 fmt.cs.font=fmt.cs.font_size=fmt.cs.strikethrough=fmt.cs.color=fmt.cs.bold=fmt.cs.italic=fmt.cs.underline=fmt.cs.text_position=0;
2639
2640 if (set_family) { fmt.font=wp_get_font_index(family, 1); fmt.cs.font=1; }
2641 if (set_size) { fmt.font_size=wp_get_font_size_index(size, 16); fmt.cs.font_size=1; }
2642
2643 if (set_strikethrough)
2644 {
2645 fmt.cs.strikethrough=1;
2646 fmt.strikethrough=strikethrough;
2647 }
2648
2649 if (set_color)
2650 {
2651 /*
2652 GLIB WARNING ** GLib-GObject - IA__g_object_set_valist: object class `GtkTextTag' has no property named `'
2653 */
2654 fmt.cs.color=1;
2655 fmt.color.pixel=color->pixel;
2656 fmt.color.red=color->red;
2657 fmt.color.green=color->green;
2658 fmt.color.blue=color->blue;
2659 }
2660
2661 if (set_position)
2662 {
2663 if (position==1) ri=TEXT_POSITION_SUPERSCRIPT;
2664 else if (position==-1) ri=TEXT_POSITION_SUBSCRIPT;
2665 else ri=TEXT_POSITION_NORMAL;
2666
2667 fmt.cs.text_position=1;
2668 fmt.text_position=ri;
2669 }
2670
2671 if (set_bold)
2672 {
2673 fmt.cs.bold=1;
2674 fmt.bold=bold;
2675 }
2676 if (set_italic)
2677 {
2678 fmt.cs.italic=1;
2679 fmt.italic=italic;
2680 }
2681 if (set_underline)
2682 {
2683 fmt.cs.underline=1;
2684 fmt.underline=underline;
2685 }
2686
2687 wp_text_buffer_set_format(mainview->buffer, &fmt);
2688 }
2689
2690 gtk_widget_destroy(GTK_WIDGET(dialog));
2691 }
2692
2693 void callback_fontstyle(GtkAction * action, GtkWidget * wid)
2694 {
2695 MainView *mainview = gtk_object_get_data(GTK_OBJECT(wid), "m");
2696 g_assert(mainview != NULL && mainview->data != NULL);
2697
2698 nodeData *nd = getSelectedNode(mainview);
2699
2700 if (nd == NULL)
2701 return;
2702 if (nd->typ == NODE_TEXT)
2703 {
2704 gboolean act=gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(wid));
2705
2706 gint style = (gint)gtk_object_get_data(GTK_OBJECT(wid), "s");
2707 wp_text_buffer_set_attribute(mainview->buffer, style, (gpointer)act);
2708 }
2709 else if (nd->typ == NODE_CHECKLIST)
2710 {
2711 gboolean act=gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(wid));
2712 gint style = (gint)gtk_object_get_data(GTK_OBJECT(wid), "s");
2713 if (style!=WPT_BOLD && style!=WPT_STRIKE && style!=WPT_LEFT) return;
2714
2715 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
2716 GList* l=gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->listview)), NULL);
2717
2718 gint styletoset_weight=PANGO_WEIGHT_NORMAL;
2719 gboolean styletoset_strike=FALSE;
2720 gboolean checkit=FALSE;
2721
2722 if (style==WPT_BOLD && act==TRUE) styletoset_weight=PANGO_WEIGHT_BOLD;
2723 else if (style==WPT_STRIKE && act==TRUE) styletoset_strike=TRUE;
2724 else if (style==WPT_LEFT && act==TRUE) checkit=TRUE;
2725
2726 GList* cur=l;
2727 while(cur)
2728 {
2729 GtkTreePath *path=cur->data;
2730
2731 GtkTreeIter iter;
2732 if (gtk_tree_model_get_iter(model, &iter, path))
2733 {
2734 if (style==WPT_BOLD) gtk_list_store_set(GTK_LIST_STORE(model), &iter, CHECKNODE_BOLD, styletoset_weight, -1);
2735 else if (style==WPT_STRIKE) gtk_list_store_set(GTK_LIST_STORE(model), &iter, CHECKNODE_STRIKE, styletoset_strike, -1);
2736 else if (style==WPT_LEFT) gtk_list_store_set(GTK_LIST_STORE(model), &iter, CHECKNODE_CHECKED, checkit, -1);
2737 }
2738 gtk_tree_path_free(path);
2739 cur=cur->next;
2740 }
2741
2742 g_list_free(l);
2743 gtk_object_set_data(GTK_OBJECT(mainview->listview), "edited", TRUE);
2744 }
2745 }
2746
2747
2748 void callback_textbuffer_move(WPTextBuffer *textbuffer, MainView *mainview)
2749 {
2750 g_assert(mainview != NULL && mainview->data != NULL);
2751
2752 /*
2753 gboolean gotsel=wp_text_buffer_has_selection(mainview->buffer);
2754
2755 _toggle_tool_button_set_inconsistent(GTK_TOGGLE_TOOL_BUTTON(mainview->bold_tb), gotsel);
2756 _toggle_tool_button_set_inconsistent(GTK_TOGGLE_TOOL_BUTTON(mainview->italic_tb), gotsel);
2757 _toggle_tool_button_set_inconsistent(GTK_TOGGLE_TOOL_BUTTON(mainview->underline_tb), gotsel);
2758 _toggle_tool_button_set_inconsistent(GTK_TOGGLE_TOOL_BUTTON(mainview->bullet_tb), gotsel);
2759 */
2760 WPTextBufferFormat fmt;
2761 wp_text_buffer_get_attributes(mainview->buffer, &fmt, FALSE/*gotsel*/);
2762
2763 g_signal_handlers_block_by_func(mainview->bold_tb, callback_fontstyle, mainview->bold_tb);
2764 g_signal_handlers_block_by_func(mainview->italic_tb, callback_fontstyle, mainview->italic_tb);
2765 g_signal_handlers_block_by_func(mainview->underline_tb, callback_fontstyle, mainview->underline_tb);
2766 g_signal_handlers_block_by_func(mainview->bullet_tb, callback_fontstyle, mainview->bullet_tb);
2767
2768 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->bold_tb), fmt.bold);
2769 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->italic_tb), fmt.italic);
2770 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->underline_tb), fmt.underline);
2771 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->bullet_tb), fmt.bullet);
2772
2773 g_signal_handlers_unblock_by_func(mainview->bold_tb, callback_fontstyle, mainview->bold_tb);
2774 g_signal_handlers_unblock_by_func(mainview->italic_tb, callback_fontstyle, mainview->italic_tb);
2775 g_signal_handlers_unblock_by_func(mainview->underline_tb, callback_fontstyle, mainview->underline_tb);
2776 g_signal_handlers_unblock_by_func(mainview->bullet_tb, callback_fontstyle, mainview->bullet_tb);
2777 }
2778
2779 gint wp_savecallback(const gchar *buffer, GString * gstr)
2780 {
2781 gstr=g_string_append(gstr, buffer);
2782 return(0);
2783 }
2784
2785 void callback_undo(GtkAction * action, MainView * mainview)
2786 {
2787 g_assert(mainview != NULL && mainview->data != NULL);
2788
2789 nodeData *nd = getSelectedNode(mainview);
2790
2791 if (nd == NULL) return;
2792
2793 if (nd->typ == NODE_SKETCH) sketchwidget_undo(mainview->sk);
2794 else if (nd->typ == NODE_TEXT) wp_text_buffer_undo(mainview->buffer);
2795 }
2796
2797 void callback_redo(GtkAction * action, MainView * mainview)
2798 {
2799 g_assert(mainview != NULL && mainview->data != NULL);
2800
2801 nodeData *nd = getSelectedNode(mainview);
2802
2803 if (nd == NULL) return;
2804
2805 if (nd->typ == NODE_SKETCH) sketchwidget_redo(mainview->sk);
2806 else if (nd->typ == NODE_TEXT) wp_text_buffer_redo(mainview->buffer);
2807 }
2808
2809 void callback_undotoggle(gpointer widget, gboolean st, MainView * mainview)
2810 {
2811 g_assert(mainview != NULL && mainview->data != NULL);
2812
2813 gtk_widget_set_sensitive(GTK_WIDGET(mainview->undo_tb), st);
2814 }
2815
2816 void callback_redotoggle(gpointer widget, gboolean st, MainView * mainview)
2817 {
2818 g_assert(mainview != NULL && mainview->data != NULL);
2819
2820 gtk_widget_set_sensitive(GTK_WIDGET(mainview->redo_tb), st);
2821 }
2822
2823 void callback_finger(SketchWidget * sk, gint x, gint y, gdouble pressure, MainView * mainview)
2824 {
2825 g_assert(mainview != NULL && mainview->data != NULL);
2826
2827 if ((mainview->viewflags & 2) == 0) mainview->viewflags |= 2;
2828 else mainview->viewflags &= ~2;
2829 callback_setview(mainview, 1);
2830 }
2831
2832 gboolean close_cb(GtkWidget * widget, GdkEventAny * event, MainView * mainview)
2833 {
2834 callback_file_close(NULL, mainview);
2835 return (TRUE);
2836 }
2837
2838 gboolean key_press_cb(GtkWidget * widget, GdkEventKey * event, MainView * mainview)
2839 {
2840 switch (event->keyval)
2841 {
2842
2843 /*
2844 * case GDK_Up:
2845 * gtk_infoprint(GTK_WINDOW(app), "Navigation Key Up");
2846 * return TRUE;
2847 *
2848 * case GDK_Down:
2849 * gtk_infoprint(GTK_WINDOW(app), "Navigation Key Down");
2850 * return TRUE;
2851 *
2852 * case GDK_Left:
2853 * gtk_infoprint(GTK_WINDOW(app), "Navigation Key Left");
2854 * return TRUE;
2855 *
2856 * case GDK_Right:
2857 * gtk_infoprint(GTK_WINDOW(app), "Navigation Key Right");
2858 * return TRUE;
2859 *
2860 * case GDK_Return:
2861 * gtk_infoprint(GTK_WINDOW(app), "Navigation Key select");
2862 * return TRUE;
2863 */
2864 /*code below messes up when you have a textview*/
2865 /*
2866 case GDK_Left:
2867 case GDK_Right:
2868 {
2869 gtk_widget_child_focus(widget, event->keyval==GDK_Left?GTK_DIR_TAB_BACKWARD:GTK_DIR_TAB_FORWARD);
2870 return TRUE;
2871 }
2872 */
2873 case GDK_Left:
2874 {
2875 nodeData *selnode = getSelectedNode(mainview);
2876 if (selnode!=NULL && selnode->typ==NODE_SKETCH)
2877 {
2878 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Squared shapes ON"));
2879 sketchwidget_set_shift(mainview->sk, TRUE);
2880 return TRUE;
2881 }
2882 return FALSE;
2883 }
2884 case GDK_Right:
2885 {
2886 nodeData *selnode = getSelectedNode(mainview);
2887 if (selnode!=NULL && selnode->typ==NODE_SKETCH)
2888 {
2889 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Squared shapes OFF"));
2890 sketchwidget_set_shift(mainview->sk, FALSE);
2891 return TRUE;
2892 }
2893 return FALSE;
2894 }
2895 case GDK_Down:
2896 {
2897 nodeData *selnode = getSelectedNode(mainview);
2898 if (selnode!=NULL && selnode->typ==NODE_SKETCH)
2899 {
2900 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Filled shapes OFF"));
2901 sketchwidget_set_fillmode(mainview->sk, FALSE);
2902 return TRUE;
2903 }
2904 return FALSE;
2905 }
2906 case GDK_Up:
2907 {
2908 nodeData *selnode = getSelectedNode(mainview);
2909 if (selnode!=NULL && selnode->typ==NODE_SKETCH)
2910 {
2911 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Filled shapes ON"));
2912 sketchwidget_set_fillmode(mainview->sk, TRUE);
2913 return TRUE;
2914 }
2915 return FALSE;
2916 }
2917 case GDK_F6:
2918 {
2919 if ((mainview->viewflags & 4) == 0) mainview->viewflags |= 4;
2920 else mainview->viewflags &= ~4;
2921 callback_setview(mainview, 1);
2922 return TRUE;
2923 }
2924 case GDK_F7:
2925 {
2926 callback_redo(NULL, mainview);
2927 return TRUE;
2928 }
2929 case GDK_F8:
2930 {
2931 callback_undo(NULL, mainview);
2932 return TRUE;
2933 }
2934 case GDK_Escape:
2935 {
2936 if ((mainview->viewflags & 1) == 0) mainview->viewflags |= 1;
2937 else mainview->viewflags &= ~1;
2938 callback_setview(mainview, 1);
2939
2940 return TRUE;
2941 }
2942 /*
2943 case GDK_Return:
2944 {
2945 if ((mainview->viewflags & 2) == 0) mainview->viewflags |= 2;
2946 else mainview->viewflags &= ~2;
2947 callback_setview(mainview, 1);
2948 return TRUE;
2949 }
2950 */
2951 }
2952
2953 return FALSE;
2954 }
2955
2956 void callback_viewmenu(GtkAction * action, GtkWidget * wid)
2957 {
2958 int flag = (int)gtk_object_get_user_data(GTK_OBJECT(wid));
2959 MainView *mainview = gtk_object_get_data(GTK_OBJECT(wid), "m");
2960
2961 g_assert(mainview != NULL);
2962
2963 if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(wid))) mainview->viewflags |= flag;
2964 else mainview->viewflags &= ~flag;
2965
2966 if (flag==1)
2967 {
2968 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->toggletree_tb), gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(wid)));
2969 return;
2970 }
2971
2972 callback_setview(mainview, 0);
2973 }
2974
2975
2976 void callback_setview(MainView *mainview, int setmenu)
2977 {
2978 if (setmenu>0)
2979 {
2980 if ((mainview->viewflags&4)>0)
2981 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->viewmenuitems[2]), TRUE);
2982 else
2983 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->viewmenuitems[2]), FALSE);
2984
2985 if ((mainview->viewflags&2)>0)
2986 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->viewmenuitems[1]), TRUE);
2987 else
2988 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->viewmenuitems[1]), FALSE);
2989
2990 if ((mainview->viewflags&1)>0)
2991 {
2992 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->viewmenuitems[0]), TRUE);
2993 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->toggletree_tb), TRUE);
2994 }
2995 else
2996 {
2997 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mainview->viewmenuitems[0]), FALSE);
2998 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->toggletree_tb), FALSE);
2999 }
3000
3001 return;
3002 }
3003
3004 setBusy(mainview, 1);
3005
3006 if ((mainview->viewflags&4)>0)
3007 gtk_window_fullscreen(GTK_WINDOW(mainview->data->main_view));
3008 else
3009 gtk_window_unfullscreen(GTK_WINDOW(mainview->data->main_view));
3010
3011 if ((mainview->viewflags&2)>0)
3012 gtk_widget_show(mainview->toolbar);
3013 else
3014 gtk_widget_hide(mainview->toolbar);
3015
3016 if ((mainview->viewflags&1)>0)
3017 gtk_widget_show(mainview->scrolledtree);
3018 else
3019 gtk_widget_hide(mainview->scrolledtree);
3020
3021 if (mainview->viewflags==4)
3022 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sketchwidget_get_mainwidget(mainview->sk)), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
3023 else
3024 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sketchwidget_get_mainwidget(mainview->sk)), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
3025
3026 setBusy(mainview, 2);
3027 }
3028
3029
3030 void callback_buffer_modified(GtkAction * action, gpointer data)
3031 {
3032 MainView *mainview = (MainView *) data;
3033 g_assert(mainview != NULL && mainview->data != NULL);
3034
3035 mainview->file_edited = TRUE;
3036 }
3037
3038 /*
3039 * Callback for exit D-BUS event
3040 */
3041 void exit_event_handler(gboolean die_now, gpointer data)
3042 {
3043 MainView *mainview = (MainView *) data;
3044 g_assert(mainview != NULL && mainview->data != NULL);
3045
3046 if (!die_now)
3047 {
3048 if (callback_file_close(NULL, mainview)==FALSE) gtk_main_quit(); /*make sure we call gtk_main_quit*/
3049 }
3050 else
3051 {
3052 gtk_main_quit();
3053 }
3054 /*
3055 * application_exit(mainview->data);
3056 */
3057 }
3058
3059 /*
3060 * Callback for hardware D-BUS events
3061 */
3062 void hw_event_handler(osso_hw_state_t * state, gpointer data)
3063 {
3064 MainView *mainview = (MainView *) data;
3065 g_assert(mainview != NULL && mainview->data != NULL);
3066
3067 /*
3068 * if (state->shutdown_ind)
3069 * {
3070 * gtk_infoprint(GTK_WINDOW(mainview->data->app),
3071 * "Shutdown event!");
3072 * }
3073 * if (state->memory_low_ind)
3074 * {
3075 * gtk_infoprint(GTK_WINDOW(mainview->data->app),
3076 * "Memory low event!");
3077 * }
3078 */
3079 if (state->save_unsaved_data_ind)
3080 {
3081 fprintf(stderr, "Saving unsaved data!\n");
3082 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, "Saving unsaved data!");
3083 callback_file_save(NULL, mainview);
3084 }
3085
3086 /*
3087 * if (state->system_inactivity_ind)
3088 * {
3089 * gtk_infoprint(GTK_WINDOW(mainview->data->app),
3090 * "Minimize application inactivity event!");
3091 * }
3092 */
3093 }
3094
3095 GtkTreeRowReference *read_sqlite3_data(MainView * mainview, unsigned int parentid, GtkTreeRowReference * parenttree, unsigned int selected, GtkTreeStore * model)
3096 {
3097 GtkTreeRowReference *resref = NULL;
3098
3099 char q[256];
3100
3101 snprintf(q, sizeof(q), "SELECT nodeid, bodytype, name, nameblob, lastmodified, flags FROM %s WHERE parent=%d ORDER BY ord", datatable_tmpname, parentid);
3102
3103 sqlite3_stmt *stmt = NULL;
3104 const char *dum;
3105 int rc = sqlite3_prepare(mainview->db, q, strlen(q), &stmt, &dum);
3106
3107 if (rc)
3108 {
3109 fprintf(stderr, "Error %s\n", sqlite3_errmsg(mainview->db));
3110 return (NULL);
3111 }
3112
3113 rc = SQLITE_BUSY;
3114 while(rc == SQLITE_BUSY || rc == SQLITE_ROW)
3115 {
3116 rc = sqlite3_step(stmt);
3117 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
3118 break;
3119 else if (rc == SQLITE_ROW)
3120 {
3121 int nodeid = sqlite3_column_int(stmt, 0);
3122 int typ = sqlite3_column_int(stmt, 1);
3123 const unsigned char *name = sqlite3_column_text(stmt, 2);
3124 const unsigned char *nameblob = sqlite3_column_text(stmt, 3);
3125 int lastmod = sqlite3_column_int(stmt, 4);
3126 int flags = sqlite3_column_int(stmt, 5);
3127
3128 /*
3129 * fprintf(stderr, "CARD=%s TYPE=%d\n", name, typ);
3130 */
3131 if ((typ != NODE_TEXT && typ != NODE_SKETCH && typ != NODE_CHECKLIST) || (name == NULL && nameblob == NULL))
3132 {
3133
3134 /*
3135 * fprintf(stderr, "invalid card, skipping\n");
3136 */
3137 continue;
3138 }
3139
3140 nodeData *node = g_malloc(sizeof(nodeData));
3141
3142 node->sql3id = nodeid;
3143 node->typ = typ;
3144 node->flags = flags;
3145 node->name = NULL;
3146 node->namepix = NULL;
3147 if (name != NULL)
3148 node->name = g_strdup((char *)name);
3149 if (nameblob != NULL)
3150 {
3151 int blobsize = sqlite3_column_bytes(stmt, 3);
3152
3153 GdkPixbufLoader *pl = gdk_pixbuf_loader_new_with_type("png", NULL);
3154 GError *err = NULL;
3155
3156 gdk_pixbuf_loader_write(pl, (guchar *) nameblob, blobsize, &err);
3157 if (err != NULL)
3158 {
3159 fprintf(stderr, "Error loading nodename! %s\n", err->message);
3160 g_error_free(err);
3161 err = NULL;
3162 }
3163 gdk_pixbuf_loader_close(pl, NULL);
3164 GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf(pl);
3165
3166 if (GDK_IS_PIXBUF(pixbuf))
3167 node->namepix = pixbuf;
3168 }
3169 node->lastMod = lastmod;
3170
3171 GtkTreeIter parentiter, newiter;
3172 void *par = NULL;
3173
3174 if (parenttree != NULL)
3175 {
3176 GtkTreePath *pa = gtk_tree_row_reference_get_path(parenttree);
3177
3178 gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &parentiter, pa);
3179 gtk_tree_path_free(pa);
3180 par = &parentiter;
3181 }
3182
3183 gtk_tree_store_append(model, &newiter, par);
3184 gtk_tree_store_set(model, &newiter, NODE_NAME, node->name, NODE_PIXBUF, node->namepix, NODE_DATA, node, -1);
3185
3186 GtkTreePath *pa = gtk_tree_model_get_path(GTK_TREE_MODEL(model), &newiter);
3187
3188 GtkTreeRowReference *newref = gtk_tree_row_reference_new(GTK_TREE_MODEL(model), pa);
3189
3190 if (selected == nodeid)
3191 resref = newref;
3192
3193 gtk_tree_path_free(pa);
3194 GtkTreeRowReference *r = read_sqlite3_data(mainview, nodeid, newref, selected,
3195 model);
3196
3197 if (resref != newref)
3198 gtk_tree_row_reference_free(newref);
3199
3200 if (r != NULL)
3201 {
3202 if (resref == NULL)
3203 resref = r;
3204 else
3205 gtk_tree_row_reference_free(r); /*safeguard */
3206 }
3207 }
3208 }
3209
3210 if (stmt)
3211 sqlite3_finalize(stmt);
3212
3213 return (resref); /*ref to supposed-to-be-selected treeitem */
3214 }
3215
3216 /*
3217 * read file
3218 */
3219 gboolean read_file_to_buffer(MainView * mainview)
3220 {
3221 char tq[512];
3222
3223 g_assert(mainview != NULL);
3224 gboolean res = FALSE;
3225
3226 gchar *filename = mainview->file_name;
3227
3228 new_file(mainview);
3229 mainview->file_name = filename;
3230 mainview->loading=TRUE;
3231
3232 fprintf(stderr, "read:*%s*\n", filename);
3233
3234 int rc;
3235 sqlite3_stmt *stmt = NULL;
3236
3237 rc = sqlite3_open(filename, &mainview->db);
3238 do
3239 {
3240 if (rc)
3241 {
3242 fprintf(stderr, "Can't open database %s: %s\n", filename, sqlite3_errmsg(mainview->db));
3243 break;
3244 }
3245
3246 sqlite3_exec(mainview->db, "PRAGMA synchronous = OFF;", NULL, NULL, NULL);
3247
3248 char *q = "SELECT skey, sval FROM settings";
3249 const char *dum;
3250
3251 rc = sqlite3_prepare(mainview->db, q, strlen(q), &stmt, &dum);
3252 if (rc)
3253 {
3254 fprintf(stderr, "Error %s\n", sqlite3_errmsg(mainview->db));
3255 break;
3256 }
3257
3258 unsigned int selectedCard = 0;
3259
3260 /*
3261 * fprintf(stderr, "start config\n");
3262 */
3263 unsigned int curDataVersion = 0;
3264 unsigned int curChecklistVersion = 0;
3265
3266 rc = SQLITE_BUSY;
3267 while(rc == SQLITE_BUSY || rc == SQLITE_ROW)
3268 {
3269 rc = sqlite3_step(stmt);
3270 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE || rc == SQLITE_DONE)
3271 break;
3272 else if (rc == SQLITE_ROW)
3273 {
3274 const unsigned char *col_key = sqlite3_column_text(stmt, 0);
3275 const unsigned char *col_val = sqlite3_column_text(stmt, 1);
3276
3277 /*
3278 * fprintf(stderr, "%s=%s\n", col_key, col_val);
3279 */
3280 if (!strcmp(col_key, "leftPanedPos"))
3281 {
3282 gint panedPos = atoi((char *)col_val);
3283
3284 if (panedPos > 0)
3285 gtk_paned_set_position(GTK_PANED(mainview->hpaned), panedPos);
3286 }
3287 if (!strcmp(col_key, "selectedNode"))
3288 {
3289 gint tmp = atoi((char *)col_val);
3290
3291 if (tmp > 0)
3292 selectedCard = tmp;
3293 }
3294 if (!strcmp(col_key, "dataVersion"))
3295 {
3296 gint tmp = atoi((char *)col_val);
3297
3298 if (tmp > 0)
3299 curDataVersion = tmp;
3300 }
3301 if (!strcmp(col_key, "checklistVersion"))
3302 {
3303 gint tmp = atoi((char *)col_val);
3304
3305 if (tmp > 0)
3306 curChecklistVersion = tmp;
3307 }
3308 if (!strcmp(col_key, "newNodeDlgCreateChild"))
3309 {
3310 gint tmp = atoi((char *)col_val);
3311
3312 mainview->newnodedialog_createchild = TRUE;
3313 if (tmp == 0)
3314 mainview->newnodedialog_createchild = FALSE;
3315 }
3316 if (!strcmp(col_key, "fullScreen"))
3317 {
3318 gint tmp = atoi((char *)col_val);
3319 if (tmp<0 || tmp>4) tmp=0;
3320 if (tmp==0) tmp=4;
3321 else tmp--;
3322 if (tmp==0) tmp=3;
3323 else if (tmp==1) tmp=2;
3324 else if (tmp==2) tmp=7;
3325 else if (tmp==3) tmp=6;
3326 else if (tmp==4) tmp=4;
3327 mainview->viewflags=tmp;
3328 callback_setview(mainview, TRUE);
3329 }
3330 if (!strcmp(col_key, "viewFlags"))
3331 {
3332 gint tmp = atoi((char *)col_val);
3333 if (tmp<0) tmp=3;
3334 mainview->viewflags=tmp;
3335 callback_setview(mainview, TRUE);
3336 }
3337 if (!strcmp(col_key, "brushSize"))
3338 {
3339 gint tmp = atoi((char *)col_val);
3340 if (tmp>0) sk_set_brushsize(mainview, tmp);
3341 }
3342 if (!strcmp(col_key, "brushColor"))
3343 {
3344 unsigned long tmp = atol((char *)col_val);
3345 GdkColor c2;
3346
3347 c2.red = ((tmp & 0xFF0000) >> 16) << 8;
3348 c2.green = ((tmp & 0xFF00) >> 8) << 8;
3349 c2.blue = (tmp & 0xFF) << 8;
3350 /* fprintf(stderr, "READ BRUSHCOLOR is %ul (%d,%d,%d)\n", tmp, c2.red, c2.green, c2.blue);*/
3351
3352 sketchwidget_set_brushcolor(mainview->sk, c2);
3353 hildon_color_button_set_color(HILDON_COLOR_BUTTON(mainview->colorbutton), &c2);
3354 }
3355
3356 }
3357 }
3358 if (rc == SQLITE_ERROR || rc == SQLITE_MISUSE)
3359 {
3360 fprintf(stderr, "Error2 %s\n", sqlite3_errmsg(mainview->db));
3361 break;
3362 }
3363
3364 /*
3365 * fprintf(stderr, "end config\n");
3366 */
3367 if (stmt)
3368 sqlite3_finalize(stmt);
3369
3370 gboolean resback = FALSE;
3371
3372 while(curDataVersion < datatableversion)
3373 {
3374 if (curDataVersion == 0)
3375 {
3376 snprintf(tq, sizeof(tq), "DROP TABLE %s", datatable_backupname);
3377 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3378
3379 snprintf(tq, sizeof(tq), "ALTER TABLE %s RENAME TO %s", datatable_name, datatable_backupname);
3380 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3381 {
3382 fprintf(stderr, "ERROR backing up table!\n");
3383 break;
3384 }
3385 resback = TRUE;
3386
3387 snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", datatable_name, datatable);
3388 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3389 {
3390 fprintf(stderr, "ERROR creating table!\n");
3391 break;
3392 }
3393 snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT nodeid, parent, bodytype, name, body, nameblob, bodyblob, lastmodified, ord, 0 FROM %s", datatable_name, datatable_backupname);
3394 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3395 {
3396 fprintf(stderr, "ERROR copying data!\n");
3397 break;
3398 }
3399
3400 snprintf(tq, sizeof(tq), "DROP TABLE %s", datatable_backupname);
3401 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3402
3403 curDataVersion = datatableversion;
3404 }
3405 break;
3406 }
3407
3408 if (curDataVersion != datatableversion)
3409 {
3410 fprintf(stderr, "Data version mismatch\n");
3411
3412 if (resback == TRUE)
3413 {
3414 snprintf(tq, sizeof(tq), "DROP TABLE %s", datatable_name);
3415 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3416 snprintf(tq, sizeof(tq), "ALTER TABLE %s RENAME TO %s", datatable_backupname, datatable_name);
3417 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3418 }
3419
3420 break;
3421 }
3422
3423
3424 while(curChecklistVersion < checklisttableversion)
3425 {
3426 if (curChecklistVersion == 0) /*no checklisttable at all*/
3427 {
3428 snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", checklisttable_name, checklisttable);
3429 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3430 {
3431 fprintf(stderr, "ERROR creating checklist table!\n");
3432 break;
3433 }
3434 curChecklistVersion = checklisttableversion;
3435 }
3436 break;
3437 }
3438
3439
3440 GtkTreeStore *model = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview)));
3441
3442 g_object_ref(model);
3443 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), NULL);
3444
3445 do
3446 {
3447 char tq[512];
3448
3449 snprintf(tq, sizeof(tq), "CREATE%s TABLE %s%s", TEMPTABLE_KEYWORD, datatable_tmpname, datatable);
3450 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3451 {
3452 fprintf(stderr, "ERROR creating temp table!\n");
3453 break;
3454 }
3455 snprintf(tq, sizeof(tq), "CREATE INDEX %s_index ON %s %s", datatable_tmpname, datatable_tmpname, dataindex);
3456 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3457 {
3458 fprintf(stderr, "ERROR creating temp index!\n");
3459 break;
3460 }
3461 snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", datatable_tmpname, datatable_name);
3462 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3463 {
3464 fprintf(stderr, "ERROR copying data to temp table!\n");
3465 break;
3466 }
3467
3468 snprintf(tq, sizeof(tq), "CREATE%s TABLE %s%s", TEMPTABLE_KEYWORD, checklisttable_tmpname, checklisttable);
3469 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3470 {
3471 fprintf(stderr, "ERROR creating temp table! (checklist)\n");
3472 break;
3473 }
3474 snprintf(tq, sizeof(tq), "CREATE INDEX %s_index ON %s %s", checklisttable_tmpname, checklisttable_tmpname, checklistindex);
3475 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3476 {
3477 fprintf(stderr, "ERROR creating temp index! (checklist)\n");
3478 break;
3479 }
3480 snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", checklisttable_tmpname, checklisttable_name);
3481 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3482 {
3483 fprintf(stderr, "ERROR copying data to temp table! (checklist)\n");
3484 break;
3485 }
3486 }
3487 while(FALSE);
3488
3489 GtkTreeRowReference *selectedRef = read_sqlite3_data(mainview, 0, NULL, selectedCard, model);
3490
3491 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->treeview), GTK_TREE_MODEL(model));
3492 g_object_unref(model);
3493 gtk_tree_view_expand_all(GTK_TREE_VIEW(mainview->treeview));
3494
3495 if (selectedRef != NULL)
3496 {
3497 GtkTreeIter seliter;
3498
3499 if (ref2iter(GTK_TREE_MODEL(model), selectedRef, &seliter) == TRUE)
3500 {
3501 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->treeview));
3502 gtk_tree_selection_select_iter(selection, &seliter);
3503 }
3504
3505 gtk_tree_row_reference_free(selectedRef);
3506 }
3507 res = TRUE;
3508 }
3509 while(FALSE);
3510
3511 if (stmt)
3512 sqlite3_finalize(stmt);
3513
3514
3515 mainview->loading=FALSE;
3516
3517 return (res);
3518 }
3519
3520 /*
3521 * write to file
3522 */
3523 void write_buffer_to_file(MainView * mainview)
3524 {
3525 fprintf(stderr, "write:*%s*\n", mainview->file_name);
3526 saveCurrentData(mainview);
3527
3528 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->treeview));
3529 /*update ord value in database for all nodes*/
3530 gtk_tree_model_foreach(GTK_TREE_MODEL(model),(GtkTreeModelForeachFunc) foreach_func_update_ord,mainview);
3531
3532 setBusy(mainview, 1);
3533
3534 char tq[512];
3535
3536 snprintf(tq, sizeof(tq), "DROP TABLE %s", misctable_name);
3537 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3538
3539 snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", misctable_name, misctable);
3540 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3541
3542 gint panedPos = gtk_paned_get_position(GTK_PANED(mainview->hpaned));
3543
3544 snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('leftPanedPos', '%d');", misctable_name, panedPos);
3545 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3546
3547 gint nndcc = 1;
3548
3549 if (mainview->newnodedialog_createchild == FALSE)
3550 nndcc = 0;
3551 snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('newNodeDlgCreateChild', '%d');", misctable_name, nndcc);
3552 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3553
3554 snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('viewFlags', '%d');", misctable_name, mainview->viewflags);
3555 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3556
3557 nodeData *node = getSelectedNode(mainview);
3558
3559 if (node)
3560 {
3561 snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('selectedNode', '%d');", misctable_name, node->sql3id);
3562 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3563 }
3564
3565 guint bsize;
3566 if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(mainview->eraser_tb)) == TRUE)
3567 {
3568 bsize=mainview->brushsize_backup;
3569 }
3570 else
3571 {
3572 bsize=sketchwidget_get_brushsize(mainview->sk);
3573 }
3574 snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('brushSize', '%d');", misctable_name, bsize);
3575 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3576
3577 #if HILDON == 1
3578 GdkColor col;
3579 hildon_color_button_get_color(HILDON_COLOR_BUTTON(mainview->colorbutton), &col);
3580 unsigned long bcol=((col.red >> 8) << 16) | ((col.green >> 8) << 8) | (col.blue >> 8);
3581 #else
3582 GdkColor *col = hildon_color_button_get_color(HILDON_COLOR_BUTTON(mainview->colorbutton));
3583 unsigned long bcol=((col->red >> 8) << 16) | ((col->green >> 8) << 8) | (col->blue >> 8);
3584 #endif
3585
3586 /* fprintf(stderr, "BRUSHCOLOR is %d (%d,%d,%d)\n", bcol, col->red, col->green, col->blue);*/
3587 snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('brushColor', '%lu');", misctable_name, bcol);
3588 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3589
3590 snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('dataVersion', '%d');", misctable_name, datatableversion);
3591 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3592
3593 snprintf(tq, sizeof(tq), "INSERT INTO %s VALUES('checklistVersion', '%d');", misctable_name, checklisttableversion);
3594 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3595
3596 snprintf(tq, sizeof(tq), "DROP TABLE %s", datatable_backupname);
3597 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3598 snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", datatable_backupname, datatable);
3599 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3600 {
3601 fprintf(stderr, "ERROR creating backup table!\n");
3602 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, "Error 1");
3603
3604 setBusy(mainview, 2);
3605 return;
3606 }
3607 snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", datatable_backupname, datatable_name);
3608 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3609 {
3610 fprintf(stderr, "ERROR backing up table!\n");
3611 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, "Error 2");
3612
3613 setBusy(mainview, 2);
3614 return;
3615 }
3616 snprintf(tq, sizeof(tq), "DELETE FROM %s", datatable_name);
3617 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3618
3619 snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", datatable_name, datatable_tmpname);
3620 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3621 {
3622 fprintf(stderr, "ERROR saving table!\n");
3623 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, "Error 3");
3624
3625 snprintf(tq, sizeof(tq), "DELETE FROM %s", datatable_name);
3626 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3627
3628 snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", datatable_name, datatable_backupname);
3629 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3630 {
3631 fprintf(stderr, "ERROR restoring backup! data lost!\n");
3632 }
3633
3634 setBusy(mainview, 2);
3635 return;
3636 }
3637
3638 snprintf(tq, sizeof(tq), "DROP TABLE %s", datatable_backupname);
3639 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3640
3641 /*checklist*/
3642 snprintf(tq, sizeof(tq), "DROP TABLE %s", checklisttable_backupname);
3643 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3644 snprintf(tq, sizeof(tq), "CREATE TABLE %s%s", checklisttable_backupname, checklisttable);
3645 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3646 {
3647 fprintf(stderr, "ERROR creating backup table! (checklist)\n");
3648 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, "Error 4");
3649
3650 setBusy(mainview, 2);
3651 return;
3652 }
3653
3654 snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", checklisttable_backupname, checklisttable_name);
3655 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3656 {
3657 fprintf(stderr, "ERROR backing up table! (checklist)\n");
3658 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, "Error 5");
3659
3660 setBusy(mainview, 2);
3661 return;
3662 }
3663 snprintf(tq, sizeof(tq), "DELETE FROM %s", checklisttable_name);
3664 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3665
3666 snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", checklisttable_name, checklisttable_tmpname);
3667 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3668 {
3669 fprintf(stderr, "ERROR saving table! (checklist)\n");
3670 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, "Error 6");
3671
3672 snprintf(tq, sizeof(tq), "DELETE FROM %s", checklisttable_name);
3673 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3674
3675 snprintf(tq, sizeof(tq), "INSERT INTO %s SELECT * FROM %s", checklisttable_name, checklisttable_backupname);
3676 if (sqlite3_exec(mainview->db, tq, NULL, NULL, NULL) != 0)
3677 {
3678 fprintf(stderr, "ERROR restoring backup! data lost! (checklist)\n");
3679 }
3680 setBusy(mainview, 2);
3681 return;
3682 }
3683
3684 snprintf(tq, sizeof(tq), "DROP TABLE %s", checklisttable_backupname);
3685 sqlite3_exec(mainview->db, tq, NULL, NULL, NULL);
3686
3687 mainview->file_edited = FALSE;
3688 setBusy(mainview, 2);
3689 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), GTK_STOCK_SAVE, _("Saved"));
3690 }
3691
3692
3693 void callback_checklist_toggled(GtkCellRendererToggle *cell_renderer, gchar *path, GtkWidget *source)
3694 {
3695 gtk_object_set_data(GTK_OBJECT(source), "edited", TRUE);
3696
3697 GtkTreeIter iter;
3698 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(source));
3699 GtkTreePath *treepath = gtk_tree_path_new_from_string(path);
3700 if(gtk_tree_model_get_iter(model, &iter, treepath))
3701 {
3702 gboolean val;
3703 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, CHECKNODE_CHECKED, &val, -1);
3704 gtk_list_store_set(GTK_LIST_STORE(model), &iter, CHECKNODE_CHECKED, !val, -1);
3705 }
3706 gtk_tree_path_free(treepath);
3707 }
3708
3709 void callback_checklist_edited(GtkCellRendererToggle *cell_renderer, gchar *arg1, gchar *arg2, GtkWidget *source)
3710 {
3711 gtk_object_set_data(GTK_OBJECT(source), "edited", TRUE);
3712
3713 GtkTreeIter iter;
3714 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(source));
3715 GtkTreePath *treepath = gtk_tree_path_new_from_string(arg1);
3716 if(gtk_tree_model_get_iter(model, &iter, treepath))
3717 {
3718 gtk_list_store_set(GTK_LIST_STORE(model), &iter, CHECKNODE_TEXT, arg2, -1);
3719 }
3720 gtk_tree_path_free(treepath);
3721 }
3722
3723 void callback_checklist_change(GtkTreeSelection *selection, MainView *mainview)
3724 {
3725 g_assert(mainview != NULL && mainview->data != NULL);
3726
3727 g_signal_handlers_block_by_func(mainview->bold_tb, callback_fontstyle, mainview->bold_tb);
3728 g_signal_handlers_block_by_func(mainview->strikethru_tb, callback_fontstyle, mainview->strikethru_tb);
3729 g_signal_handlers_block_by_func(mainview->check_tb, callback_fontstyle, mainview->check_tb);
3730
3731 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->bold_tb), FALSE);
3732 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->strikethru_tb), FALSE);
3733 gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->check_tb), FALSE);
3734
3735 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
3736 GList* l=gtk_tree_selection_get_selected_rows(selection, NULL);
3737
3738 gboolean gotit=FALSE;
3739
3740 GList* cur=l;
3741 while(cur)
3742 {
3743 GtkTreePath *path=cur->data;
3744
3745 if (!gotit)
3746 {
3747 GtkTreeIter iter;
3748 if (gtk_tree_model_get_iter(model, &iter, path))
3749 {
3750 gint styletoset_weight;
3751 gboolean styletoset_strike;
3752 gboolean ischecked;
3753
3754 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, CHECKNODE_BOLD, &styletoset_weight, CHECKNODE_STRIKE, &styletoset_strike, CHECKNODE_CHECKED, &ischecked, -1);
3755 if (styletoset_weight==PANGO_WEIGHT_BOLD) gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->bold_tb), TRUE);
3756 if (styletoset_strike==TRUE) gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->strikethru_tb), TRUE);
3757 if (ischecked==TRUE) gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(mainview->check_tb), TRUE);
3758 gotit=TRUE;
3759 }
3760 }
3761 gtk_tree_path_free(path);
3762 cur=cur->next;
3763 }
3764
3765 g_list_free(l);
3766
3767 g_signal_handlers_unblock_by_func(mainview->bold_tb, callback_fontstyle, mainview->bold_tb);
3768 g_signal_handlers_unblock_by_func(mainview->strikethru_tb, callback_fontstyle, mainview->strikethru_tb);
3769 g_signal_handlers_unblock_by_func(mainview->check_tb, callback_fontstyle, mainview->check_tb);
3770 }
3771
3772 void callback_checklist_add(GtkAction *action, MainView *mainview)
3773 {
3774 g_assert(mainview != NULL && mainview->data != NULL);
3775
3776 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
3777 GtkTreeIter toplevel;
3778 gtk_list_store_append(GTK_LIST_STORE(model), &toplevel);
3779
3780 gtk_list_store_set(GTK_LIST_STORE(model), &toplevel, CHECKNODE_CHECKED, FALSE, CHECKNODE_TEXT, "", -1);
3781 GtkTreePath *path = gtk_tree_model_get_path(model, &toplevel);
3782 if (path)
3783 {
3784 gtk_tree_view_set_cursor(GTK_TREE_VIEW(mainview->listview), path, mainview->listtextcol, TRUE);
3785 gtk_tree_path_free(path);
3786 }
3787
3788 gtk_object_set_data(GTK_OBJECT(mainview->listview), "edited", TRUE);
3789 }
3790
3791 void callback_checklist_delete(GtkAction *action, MainView *mainview)
3792 {
3793 g_assert(mainview != NULL && mainview->data != NULL);
3794
3795 if (gtk_tree_selection_count_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->listview)))==0)
3796 {
3797 hildon_banner_show_information(GTK_WIDGET(mainview->data->main_view), NULL, _("Select items first"));
3798 return;
3799 }
3800
3801 GtkWidget *dialog, *label, *but_ok, *but_cancel;
3802
3803 dialog = gtk_dialog_new();
3804
3805 label = gtk_label_new(_("Delete selected items?"));
3806
3807 but_ok = gtk_button_new_with_label(_("Yes, Delete"));
3808 but_cancel = gtk_button_new_with_label(_("Cancel"));
3809
3810 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), but_ok);
3811 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), but_cancel);
3812
3813 gtk_object_set_user_data(GTK_OBJECT(dialog), mainview);
3814
3815 gtk_signal_connect_object(GTK_OBJECT(but_cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), dialog);
3816 g_signal_connect(G_OBJECT(but_ok), "clicked", G_CALLBACK(callback_checklist_delete_real), dialog);
3817
3818 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
3819
3820 gtk_widget_show_all(dialog);
3821 gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
3822 }
3823
3824 void callback_checklist_delete_real(GtkAction *action, gpointer data)
3825 {
3826 GtkWidget *dialog = data;
3827 MainView *mainview = gtk_object_get_user_data(GTK_OBJECT(dialog));
3828 gtk_widget_destroy(dialog);
3829
3830 GtkTreeModel *model=gtk_tree_view_get_model(GTK_TREE_VIEW(mainview->listview));
3831 GList* l=gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(mainview->listview)), NULL);
3832
3833 GList* rowrefs=NULL;
3834 GList* cur=l;
3835 while(cur)
3836 {
3837 GtkTreePath *path=cur->data;
3838
3839 GtkTreeIter iter;
3840 if (gtk_tree_model_get_iter(model, &iter, path))
3841 {
3842 GtkTreeRowReference *rowref = gtk_tree_row_reference_new(model, path);
3843 rowrefs=g_list_append(rowrefs, rowref);
3844 }
3845 gtk_tree_path_free(path);
3846 cur=cur->next;
3847 }
3848 g_list_free(l);
3849
3850 g_object_ref(model);
3851 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->listview), NULL);
3852
3853 cur=rowrefs;
3854 while(cur)
3855 {
3856 GtkTreeRowReference *rowref=cur->data;
3857 GtkTreePath *path= gtk_tree_row_reference_get_path(rowref);
3858 if (path)
3859 {
3860 GtkTreeIter iter;
3861 if (gtk_tree_model_get_iter(model, &iter, path)) gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
3862 gtk_tree_path_free(path);
3863 }
3864 gtk_tree_row_reference_free(rowref);
3865 cur=cur->next;
3866 }
3867 g_list_free(rowrefs);
3868
3869 gtk_tree_view_set_model(GTK_TREE_VIEW(mainview->listview), model);
3870 g_object_unref(model);
3871 gtk_object_set_data(GTK_OBJECT(mainview->listview), "edited", TRUE);
3872 }
Tree-based notes, sketches and checklists for Maemo