src/ui/interface.c

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