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
  52 void sk_set_brushsize(MainView * main, guint bsize)
  53 {
  54         int i = (bsize / 2) - 1;
  55
  56         if (i >= BRUSHSIZE_COUNT)
  57                 i = BRUSHSIZE_COUNT - 1;
  58         if (i < 0)
  59                 i = 0;
  60
  61         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(main->brushsizemenuitems[i]), FALSE);
  62         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(main->brushsizemenuitems[i]), TRUE);
  63 }
  64
  65 /*
  66  * Creates and initialises a main_view
  67  */
  68 MainView *interface_main_view_new(AppData * data)
  69 {
  70         /*
  71          * Zero memory with g_new0
  72          */
  73         MainView *result = g_new0(MainView, 1);
  74         /*
  75          * Create GTK vbox which will be our text area
  76          */
  77         GtkWidget *main_vbox = gtk_vbox_new(FALSE, 0);
  78
  79         /*
  80          * GtkWidget *main_vbox2 = gtk_vbox_new( FALSE, 0 );
  81          */
  82         result->hpaned = gtk_hpaned_new();
  83
  84         result->clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
  85         gtk_clipboard_set_can_store(result->clipboard, NULL, 0);
  86
  87         result->file_edited = FALSE;
  88
  89         result->data = data;
  90         result->data->main_view = HILDON_WINDOW(hildon_window_new());
  91
  92         create_treeview(result);
  93         create_textarea(result);
  94         result->brushsizemenu = create_brushsizemenu(result);
  95         result->sketchlinesmenu = create_sketchlinesmenu(result);
  96         result->viewmenu = create_viewmenu(result);
  97         result->shapemenu = create_shapemenu(result);
  98
  99         create_toolbar(result);
 100         GtkWidget *nodemenu = create_menu(result);
 101
 102         g_signal_connect_swapped(result->treeview, "button_press_event", G_CALLBACK(cb_popup), nodemenu);
 103         gtk_widget_tap_and_hold_setup(GTK_WIDGET(result->treeview), nodemenu, NULL, GTK_TAP_AND_HOLD_NONE);
 104
 105         gtk_container_add(GTK_CONTAINER(result->data->main_view), result->hpaned);
 106 /*      hildon_window_add_with_scrollbar(result->data->main_view, result->hpaned);*/ /*doesn't fix the gutter*/
 107
 108         gtk_paned_add1(GTK_PANED(result->hpaned), result->scrolledtree);
 109
 110         result->sk = sketchwidget_new(800, 480, FALSE);
 111         sketchwidget_set_undocallback(result->sk, callback_undotoggle, result);
 112         sketchwidget_set_redocallback(result->sk, callback_redotoggle, result);
 113
 114         gtk_box_pack_start(GTK_BOX(main_vbox), result->scrolledwindow, TRUE, TRUE, 0);
 115         gtk_box_pack_start(GTK_BOX(main_vbox), sketchwidget_get_mainwidget(result->sk), TRUE, TRUE, 0);
 116         hildon_window_add_toolbar(result->data->main_view, GTK_TOOLBAR(result->toolbar));
 117
 118         gtk_paned_add2(GTK_PANED(result->hpaned), main_vbox);
 119
 120         gtk_widget_show(main_vbox);
 121         gtk_widget_show(result->hpaned);
 122
 123         gtk_widget_show_all(GTK_WIDGET(result->data->main_view));
 124         gtk_widget_grab_focus(GTK_WIDGET(result->textview));
 125
 126         result->file_edited = FALSE;
 127         result->file_name = NULL;
 128
 129         g_signal_connect(G_OBJECT(result->data->main_view), "key_press_event", G_CALLBACK(key_press_cb), result);
 130         g_signal_connect(G_OBJECT(result->data->main_view), "delete_event", G_CALLBACK(close_cb), result);
 131
 132         sk_set_brushsize(result, 2);
 133         sk_set_brushsize(result, 4);
 134
 135         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(result->sketchlinesmenuitems[0]), TRUE);
 136         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(result->shapemenuitems[0]), TRUE);
 137
 138         result->newnodedialog_createchild = TRUE;
 139
 140         result->cursorBusy = gdk_cursor_new(GDK_WATCH);
 141         result->loading=FALSE;
 142
 143         return result;
 144 }
 145
 146 /*
 147  * clean up the allocated memory
 148  */
 149 void interface_main_view_destroy(MainView * main)
 150 {
 151         gdk_cursor_unref(main->cursorBusy);
 152         g_free(main);
 153 }
 154
 155 /*
 156  * File chooser
 157  */
 158 gchar *interface_file_chooser(MainView * mainview, GtkFileChooserAction action, gchar * suggname, gchar * suggext)
 159 {
 160         GtkWidget *dialog;
 161         gchar *filename = NULL;
 162
 163         dialog = hildon_file_chooser_dialog_new(GTK_WINDOW(mainview->data->main_view), action);
 164         gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), TRUE);
 165
 166         if (action == GTK_FILE_CHOOSER_ACTION_SAVE && suggname != NULL)
 167                 {
 168                         gchar fn[128];
 169
 170                         if (suggext == NULL)
 171                                 snprintf(fn, sizeof(fn), "%s", suggname);
 172                         else
 173                                 snprintf(fn, sizeof(fn), "%s.%s", suggname, suggext);
 174
 175                         int i = 0;
 176                         struct stat s;
 177
 178                         while(stat(fn, &s) == 0)
 179                                 {
 180                                         i++;
 181                                         if (suggext == NULL)
 182                                                 snprintf(fn, sizeof(fn), "%s(%d)", suggname, i);
 183                                         else
 184                                                 snprintf(fn, sizeof(fn), "%s(%d).%s", suggname, i, suggext);
 185                                 }
 186
 187                         fprintf(stderr, "%s\n", fn);
 188                         gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), fn);
 189                 }
 190
 191         gtk_widget_show_all(GTK_WIDGET(dialog));
 192         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
 193                 {
 194                         filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
 195                 }
 196
 197         gtk_widget_destroy(dialog);
 198         return filename;
 199 }
 200
 201 /*
 202  * Font chooser
 203  */
 204 PangoFontDescription *interface_font_chooser(MainView * main)
 205 {
 206         HildonFontSelectionDialog *dialog = NULL;
 207
 208         PangoFontDescription *font = NULL;
 209         gint size;
 210         gboolean bold, italic;
 211         gchar *family = NULL;
 212
 213         font = pango_font_description_new();
 214
 215         /*
 216          * create dialog
 217          */
 218         dialog = HILDON_FONT_SELECTION_DIALOG(hildon_font_selection_dialog_new(NULL, NULL));
 219
 220         gtk_widget_show_all(GTK_WIDGET(dialog));
 221         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
 222                 {
 223                         g_object_get(G_OBJECT(dialog), "family", &family, "size", &size, "bold", &bold, "italic", &italic, NULL);
 224                         pango_font_description_set_family(font, family);
 225                         pango_font_description_set_size(font, size * PANGO_SCALE);
 226                         if (bold)
 227                                 {
 228                                         pango_font_description_set_weight(font, PANGO_WEIGHT_BOLD);
 229                                 }
 230                         else
 231                                 {
 232                                         pango_font_description_set_weight(font, PANGO_WEIGHT_NORMAL);
 233                                 }
 234                         if (italic)
 235                                 {
 236                                         pango_font_description_set_style(font, PANGO_STYLE_ITALIC);
 237                                 }
 238                         else
 239                                 {
 240                                         pango_font_description_set_style(font, PANGO_STYLE_NORMAL);
 241                                 }
 242                 }
 243         gtk_widget_destroy(GTK_WIDGET(dialog));
 244
 245         return font;
 246 }
 247
 248 gint interface_create_new_file(MainView * main)
 249 {
 250         HildonNote *hn = NULL;
 251         gint response = FALSE;
 252
 253         g_assert(main != NULL && main->data->app != NULL);
 254
 255         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));
 256         response = gtk_dialog_run(GTK_DIALOG(hn));
 257         gtk_widget_destroy(GTK_WIDGET(hn));
 258         return response;
 259 }
 260
 261 /*
 262  * Privates
 263  */
 264
 265 /*
 266  * Create the menu items needed for the drop down menu
 267  */
 268 GtkWidget *create_menu(MainView * main)
 269 {
 270         /*
 271          * Create needed handles
 272          */
 273         GtkMenu *main_menu;
 274         GtkWidget *file_menu, *close, *about, *edit_menu, *tools_menu, *node_menu, *node_item;
 275
 276         /*
 277          * Get the menu of our view
 278          */
 279         main_menu = GTK_MENU( gtk_menu_new () );
 280         /* Add menu to HildonWindow */
 281         hildon_window_set_menu(main->data->main_view, main_menu);
 282
 283         /*
 284          * Create new menus for submenus in our drop down menu
 285          */
 286         file_menu = gtk_menu_new();
 287         node_menu = gtk_menu_new();
 288         edit_menu = gtk_menu_new();
 289         tools_menu = gtk_menu_new();
 290
 291         /*
 292          * Create the menu items
 293          */
 294         main->file_item = gtk_menu_item_new_with_label(_("File"));
 295         node_item = gtk_menu_item_new_with_label(_("Memo"));
 296
 297         main->new_node_item = gtk_menu_item_new_with_label(_("New memo"));
 298         main->delete_node_item = gtk_menu_item_new_with_label(_("Delete memo"));
 299         main->expand_collapse_node_item = gtk_menu_item_new_with_label(_("Expand/collapse node"));
 300         main->export_node_item = gtk_menu_item_new_with_label(_("Export memo"));
 301
 302         main->new_item = gtk_menu_item_new_with_label(_("New data file"));
 303         main->open_item = gtk_menu_item_new_with_label(_("Open data file..."));
 304         main->save_item = gtk_menu_item_new_with_label(_("Save data"));
 305         main->view_item = gtk_menu_item_new_with_label(_("View"));
 306         main->edit_item = gtk_menu_item_new_with_label(_("Edit"));
 307         main->cut_item = gtk_menu_item_new_with_label(_("Cut"));
 308         main->copy_item = gtk_menu_item_new_with_label(_("Copy"));
 309         main->paste_item = gtk_menu_item_new_with_label(_("Paste"));
 310         main->clear_item = gtk_menu_item_new_with_label(_("Clear"));
 311         main->tools_item = gtk_menu_item_new_with_label(_("Tools"));
 312         close = gtk_menu_item_new_with_label(_("Exit"));
 313
 314         /*
 315          * Add menu items to right menus
 316          */
 317         gtk_menu_append(main_menu, main->file_item);
 318         gtk_menu_append(file_menu, main->new_item);
 319         gtk_menu_append(file_menu, main->open_item);
 320         gtk_menu_append(file_menu, main->save_item);
 321
 322         gtk_menu_append(main_menu, main->view_item);
 323
 324         gtk_menu_append(main_menu, main->edit_item);
 325         gtk_menu_append(edit_menu, main->cut_item);
 326         gtk_menu_append(edit_menu, main->copy_item);
 327         gtk_menu_append(edit_menu, main->paste_item);
 328         gtk_menu_append(edit_menu, gtk_separator_menu_item_new());
 329         gtk_menu_append(edit_menu, main->clear_item);
 330
 331         gtk_menu_append(main_menu, node_item);
 332         gtk_menu_append(node_menu, main->new_node_item);
 333         gtk_menu_append(node_menu, main->delete_node_item);
 334         gtk_menu_append(node_menu, gtk_separator_menu_item_new());
 335         gtk_menu_append(node_menu, main->export_node_item);
 336 #ifdef EXPANDING_ROWS
 337         gtk_menu_append(node_menu, gtk_separator_menu_item_new());
 338         gtk_menu_append(node_menu, main->expand_collapse_node_item);
 339 #endif
 340         gtk_menu_append(main_menu, main->tools_item);
 341         gtk_menu_append(main_menu, gtk_separator_menu_item_new());
 342         about = gtk_menu_item_new_with_label(_("About..."));
 343         gtk_menu_append(main_menu, about);
 344         gtk_menu_append(main_menu, close);
 345
 346         g_signal_connect(G_OBJECT(about), "activate", G_CALLBACK(callback_about), main);
 347
 348         /*
 349          * Add submenus to the right items
 350          */
 351         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->file_item), file_menu);
 352         gtk_menu_item_set_submenu(GTK_MENU_ITEM(node_item), node_menu);
 353         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->edit_item), edit_menu);
 354         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->tools_item), tools_menu);
 355
 356         main->tools_brushsize = gtk_menu_item_new_with_label(_("Brush size"));
 357         main->tools_pagestyle = gtk_menu_item_new_with_label(_("Page style"));
 358         main->tools_shape = gtk_menu_item_new_with_label(_("Shape"));
 359         main->tools_color = gtk_menu_item_new_with_label(_("Color..."));
 360         main->tools_font = gtk_menu_item_new_with_label(_("Font..."));
 361         gtk_menu_append(tools_menu, main->tools_color);
 362         gtk_menu_append(tools_menu, main->tools_brushsize);
 363         gtk_menu_append(tools_menu, main->tools_shape);
 364         gtk_menu_append(tools_menu, main->tools_pagestyle);
 365         gtk_menu_append(tools_menu, main->tools_font);
 366         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->tools_brushsize), main->brushsizemenu);
 367         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->tools_pagestyle), main->sketchlinesmenu);
 368         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->tools_shape), main->shapemenu);
 369
 370         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->view_item), main->viewmenu);
 371
 372         /*
 373          * Attach the callback functions to the activate signal
 374          */
 375         g_signal_connect(G_OBJECT(main->new_node_item), "activate", G_CALLBACK(callback_file_new_node), main);
 376         g_signal_connect(G_OBJECT(main->delete_node_item), "activate", G_CALLBACK(callback_file_delete_node), main);
 377         g_signal_connect(G_OBJECT(main->export_node_item), "activate", G_CALLBACK(callback_file_export_node), main);
 378         g_signal_connect(G_OBJECT(main->expand_collapse_node_item), "activate", G_CALLBACK(callback_file_expand_collapse_node), main);
 379
 380         g_signal_connect(G_OBJECT(main->new_item), "activate", G_CALLBACK(callback_file_new), main);
 381         g_signal_connect(G_OBJECT(main->open_item), "activate", G_CALLBACK(callback_file_open), main);
 382         g_signal_connect(G_OBJECT(main->save_item), "activate", G_CALLBACK(callback_file_save), main);
 383         g_signal_connect(G_OBJECT(main->cut_item), "activate", G_CALLBACK(callback_edit_cut), main);
 384         g_signal_connect(G_OBJECT(main->copy_item), "activate", G_CALLBACK(callback_edit_copy), main);
 385         g_signal_connect(G_OBJECT(main->paste_item), "activate", G_CALLBACK(callback_edit_paste), main);
 386         g_signal_connect(G_OBJECT(main->clear_item), "activate", G_CALLBACK(callback_edit_clear), main);
 387         g_signal_connect(G_OBJECT(main->tools_font), "activate", G_CALLBACK(callback_font), main);
 388         g_signal_connect(G_OBJECT(main->tools_color), "activate", G_CALLBACK(callback_color_invoke), main);
 389
 390         g_signal_connect(G_OBJECT(close), "activate", G_CALLBACK(callback_file_close), main);
 391
 392         /*
 393          * We need to show menu items
 394          */
 395         gtk_widget_show_all(GTK_WIDGET(main_menu));
 396
 397         return (node_menu);
 398 }
 399
 400 GtkWidget *create_brushsizemenu(MainView * main)
 401 {
 402         GtkWidget *menu;
 403         int i;
 404
 405         GSList *gr = NULL;
 406
 407         menu = gtk_menu_new();
 408
 409         for(i = 0; i < BRUSHSIZE_COUNT; i++)
 410                 {
 411                         int bsize = (i + 1) * 2;
 412
 413                         char fpa[PATH_MAX];
 414
 415                         snprintf(fpa, sizeof(fpa), "%s/pencil%d.png", PIXMAPDIR, i + 1);
 416                         GtkWidget *pix = gtk_image_new_from_file(fpa);
 417
 418                         g_object_ref(pix);
 419
 420                         char st[128];
 421
 422                         snprintf(st, sizeof(st), _("%dpt"), bsize);
 423                         main->brushsizemenuitems[i] = gtk_radio_menu_item_new_with_label(gr, st);
 424                         gr = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(main->brushsizemenuitems[i]));
 425
 426                         gtk_object_set_user_data(GTK_OBJECT(main->brushsizemenuitems[i]), bsize);
 427                         gtk_object_set_data(GTK_OBJECT(main->brushsizemenuitems[i]), "mainview", main);
 428                         gtk_object_set_data(GTK_OBJECT(main->brushsizemenuitems[i]), "icon", pix);
 429
 430                         gtk_menu_prepend(menu, main->brushsizemenuitems[i]);
 431                         g_signal_connect(G_OBJECT(main->brushsizemenuitems[i]), "activate", G_CALLBACK(callback_brushsize), main->brushsizemenuitems[i]);
 432                 }
 433
 434         gtk_widget_show_all(GTK_WIDGET(menu));
 435
 436         return (menu);
 437 }
 438
 439 GtkWidget *create_sketchlinesmenu(MainView * main)
 440 {
 441         GtkWidget *menu;
 442         int i;
 443
 444         GSList *gr = NULL;
 445
 446         menu = gtk_menu_new();
 447
 448         char st[3][128];
 449
 450         snprintf(st[0], sizeof(st[0]), _("No background"));
 451         snprintf(st[1], sizeof(st[1]), _("Notebook lines"));
 452         snprintf(st[2], sizeof(st[2]), _("Graph lines"));
 453
 454         for(i = 0; i < 3; i++)
 455                 {
 456                         char fpa[PATH_MAX];
 457
 458                         snprintf(fpa, sizeof(fpa), "%s/sketchbg%d.png", PIXMAPDIR, i);
 459                         GtkWidget *pix = gtk_image_new_from_file(fpa);
 460
 461                         g_object_ref(pix);
 462
 463                         main->sketchlinesmenuitems[i] = gtk_radio_menu_item_new_with_label(gr, st[i]);
 464                         gr = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(main->sketchlinesmenuitems[i]));
 465
 466                         gtk_object_set_user_data(GTK_OBJECT(main->sketchlinesmenuitems[i]), i);
 467                         gtk_object_set_data(GTK_OBJECT(main->sketchlinesmenuitems[i]), "mainview", main);
 468                         gtk_object_set_data(GTK_OBJECT(main->sketchlinesmenuitems[i]), "icon", pix);
 469
 470                         gtk_menu_prepend(menu, main->sketchlinesmenuitems[i]);
 471                         g_signal_connect(G_OBJECT(main->sketchlinesmenuitems[i]), "activate", G_CALLBACK(callback_sketchlines), main->sketchlinesmenuitems[i]);
 472                 }
 473
 474         gtk_widget_show_all(GTK_WIDGET(menu));
 475
 476         return (menu);
 477 }
 478
 479 GtkWidget *create_viewmenu(MainView * main)
 480 {
 481         GtkWidget *menu;
 482         int i;
 483
 484         menu = gtk_menu_new();
 485
 486         char st[3][128];
 487         int stf[3];
 488
 489         snprintf(st[0], sizeof(st[0]), _("Tree"));
 490         snprintf(st[1], sizeof(st[1]), _("Toolbar"));
 491         snprintf(st[2], sizeof(st[2]), _("Full screen"));
 492
 493 /*
 494 this is here because we might want to change the order of the items
 495 warning: these are also in callback_setview()
 496 */
 497
 498         stf[0]=1;
 499         stf[1]=2;
 500         stf[2]=4;
 501
 502         for(i = 0; i < 3; i++)
 503                 {
 504                         main->viewmenuitems[i] = gtk_check_menu_item_new_with_label(st[i]);
 505
 506                         gtk_object_set_user_data(GTK_OBJECT(main->viewmenuitems[i]), stf[i]);
 507                         gtk_object_set_data(GTK_OBJECT(main->viewmenuitems[i]), "mainview", main);
 508
 509                         gtk_menu_prepend(menu, main->viewmenuitems[i]);
 510                         g_signal_connect(G_OBJECT(main->viewmenuitems[i]), "toggled", G_CALLBACK(callback_viewmenu), main->viewmenuitems[i]);
 511                 }
 512
 513         gtk_widget_show_all(GTK_WIDGET(menu));
 514
 515         return (menu);
 516 }
 517
 518 GtkWidget *create_shapemenu(MainView * main)
 519 {
 520         GtkWidget *menu;
 521         int i;
 522
 523         GSList *gr = NULL;
 524
 525         menu = gtk_menu_new();
 526
 527         char st[4][128];
 528
 529         snprintf(st[0], sizeof(st[0]), _("Free"));
 530         snprintf(st[1], sizeof(st[1]), _("Line"));
 531         snprintf(st[2], sizeof(st[2]), _("Rectangle"));
 532         snprintf(st[3], sizeof(st[3]), _("Ellipse"));
 533
 534         for(i = 0; i < 4; i++)
 535                 {
 536                         main->shapemenuitems[i] = gtk_radio_menu_item_new_with_label(gr, st[i]);
 537                         gr = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(main->shapemenuitems[i]));
 538
 539                         gtk_object_set_user_data(GTK_OBJECT(main->shapemenuitems[i]), i);
 540                         gtk_object_set_data(GTK_OBJECT(main->shapemenuitems[i]), "mainview", main);
 541
 542                         gtk_menu_prepend(menu, main->shapemenuitems[i]);
 543                         g_signal_connect(G_OBJECT(main->shapemenuitems[i]), "activate", G_CALLBACK(callback_shapemenu), main->shapemenuitems[i]);
 544                 }
 545
 546         gtk_widget_show_all(GTK_WIDGET(menu));
 547
 548         return (menu);
 549 }
 550 /*
 551  * Create toolbar to mainview
 552  */
 553 static void create_toolbar(MainView * main)
 554 {
 555         /*
 556          * Create new GTK toolbar
 557          */
 558         main->toolbar = gtk_toolbar_new();
 559
 560         /*
 561          * Set toolbar properties
 562          */
 563         gtk_toolbar_set_orientation(GTK_TOOLBAR(main->toolbar), GTK_ORIENTATION_HORIZONTAL);
 564         gtk_toolbar_set_style(GTK_TOOLBAR(main->toolbar), GTK_TOOLBAR_BOTH_HORIZ);
 565
 566         /*
 567          * Make menus and buttons to toolbar:
 568          */
 569         main->toggletree_tb = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_INDEX);
 570         g_signal_connect(G_OBJECT(main->toggletree_tb), "toggled", G_CALLBACK(callback_toggletree), main);
 571
 572         main->new_tb = gtk_tool_button_new_from_stock( /*GTK_STOCK_NEW */ GTK_STOCK_ADD);
 573
 574         main->save_tb = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE);
 575         main->separator_tb1 = gtk_separator_tool_item_new();
 576
 577         /*
 578          * main->cut_tb = gtk_tool_button_new_from_stock(GTK_STOCK_CUT);
 579          * main->copy_tb = gtk_tool_button_new_from_stock(GTK_STOCK_COPY);
 580          * main->paste_tb = gtk_tool_button_new_from_stock(GTK_STOCK_PASTE);
 581          * main->separator_tb2 = gtk_separator_tool_item_new();
 582          */
 583         main->font_tb = gtk_tool_button_new_from_stock(GTK_STOCK_SELECT_FONT);
 584
 585 /*      main->fullscreen_tb = gtk_tool_button_new_from_stock(GTK_STOCK_ZOOM_FIT);*/
 586
 587         /*
 588          * Insert items to toolbar
 589          */
 590         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->toggletree_tb, -1);
 591 /*      gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), gtk_separator_tool_item_new(), -1);*/
 592         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->new_tb, -1);
 593         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->save_tb, -1);
 594 /*      gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->fullscreen_tb, -1);*/
 595         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->separator_tb1, -1);
 596
 597         /*
 598          * gtk_toolbar_insert ( GTK_TOOLBAR(main->toolbar), main->cut_tb, -1);
 599          * gtk_toolbar_insert ( GTK_TOOLBAR(main->toolbar), main->copy_tb, -1);
 600          * gtk_toolbar_insert ( GTK_TOOLBAR(main->toolbar), main->paste_tb, -1);
 601          * gtk_toolbar_insert ( GTK_TOOLBAR(main->toolbar), main->separator_tb2, -1);
 602          */
 603         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->font_tb, -1);
 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         GtkWidget *pix = gtk_image_new_from_file(PIXMAPDIR "/" "eraser.png");
 621
 622         main->eraser_tb = gtk_toggle_tool_button_new();
 623         gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(main->eraser_tb), pix);
 624         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->eraser_tb, -1);
 625         g_signal_connect(G_OBJECT(main->eraser_tb), "toggled", G_CALLBACK(callback_eraser), main);
 626
 627 #if 1
 628         main->shape_tb = gtk_tool_button_new_from_stock(GTK_STOCK_CONVERT);
 629 #else
 630         pix = gtk_image_new_from_file(PIXMAPDIR "/" "eraser.png")
 631         main->shape_tb = gtk_tool_button_new(NULL, NULL);
 632         gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(main->shape_tb), pix);
 633 #endif
 634         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->shape_tb, -1);
 635         g_signal_connect(G_OBJECT(main->shape_tb), "clicked", G_CALLBACK(callback_menu), main->shapemenu);
 636
 637         main->sketchlines_tb = gtk_tool_button_new(NULL, NULL);
 638         g_signal_connect(G_OBJECT(main->sketchlines_tb), "clicked", G_CALLBACK(callback_menu), main->sketchlinesmenu);
 639         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->sketchlines_tb, -1);
 640
 641         main->undo_tb = gtk_tool_button_new_from_stock(GTK_STOCK_UNDO);
 642         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->undo_tb, -1);
 643         g_signal_connect(G_OBJECT(main->undo_tb), "clicked", G_CALLBACK(callback_undo), main);
 644
 645         main->redo_tb = gtk_tool_button_new_from_stock(GTK_STOCK_REDO);
 646         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->redo_tb, -1);
 647         g_signal_connect(G_OBJECT(main->redo_tb), "clicked", G_CALLBACK(callback_redo), main);
 648
 649         /*
 650          * Connect signals to buttons
 651          */
 652         g_signal_connect(G_OBJECT(main->new_tb), "clicked", G_CALLBACK(callback_file_new_node), main);
 653         g_signal_connect(G_OBJECT(main->save_tb), "clicked", G_CALLBACK(callback_file_save), main);
 654
 655         /*
 656          * g_signal_connect(G_OBJECT(main->cut_tb), "clicked",
 657          * G_CALLBACK(callback_edit_cut), main);
 658          * g_signal_connect(G_OBJECT(main->copy_tb), "clicked",
 659          * G_CALLBACK(callback_edit_copy), main);
 660          * g_signal_connect(G_OBJECT(main->paste_tb), "clicked",
 661          * G_CALLBACK(callback_edit_paste), main);
 662          */
 663         g_signal_connect(G_OBJECT(main->font_tb), "clicked", G_CALLBACK(callback_font), main);
 664 /*      g_signal_connect(G_OBJECT(main->fullscreen_tb), "clicked", G_CALLBACK(callback_menu), main->fullscreenmenu);*/
 665
 666         /*
 667          * Show toolbar
 668          */
 669         gtk_widget_show_all(GTK_WIDGET(main->toolbar));
 670 }
 671
 672 /*
 673  * Create the text area
 674  */
 675 void create_textarea(MainView * main)
 676 {
 677         /*
 678          * Scrolled window
 679          */
 680         main->scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
 681         gtk_widget_hide(main->scrolledwindow);
 682         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(main->scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 683
 684         /*
 685          * Text view
 686          */
 687         main->textview = gtk_text_view_new();
 688
 689         /*
 690          * Some text view settings
 691          */
 692         gtk_text_view_set_editable(GTK_TEXT_VIEW(main->textview), TRUE);
 693         gtk_text_view_set_left_margin(GTK_TEXT_VIEW(main->textview), 10);
 694         gtk_text_view_set_right_margin(GTK_TEXT_VIEW(main->textview), 10);
 695
 696         /*
 697          * Get handle
 698          */
 699         main->buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(main->textview));
 700
 701         /*
 702          * Enable Rich Text Support
 703          */
 704         gtk_text_buffer_set_can_paste_rich_text(main->buffer, TRUE);
 705         gtk_text_buffer_set_rich_text_format(main->buffer, "RTF");
 706
 707         /*
 708          * Put textview under scrolledwindow and show it
 709          */
 710         gtk_container_add(GTK_CONTAINER(main->scrolledwindow), main->textview);
 711         gtk_widget_show(main->textview);
 712
 713         /*
 714          * Change default font throughout the widget
 715          */
 716         main->font_desc = pango_font_description_from_string("Monospace Regular 22");
 717         gtk_widget_modify_font(main->textview, main->font_desc);
 718
 719         /*
 720          * Connect signals
 721          */
 722         g_signal_connect(G_OBJECT(main->buffer), "modified-changed", G_CALLBACK(callback_buffer_modified), main);
 723         g_signal_connect(G_OBJECT(main->buffer), "changed", G_CALLBACK(callback_buffer_modified), main);
 724 }
 725
 726 /*
 727  * Create the treeview
 728  */
 729 void create_treeview(MainView * main)
 730 {
 731         main->scrolledtree = gtk_scrolled_window_new(NULL, NULL);
 732         gtk_widget_show(main->scrolledtree);
 733         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(main->scrolledtree), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 734
 735         GtkTreeStore *tstore = gtk_tree_store_new(N_COLUMNS, G_TYPE_STRING, GDK_TYPE_PIXBUF,
 736                                                                                                                                                                                 G_TYPE_POINTER);
 737
 738         main->treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(tstore));
 739         g_object_unref(G_OBJECT(tstore));
 740
 741         GtkCellRenderer *renderer1 = gtk_cell_renderer_text_new();
 742         GtkCellRenderer *renderer2 = gtk_cell_renderer_pixbuf_new();
 743
 744         GtkTreeViewColumn *column = gtk_tree_view_column_new();
 745
 746         gtk_tree_view_column_pack_start(column, renderer2, FALSE);
 747         gtk_tree_view_column_pack_start(column, renderer1, FALSE);
 748
 749         gtk_tree_view_column_add_attribute(column, renderer1, "text", NODE_NAME);
 750         gtk_tree_view_column_add_attribute(column, renderer2, "pixbuf", NODE_PIXBUF);
 751
 752         /*
 753          * gtk_tree_view_column_add_attribute(column, renderer2, "width", 0);
 754          * gtk_tree_view_column_add_attribute(column, renderer2, "height", 0);
 755          */
 756         gtk_tree_view_column_set_cell_data_func(column, renderer2, callback_treeview_celldatafunc, main, NULL);
 757
 758         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 759         gtk_tree_view_column_set_resizable(column, FALSE);
 760
 761         gtk_tree_view_append_column(GTK_TREE_VIEW(main->treeview), column);
 762
 763         GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(main->treeview));
 764
 765         gtk_tree_selection_set_mode(select, GTK_SELECTION_BROWSE);
 766         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(main->treeview), FALSE);
 767         gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(main->treeview), FALSE);
 768 #ifdef EXPANDING_ROWS
 769         gtk_tree_view_set_expander_column(GTK_TREE_VIEW(main->treeview), column);
 770 #else
 771         gtk_tree_view_set_expander_column(GTK_TREE_VIEW(main->treeview), NULL);
 772 #endif
 773
 774         gtk_tree_view_expand_all(GTK_TREE_VIEW(main->treeview));
 775         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(main->treeview), TRUE);
 776         gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(main->treeview), FALSE);
 777
 778         g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK(callback_treeview_change), main);
 779 #ifndef EXPANDING_ROWS
 780         g_signal_connect(G_OBJECT(main->treeview), "test-collapse-row", G_CALLBACK(callback_treeview_testcollapse), main);
 781 #endif
 782         gtk_tree_selection_set_select_function(select, treeview_canselect, main, NULL);
 783         gtk_object_set_user_data(GTK_OBJECT(main->treeview), (gpointer) main);
 784
 785         gtk_container_add(GTK_CONTAINER(main->scrolledtree), main->treeview);
 786
 787         gtk_widget_set_name(main->treeview, "maemopadplus-treeview");
 788
 789         gtk_rc_parse(PIXMAPDIR "/maemopadplus.rc");
 790
 791         gtk_widget_show(main->treeview);
 792 }