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