src/ui/interface.c

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