src/ui/interface.c

   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/interface.h>
  23 #include <ui/callbacks.h>
  24 #include <ui/sketchwidget.h>
  25 #include <gtk/gtk.h>
  26 #include <libintl.h>
  27 #include <sys/param.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <unistd.h>
  31 #include <stdio.h>
  32
  33 #include <hildon-widgets/hildon-program.h>
  34 #include <hildon-widgets/hildon-file-chooser-dialog.h>
  35 #include <hildon-widgets/hildon-note.h>
  36 #include <hildon-widgets/hildon-font-selection-dialog.h>
  37 #include <hildon-widgets/hildon-color-button.h>
  38
  39 /*
  40  * Privates:
  41  */
  42
  43 GtkWidget *create_brushsizemenu(MainView * main);
  44 GtkWidget *create_viewmenu(MainView * main);
  45 GtkWidget *create_shapemenu(MainView * main);
  46 GtkWidget *create_sketchlinesmenu(MainView * main);
  47 GtkWidget *create_menu(MainView * main);
  48 static void create_toolbar(MainView * main);
  49 void create_textarea(MainView * main);
  50 void create_treeview(MainView * main);
  51 static void _tool_button_set_icon_name(GtkToolButton *button, const gchar *icon_name);
  52 void create_checklist(MainView * main);
  53
  54 void sk_set_brushsize(MainView * main, guint bsize)
  55 {
  56         int i = (bsize / 2) - 1;
  57
  58         if (i >= BRUSHSIZE_COUNT)
  59                 i = BRUSHSIZE_COUNT - 1;
  60         if (i < 0)
  61                 i = 0;
  62
  63         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(main->brushsizemenuitems[i]), FALSE);
  64         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(main->brushsizemenuitems[i]), TRUE);
  65 }
  66
  67 static void _tool_button_set_icon_name(GtkToolButton *button, const gchar *icon_name)
  68 {
  69         GtkWidget *image;
  70         image = gtk_image_new_from_icon_name(icon_name, GTK_ICON_SIZE_SMALL_TOOLBAR);
  71         gtk_tool_button_set_icon_widget(button, image);
  72 }
  73
  74 void _toggle_tool_button_set_inconsistent(GtkToggleToolButton *button, gboolean inconsistent)
  75 {
  76 GtkWidget *toggle_button = gtk_bin_get_child(GTK_BIN(button));
  77 gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(toggle_button), inconsistent);
  78 }
  79
  80 MainView *interface_main_view_new(AppData * data)
  81 {
  82         MainView *result = g_new0(MainView, 1);
  83
  84         GtkWidget *main_vbox = gtk_vbox_new(FALSE, 0);
  85
  86         result->hpaned = gtk_hpaned_new();
  87
  88         result->clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
  89         gtk_clipboard_set_can_store(result->clipboard, NULL, 0);
  90
  91         result->file_edited = FALSE;
  92
  93         result->data = data;
  94         result->data->main_view = HILDON_WINDOW(hildon_window_new());
  95
  96         create_treeview(result);
  97         create_textarea(result);
  98         create_checklist(result);
  99
 100         result->brushsizemenu = create_brushsizemenu(result);
 101         result->sketchlinesmenu = create_sketchlinesmenu(result);
 102         result->viewmenu = create_viewmenu(result);
 103         result->shapemenu = create_shapemenu(result);
 104
 105         create_toolbar(result);
 106         GtkWidget *nodemenu = create_menu(result);
 107
 108         g_signal_connect_swapped(result->treeview, "button_press_event", G_CALLBACK(cb_popup), nodemenu);
 109         gtk_widget_tap_and_hold_setup(GTK_WIDGET(result->treeview), nodemenu, NULL, GTK_TAP_AND_HOLD_NONE);
 110
 111         gtk_container_add(GTK_CONTAINER(result->data->main_view), result->hpaned);
 112
 113         gtk_paned_add1(GTK_PANED(result->hpaned), result->scrolledtree);
 114
 115         result->sk = sketchwidget_new(800, 480, FALSE);
 116         sketchwidget_set_undocallback(result->sk, callback_undotoggle, result);
 117         sketchwidget_set_redocallback(result->sk, callback_redotoggle, result);
 118 /*      sketchwidget_set_fingercallback(result->sk, callback_finger, result);*/
 119
 120         gtk_box_pack_start(GTK_BOX(main_vbox), result->scrolledwindow, TRUE, TRUE, 0);
 121         gtk_box_pack_start(GTK_BOX(main_vbox), sketchwidget_get_mainwidget(result->sk), TRUE, TRUE, 0);
 122         gtk_box_pack_start(GTK_BOX(main_vbox), result->listscroll, TRUE, TRUE, 0);
 123         hildon_window_add_toolbar(result->data->main_view, GTK_TOOLBAR(result->toolbar));
 124
 125         gtk_paned_add2(GTK_PANED(result->hpaned), main_vbox);
 126
 127         gtk_widget_show(main_vbox);
 128         gtk_widget_show(result->hpaned);
 129
 130         gtk_widget_show_all(GTK_WIDGET(result->data->main_view));
 131         gtk_widget_grab_focus(GTK_WIDGET(result->textview));
 132
 133         result->file_edited = FALSE;
 134         result->file_name = NULL;
 135
 136         g_signal_connect(G_OBJECT(result->data->main_view), "key_press_event", G_CALLBACK(key_press_cb), result);
 137         g_signal_connect(G_OBJECT(result->data->main_view), "delete_event", G_CALLBACK(close_cb), result);
 138
 139         sk_set_brushsize(result, 2);
 140         sk_set_brushsize(result, 4);
 141
 142         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(result->sketchlinesmenuitems[0]), TRUE);
 143         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(result->shapemenuitems[0]), TRUE);
 144
 145         result->newnodedialog_createchild = TRUE;
 146
 147         result->cursorBusy = gdk_cursor_new(GDK_WATCH);
 148         result->loading=FALSE;
 149
 150         return result;
 151 }
 152
 153 void interface_main_view_destroy(MainView * main)
 154 {
 155         gdk_cursor_unref(main->cursorBusy);
 156         g_free(main);
 157 }
 158
 159 gchar *interface_file_chooser(MainView * mainview, GtkFileChooserAction action, gchar * suggname, gchar * suggext)
 160 {
 161         GtkWidget *dialog;
 162         gchar *filename = NULL;
 163
 164         dialog = hildon_file_chooser_dialog_new(GTK_WINDOW(mainview->data->main_view), action);
 165         gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), TRUE);
 166
 167         if (action == GTK_FILE_CHOOSER_ACTION_SAVE && suggname != NULL)
 168                 {
 169                         gchar fn[128];
 170
 171                         if (suggext == NULL)
 172                                 snprintf(fn, sizeof(fn), "%s", suggname);
 173                         else
 174                                 snprintf(fn, sizeof(fn), "%s.%s", suggname, suggext);
 175
 176                         int i = 0;
 177                         struct stat s;
 178
 179                         while(stat(fn, &s) == 0)
 180                                 {
 181                                         i++;
 182                                         if (suggext == NULL)
 183                                                 snprintf(fn, sizeof(fn), "%s(%d)", suggname, i);
 184                                         else
 185                                                 snprintf(fn, sizeof(fn), "%s(%d).%s", suggname, i, suggext);
 186                                 }
 187
 188                         fprintf(stderr, "%s\n", fn);
 189                         gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), fn);
 190                 }
 191
 192         gtk_widget_show_all(GTK_WIDGET(dialog));
 193         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
 194                 {
 195                         filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
 196                 }
 197
 198         gtk_widget_destroy(dialog);
 199         return filename;
 200 }
 201
 202 gint interface_create_new_file(MainView * main)
 203 {
 204         HildonNote *hn = NULL;
 205         gint response = FALSE;
 206
 207         g_assert(main != NULL && main->data->app != NULL);
 208
 209         hn = HILDON_NOTE(hildon_note_new_confirmation_add_buttons(GTK_WINDOW(main->data->main_view), _("Create new file?"), _("Yes"), CONFRESP_YES, _("No"), CONFRESP_NO, NULL, NULL));
 210         response = gtk_dialog_run(GTK_DIALOG(hn));
 211         gtk_widget_destroy(GTK_WIDGET(hn));
 212         return response;
 213 }
 214
 215 /*
 216  * Privates
 217  */
 218
 219 /*
 220  * Create the menu items needed for the drop down menu
 221  */
 222 GtkWidget *create_menu(MainView * main)
 223 {
 224         /*
 225          * Create needed handles
 226          */
 227         GtkMenu *main_menu;
 228         GtkWidget *file_menu, *close, *about, *edit_menu, *tools_menu, *node_menu, *node_item;
 229
 230         /*
 231          * Get the menu of our view
 232          */
 233         main_menu = GTK_MENU( gtk_menu_new () );
 234         /* Add menu to HildonWindow */
 235         hildon_window_set_menu(main->data->main_view, main_menu);
 236
 237         /*
 238          * Create new menus for submenus in our drop down menu
 239          */
 240         file_menu = gtk_menu_new();
 241         node_menu = gtk_menu_new();
 242         edit_menu = gtk_menu_new();
 243         tools_menu = gtk_menu_new();
 244
 245         /*
 246          * Create the menu items
 247          */
 248         main->file_item = gtk_menu_item_new_with_label(_("File"));
 249         node_item = gtk_menu_item_new_with_label(_("Memo"));
 250
 251         main->new_node_item = gtk_menu_item_new_with_label(_("New memo"));
 252         main->delete_node_item = gtk_menu_item_new_with_label(_("Delete memo"));
 253         main->expand_collapse_node_item = gtk_menu_item_new_with_label(_("Expand/collapse node"));
 254         main->export_node_item = gtk_menu_item_new_with_label(_("Export memo"));
 255
 256         main->new_item = gtk_menu_item_new_with_label(_("New data file"));
 257         main->open_item = gtk_menu_item_new_with_label(_("Open data file..."));
 258         main->save_item = gtk_menu_item_new_with_label(_("Save data"));
 259         main->view_item = gtk_menu_item_new_with_label(_("View"));
 260         main->edit_item = gtk_menu_item_new_with_label(_("Edit"));
 261         main->cut_item = gtk_menu_item_new_with_label(_("Cut"));
 262         main->copy_item = gtk_menu_item_new_with_label(_("Copy"));
 263         main->paste_item = gtk_menu_item_new_with_label(_("Paste"));
 264         main->clear_item = gtk_menu_item_new_with_label(_("Clear"));
 265         main->tools_item = gtk_menu_item_new_with_label(_("Tools"));
 266         close = gtk_menu_item_new_with_label(_("Exit"));
 267
 268         /*
 269          * Add menu items to right menus
 270          */
 271         gtk_menu_append(main_menu, main->file_item);
 272         gtk_menu_append(file_menu, main->new_item);
 273         gtk_menu_append(file_menu, main->open_item);
 274         gtk_menu_append(file_menu, main->save_item);
 275
 276         gtk_menu_append(main_menu, main->view_item);
 277
 278         gtk_menu_append(main_menu, main->edit_item);
 279         gtk_menu_append(edit_menu, main->cut_item);
 280         gtk_menu_append(edit_menu, main->copy_item);
 281         gtk_menu_append(edit_menu, main->paste_item);
 282         gtk_menu_append(edit_menu, gtk_separator_menu_item_new());
 283         gtk_menu_append(edit_menu, main->clear_item);
 284
 285         gtk_menu_append(main_menu, node_item);
 286         gtk_menu_append(node_menu, main->new_node_item);
 287         gtk_menu_append(node_menu, main->delete_node_item);
 288         gtk_menu_append(node_menu, gtk_separator_menu_item_new());
 289         gtk_menu_append(node_menu, main->export_node_item);
 290 #ifdef EXPANDING_ROWS
 291         gtk_menu_append(node_menu, gtk_separator_menu_item_new());
 292         gtk_menu_append(node_menu, main->expand_collapse_node_item);
 293 #endif
 294         gtk_menu_append(main_menu, main->tools_item);
 295         gtk_menu_append(main_menu, gtk_separator_menu_item_new());
 296         about = gtk_menu_item_new_with_label(_("About..."));
 297         gtk_menu_append(main_menu, about);
 298         gtk_menu_append(main_menu, close);
 299
 300         g_signal_connect(G_OBJECT(about), "activate", G_CALLBACK(callback_about), main);
 301
 302         /*
 303          * Add submenus to the right items
 304          */
 305         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->file_item), file_menu);
 306         gtk_menu_item_set_submenu(GTK_MENU_ITEM(node_item), node_menu);
 307         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->edit_item), edit_menu);
 308         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->tools_item), tools_menu);
 309
 310         main->tools_brushsize = gtk_menu_item_new_with_label(_("Brush size"));
 311         main->tools_pagestyle = gtk_menu_item_new_with_label(_("Page style"));
 312         main->tools_shape = gtk_menu_item_new_with_label(_("Shape"));
 313         main->tools_color = gtk_menu_item_new_with_label(_("Color..."));
 314         main->tools_font = gtk_menu_item_new_with_label(_("Font..."));
 315         main->tools_wordwrap = gtk_check_menu_item_new_with_label(_("Word wrap"));
 316         main->tools_pressure = gtk_check_menu_item_new_with_label(_("Pressure sensitive brush color"));
 317
 318         gtk_menu_append(tools_menu, main->tools_color);
 319         gtk_menu_append(tools_menu, main->tools_brushsize);
 320         gtk_menu_append(tools_menu, main->tools_shape);
 321         gtk_menu_append(tools_menu, main->tools_pagestyle);
 322         gtk_menu_append(tools_menu, main->tools_font);
 323         gtk_menu_append(tools_menu, main->tools_wordwrap);
 324         gtk_menu_append(tools_menu, main->tools_pressure);
 325         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->tools_brushsize), main->brushsizemenu);
 326         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->tools_pagestyle), main->sketchlinesmenu);
 327         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->tools_shape), main->shapemenu);
 328
 329         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->view_item), main->viewmenu);
 330
 331         /*
 332          * Attach the callback functions to the activate signal
 333          */
 334         g_signal_connect(G_OBJECT(main->new_node_item), "activate", G_CALLBACK(callback_file_new_node), main);
 335         g_signal_connect(G_OBJECT(main->delete_node_item), "activate", G_CALLBACK(callback_file_delete_node), main);
 336         g_signal_connect(G_OBJECT(main->export_node_item), "activate", G_CALLBACK(callback_file_export_node), main);
 337         g_signal_connect(G_OBJECT(main->expand_collapse_node_item), "activate", G_CALLBACK(callback_file_expand_collapse_node), main);
 338
 339         g_signal_connect(G_OBJECT(main->new_item), "activate", G_CALLBACK(callback_file_new), main);
 340         g_signal_connect(G_OBJECT(main->open_item), "activate", G_CALLBACK(callback_file_open), main);
 341         g_signal_connect(G_OBJECT(main->save_item), "activate", G_CALLBACK(callback_file_save), main);
 342         g_signal_connect(G_OBJECT(main->cut_item), "activate", G_CALLBACK(callback_edit_cut), main);
 343         g_signal_connect(G_OBJECT(main->copy_item), "activate", G_CALLBACK(callback_edit_copy), main);
 344         g_signal_connect(G_OBJECT(main->paste_item), "activate", G_CALLBACK(callback_edit_paste), main);
 345         g_signal_connect(G_OBJECT(main->clear_item), "activate", G_CALLBACK(callback_edit_clear), main);
 346         g_signal_connect(G_OBJECT(main->tools_font), "activate", G_CALLBACK(callback_font), main);
 347         g_signal_connect(G_OBJECT(main->tools_wordwrap), "toggled", G_CALLBACK(callback_wordwrap), main);
 348         g_signal_connect(G_OBJECT(main->tools_pressure), "toggled", G_CALLBACK(callback_pressure), main);
 349         g_signal_connect(G_OBJECT(main->tools_color), "activate", G_CALLBACK(callback_color_invoke), main);
 350
 351         g_signal_connect(G_OBJECT(close), "activate", G_CALLBACK(callback_file_close), main);
 352
 353         /*
 354          * We need to show menu items
 355          */
 356         gtk_widget_show_all(GTK_WIDGET(main_menu));
 357
 358         return (node_menu);
 359 }
 360
 361 GtkWidget *create_brushsizemenu(MainView * main)
 362 {
 363         GtkWidget *menu;
 364         int i;
 365
 366         GSList *gr = NULL;
 367
 368         menu = gtk_menu_new();
 369
 370         for(i = 0; i < BRUSHSIZE_COUNT; i++)
 371                 {
 372                         int bsize = (i + 1) * 2;
 373
 374                         char fpa[PATH_MAX];
 375
 376                         snprintf(fpa, sizeof(fpa), "%s/pencil%d.png", PIXMAPDIR, i + 1);
 377                         GtkWidget *pix = gtk_image_new_from_file(fpa);
 378
 379                         g_object_ref(pix);
 380
 381                         char st[128];
 382
 383                         snprintf(st, sizeof(st), _("%dpt"), bsize);
 384                         main->brushsizemenuitems[i] = gtk_radio_menu_item_new_with_label(gr, st);
 385                         gr = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(main->brushsizemenuitems[i]));
 386
 387                         gtk_object_set_user_data(GTK_OBJECT(main->brushsizemenuitems[i]), bsize);
 388                         gtk_object_set_data(GTK_OBJECT(main->brushsizemenuitems[i]), "m", main);
 389                         gtk_object_set_data(GTK_OBJECT(main->brushsizemenuitems[i]), "i", pix);
 390
 391                         gtk_menu_prepend(menu, main->brushsizemenuitems[i]);
 392                         g_signal_connect(G_OBJECT(main->brushsizemenuitems[i]), "activate", G_CALLBACK(callback_brushsize), main->brushsizemenuitems[i]);
 393                 }
 394
 395         gtk_widget_show_all(GTK_WIDGET(menu));
 396
 397         return (menu);
 398 }
 399
 400 GtkWidget *create_sketchlinesmenu(MainView * main)
 401 {
 402         GtkWidget *menu;
 403         int i;
 404
 405         GSList *gr = NULL;
 406
 407         menu = gtk_menu_new();
 408
 409         char st[3][128];
 410
 411         snprintf(st[0], sizeof(st[0]), _("No background"));
 412         snprintf(st[1], sizeof(st[1]), _("Notebook lines"));
 413         snprintf(st[2], sizeof(st[2]), _("Graph lines"));
 414
 415         for(i = 0; i < 3; i++)
 416                 {
 417                         char fpa[PATH_MAX];
 418
 419                         snprintf(fpa, sizeof(fpa), "%s/sketchbg%d.png", PIXMAPDIR, i);
 420                         GtkWidget *pix = gtk_image_new_from_file(fpa);
 421
 422                         g_object_ref(pix);
 423
 424                         main->sketchlinesmenuitems[i] = gtk_radio_menu_item_new_with_label(gr, st[i]);
 425                         gr = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(main->sketchlinesmenuitems[i]));
 426
 427                         gtk_object_set_user_data(GTK_OBJECT(main->sketchlinesmenuitems[i]), i);
 428                         gtk_object_set_data(GTK_OBJECT(main->sketchlinesmenuitems[i]), "m", main);
 429                         gtk_object_set_data(GTK_OBJECT(main->sketchlinesmenuitems[i]), "i", pix);
 430
 431                         gtk_menu_prepend(menu, main->sketchlinesmenuitems[i]);
 432                         g_signal_connect(G_OBJECT(main->sketchlinesmenuitems[i]), "activate", G_CALLBACK(callback_sketchlines), main->sketchlinesmenuitems[i]);
 433                 }
 434
 435         gtk_widget_show_all(GTK_WIDGET(menu));
 436
 437         return (menu);
 438 }
 439
 440 GtkWidget *create_viewmenu(MainView * main)
 441 {
 442         GtkWidget *menu;
 443         int i;
 444
 445         menu = gtk_menu_new();
 446
 447         char st[3][128];
 448         int stf[3];
 449
 450         snprintf(st[0], sizeof(st[0]), _("Tree"));
 451         snprintf(st[1], sizeof(st[1]), _("Toolbar"));
 452         snprintf(st[2], sizeof(st[2]), _("Full screen"));
 453
 454 /*
 455 this is here because we might want to change the order of the items
 456 warning: these are also in callback_setview()
 457 */
 458
 459         stf[0]=1;
 460         stf[1]=2;
 461         stf[2]=4;
 462
 463         for(i = 0; i < 3; i++)
 464                 {
 465                         main->viewmenuitems[i] = gtk_check_menu_item_new_with_label(st[i]);
 466
 467                         gtk_object_set_user_data(GTK_OBJECT(main->viewmenuitems[i]), stf[i]);
 468                         gtk_object_set_data(GTK_OBJECT(main->viewmenuitems[i]), "m", main);
 469
 470                         gtk_menu_prepend(menu, main->viewmenuitems[i]);
 471                         g_signal_connect(G_OBJECT(main->viewmenuitems[i]), "toggled", G_CALLBACK(callback_viewmenu), main->viewmenuitems[i]);
 472                 }
 473
 474         gtk_widget_show_all(GTK_WIDGET(menu));
 475
 476         return (menu);
 477 }
 478
 479 GtkWidget *create_shapemenu(MainView * main)
 480 {
 481         GtkWidget *menu;
 482         int i;
 483
 484         GSList *gr = NULL;
 485
 486         menu = gtk_menu_new();
 487
 488         char st[4][128];
 489
 490         snprintf(st[0], sizeof(st[0]), _("Free"));
 491         snprintf(st[1], sizeof(st[1]), _("Line"));
 492         snprintf(st[2], sizeof(st[2]), _("Rectangle"));
 493         snprintf(st[3], sizeof(st[3]), _("Ellipse"));
 494
 495         for(i = 0; i < 4; i++)
 496                 {
 497                         main->shapemenuitems[i] = gtk_radio_menu_item_new_with_label(gr, st[i]);
 498                         gr = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(main->shapemenuitems[i]));
 499
 500                         gtk_object_set_user_data(GTK_OBJECT(main->shapemenuitems[i]), i);
 501                         gtk_object_set_data(GTK_OBJECT(main->shapemenuitems[i]), "m", main);
 502
 503                         gtk_menu_prepend(menu, main->shapemenuitems[i]);
 504                         g_signal_connect(G_OBJECT(main->shapemenuitems[i]), "activate", G_CALLBACK(callback_shapemenu), main->shapemenuitems[i]);
 505                 }
 506
 507         gtk_widget_show_all(GTK_WIDGET(menu));
 508
 509         return (menu);
 510 }
 511 /*
 512  * Create toolbar to mainview
 513  */
 514 static void create_toolbar(MainView * main)
 515 {
 516         /*
 517          * Create new GTK toolbar
 518          */
 519         main->toolbar = gtk_toolbar_new();
 520
 521         /*
 522          * Set toolbar properties
 523          */
 524         gtk_toolbar_set_orientation(GTK_TOOLBAR(main->toolbar), GTK_ORIENTATION_HORIZONTAL);
 525         gtk_toolbar_set_style(GTK_TOOLBAR(main->toolbar), GTK_TOOLBAR_BOTH_HORIZ);
 526
 527         /*
 528          * Make menus and buttons to toolbar:
 529          */
 530
 531 /*      main->toggletree_tb = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_INDEX);*/
 532         main->toggletree_tb = gtk_toggle_tool_button_new();
 533         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->toggletree_tb), "qgn_toolb_im_showpane");
 534         g_signal_connect(G_OBJECT(main->toggletree_tb), "toggled", G_CALLBACK(callback_toggletree), main);
 535
 536         main->new_tb = gtk_tool_button_new_from_stock(GTK_STOCK_ADD);
 537
 538 /*      main->save_tb = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE);*/
 539         main->save_tb = gtk_tool_button_new(NULL, NULL);
 540         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->save_tb), "qgn_toolb_gene_save");
 541
 542         main->separator_tb1 = gtk_separator_tool_item_new();
 543
 544         /*
 545          * main->cut_tb = gtk_tool_button_new_from_stock(GTK_STOCK_CUT);
 546          * main->copy_tb = gtk_tool_button_new_from_stock(GTK_STOCK_COPY);
 547          * main->paste_tb = gtk_tool_button_new_from_stock(GTK_STOCK_PASTE);
 548          * main->separator_tb2 = gtk_separator_tool_item_new();
 549          */
 550
 551         main->bold_tb = gtk_toggle_tool_button_new();
 552         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->bold_tb), "qgn_list_gene_bold");
 553
 554         main->italic_tb = gtk_toggle_tool_button_new();
 555         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->italic_tb), "qgn_list_gene_italic");
 556
 557         main->underline_tb = gtk_toggle_tool_button_new();
 558         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->underline_tb), "qgn_list_gene_underline");
 559
 560         main->bullet_tb = gtk_toggle_tool_button_new();
 561         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->bullet_tb), "qgn_list_gene_bullets");
 562
 563         main->strikethru_tb = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_STRIKETHROUGH);
 564 /*      _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->strikethru_tb), "qgn_list_gene_strikethrough");*/
 565
 566         main->check_tb = gtk_toggle_tool_button_new();
 567         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->check_tb), "qgn_list_continuous_multi_select");
 568
 569         main->checkadd_tb = gtk_tool_button_new_from_stock(GTK_STOCK_FILE);
 570         main->checkdel_tb = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE);
 571
 572 /*
 573         main->bold_tb = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_BOLD);
 574         main->italic_tb = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_ITALIC);
 575         main->underline_tb = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_UNDERLINE);
 576 */
 577         main->font_tb = gtk_tool_button_new_from_stock(GTK_STOCK_SELECT_FONT);
 578
 579 /*      main->fullscreen_tb = gtk_tool_button_new_from_stock(GTK_STOCK_ZOOM_FIT);*/
 580
 581         /*
 582          * Insert items to toolbar
 583          */
 584         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->toggletree_tb, -1);
 585 /*      gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), gtk_separator_tool_item_new(), -1);*/
 586         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->new_tb, -1);
 587         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->save_tb, -1);
 588         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->separator_tb1, -1);
 589
 590         /*
 591          * gtk_toolbar_insert ( GTK_TOOLBAR(main->toolbar), main->cut_tb, -1);
 592          * gtk_toolbar_insert ( GTK_TOOLBAR(main->toolbar), main->copy_tb, -1);
 593          * gtk_toolbar_insert ( GTK_TOOLBAR(main->toolbar), main->paste_tb, -1);
 594          * gtk_toolbar_insert ( GTK_TOOLBAR(main->toolbar), main->separator_tb2, -1);
 595          */
 596         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->font_tb, -1);
 597         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->bold_tb, -1);
 598         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->italic_tb, -1);
 599         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->underline_tb, -1);
 600         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->bullet_tb, -1);
 601         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->strikethru_tb, -1);
 602         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->check_tb, -1);
 603
 604         GdkColor col;
 605
 606         col.red = 0;
 607         col.green = 0;
 608         col.blue = 0;
 609         main->colorbutton = hildon_color_button_new_with_color(&col);
 610
 611         main->colorbutton_tb = gtk_tool_item_new();
 612         gtk_container_add(GTK_CONTAINER(main->colorbutton_tb), main->colorbutton);
 613         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->colorbutton_tb, -1);
 614         g_signal_connect(G_OBJECT(main->colorbutton), "clicked", G_CALLBACK(callback_color), main);
 615
 616         main->brushsize_tb = gtk_tool_button_new(NULL, NULL);
 617         g_signal_connect(G_OBJECT(main->brushsize_tb), "clicked", G_CALLBACK(callback_brushsizetb), main);
 618         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->brushsize_tb, -1);
 619
 620         main->eraser_tb = gtk_toggle_tool_button_new();
 621         gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(main->eraser_tb), gtk_image_new_from_file(PIXMAPDIR "/" "eraser.png"));
 622         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->eraser_tb, -1);
 623         g_signal_connect(G_OBJECT(main->eraser_tb), "toggled", G_CALLBACK(callback_eraser), main);
 624
 625         main->shape_tb = gtk_tool_button_new_from_stock(GTK_STOCK_CONVERT);
 626         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->shape_tb, -1);
 627         g_signal_connect(G_OBJECT(main->shape_tb), "clicked", G_CALLBACK(callback_menu), main->shapemenu);
 628
 629         main->sketchlines_tb = gtk_tool_button_new(NULL, NULL);
 630         g_signal_connect(G_OBJECT(main->sketchlines_tb), "clicked", G_CALLBACK(callback_menu), main->sketchlinesmenu);
 631         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->sketchlines_tb, -1);
 632
 633
 634         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), gtk_separator_tool_item_new(), -1);
 635
 636         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->checkadd_tb, -1);
 637         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->checkdel_tb, -1);
 638
 639         main->undo_tb = gtk_tool_button_new_from_stock(GTK_STOCK_UNDO);
 640         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->undo_tb, -1);
 641         g_signal_connect(G_OBJECT(main->undo_tb), "clicked", G_CALLBACK(callback_undo), main);
 642
 643         main->redo_tb = gtk_tool_button_new_from_stock(GTK_STOCK_REDO);
 644         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->redo_tb, -1);
 645         g_signal_connect(G_OBJECT(main->redo_tb), "clicked", G_CALLBACK(callback_redo), main);
 646
 647         /*
 648          * Connect signals to buttons
 649          */
 650         g_signal_connect(G_OBJECT(main->new_tb), "clicked", G_CALLBACK(callback_file_new_node), main);
 651         g_signal_connect(G_OBJECT(main->save_tb), "clicked", G_CALLBACK(callback_file_save), main);
 652
 653         /*
 654          * g_signal_connect(G_OBJECT(main->cut_tb), "clicked",
 655          * G_CALLBACK(callback_edit_cut), main);
 656          * g_signal_connect(G_OBJECT(main->copy_tb), "clicked",
 657          * G_CALLBACK(callback_edit_copy), main);
 658          * g_signal_connect(G_OBJECT(main->paste_tb), "clicked",
 659          * G_CALLBACK(callback_edit_paste), main);
 660          */
 661         g_signal_connect(G_OBJECT(main->font_tb), "clicked", G_CALLBACK(callback_font), main);
 662
 663         gtk_object_set_data(GTK_OBJECT(main->bold_tb), "s", WPT_BOLD);
 664         gtk_object_set_data(GTK_OBJECT(main->italic_tb), "s", WPT_ITALIC);
 665         gtk_object_set_data(GTK_OBJECT(main->underline_tb), "s", WPT_UNDERLINE);
 666         gtk_object_set_data(GTK_OBJECT(main->bullet_tb), "s", WPT_BULLET);
 667         gtk_object_set_data(GTK_OBJECT(main->strikethru_tb), "s", WPT_STRIKE);
 668         gtk_object_set_data(GTK_OBJECT(main->check_tb), "s", WPT_LEFT);
 669
 670         gtk_object_set_data(GTK_OBJECT(main->bold_tb), "m", main);
 671         gtk_object_set_data(GTK_OBJECT(main->italic_tb), "m", main);
 672         gtk_object_set_data(GTK_OBJECT(main->underline_tb), "m", main);
 673         gtk_object_set_data(GTK_OBJECT(main->bullet_tb), "m", main);
 674         gtk_object_set_data(GTK_OBJECT(main->strikethru_tb), "m", main);
 675         gtk_object_set_data(GTK_OBJECT(main->check_tb), "m", main);
 676
 677         g_signal_connect(G_OBJECT(main->bold_tb), "toggled", G_CALLBACK(callback_fontstyle), main->bold_tb);
 678         g_signal_connect(G_OBJECT(main->italic_tb), "toggled", G_CALLBACK(callback_fontstyle), main->italic_tb);
 679         g_signal_connect(G_OBJECT(main->underline_tb), "toggled", G_CALLBACK(callback_fontstyle), main->underline_tb);
 680         g_signal_connect(G_OBJECT(main->bullet_tb), "toggled", G_CALLBACK(callback_fontstyle), main->bullet_tb);
 681         g_signal_connect(G_OBJECT(main->strikethru_tb), "toggled", G_CALLBACK(callback_fontstyle), main->strikethru_tb);
 682         g_signal_connect(G_OBJECT(main->check_tb), "toggled", G_CALLBACK(callback_fontstyle), main->check_tb);
 683
 684         g_signal_connect(G_OBJECT(main->checkadd_tb), "clicked", G_CALLBACK(callback_checklist_add), main);
 685         g_signal_connect(G_OBJECT(main->checkdel_tb), "clicked", G_CALLBACK(callback_checklist_delete), main);
 686
 687         gtk_widget_show_all(GTK_WIDGET(main->toolbar));
 688 }
 689
 690 /*
 691  * Create the text area
 692  */
 693 void create_textarea(MainView * main)
 694 {
 695         main->scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
 696         gtk_widget_hide(main->scrolledwindow);
 697         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(main->scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 698
 699         main->textview = wp_text_view_new();
 700 /*
 701         gtk_text_view_set_editable(GTK_TEXT_VIEW(main->textview), TRUE);
 702         gtk_text_view_set_left_margin(GTK_TEXT_VIEW(main->textview), 10);
 703         gtk_text_view_set_right_margin(GTK_TEXT_VIEW(main->textview), 10);
 704         main->buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(main->textview));
 705         main->buffer = wp_text_buffer_new(NULL);
 706 */
 707         main->buffer = WP_TEXT_BUFFER(gtk_text_view_get_buffer(GTK_TEXT_VIEW(main->textview)));
 708
 709         g_signal_connect(G_OBJECT(main->buffer), "refresh_attributes", G_CALLBACK(callback_textbuffer_move), main);
 710         g_signal_connect(G_OBJECT(main->buffer), "can_undo", G_CALLBACK(callback_undotoggle), main);
 711         g_signal_connect(G_OBJECT(main->buffer), "can_redo", G_CALLBACK(callback_redotoggle), main);
 712
 713         wp_text_buffer_enable_rich_text(main->buffer, TRUE);
 714         gtk_text_buffer_set_can_paste_rich_text(GTK_TEXT_BUFFER(main->buffer), TRUE);
 715
 716         gtk_container_add(GTK_CONTAINER(main->scrolledwindow), main->textview);
 717         gtk_widget_show(main->textview);
 718
 719         gtk_widget_modify_font(main->textview, pango_font_description_from_string("Monospace Regular 16"));
 720
 721         g_signal_connect(G_OBJECT(main->buffer), "modified-changed", G_CALLBACK(callback_buffer_modified), main);
 722         g_signal_connect(G_OBJECT(main->buffer), "changed", G_CALLBACK(callback_buffer_modified), main);
 723 }
 724
 725 /*
 726  * Create the treeview
 727  */
 728 void create_treeview(MainView * main)
 729 {
 730         main->scrolledtree = gtk_scrolled_window_new(NULL, NULL);
 731         gtk_widget_show(main->scrolledtree);
 732         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(main->scrolledtree), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 733
 734         GtkTreeStore *tstore = gtk_tree_store_new(N_COLUMNS, G_TYPE_STRING, GDK_TYPE_PIXBUF,
 735                                                                                                                                                                                 G_TYPE_POINTER);
 736
 737         main->treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(tstore));
 738         g_object_unref(G_OBJECT(tstore));
 739
 740         GtkCellRenderer *renderer1 = gtk_cell_renderer_text_new();
 741         GtkCellRenderer *renderer2 = gtk_cell_renderer_pixbuf_new();
 742
 743         GtkTreeViewColumn *column = gtk_tree_view_column_new();
 744
 745         gtk_tree_view_column_pack_start(column, renderer2, FALSE);
 746         gtk_tree_view_column_pack_start(column, renderer1, FALSE);
 747
 748         gtk_tree_view_column_add_attribute(column, renderer1, "text", NODE_NAME);
 749         gtk_tree_view_column_add_attribute(column, renderer2, "pixbuf", NODE_PIXBUF);
 750
 751         /*
 752          * gtk_tree_view_column_add_attribute(column, renderer2, "width", 0);
 753          * gtk_tree_view_column_add_attribute(column, renderer2, "height", 0);
 754          */
 755         gtk_tree_view_column_set_cell_data_func(column, renderer2, callback_treeview_celldatafunc, main, NULL);
 756
 757         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 758         gtk_tree_view_column_set_resizable(column, FALSE);
 759
 760         gtk_tree_view_append_column(GTK_TREE_VIEW(main->treeview), column);
 761
 762         GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(main->treeview));
 763
 764         gtk_tree_selection_set_mode(select, GTK_SELECTION_BROWSE);
 765         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(main->treeview), FALSE);
 766         gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(main->treeview), FALSE);
 767 #ifdef EXPANDING_ROWS
 768         gtk_tree_view_set_expander_column(GTK_TREE_VIEW(main->treeview), column);
 769 #else
 770         gtk_tree_view_set_expander_column(GTK_TREE_VIEW(main->treeview), NULL);
 771 #endif
 772
 773         gtk_tree_view_expand_all(GTK_TREE_VIEW(main->treeview));
 774         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(main->treeview), TRUE);
 775         gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(main->treeview), FALSE);
 776
 777         g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK(callback_treeview_change), main);
 778 #ifndef EXPANDING_ROWS
 779         g_signal_connect(G_OBJECT(main->treeview), "test-collapse-row", G_CALLBACK(callback_treeview_testcollapse), main);
 780 #endif
 781         gtk_tree_selection_set_select_function(select, treeview_canselect, main, NULL);
 782         gtk_object_set_user_data(GTK_OBJECT(main->treeview), (gpointer) main);
 783
 784         gtk_container_add(GTK_CONTAINER(main->scrolledtree), main->treeview);
 785
 786         gtk_widget_set_name(main->treeview, "maemopadplus-treeview");
 787
 788         gtk_rc_parse(PIXMAPDIR "/maemopadplus.rc");
 789
 790         gtk_widget_show(main->treeview);
 791 }
 792
 793
 794 void create_checklist(MainView * main)
 795 {
 796         main->check_newitemcounter=0;
 797         main->listscroll = gtk_scrolled_window_new(NULL, NULL);
 798         gtk_widget_hide(main->listscroll);
 799         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(main->listscroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 800
 801         GtkListStore *store = gtk_list_store_new(CHECKN_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN);
 802
 803         main->listview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 804         g_object_unref(G_OBJECT(store));
 805
 806         g_object_set(main->listview, "allow-checkbox-mode", FALSE, NULL);
 807
 808         GtkCellRenderer *renderer1 = gtk_cell_renderer_toggle_new();
 809         g_object_set(renderer1, "activatable", TRUE, NULL);
 810         g_object_set(renderer1, "checkbox-mode", FALSE, NULL);
 811         g_object_set(renderer1, "radio", FALSE, NULL);
 812         g_signal_connect(G_OBJECT(renderer1), "toggled", G_CALLBACK(callback_checklist_toggled), main->listview);
 813
 814         GtkCellRenderer *renderer2 = gtk_cell_renderer_text_new();
 815         g_object_set(renderer2, "editable", TRUE, NULL);
 816         g_signal_connect(G_OBJECT(renderer2), "edited", G_CALLBACK(callback_checklist_edited), main->listview);
 817
 818         GtkTreeViewColumn *col1 = gtk_tree_view_column_new_with_attributes("", renderer1,
 819 /*                                                      "cell-background", CHECKNODE_COLOR,*/
 820                                                       "active", CHECKNODE_CHECKED,
 821                                                       NULL);
 822
 823         main->listtextcol = gtk_tree_view_column_new_with_attributes("", renderer2,
 824                                                       "text", CHECKNODE_TEXT,
 825 /*                                                      "cell-background", CHECKNODE_COLOR,*/
 826                                                       "foreground", CHECKNODE_COLOR,
 827                                                       "strikethrough", CHECKNODE_STRIKE,
 828                                                       "weight", CHECKNODE_BOLD,
 829                                                       NULL);
 830
 831         gtk_tree_view_append_column(GTK_TREE_VIEW(main->listview), col1);
 832         gtk_tree_view_append_column(GTK_TREE_VIEW(main->listview), main->listtextcol);
 833
 834         GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(main->listview));
 835
 836         gtk_tree_selection_set_mode(select, GTK_SELECTION_MULTIPLE);
 837         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(main->listview), FALSE);
 838         gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(main->listview), FALSE);
 839         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(main->listview), TRUE);
 840
 841 /*
 842         gtk_tree_selection_set_select_function(select, treeview_canselect, main, NULL);
 843 */
 844         g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK(callback_checklist_change), main);
 845
 846         gtk_object_set_user_data(GTK_OBJECT(main->listview), (gpointer) main);
 847         gtk_object_set_data(GTK_OBJECT(main->listview), "edited", FALSE);
 848
 849         gtk_container_add(GTK_CONTAINER(main->listscroll), main->listview);
 850         gtk_widget_show(main->listview);
 851 /*
 852 GtkTreeIter    toplevel;
 853 gtk_list_store_append(store, &toplevel);
 854 gtk_list_store_set(store, &toplevel,
 855                      CHECKNODE_CHECKED, TRUE, CHECKNODE_TEXT, "sample text", -1);
 856 */
 857 }