src/ui/interface.c

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