src/ui/interface.c

   1 /*
   2  * This file is part of MaePad
   3  * Copyright (c) 2010 Thomas Perl <thp.io/about>
   4  * http://thp.io/2010/maepad/
   5  *
   6  * Based on Maemopad+:
   7  * Copyright (c) 2006-2008 Kemal Hadimli
   8  * Copyright (c) 2008 Thomas Perl
   9  *
  10  * This software is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public License
  12  * as published by the Free Software Foundation; either version 2.1 of
  13  * the License, or (at your option) any later version.
  14  *
  15  * This software is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this software; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  23  * 02110-1301 USA
  24  *
  25  */
  26
  27 #include <gtk/gtk.h>
  28 #include <libintl.h>
  29 #include <sys/param.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <unistd.h>
  33 #include <stdio.h>
  34 #include <config.h>
  35
  36 #include <hildon/hildon-program.h>
  37 #include <hildon/hildon-file-chooser-dialog.h>
  38 #include <hildon/hildon-note.h>
  39 #include <hildon/hildon-font-selection-dialog.h>
  40 #include <hildon/hildon-color-button.h>
  41
  42 #include "callbacks.h"
  43 #include "interface.h"
  44 #include "sketchwidget.h"
  45
  46 /* Function prototype for strcasestr(3) - a GNU function */
  47 char *strcasestr(const char *haystack, const char *needle);
  48
  49 /*
  50  * Privates:
  51  */
  52
  53 GtkWidget *create_brushsizemenu(MainView * main);
  54 GtkWidget *create_shapemenu(MainView * main);
  55 GtkWidget *create_sketchlinesmenu(MainView * main);
  56 GtkWidget *create_menu(MainView * main);
  57 static void create_toolbar(MainView * main);
  58 void create_textarea(MainView * main);
  59 void create_treeview(MainView * main);
  60 static void _tool_button_set_icon_name(GtkToolButton *button, const gchar *icon_name);
  61 static void _tool_button_set_icon_file(GtkToolButton* button, const gchar* file_name);
  62 void create_checklist(MainView * main);
  63
  64 void sk_set_brushsize(MainView * main, guint bsize)
  65 {
  66         int i = (bsize / 2) - 1;
  67
  68         if (i >= BRUSHSIZE_COUNT)
  69                 i = BRUSHSIZE_COUNT - 1;
  70         if (i < 0)
  71                 i = 0;
  72
  73         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(main->brushsizemenuitems[i]), FALSE);
  74         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(main->brushsizemenuitems[i]), TRUE);
  75 }
  76
  77 static void _tool_button_set_icon_name(GtkToolButton *button, const gchar *icon_name)
  78 {
  79         GtkWidget *image;
  80         image = gtk_image_new_from_icon_name(icon_name, GTK_ICON_SIZE_SMALL_TOOLBAR);
  81         gtk_tool_button_set_icon_widget(button, image);
  82 }
  83
  84 static void _tool_button_set_icon_file(GtkToolButton* button, const gchar* file_name)
  85 {
  86         GtkWidget *image;
  87         image = gtk_image_new_from_file(file_name);
  88         gtk_tool_button_set_icon_widget(button, image);
  89 }
  90
  91 void _toggle_tool_button_set_inconsistent(GtkToggleToolButton *button, gboolean inconsistent)
  92 {
  93 GtkWidget *toggle_button = gtk_bin_get_child(GTK_BIN(button));
  94 gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(toggle_button), inconsistent);
  95 }
  96
  97 MainView *interface_main_view_new(AppData * data)
  98 {
  99         MainView *result = g_new0(MainView, 1);
 100
 101         result->checklist_edited = FALSE;
 102         result->checklist_prepend = FALSE;
 103         result->current_color = NULL;
 104         result->can_show_node_view = FALSE;
 105         result->node_list_longpress_path = NULL;
 106         result->checklist_longpress_source_id = 0;
 107         result->node_view_prev_keyval = GDK_VoidSymbol;
 108         result->node_view_prev_keyval_reset = FALSE;
 109         result->main_view_prev_keyval = GDK_VoidSymbol;
 110         result->main_view_prev_keyval_reset = FALSE;
 111
 112         GtkWidget *main_vbox = gtk_vbox_new(FALSE, 0);
 113
 114         result->clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
 115         gtk_clipboard_set_can_store(result->clipboard, NULL, 0);
 116
 117         result->file_edited = FALSE;
 118
 119         result->data = data;
 120
 121         data->main_view = HILDON_STACKABLE_WINDOW(hildon_stackable_window_new());
 122         data->node_view = HILDON_STACKABLE_WINDOW(hildon_stackable_window_new());
 123
 124         /* Enable auto-rotation on Maemo 5 (automatic since PR1.2?) */
 125         hildon_gtk_window_set_portrait_flags(data->main_view,
 126                 HILDON_PORTRAIT_MODE_SUPPORT);
 127         hildon_gtk_window_set_portrait_flags(data->node_view,
 128                 HILDON_PORTRAIT_MODE_SUPPORT);
 129
 130         /* Fullscreen and toolbar handling for the node view window */
 131         g_signal_connect(G_OBJECT(data->node_view),
 132                          "window-state-event",
 133                          G_CALLBACK(callback_node_view_window_state),
 134                          result);
 135         result->node_view_fullscreen_button = he_fullscreen_button_new(
 136                 GTK_WINDOW(data->node_view));
 137
 138         /* Make sure node view only gets hidden when closed */
 139         g_signal_connect(G_OBJECT(data->node_view),
 140                          "delete-event",
 141                          G_CALLBACK(gtk_widget_hide_on_delete),
 142                          NULL);
 143
 144         /**
 145          * We need to connect to these signals very early (before setting
 146          * up the HildonLiveSearch hook), so that we can control and
 147          * override the key presses in the main view
 148          **/
 149         g_signal_connect(G_OBJECT(result->data->main_view),
 150                         "key-press-event",
 151                         G_CALLBACK(on_main_view_key_press),
 152                         result);
 153         g_signal_connect(G_OBJECT(result->data->main_view),
 154                         "key-release-event",
 155                         G_CALLBACK(on_main_view_key_release),
 156                         result);
 157
 158         create_treeview(result);
 159         create_textarea(result);
 160         create_checklist(result);
 161
 162         result->brushsizemenu = create_brushsizemenu(result);
 163         result->sketchlinesmenu = create_sketchlinesmenu(result);
 164         result->shapemenu = create_shapemenu(result);
 165
 166         create_toolbar(result);
 167         GtkWidget *nodemenu = create_menu(result);
 168
 169         /* Handle the event when the longpress menu is shown */
 170         g_signal_connect(G_OBJECT(nodemenu), "show",
 171                 G_CALLBACK(on_node_menu_show), result);
 172
 173         g_signal_connect_swapped(result->treeview, "button_press_event", G_CALLBACK(cb_popup), nodemenu);
 174         gtk_widget_tap_and_hold_setup(GTK_WIDGET(result->treeview), nodemenu, NULL, GTK_TAP_AND_HOLD_NONE);
 175
 176         /**
 177          * Setup the main window layout:
 178          *   window -- vbox
 179          *             |- scrolledtree -- treeview
 180          *             |- livesearch
 181          **/
 182         GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
 183         gtk_box_pack_start(GTK_BOX(vbox), result->scrolledtree, TRUE, TRUE, 0);
 184         gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(result->main_view_live_search), FALSE, FALSE, 0);
 185         gtk_container_add(GTK_CONTAINER(data->main_view), vbox);
 186
 187         result->sk = sketchwidget_new(800, 480, FALSE);
 188         sketchwidget_set_undocallback(result->sk, callback_undotoggle, result);
 189         sketchwidget_set_redocallback(result->sk, callback_redotoggle, result);
 190
 191         gtk_box_pack_start(GTK_BOX(main_vbox), result->scrolledwindow, TRUE, TRUE, 0);
 192         gtk_box_pack_start(GTK_BOX(main_vbox), sketchwidget_get_mainwidget(result->sk), TRUE, TRUE, 0);
 193         gtk_box_pack_start(GTK_BOX(main_vbox), result->checklist_content, TRUE, TRUE, 0);
 194         hildon_window_add_toolbar(HILDON_WINDOW(result->data->node_view), GTK_TOOLBAR(result->toolbar));
 195
 196         gtk_container_add(GTK_CONTAINER(data->node_view), main_vbox);
 197
 198         gtk_widget_show(main_vbox);
 199
 200         gtk_widget_show_all(GTK_WIDGET(result->data->main_view));
 201         gtk_widget_grab_focus(GTK_WIDGET(result->textview));
 202
 203         result->file_edited = FALSE;
 204         result->file_name = NULL;
 205
 206         /* Signals on the main view */
 207         g_signal_connect(G_OBJECT(result->data->main_view), "delete_event", G_CALLBACK(close_cb), result);
 208
 209         /* Signals on the node view */
 210         g_signal_connect(G_OBJECT(result->data->node_view), "key-press-event", G_CALLBACK(on_node_view_key_press), result);
 211         g_signal_connect(G_OBJECT(result->data->node_view), "key-release-event", G_CALLBACK(on_node_view_key_release), result);
 212
 213         sk_set_brushsize(result, 2);
 214         sk_set_brushsize(result, 4);
 215
 216         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(result->sketchlinesmenuitems[0]), TRUE);
 217         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(result->shapemenuitems[0]), TRUE);
 218
 219         result->newnodedialog_createchild = TRUE;
 220
 221         result->loading=FALSE;
 222
 223         /* Initialize the sketch widget and main view */
 224         gtk_widget_show(GTK_WIDGET(data->main_view));
 225         gtk_widget_hide(result->scrolledwindow);
 226         gtk_widget_show(sketchwidget_get_mainwidget(result->sk));
 227         gtk_widget_realize(sketchwidget_get_drawingarea(result->sk));
 228         gtk_widget_hide(sketchwidget_get_mainwidget(result->sk));
 229
 230         return result;
 231 }
 232
 233 void interface_main_view_destroy(MainView * main)
 234 {
 235     if (main->db != NULL) {
 236         sqlite3_close(main->db);
 237     }
 238
 239     sketchwidget_destroy(main->sk);
 240     g_free(main);
 241 }
 242
 243 gchar *interface_file_chooser(MainView * mainview, GtkFileChooserAction action, gchar * suggname, gchar * suggext)
 244 {
 245         GtkWidget *dialog;
 246         gchar *filename = NULL;
 247
 248         dialog = hildon_file_chooser_dialog_new(GTK_WINDOW(mainview->data->main_view), action);
 249         gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), TRUE);
 250
 251         /* Use the "Documents" folder as default storage location */
 252         gchar* folder = g_strdup_printf("%s/MyDocs/.documents/", g_get_home_dir());
 253         gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), folder);
 254         g_free(folder);
 255
 256         if (action == GTK_FILE_CHOOSER_ACTION_SAVE && suggname != NULL)
 257                 {
 258                         gchar fn[128];
 259
 260                         if (suggext == NULL)
 261                                 g_snprintf(fn, sizeof(fn), "%s", suggname);
 262                         else
 263                                 g_snprintf(fn, sizeof(fn), "%s.%s", suggname, suggext);
 264
 265                         int i = 0;
 266                         struct stat s;
 267
 268                         while(stat(fn, &s) == 0)
 269                                 {
 270                                         i++;
 271                                         if (suggext == NULL)
 272                                                 g_snprintf(fn, sizeof(fn), "%s(%d)", suggname, i);
 273                                         else
 274                                                 g_snprintf(fn, sizeof(fn), "%s(%d).%s", suggname, i, suggext);
 275                                 }
 276
 277                         maepad_debug("Generated filename: %s", fn);
 278                         gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), fn);
 279                 }
 280
 281         gtk_widget_show_all(GTK_WIDGET(dialog));
 282         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
 283                 {
 284                         filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
 285                 }
 286
 287         gtk_widget_destroy(dialog);
 288         return filename;
 289 }
 290
 291 SetupResponse interface_initial_setup(MainView* main)
 292 {
 293         HildonNote *hn = NULL;
 294         SetupResponse response = RESPONSE_QUIT;
 295
 296         g_assert(main != NULL && main->data->app != NULL);
 297
 298         hn = HILDON_NOTE(hildon_note_new_confirmation_add_buttons(
 299                     GTK_WINDOW(main->data->main_view),
 300                     _("Welcome to MaePad!\nWhat do you want to do?"),
 301                     _("New file"), RESPONSE_CREATE_NEW,
 302                     _("Open file"), RESPONSE_OPEN_FILE,
 303                     _("Quit"), RESPONSE_QUIT,
 304                     NULL, NULL));
 305
 306         response = gtk_dialog_run(GTK_DIALOG(hn));
 307         gtk_widget_destroy(GTK_WIDGET(hn));
 308
 309         return response;
 310 }
 311
 312 /*
 313  * Privates
 314  */
 315
 316 /*
 317  * Create the menu items needed for the drop down menu
 318  */
 319 GtkWidget *create_menu(MainView * main)
 320 {
 321     /* Create the main window app menu */
 322     main->main_view_app_menu = GTK_WIDGET(hildon_app_menu_new());
 323
 324     main->menu_button_new = hildon_button_new_with_text(0, 0, _("New database"), NULL);
 325     main->menu_button_open = hildon_button_new_with_text(0, 0, _("Open database"), NULL);
 326     main->menu_button_save = hildon_button_new_with_text(0, 0, _("Save changes"), NULL);
 327     main->menu_button_about = hildon_button_new_with_text(0, 0, _("About"), NULL);
 328
 329     g_signal_connect(G_OBJECT(main->menu_button_new), "clicked", G_CALLBACK(callback_file_new), main);
 330     g_signal_connect(G_OBJECT(main->menu_button_open), "clicked", G_CALLBACK(callback_file_open), main);
 331     g_signal_connect(G_OBJECT(main->menu_button_save), "clicked", G_CALLBACK(callback_file_save), main);
 332     g_signal_connect(G_OBJECT(main->menu_button_about), "clicked", G_CALLBACK(callback_about), main);
 333
 334     hildon_app_menu_append(HILDON_APP_MENU(main->main_view_app_menu), GTK_BUTTON(main->menu_button_new));
 335     hildon_app_menu_append(HILDON_APP_MENU(main->main_view_app_menu), GTK_BUTTON(main->menu_button_open));
 336     hildon_app_menu_append(HILDON_APP_MENU(main->main_view_app_menu), GTK_BUTTON(main->menu_button_save));
 337     hildon_app_menu_append(HILDON_APP_MENU(main->main_view_app_menu), GTK_BUTTON(main->menu_button_about));
 338
 339     hildon_window_set_app_menu(HILDON_WINDOW(main->data->main_view),
 340             HILDON_APP_MENU(main->main_view_app_menu));
 341     gtk_widget_show_all(GTK_WIDGET(main->main_view_app_menu));
 342
 343
 344     /* Create the node window app menu */
 345     main->node_view_app_menu = GTK_WIDGET(hildon_app_menu_new());
 346
 347     main->menu_button_rename = hildon_button_new_with_text(0, 0, _("Rename memo"), NULL);
 348     main->menu_button_delete = hildon_button_new_with_text(0, 0, _("Delete memo"), NULL);
 349     main->menu_button_export = hildon_button_new_with_text(0, 0, _("Export to file"), NULL);
 350     main->menu_button_clear = hildon_button_new_with_text(0, 0, _("Clear contents"), NULL);
 351
 352     /* Sketch-specific */
 353     main->menu_button_square = hildon_check_button_new(0);
 354     gtk_button_set_label(GTK_BUTTON(main->menu_button_square), _("Square shapes"));
 355     main->menu_button_filled = hildon_check_button_new(0);
 356     gtk_button_set_label(GTK_BUTTON(main->menu_button_filled), _("Fill shapes"));
 357
 358     /* Rich text-specific */
 359     main->menu_button_wordwrap = hildon_check_button_new(0);
 360     gtk_button_set_label(GTK_BUTTON(main->menu_button_wordwrap), _("Word wrap"));
 361
 362     /* Checklist-specific */
 363     main->menu_button_remove_checked = hildon_button_new_with_text(0, 0, _("Remove checked items"), NULL);
 364
 365     g_signal_connect(G_OBJECT(main->menu_button_rename), "clicked", G_CALLBACK(callback_file_rename_node), main);
 366     g_signal_connect(G_OBJECT(main->menu_button_delete), "clicked", G_CALLBACK(callback_file_delete_node), main);
 367     g_signal_connect(G_OBJECT(main->menu_button_export), "clicked", G_CALLBACK(callback_file_export_node), main);
 368     g_signal_connect(G_OBJECT(main->menu_button_clear), "clicked", G_CALLBACK(callback_edit_clear), main);
 369     g_signal_connect(G_OBJECT(main->menu_button_square), "toggled", G_CALLBACK(callback_sketch_button_toggled), main);
 370     g_signal_connect(G_OBJECT(main->menu_button_filled), "toggled", G_CALLBACK(callback_sketch_button_toggled), main);
 371     g_signal_connect(G_OBJECT(main->menu_button_wordwrap), "toggled", G_CALLBACK(callback_wordwrap), main);
 372     g_signal_connect(G_OBJECT(main->menu_button_remove_checked), "clicked", G_CALLBACK(callback_remove_checked), main);
 373
 374     hildon_app_menu_append(HILDON_APP_MENU(main->node_view_app_menu), GTK_BUTTON(main->menu_button_rename));
 375     hildon_app_menu_append(HILDON_APP_MENU(main->node_view_app_menu), GTK_BUTTON(main->menu_button_delete));
 376     hildon_app_menu_append(HILDON_APP_MENU(main->node_view_app_menu), GTK_BUTTON(main->menu_button_export));
 377     hildon_app_menu_append(HILDON_APP_MENU(main->node_view_app_menu), GTK_BUTTON(main->menu_button_clear));
 378     hildon_app_menu_append(HILDON_APP_MENU(main->node_view_app_menu), GTK_BUTTON(main->menu_button_square));
 379     hildon_app_menu_append(HILDON_APP_MENU(main->node_view_app_menu), GTK_BUTTON(main->menu_button_filled));
 380     hildon_app_menu_append(HILDON_APP_MENU(main->node_view_app_menu), GTK_BUTTON(main->menu_button_wordwrap));
 381     hildon_app_menu_append(HILDON_APP_MENU(main->node_view_app_menu), GTK_BUTTON(main->menu_button_remove_checked));
 382
 383     hildon_window_set_app_menu(HILDON_WINDOW(main->data->node_view),
 384             HILDON_APP_MENU(main->node_view_app_menu));
 385     gtk_widget_show_all(GTK_WIDGET(main->node_view_app_menu));
 386
 387
 388
 389
 390         /*
 391          * Create needed handles
 392          */
 393         GtkMenu *main_menu;
 394         GtkWidget *file_menu, *about, *edit_menu, *tools_menu, *node_menu, *node_item,*move_node_menu;
 395
 396         /*
 397          * Get the menu of our view
 398          */
 399         main_menu = GTK_MENU( hildon_gtk_menu_new () );
 400         /* Add menu to HildonWindow */
 401         /*hildon_window_set_menu(main->data->main_view, main_menu); XXX */
 402
 403         /*
 404          * Create new menus for submenus in our drop down menu
 405          */
 406         file_menu = hildon_gtk_menu_new();
 407         node_menu = hildon_gtk_menu_new();
 408         edit_menu = hildon_gtk_menu_new();
 409         tools_menu = hildon_gtk_menu_new();
 410         move_node_menu = hildon_gtk_menu_new();
 411
 412         /*
 413          * Create the menu items
 414          */
 415         node_item = gtk_menu_item_new_with_label(_("Memo"));
 416
 417         main->delete_node_item = gtk_menu_item_new_with_label(_("Delete memo"));
 418         main->rename_node_item = gtk_menu_item_new_with_label(_("Rename memo"));
 419         main->export_node_item = gtk_menu_item_new_with_label(_("Export memo"));
 420
 421         main->move_node_item = gtk_menu_item_new_with_label(_("Move memo"));
 422         main->move_up_node_item = gtk_menu_item_new_with_label(_("Move up"));
 423         main->move_down_node_item = gtk_menu_item_new_with_label(_("Move down"));
 424
 425         main->tools_item = gtk_menu_item_new_with_label(_("Tools"));
 426
 427         /*
 428          * Add menu items to right menus
 429          */
 430         gtk_menu_append(main_menu, node_item);
 431         gtk_menu_append(node_menu, main->delete_node_item);
 432         gtk_menu_append(node_menu, main->rename_node_item);
 433         gtk_menu_append(node_menu, main->move_node_item);
 434         gtk_menu_append(node_menu, gtk_separator_menu_item_new());
 435         gtk_menu_append(node_menu, main->export_node_item);
 436
 437         /*move node sub-menu*/
 438         gtk_menu_append(move_node_menu, main->move_up_node_item);
 439         gtk_menu_append(move_node_menu, main->move_down_node_item);
 440
 441         gtk_menu_append(main_menu, main->tools_item);
 442         gtk_menu_append(main_menu, gtk_separator_menu_item_new());
 443         about = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
 444         gtk_menu_append(main_menu, about);
 445         gtk_menu_append(main_menu, gtk_separator_menu_item_new());
 446
 447         g_signal_connect(G_OBJECT(about), "activate", G_CALLBACK(callback_about), main);
 448
 449         /*
 450          * Add submenus to the right items
 451          */
 452         gtk_menu_item_set_submenu(GTK_MENU_ITEM(node_item), node_menu);
 453         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->tools_item), tools_menu);
 454         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->move_node_item), move_node_menu);
 455
 456         main->tools_brushsize = gtk_menu_item_new_with_label(_("Brush size"));
 457         main->tools_pagestyle = gtk_menu_item_new_with_label(_("Page style"));
 458         main->tools_shape = gtk_menu_item_new_with_label(_("Shape"));
 459         main->tools_color = gtk_menu_item_new_with_label(_("Color..."));
 460         main->tools_font = gtk_menu_item_new_with_label(_("Font..."));
 461         main->tools_pressure = gtk_check_menu_item_new_with_label(_("Pressure sensitive brush color"));
 462
 463         gtk_menu_append(tools_menu, main->tools_color);
 464         gtk_menu_append(tools_menu, main->tools_brushsize);
 465         gtk_menu_append(tools_menu, main->tools_shape);
 466         gtk_menu_append(tools_menu, main->tools_pagestyle);
 467         gtk_menu_append(tools_menu, main->tools_font);
 468         gtk_menu_append(tools_menu, main->tools_pressure);
 469         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->tools_brushsize), main->brushsizemenu);
 470         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->tools_pagestyle), main->sketchlinesmenu);
 471         gtk_menu_item_set_submenu(GTK_MENU_ITEM(main->tools_shape), main->shapemenu);
 472
 473         /*
 474          * Attach the callback functions to the activate signal
 475          */
 476         g_signal_connect(G_OBJECT(main->delete_node_item), "activate", G_CALLBACK(callback_file_delete_node), main);
 477         g_signal_connect(G_OBJECT(main->rename_node_item), "activate", G_CALLBACK(callback_file_rename_node), main);
 478         g_signal_connect(G_OBJECT(main->export_node_item), "activate", G_CALLBACK(callback_file_export_node), main);
 479
 480         g_signal_connect(G_OBJECT(main->move_up_node_item), "activate", G_CALLBACK(callback_move_up_node), main);
 481         g_signal_connect(G_OBJECT(main->move_down_node_item), "activate", G_CALLBACK(callback_move_down_node), main);
 482
 483         g_signal_connect(G_OBJECT(main->tools_font), "activate", G_CALLBACK(callback_font), main);
 484         g_signal_connect(G_OBJECT(main->tools_pressure), "toggled", G_CALLBACK(callback_pressure), main);
 485         g_signal_connect(G_OBJECT(main->tools_color), "activate", G_CALLBACK(callback_color_invoke), main);
 486
 487         /*
 488          * We need to show menu items
 489          */
 490         gtk_widget_show_all(GTK_WIDGET(main_menu));
 491
 492         return (node_menu);
 493 }
 494
 495 GtkWidget *create_brushsizemenu(MainView * main)
 496 {
 497         GtkWidget *menu;
 498         int i;
 499
 500         GSList *gr = NULL;
 501
 502         menu = hildon_gtk_menu_new();
 503
 504         for(i = 0; i < BRUSHSIZE_COUNT; i++)
 505                 {
 506                         int bsize = (i + 1) * 2;
 507
 508                         char fpa[PATH_MAX];
 509
 510                         g_snprintf(fpa, sizeof(fpa), "%s/pencil%d.png", PIXMAPDIR, i + 1);
 511                         GtkWidget *pix = gtk_image_new_from_file(fpa);
 512
 513                         g_object_ref(pix);
 514
 515                         char st[128];
 516
 517                         g_snprintf(st, sizeof(st), _("%dpt"), bsize);
 518                         main->brushsizemenuitems[i] = gtk_radio_menu_item_new_with_label(gr, st);
 519                         gr = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(main->brushsizemenuitems[i]));
 520
 521                         gtk_object_set_user_data(GTK_OBJECT(main->brushsizemenuitems[i]), GINT_TO_POINTER(bsize));
 522                         gtk_object_set_data(GTK_OBJECT(main->brushsizemenuitems[i]), "m", main);
 523                         gtk_object_set_data(GTK_OBJECT(main->brushsizemenuitems[i]), "i", pix);
 524
 525                         gtk_menu_prepend(menu, main->brushsizemenuitems[i]);
 526                         g_signal_connect(G_OBJECT(main->brushsizemenuitems[i]), "activate", G_CALLBACK(callback_brushsize), main->brushsizemenuitems[i]);
 527                 }
 528
 529         gtk_widget_show_all(GTK_WIDGET(menu));
 530
 531         return (menu);
 532 }
 533
 534 GtkWidget *create_sketchlinesmenu(MainView * main)
 535 {
 536         GtkWidget *menu;
 537         int i;
 538
 539         GSList *gr = NULL;
 540
 541         menu = hildon_gtk_menu_new();
 542
 543         char st[3][128];
 544
 545         g_snprintf(st[0], sizeof(st[0]), _("No background"));
 546         g_snprintf(st[1], sizeof(st[1]), _("Notebook lines"));
 547         g_snprintf(st[2], sizeof(st[2]), _("Graph lines"));
 548
 549         for(i = 0; i < 3; i++)
 550                 {
 551                         char fpa[PATH_MAX];
 552
 553                         g_snprintf(fpa, sizeof(fpa), "%s/sketchbg%d.png", PIXMAPDIR, i);
 554                         GtkWidget *pix = gtk_image_new_from_file(fpa);
 555
 556                         g_object_ref(pix);
 557
 558                         main->sketchlinesmenuitems[i] = gtk_radio_menu_item_new_with_label(gr, st[i]);
 559                         gr = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(main->sketchlinesmenuitems[i]));
 560
 561                         gtk_object_set_user_data(GTK_OBJECT(main->sketchlinesmenuitems[i]), GINT_TO_POINTER(i));
 562                         gtk_object_set_data(GTK_OBJECT(main->sketchlinesmenuitems[i]), "m", main);
 563                         gtk_object_set_data(GTK_OBJECT(main->sketchlinesmenuitems[i]), "i", pix);
 564
 565                         gtk_menu_prepend(menu, main->sketchlinesmenuitems[i]);
 566                         g_signal_connect(G_OBJECT(main->sketchlinesmenuitems[i]), "activate", G_CALLBACK(callback_sketchlines), main->sketchlinesmenuitems[i]);
 567                 }
 568
 569         gtk_widget_show_all(GTK_WIDGET(menu));
 570
 571         return (menu);
 572 }
 573
 574 GtkWidget *create_shapemenu(MainView * main)
 575 {
 576         GtkWidget* menu = NULL;
 577         GSList *gr = NULL;
 578         int i = 0;
 579
 580         const gchar* labels[] = {
 581             _("Freehand"),
 582             _("Line"),
 583             _("Rectangle"),
 584             _("Ellipse"),
 585         };
 586
 587         menu = hildon_gtk_menu_new();
 588
 589         for(i=0; i<SKETCHSHAPE_COUNT; i++) {
 590             gchar* filename = g_strdup_printf("%s/shape%d.png", PIXMAPDIR, i);
 591             GtkWidget* pix = gtk_image_new_from_file(filename);
 592             if (pix == NULL) {
 593                 g_error("Cannot load file: %s", filename);
 594             }
 595             g_object_ref(pix);
 596             g_free(filename);
 597
 598             main->shapemenuitems[i] = gtk_radio_menu_item_new_with_label(gr, labels[i]);
 599             gr = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(main->shapemenuitems[i]));
 600
 601             gtk_object_set_user_data(GTK_OBJECT(main->shapemenuitems[i]), GINT_TO_POINTER(i));
 602             gtk_object_set_data(GTK_OBJECT(main->shapemenuitems[i]), "m", main);
 603             gtk_object_set_data(GTK_OBJECT(main->shapemenuitems[i]), "i", pix);
 604
 605             gtk_menu_prepend(menu, main->shapemenuitems[i]);
 606             g_signal_connect(G_OBJECT(main->shapemenuitems[i]), "activate", G_CALLBACK(callback_shapemenu), main->shapemenuitems[i]);
 607         }
 608
 609         gtk_widget_show_all(GTK_WIDGET(menu));
 610
 611         return (menu);
 612 }
 613 /*
 614  * Create toolbar to mainview
 615  */
 616 static void create_toolbar(MainView * main)
 617 {
 618         /*
 619          * Create new GTK toolbar
 620          */
 621         main->toolbar = gtk_toolbar_new();
 622
 623         /*
 624          * Set toolbar properties
 625          */
 626         gtk_toolbar_set_orientation(GTK_TOOLBAR(main->toolbar), GTK_ORIENTATION_HORIZONTAL);
 627         gtk_toolbar_set_style(GTK_TOOLBAR(main->toolbar), GTK_TOOLBAR_BOTH_HORIZ);
 628
 629         /*
 630          * Make menus and buttons to toolbar:
 631          */
 632
 633         /*
 634          * main->cut_tb = gtk_tool_button_new_from_stock(GTK_STOCK_CUT);
 635          * main->copy_tb = gtk_tool_button_new_from_stock(GTK_STOCK_COPY);
 636          * main->paste_tb = gtk_tool_button_new_from_stock(GTK_STOCK_PASTE);
 637          * main->separator_tb2 = gtk_separator_tool_item_new();
 638          */
 639
 640         main->bold_tb = gtk_toggle_tool_button_new();
 641         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->bold_tb), "general_bold");
 642
 643         main->italic_tb = gtk_toggle_tool_button_new();
 644         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->italic_tb), "general_italic");
 645
 646         main->underline_tb = gtk_toggle_tool_button_new();
 647         _tool_button_set_icon_file(GTK_TOOL_BUTTON(main->underline_tb), PIXMAPDIR "/underline.png");
 648
 649         main->bullet_tb = gtk_toggle_tool_button_new();
 650         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->bullet_tb), "notes_bullets");
 651
 652         main->strikethru_tb = gtk_toggle_tool_button_new();
 653         _tool_button_set_icon_file(GTK_TOOL_BUTTON(main->strikethru_tb), PIXMAPDIR "/strike.png");
 654
 655         main->check_tb = gtk_toggle_tool_button_new();
 656         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->check_tb), "widgets_tickmark_list");
 657
 658         main->checkadd_tb = gtk_tool_button_new(NULL, NULL);
 659         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->checkadd_tb), "general_add");
 660
 661         main->checkedit_tb = gtk_tool_button_new(NULL, NULL);
 662         _tool_button_set_icon_file(GTK_TOOL_BUTTON(main->checkedit_tb), PIXMAPDIR "/sketch.png");
 663
 664         main->checkdel_tb = gtk_tool_button_new(NULL, NULL);
 665         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->checkdel_tb), "general_delete");
 666
 667 /*
 668         main->bold_tb = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_BOLD);
 669         main->italic_tb = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_ITALIC);
 670         main->underline_tb = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_UNDERLINE);
 671 */
 672         main->font_tb = gtk_tool_button_new(NULL, NULL);
 673         _tool_button_set_icon_file(GTK_TOOL_BUTTON(main->font_tb), PIXMAPDIR "/font.png");
 674
 675 /*      main->fullscreen_tb = gtk_tool_button_new_from_stock(GTK_STOCK_ZOOM_FIT);*/
 676
 677         /*
 678          * Insert items to toolbar
 679          */
 680         /*
 681          * gtk_toolbar_insert ( GTK_TOOLBAR(main->toolbar), main->cut_tb, -1);
 682          * gtk_toolbar_insert ( GTK_TOOLBAR(main->toolbar), main->copy_tb, -1);
 683          * gtk_toolbar_insert ( GTK_TOOLBAR(main->toolbar), main->paste_tb, -1);
 684          * gtk_toolbar_insert ( GTK_TOOLBAR(main->toolbar), main->separator_tb2, -1);
 685          */
 686         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->check_tb, -1);
 687         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->font_tb, -1);
 688         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->bold_tb, -1);
 689         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->italic_tb, -1);
 690         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->underline_tb, -1);
 691         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->bullet_tb, -1);
 692         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->strikethru_tb, -1);
 693
 694         main->colorbutton_tb = gtk_tool_button_new(NULL, NULL);
 695         _tool_button_set_icon_file(GTK_TOOL_BUTTON(main->colorbutton_tb), PIXMAPDIR "/palette.png");
 696         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->colorbutton_tb, -1);
 697         g_signal_connect(G_OBJECT(main->colorbutton_tb), "clicked", G_CALLBACK(callback_color), main);
 698
 699         main->brushsize_tb = gtk_tool_button_new(NULL, NULL);
 700         _tool_button_set_icon_file(GTK_TOOL_BUTTON(main->brushsize_tb), PIXMAPDIR "/pencil1.png");
 701         g_signal_connect(G_OBJECT(main->brushsize_tb), "clicked", G_CALLBACK(callback_brushsizetb), main);
 702         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->brushsize_tb, -1);
 703
 704         main->eraser_tb = gtk_toggle_tool_button_new();
 705         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->eraser_tb), "sketch_erase");
 706         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->eraser_tb, -1);
 707         g_signal_connect(G_OBJECT(main->eraser_tb), "toggled", G_CALLBACK(callback_eraser), main);
 708
 709         main->shape_tb = gtk_tool_button_new(NULL, NULL);
 710         _tool_button_set_icon_file(GTK_TOOL_BUTTON(main->shape_tb), PIXMAPDIR "/shape0.png");
 711         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->shape_tb, -1);
 712         g_signal_connect(G_OBJECT(main->shape_tb), "clicked", G_CALLBACK(callback_menu), main->shapemenu);
 713
 714         main->sketchlines_tb = gtk_tool_button_new(NULL, NULL);
 715         _tool_button_set_icon_file(GTK_TOOL_BUTTON(main->sketchlines_tb), PIXMAPDIR "/sketchbg0.png");
 716         g_signal_connect(G_OBJECT(main->sketchlines_tb), "clicked", G_CALLBACK(callback_menu), main->sketchlinesmenu);
 717         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->sketchlines_tb, -1);
 718
 719
 720         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), gtk_separator_tool_item_new(), -1);
 721
 722         main->sharing_tb = gtk_tool_button_new(NULL, NULL);
 723         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->sharing_tb), "control_sharing");
 724         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->sharing_tb, -1);
 725         g_signal_connect(G_OBJECT(main->sharing_tb), "clicked", G_CALLBACK(callback_sharing), main);
 726
 727         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->checkadd_tb, -1);
 728         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->checkedit_tb, -1);
 729         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->checkdel_tb, -1);
 730
 731         main->undo_tb = gtk_tool_button_new(NULL, NULL);
 732         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->undo_tb), "general_undo");
 733         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->undo_tb, -1);
 734         g_signal_connect(G_OBJECT(main->undo_tb), "clicked", G_CALLBACK(callback_undo), main);
 735
 736         main->redo_tb = gtk_tool_button_new(NULL, NULL);
 737         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->redo_tb), "general_redo");
 738         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->redo_tb, -1);
 739         g_signal_connect(G_OBJECT(main->redo_tb), "clicked", G_CALLBACK(callback_redo), main);
 740
 741         GtkWidget* fullscreen_separator = GTK_WIDGET(gtk_separator_tool_item_new());
 742         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), GTK_TOOL_ITEM(fullscreen_separator), -1);
 743         gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(fullscreen_separator), FALSE);
 744         gtk_tool_item_set_expand(GTK_TOOL_ITEM(fullscreen_separator), TRUE);
 745
 746         main->fullscreen_tb = gtk_tool_button_new(NULL, NULL);
 747         _tool_button_set_icon_name(GTK_TOOL_BUTTON(main->fullscreen_tb), "general_fullsize");
 748         g_signal_connect(G_OBJECT(main->fullscreen_tb), "clicked", G_CALLBACK(callback_fullscreen), main);
 749         gtk_toolbar_insert(GTK_TOOLBAR(main->toolbar), main->fullscreen_tb, -1);
 750
 751         /*
 752          * Connect signals to buttons
 753          */
 754
 755         /*
 756          * g_signal_connect(G_OBJECT(main->cut_tb), "clicked",
 757          * G_CALLBACK(callback_edit_cut), main);
 758          * g_signal_connect(G_OBJECT(main->copy_tb), "clicked",
 759          * G_CALLBACK(callback_edit_copy), main);
 760          * g_signal_connect(G_OBJECT(main->paste_tb), "clicked",
 761          * G_CALLBACK(callback_edit_paste), main);
 762          */
 763         g_signal_connect(G_OBJECT(main->font_tb), "clicked", G_CALLBACK(callback_font), main);
 764
 765         gtk_object_set_data(GTK_OBJECT(main->bold_tb), "s", GINT_TO_POINTER(WPT_BOLD));
 766         gtk_object_set_data(GTK_OBJECT(main->italic_tb), "s", GINT_TO_POINTER(WPT_ITALIC));
 767         gtk_object_set_data(GTK_OBJECT(main->underline_tb), "s", GINT_TO_POINTER(WPT_UNDERLINE));
 768         gtk_object_set_data(GTK_OBJECT(main->bullet_tb), "s", GINT_TO_POINTER(WPT_BULLET));
 769         gtk_object_set_data(GTK_OBJECT(main->strikethru_tb), "s", GINT_TO_POINTER(WPT_STRIKE));
 770         gtk_object_set_data(GTK_OBJECT(main->check_tb), "s", GINT_TO_POINTER(WPT_LEFT));
 771
 772         gtk_object_set_data(GTK_OBJECT(main->bold_tb), "m", main);
 773         gtk_object_set_data(GTK_OBJECT(main->italic_tb), "m", main);
 774         gtk_object_set_data(GTK_OBJECT(main->underline_tb), "m", main);
 775         gtk_object_set_data(GTK_OBJECT(main->bullet_tb), "m", main);
 776         gtk_object_set_data(GTK_OBJECT(main->strikethru_tb), "m", main);
 777         gtk_object_set_data(GTK_OBJECT(main->check_tb), "m", main);
 778
 779         g_signal_connect(G_OBJECT(main->bold_tb), "toggled", G_CALLBACK(callback_fontstyle), main->bold_tb);
 780         g_signal_connect(G_OBJECT(main->italic_tb), "toggled", G_CALLBACK(callback_fontstyle), main->italic_tb);
 781         g_signal_connect(G_OBJECT(main->underline_tb), "toggled", G_CALLBACK(callback_fontstyle), main->underline_tb);
 782         g_signal_connect(G_OBJECT(main->bullet_tb), "toggled", G_CALLBACK(callback_fontstyle), main->bullet_tb);
 783         g_signal_connect(G_OBJECT(main->strikethru_tb), "toggled", G_CALLBACK(callback_fontstyle), main->strikethru_tb);
 784         g_signal_connect(G_OBJECT(main->check_tb), "toggled", G_CALLBACK(callback_fontstyle), main->check_tb);
 785
 786         g_signal_connect(G_OBJECT(main->checkadd_tb), "clicked", G_CALLBACK(callback_checklist_add), main);
 787         g_signal_connect(G_OBJECT(main->checkedit_tb), "clicked", G_CALLBACK(callback_checklist_edit), main);
 788         g_signal_connect(G_OBJECT(main->checkdel_tb), "clicked", G_CALLBACK(callback_checklist_delete), main);
 789
 790         gtk_widget_show_all(GTK_WIDGET(main->toolbar));
 791 }
 792
 793 /*
 794  * Create the text area
 795  */
 796 void create_textarea(MainView * main)
 797 {
 798         main->scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
 799 #ifdef MAEMOPADPLUS_FINGER_FRIENDLY
 800         hildon_helper_set_thumb_scrollbar(main->scrolledwindow, TRUE);
 801 #endif
 802         gtk_widget_hide(main->scrolledwindow);
 803         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(main->scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 804
 805         main->textview = wp_text_view_new();
 806 /*
 807         gtk_text_view_set_editable(GTK_TEXT_VIEW(main->textview), TRUE);
 808         gtk_text_view_set_left_margin(GTK_TEXT_VIEW(main->textview), 10);
 809         gtk_text_view_set_right_margin(GTK_TEXT_VIEW(main->textview), 10);
 810         main->buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(main->textview));
 811         main->buffer = wp_text_buffer_new(NULL);
 812 */
 813         main->buffer = WP_TEXT_BUFFER(gtk_text_view_get_buffer(GTK_TEXT_VIEW(main->textview)));
 814
 815         g_signal_connect(G_OBJECT(main->buffer), "refresh_attributes", G_CALLBACK(callback_textbuffer_move), main);
 816         g_signal_connect(G_OBJECT(main->buffer), "can_undo", G_CALLBACK(callback_undotoggle), main);
 817         g_signal_connect(G_OBJECT(main->buffer), "can_redo", G_CALLBACK(callback_redotoggle), main);
 818
 819         wp_text_buffer_enable_rich_text(main->buffer, TRUE);
 820
 821         gtk_container_add(GTK_CONTAINER(main->scrolledwindow), main->textview);
 822         gtk_widget_show(main->textview);
 823
 824         gtk_widget_modify_font(main->textview, pango_font_description_from_string("Monospace Regular 16"));
 825
 826         g_signal_connect(G_OBJECT(main->buffer), "modified-changed", G_CALLBACK(callback_buffer_modified), main);
 827         g_signal_connect(G_OBJECT(main->buffer), "changed", G_CALLBACK(callback_buffer_modified), main);
 828 }
 829
 830 static gboolean
 831 livesearch_filter_func(GtkTreeModel *model, GtkTreeIter *iter,
 832                 gchar *text, gpointer data)
 833 {
 834     gboolean retvalue;
 835     gchar *rowtext = NULL;
 836     gtk_tree_model_get(model, iter, 0, &rowtext, -1);
 837
 838     if (rowtext == NULL || text == NULL) {
 839             return FALSE;
 840     }
 841
 842     retvalue = (strcasestr(rowtext, text) != NULL);
 843     g_free (rowtext);
 844     return retvalue;
 845 }
 846
 847
 848 /*
 849  * Create the treeview
 850  */
 851 void create_treeview(MainView * main)
 852 {
 853         main->scrolledtree = hildon_pannable_area_new();
 854 /*#ifdef MAEMOPADPLUS_FINGER_FRIENDLY
 855         hildon_helper_set_thumb_scrollbar(main->scrolledtree, TRUE);
 856 #endif*/
 857         gtk_widget_show(main->scrolledtree);
 858
 859         main->main_view_tree_store = gtk_tree_store_new(N_COLUMNS,
 860                         G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_POINTER);
 861
 862         /* Set up Hildon Live Search for the node list */
 863         main->main_view_live_search = HILDON_LIVE_SEARCH(hildon_live_search_new());
 864         g_signal_connect(G_OBJECT(main->main_view_live_search),
 865                        "refilter",
 866                        G_CALLBACK(callback_live_search_refilter),
 867                        main);
 868
 869         main->main_view_tree_filter = GTK_TREE_MODEL_FILTER(gtk_tree_model_filter_new(
 870                         GTK_TREE_MODEL(main->main_view_tree_store),
 871                         NULL));
 872         hildon_live_search_set_filter(main->main_view_live_search,
 873                         main->main_view_tree_filter);
 874         hildon_live_search_set_visible_func(main->main_view_live_search,
 875                         livesearch_filter_func, NULL, NULL);
 876
 877         main->treeview = hildon_gtk_tree_view_new_with_model(HILDON_UI_MODE_EDIT,
 878                         GTK_TREE_MODEL(main->main_view_tree_filter));
 879
 880         hildon_live_search_widget_hook(main->main_view_live_search,
 881                         GTK_WIDGET(main->data->main_view), main->treeview);
 882
 883
 884         /* Add a new button to the treeview action area */
 885         main->action_area_button_add = hildon_button_new_with_text(
 886                 HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH,
 887                 HILDON_BUTTON_ARRANGEMENT_HORIZONTAL,
 888                 _("Add new memo"),
 889                 NULL);
 890         hildon_button_set_image(HILDON_BUTTON(main->action_area_button_add),
 891                 gtk_image_new_from_icon_name("general_add", GTK_ICON_SIZE_BUTTON));
 892
 893         gtk_widget_show(GTK_WIDGET(main->action_area_button_add));
 894         g_signal_connect(G_OBJECT(main->action_area_button_add),
 895                          "clicked",
 896                          G_CALLBACK(callback_file_new_node),
 897                          main);
 898
 899         GtkWidget* action_area_box = hildon_tree_view_get_action_area_box(GTK_TREE_VIEW(main->treeview));
 900         gtk_container_add(GTK_CONTAINER(action_area_box), main->action_area_button_add);
 901         hildon_tree_view_set_action_area_visible(GTK_TREE_VIEW(main->treeview), TRUE);
 902         gtk_widget_show_all(GTK_WIDGET(action_area_box));
 903
 904
 905         GtkCellRenderer *renderer1 = gtk_cell_renderer_text_new();
 906         GtkCellRenderer *renderer2 = gtk_cell_renderer_pixbuf_new();
 907
 908         GtkTreeViewColumn *column = gtk_tree_view_column_new();
 909
 910         gtk_tree_view_column_pack_start(column, renderer2, FALSE);
 911         gtk_tree_view_column_pack_start(column, renderer1, TRUE);
 912
 913         gtk_tree_view_column_add_attribute(column, renderer1, "markup", NODE_NAME);
 914         gtk_tree_view_column_add_attribute(column, renderer2, "pixbuf", NODE_PIXBUF);
 915
 916         /* Ellipsize to avoid horizontal scroll bars */
 917         g_object_set(G_OBJECT(renderer1), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 918
 919         /*
 920          * gtk_tree_view_column_add_attribute(column, renderer2, "width", 0);
 921          * gtk_tree_view_column_add_attribute(column, renderer2, "height", 0);
 922          */
 923         gtk_tree_view_column_set_cell_data_func(column, renderer2, callback_treeview_celldatafunc, main, NULL);
 924
 925         /* Configure for speedier scrolling - fixed height mode */
 926         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
 927         gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(main->treeview), TRUE);
 928
 929         gtk_tree_view_append_column(GTK_TREE_VIEW(main->treeview), column);
 930
 931         GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(main->treeview));
 932
 933         gtk_tree_selection_set_mode(select, GTK_SELECTION_BROWSE);
 934         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(main->treeview), FALSE);
 935         gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(main->treeview), FALSE);
 936         gtk_tree_view_set_expander_column(GTK_TREE_VIEW(main->treeview), column);
 937
 938         gtk_tree_view_expand_all(GTK_TREE_VIEW(main->treeview));
 939         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(main->treeview), FALSE);
 940         gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(main->treeview), FALSE);
 941
 942         g_signal_connect(G_OBJECT(main->treeview), "button-press-event", G_CALLBACK(callback_treeview_button_press), main);
 943
 944         g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK(callback_treeview_change), main);
 945         gtk_tree_selection_set_select_function(select, treeview_canselect, main, NULL);
 946         gtk_object_set_user_data(GTK_OBJECT(main->treeview), (gpointer) main);
 947
 948         gtk_container_add(GTK_CONTAINER(main->scrolledtree), main->treeview);
 949
 950         gtk_widget_show(main->treeview);
 951         gtk_widget_show(main->scrolledtree);
 952 }
 953
 954
 955 void create_checklist(MainView * main)
 956 {
 957         main->checklist_content = gtk_vbox_new(FALSE, 0);
 958         main->listscroll = hildon_pannable_area_new();
 959
 960         gtk_box_pack_start(GTK_BOX(main->checklist_content),
 961                 main->listscroll, TRUE, TRUE, 0);
 962
 963         main->checklist_empty_label = gtk_label_new(_("No items"));
 964         hildon_helper_set_logical_font(main->checklist_empty_label,
 965                 "LargeSystemFont");
 966         hildon_helper_set_logical_color(main->checklist_empty_label,
 967                 GTK_RC_FG, GTK_STATE_NORMAL, "SecondaryTextColor");
 968         gtk_misc_set_alignment(GTK_MISC(main->checklist_empty_label),
 969                 .5, .5);
 970
 971         gtk_box_pack_start(GTK_BOX(main->checklist_content),
 972                 main->checklist_empty_label, TRUE, TRUE, 0);
 973
 974         /* Detect scrolling to abort longpress action on checklist */
 975         g_signal_connect(G_OBJECT(main->listscroll), "panning-started", G_CALLBACK(on_checklist_start_panning), main);
 976
 977         GtkListStore *store = gtk_list_store_new(CHECKN_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_STRING);
 978
 979         main->listview = hildon_gtk_tree_view_new_with_model(HILDON_UI_MODE_EDIT, GTK_TREE_MODEL(store));
 980         g_object_unref(G_OBJECT(store));
 981
 982         g_object_set(main->listview, "allow-checkbox-mode", FALSE, NULL);
 983
 984         GtkCellRenderer *renderer1 = gtk_cell_renderer_pixbuf_new();
 985
 986         GtkCellRenderer *renderer2 = gtk_cell_renderer_text_new();
 987
 988         main->checklist_column_check = gtk_tree_view_column_new_with_attributes("", renderer1,
 989                                                       "icon-name", CHECKNODE_ICON_NAME,
 990                                                       NULL);
 991
 992         main->checklist_column_text = gtk_tree_view_column_new_with_attributes("", renderer2,
 993                                                       "text", CHECKNODE_TEXT,
 994                                                       "foreground", CHECKNODE_COLOR,
 995                                                       "strikethrough", CHECKNODE_STRIKE,
 996                                                       "weight", CHECKNODE_BOLD,
 997                                                       NULL);
 998
 999         /* Ellipsize to avoid horizontal scroll bars */
1000         g_object_set(G_OBJECT(renderer2), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
1001
1002         gtk_tree_view_append_column(GTK_TREE_VIEW(main->listview), main->checklist_column_check);
1003         gtk_tree_view_append_column(GTK_TREE_VIEW(main->listview), main->checklist_column_text);
1004
1005         /* Configure for speedier scrolling - fixed height mode */
1006         gtk_tree_view_column_set_sizing(main->checklist_column_check, GTK_TREE_VIEW_COLUMN_FIXED);
1007         gtk_tree_view_column_set_fixed_width(main->checklist_column_check, 40);
1008         gtk_tree_view_column_set_sizing(main->checklist_column_text, GTK_TREE_VIEW_COLUMN_FIXED);
1009         gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(main->listview), TRUE);
1010
1011         GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(main->listview));
1012
1013         /*gtk_tree_selection_set_mode(select, GTK_SELECTION_MULTIPLE);*/
1014         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(main->listview), FALSE);
1015         gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(main->listview), FALSE);
1016         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(main->listview), TRUE);
1017
1018 /*
1019         gtk_tree_selection_set_select_function(select, treeview_canselect, main, NULL);
1020 */
1021         g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK(callback_checklist_change), main);
1022
1023         gtk_object_set_user_data(GTK_OBJECT(main->listview), (gpointer) main);
1024
1025         /* Add handlers for checklist interaction */
1026         g_signal_connect(main->listview, "button-press-event", G_CALLBACK(on_checklist_button_press), main);
1027         g_signal_connect(main->listview, "button-release-event", G_CALLBACK(on_checklist_button_release), main);
1028
1029         gtk_container_add(GTK_CONTAINER(main->listscroll), main->listview);
1030         gtk_widget_show_all(main->checklist_content);
1031         gtk_widget_hide(main->listscroll);
1032 /*
1033 GtkTreeIter    toplevel;
1034 gtk_list_store_append(store, &toplevel);
1035 gtk_list_store_set(store, &toplevel,
1036                      CHECKNODE_CHECKED, TRUE, CHECKNODE_TEXT, "sample text", -1);
1037 */
1038 }
1039
1040
1041 GtkWindow*
1042 mainview_get_dialog_parent(MainView* mainview)
1043 {
1044     if (GTK_WIDGET_VISIBLE(mainview->data->node_view)) {
1045         return GTK_WINDOW(mainview->data->node_view);
1046     } else {
1047         return GTK_WINDOW(mainview->data->main_view);
1048     }
1049 }
1050