From 54f21a9c94e25999b4f8f350104e4a3801ac8a4f Mon Sep 17 00:00:00 2001 From: auroux Date: Sun, 29 Jan 2006 18:58:24 +0000 Subject: [PATCH] Initial revision --- src/xo-interface.c | 2421 +++++++++++++++++++++++++++++++++++ src/xo-interface.h | 9 + src/xo-support.c | 144 +++ src/xo-support.h | 44 + src/xournal.h | 279 ++++ xournal.glade | 3045 ++++++++++++++++++++++++++++++++++++++++++++ xournal.gladep | 16 + 7 files changed, 5958 insertions(+) create mode 100644 src/xo-interface.c create mode 100644 src/xo-interface.h create mode 100644 src/xo-support.c create mode 100644 src/xo-support.h create mode 100644 src/xournal.h create mode 100644 xournal.glade create mode 100644 xournal.gladep diff --git a/src/xo-interface.c b/src/xo-interface.c new file mode 100644 index 0000000..fed9fce --- /dev/null +++ b/src/xo-interface.c @@ -0,0 +1,2421 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include +#include +#include + +#include +#include + +#include "xo-callbacks.h" +#include "xo-interface.h" +#include "xo-support.h" + +#define GLADE_HOOKUP_OBJECT(component,widget,name) \ + g_object_set_data_full (G_OBJECT (component), name, \ + gtk_widget_ref (widget), (GDestroyNotify) gtk_widget_unref) + +#define GLADE_HOOKUP_OBJECT_NO_REF(component,widget,name) \ + g_object_set_data (G_OBJECT (component), name, widget) + +GtkWidget* +create_winMain (void) +{ + GtkWidget *winMain; + GtkWidget *vboxMain; + GtkWidget *menubar; + GtkWidget *menuFile; + GtkWidget *menuFile_menu; + GtkWidget *fileNew; + GtkWidget *fileNewBackground; + GtkWidget *image500; + GtkWidget *fileOpen; + GtkWidget *fileSave; + GtkWidget *fileSaveAs; + GtkWidget *separator1; + GtkWidget *filePrintOptions; + GtkWidget *image501; + GtkWidget *filePrint; + GtkWidget *filePrintPDF; + GtkWidget *separator2; + GtkWidget *fileQuit; + GtkWidget *menuEdit; + GtkWidget *menuEdit_menu; + GtkWidget *editUndo; + GtkWidget *editRedo; + GtkWidget *separator3; + GtkWidget *editCut; + GtkWidget *editCopy; + GtkWidget *editPaste; + GtkWidget *editDelete; + GtkWidget *menuView; + GtkWidget *menuView_menu; + GSList *viewContinuous_group = NULL; + GtkWidget *viewContinuous; + GtkWidget *viewOnePage; + GtkWidget *separator20; + GtkWidget *viewFullscreen; + GtkWidget *separator4; + GtkWidget *viewZoomIn; + GtkWidget *viewZoomOut; + GtkWidget *viewNormalSize; + GtkWidget *viewPageWidth; + GtkWidget *image502; + GtkWidget *separator5; + GtkWidget *viewFirstPage; + GtkWidget *image503; + GtkWidget *viewPreviousPage; + GtkWidget *image504; + GtkWidget *viewNextPage; + GtkWidget *image505; + GtkWidget *viewLastPage; + GtkWidget *image506; + GtkWidget *separator6; + GtkWidget *viewShowLayer; + GtkWidget *image507; + GtkWidget *viewHideLayer; + GtkWidget *image508; + GtkWidget *menuJournal; + GtkWidget *menuJournal_menu; + GtkWidget *journalNewPageBefore; + GtkWidget *journalNewPageAfter; + GtkWidget *journalNewPageEnd; + GtkWidget *journalDeletePage; + GtkWidget *separator7; + GtkWidget *journalNewLayer; + GtkWidget *journalDeleteLayer; + GtkWidget *journalFlatten; + GtkWidget *separator8; + GtkWidget *journalPaperSize; + GtkWidget *journalPaperColor; + GtkWidget *journalPaperColor_menu; + GSList *papercolorWhite_group = NULL; + GtkWidget *papercolorWhite; + GtkWidget *papercolorYellow; + GtkWidget *papercolorPink; + GtkWidget *papercolorOrange; + GtkWidget *papercolorBlue; + GtkWidget *papercolorGreen; + GtkWidget *papercolorOther; + GtkWidget *papercolorNA; + GtkWidget *journalPaperStyle; + GtkWidget *journalPaperStyle_menu; + GSList *paperstylePlain_group = NULL; + GtkWidget *paperstylePlain; + GtkWidget *paperstyleLined; + GtkWidget *paperstyleRuled; + GtkWidget *paperstyleGraph; + GtkWidget *paperstyleNA; + GtkWidget *journalLoadBackground; + GtkWidget *image509; + GtkWidget *journalScreenshot; + GtkWidget *journalApplyAllPages; + GtkWidget *separator19; + GtkWidget *journalDefaultBackground; + GtkWidget *journalSetAsDefault; + GtkWidget *menuTools; + GtkWidget *menuTools_menu; + GSList *toolsPen_group = NULL; + GtkWidget *toolsPen; + GtkWidget *toolsEraser; + GtkWidget *toolsHighlighter; + GtkWidget *toolsText; + GtkWidget *separator9; + GtkWidget *toolsSelectRegion; + GtkWidget *toolsSelectRectangle; + GtkWidget *toolsVerticalSpace; + GtkWidget *separator16; + GtkWidget *toolsColor; + GtkWidget *image510; + GtkWidget *toolsColor_menu; + GSList *colorBlack_group = NULL; + GtkWidget *colorBlack; + GtkWidget *colorBlue; + GtkWidget *colorRed; + GtkWidget *colorGreen; + GtkWidget *colorGray; + GtkWidget *separator17; + GtkWidget *colorLightBlue; + GtkWidget *colorLightGreen; + GtkWidget *colorMagenta; + GtkWidget *colorOrange; + GtkWidget *colorYellow; + GtkWidget *colorWhite; + GtkWidget *colorOther; + GtkWidget *colorNA; + GtkWidget *toolsPenOptions; + GtkWidget *toolsPenOptions_menu; + GSList *penthicknessVeryFine_group = NULL; + GtkWidget *penthicknessVeryFine; + GtkWidget *penthicknessFine; + GtkWidget *penthicknessMedium; + GtkWidget *penthicknessThick; + GtkWidget *penthicknessVeryThick; + GtkWidget *toolsEraserOptions; + GtkWidget *toolsEraserOptions_menu; + GSList *eraserFine_group = NULL; + GtkWidget *eraserFine; + GtkWidget *eraserMedium; + GtkWidget *eraserThick; + GtkWidget *separator14; + GSList *eraserStandard_group = NULL; + GtkWidget *eraserStandard; + GtkWidget *eraserWhiteout; + GtkWidget *eraserDeleteStrokes; + GtkWidget *toolsHighlighterOptions; + GtkWidget *toolsHighlighterOptions_menu; + GSList *highlighterFine_group = NULL; + GtkWidget *highlighterFine; + GtkWidget *highlighterMedium; + GtkWidget *highlighterThick; + GtkWidget *toolsTextFont; + GtkWidget *image511; + GtkWidget *separator10; + GtkWidget *toolsDefaultPen; + GtkWidget *toolsDefaultEraser; + GtkWidget *toolsDefaultHighlighter; + GtkWidget *toolsDefaultText; + GtkWidget *toolsSetAsDefault; + GtkWidget *separator15; + GtkWidget *toolsRuler; + GtkWidget *menuOptions; + GtkWidget *menuOptions_menu; + GtkWidget *optionsUseXInput; + GtkWidget *optionsEmulateEraser; + GtkWidget *separator18; + GtkWidget *optionsAntialiasBG; + GtkWidget *optionsProgressiveBG; + GtkWidget *separator21; + GtkWidget *optionsSavePreferences; + GtkWidget *menuHelp; + GtkWidget *menuHelp_menu; + GtkWidget *helpIndex; + GtkWidget *helpAbout; + GtkWidget *toolbarMain; + GtkIconSize tmp_toolbar_icon_size; + GtkWidget *saveButton; + GtkWidget *toolitem11; + GtkWidget *vseparator1; + GtkWidget *buttonCut; + GtkWidget *buttonCopy; + GtkWidget *buttonPaste; + GtkWidget *toolitem12; + GtkWidget *vseparator2; + GtkWidget *buttonUndo; + GtkWidget *buttonRedo; + GtkWidget *toolitem13; + GtkWidget *vseparator3; + GtkWidget *buttonFirstPage; + GtkWidget *buttonPreviousPage; + GtkWidget *buttonNextPage; + GtkWidget *buttonLastPage; + GtkWidget *toolitem14; + GtkWidget *vseparator4; + GtkWidget *buttonZoomOut; + GtkWidget *buttonPageWidth; + GtkWidget *buttonZoomIn; + GtkWidget *buttonNormalSize; + GtkWidget *tmp_image; + GtkWidget *buttonFullscreen; + GtkWidget *toolbarPen; + GSList *buttonPen_group = NULL; + GtkWidget *buttonPen; + GtkWidget *buttonEraser; + GtkWidget *buttonHighlighter; + GtkWidget *buttonText; + GtkWidget *buttonRuler; + GtkWidget *toolitem15; + GtkWidget *vseparator5; + GtkWidget *buttonSelectRegion; + GtkWidget *buttonSelectRectangle; + GtkWidget *buttonVerticalSpace; + GtkWidget *toolitem16; + GtkWidget *vseparator6; + GtkWidget *buttonToolDefault; + GtkWidget *buttonDefaultPen; + GtkWidget *toolitem18; + GtkWidget *vseparator8; + GSList *buttonFine_group = NULL; + GtkWidget *buttonFine; + GtkWidget *buttonMedium; + GtkWidget *buttonThick; + GtkWidget *buttonThicknessOther; + GtkWidget *toolitem17; + GtkWidget *vseparator7; + GSList *buttonBlack_group = NULL; + GtkWidget *buttonBlack; + GtkWidget *buttonBlue; + GtkWidget *buttonRed; + GtkWidget *buttonGreen; + GtkWidget *buttonGray; + GtkWidget *buttonLightBlue; + GtkWidget *buttonLightGreen; + GtkWidget *buttonMagenta; + GtkWidget *buttonOrange; + GtkWidget *buttonYellow; + GtkWidget *buttonWhite; + GtkWidget *buttonColorOther; + GtkWidget *scrolledwindowMain; + GtkWidget *hbox1; + GtkWidget *labelPage; + GtkObject *spinPageNo_adj; + GtkWidget *spinPageNo; + GtkWidget *labelNumpages; + GtkWidget *vseparator9; + GtkWidget *labelLayer; + GtkWidget *comboLayer; + GtkWidget *statusbar; + GtkAccelGroup *accel_group; + GtkTooltips *tooltips; + + tooltips = gtk_tooltips_new (); + + accel_group = gtk_accel_group_new (); + + winMain = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (winMain), "Xournal"); + + vboxMain = gtk_vbox_new (FALSE, 0); + gtk_widget_show (vboxMain); + gtk_container_add (GTK_CONTAINER (winMain), vboxMain); + + menubar = gtk_menu_bar_new (); + gtk_widget_show (menubar); + gtk_box_pack_start (GTK_BOX (vboxMain), menubar, FALSE, FALSE, 0); + + menuFile = gtk_menu_item_new_with_mnemonic ("_File"); + gtk_widget_show (menuFile); + gtk_container_add (GTK_CONTAINER (menubar), menuFile); + + menuFile_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuFile), menuFile_menu); + + fileNew = gtk_image_menu_item_new_from_stock ("gtk-new", accel_group); + gtk_widget_show (fileNew); + gtk_container_add (GTK_CONTAINER (menuFile_menu), fileNew); + + fileNewBackground = gtk_image_menu_item_new_with_mnemonic ("Annotate PDF"); + gtk_widget_show (fileNewBackground); + gtk_container_add (GTK_CONTAINER (menuFile_menu), fileNewBackground); + + image500 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_MENU); + gtk_widget_show (image500); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (fileNewBackground), image500); + + fileOpen = gtk_image_menu_item_new_from_stock ("gtk-open", accel_group); + gtk_widget_show (fileOpen); + gtk_container_add (GTK_CONTAINER (menuFile_menu), fileOpen); + + fileSave = gtk_image_menu_item_new_from_stock ("gtk-save", accel_group); + gtk_widget_show (fileSave); + gtk_container_add (GTK_CONTAINER (menuFile_menu), fileSave); + + fileSaveAs = gtk_image_menu_item_new_from_stock ("gtk-save-as", accel_group); + gtk_widget_show (fileSaveAs); + gtk_container_add (GTK_CONTAINER (menuFile_menu), fileSaveAs); + + separator1 = gtk_separator_menu_item_new (); + gtk_widget_show (separator1); + gtk_container_add (GTK_CONTAINER (menuFile_menu), separator1); + gtk_widget_set_sensitive (separator1, FALSE); + + filePrintOptions = gtk_image_menu_item_new_with_mnemonic ("Print Options"); + gtk_widget_show (filePrintOptions); + gtk_container_add (GTK_CONTAINER (menuFile_menu), filePrintOptions); + + image501 = gtk_image_new_from_stock ("gtk-preferences", GTK_ICON_SIZE_MENU); + gtk_widget_show (image501); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (filePrintOptions), image501); + + filePrint = gtk_image_menu_item_new_from_stock ("gtk-print", accel_group); + gtk_widget_show (filePrint); + gtk_container_add (GTK_CONTAINER (menuFile_menu), filePrint); + + filePrintPDF = gtk_menu_item_new_with_mnemonic ("Print to PDF"); + gtk_widget_show (filePrintPDF); + gtk_container_add (GTK_CONTAINER (menuFile_menu), filePrintPDF); + + separator2 = gtk_separator_menu_item_new (); + gtk_widget_show (separator2); + gtk_container_add (GTK_CONTAINER (menuFile_menu), separator2); + gtk_widget_set_sensitive (separator2, FALSE); + + fileQuit = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group); + gtk_widget_show (fileQuit); + gtk_container_add (GTK_CONTAINER (menuFile_menu), fileQuit); + + menuEdit = gtk_menu_item_new_with_mnemonic ("_Edit"); + gtk_widget_show (menuEdit); + gtk_container_add (GTK_CONTAINER (menubar), menuEdit); + + menuEdit_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuEdit), menuEdit_menu); + + editUndo = gtk_image_menu_item_new_from_stock ("gtk-undo", accel_group); + gtk_widget_show (editUndo); + gtk_container_add (GTK_CONTAINER (menuEdit_menu), editUndo); + + editRedo = gtk_image_menu_item_new_from_stock ("gtk-redo", accel_group); + gtk_widget_show (editRedo); + gtk_container_add (GTK_CONTAINER (menuEdit_menu), editRedo); + + separator3 = gtk_separator_menu_item_new (); + gtk_widget_show (separator3); + gtk_container_add (GTK_CONTAINER (menuEdit_menu), separator3); + gtk_widget_set_sensitive (separator3, FALSE); + + editCut = gtk_image_menu_item_new_from_stock ("gtk-cut", accel_group); + gtk_widget_show (editCut); + gtk_container_add (GTK_CONTAINER (menuEdit_menu), editCut); + + editCopy = gtk_image_menu_item_new_from_stock ("gtk-copy", accel_group); + gtk_widget_show (editCopy); + gtk_container_add (GTK_CONTAINER (menuEdit_menu), editCopy); + + editPaste = gtk_image_menu_item_new_from_stock ("gtk-paste", accel_group); + gtk_widget_show (editPaste); + gtk_container_add (GTK_CONTAINER (menuEdit_menu), editPaste); + + editDelete = gtk_image_menu_item_new_from_stock ("gtk-delete", accel_group); + gtk_widget_show (editDelete); + gtk_container_add (GTK_CONTAINER (menuEdit_menu), editDelete); + + menuView = gtk_menu_item_new_with_mnemonic ("_View"); + gtk_widget_show (menuView); + gtk_container_add (GTK_CONTAINER (menubar), menuView); + + menuView_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuView), menuView_menu); + + viewContinuous = gtk_radio_menu_item_new_with_mnemonic (viewContinuous_group, "Continuous"); + viewContinuous_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (viewContinuous)); + gtk_widget_show (viewContinuous); + gtk_container_add (GTK_CONTAINER (menuView_menu), viewContinuous); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (viewContinuous), TRUE); + + viewOnePage = gtk_radio_menu_item_new_with_mnemonic (viewContinuous_group, "One Page"); + viewContinuous_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (viewOnePage)); + gtk_widget_show (viewOnePage); + gtk_container_add (GTK_CONTAINER (menuView_menu), viewOnePage); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (viewOnePage), TRUE); + + separator20 = gtk_separator_menu_item_new (); + gtk_widget_show (separator20); + gtk_container_add (GTK_CONTAINER (menuView_menu), separator20); + gtk_widget_set_sensitive (separator20, FALSE); + + viewFullscreen = gtk_check_menu_item_new_with_mnemonic ("Full Screen"); + gtk_widget_show (viewFullscreen); + gtk_container_add (GTK_CONTAINER (menuView_menu), viewFullscreen); + + separator4 = gtk_separator_menu_item_new (); + gtk_widget_show (separator4); + gtk_container_add (GTK_CONTAINER (menuView_menu), separator4); + gtk_widget_set_sensitive (separator4, FALSE); + + viewZoomIn = gtk_image_menu_item_new_from_stock ("gtk-zoom-in", accel_group); + gtk_widget_show (viewZoomIn); + gtk_container_add (GTK_CONTAINER (menuView_menu), viewZoomIn); + + viewZoomOut = gtk_image_menu_item_new_from_stock ("gtk-zoom-out", accel_group); + gtk_widget_show (viewZoomOut); + gtk_container_add (GTK_CONTAINER (menuView_menu), viewZoomOut); + + viewNormalSize = gtk_image_menu_item_new_from_stock ("gtk-zoom-100", accel_group); + gtk_widget_show (viewNormalSize); + gtk_container_add (GTK_CONTAINER (menuView_menu), viewNormalSize); + + viewPageWidth = gtk_image_menu_item_new_with_mnemonic ("Page Width"); + gtk_widget_show (viewPageWidth); + gtk_container_add (GTK_CONTAINER (menuView_menu), viewPageWidth); + + image502 = gtk_image_new_from_stock ("gtk-zoom-fit", GTK_ICON_SIZE_MENU); + gtk_widget_show (image502); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (viewPageWidth), image502); + + separator5 = gtk_separator_menu_item_new (); + gtk_widget_show (separator5); + gtk_container_add (GTK_CONTAINER (menuView_menu), separator5); + gtk_widget_set_sensitive (separator5, FALSE); + + viewFirstPage = gtk_image_menu_item_new_with_mnemonic ("First Page"); + gtk_widget_show (viewFirstPage); + gtk_container_add (GTK_CONTAINER (menuView_menu), viewFirstPage); + + image503 = gtk_image_new_from_stock ("gtk-goto-first", GTK_ICON_SIZE_MENU); + gtk_widget_show (image503); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (viewFirstPage), image503); + + viewPreviousPage = gtk_image_menu_item_new_with_mnemonic ("Previous Page"); + gtk_widget_show (viewPreviousPage); + gtk_container_add (GTK_CONTAINER (menuView_menu), viewPreviousPage); + + image504 = gtk_image_new_from_stock ("gtk-go-back", GTK_ICON_SIZE_MENU); + gtk_widget_show (image504); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (viewPreviousPage), image504); + + viewNextPage = gtk_image_menu_item_new_with_mnemonic ("Next Page"); + gtk_widget_show (viewNextPage); + gtk_container_add (GTK_CONTAINER (menuView_menu), viewNextPage); + + image505 = gtk_image_new_from_stock ("gtk-media-forward", GTK_ICON_SIZE_MENU); + gtk_widget_show (image505); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (viewNextPage), image505); + + viewLastPage = gtk_image_menu_item_new_with_mnemonic ("Last Page"); + gtk_widget_show (viewLastPage); + gtk_container_add (GTK_CONTAINER (menuView_menu), viewLastPage); + + image506 = gtk_image_new_from_stock ("gtk-goto-last", GTK_ICON_SIZE_MENU); + gtk_widget_show (image506); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (viewLastPage), image506); + + separator6 = gtk_separator_menu_item_new (); + gtk_widget_show (separator6); + gtk_container_add (GTK_CONTAINER (menuView_menu), separator6); + gtk_widget_set_sensitive (separator6, FALSE); + + viewShowLayer = gtk_image_menu_item_new_with_mnemonic ("Show Layer"); + gtk_widget_show (viewShowLayer); + gtk_container_add (GTK_CONTAINER (menuView_menu), viewShowLayer); + + image507 = gtk_image_new_from_stock ("gtk-add", GTK_ICON_SIZE_MENU); + gtk_widget_show (image507); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (viewShowLayer), image507); + + viewHideLayer = gtk_image_menu_item_new_with_mnemonic ("Hide Layer"); + gtk_widget_show (viewHideLayer); + gtk_container_add (GTK_CONTAINER (menuView_menu), viewHideLayer); + + image508 = gtk_image_new_from_stock ("gtk-remove", GTK_ICON_SIZE_MENU); + gtk_widget_show (image508); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (viewHideLayer), image508); + + menuJournal = gtk_menu_item_new_with_mnemonic ("_Journal"); + gtk_widget_show (menuJournal); + gtk_container_add (GTK_CONTAINER (menubar), menuJournal); + + menuJournal_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuJournal), menuJournal_menu); + + journalNewPageBefore = gtk_menu_item_new_with_mnemonic ("New Page Before"); + gtk_widget_show (journalNewPageBefore); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), journalNewPageBefore); + + journalNewPageAfter = gtk_menu_item_new_with_mnemonic ("New Page After"); + gtk_widget_show (journalNewPageAfter); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), journalNewPageAfter); + + journalNewPageEnd = gtk_menu_item_new_with_mnemonic ("New Page At End"); + gtk_widget_show (journalNewPageEnd); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), journalNewPageEnd); + + journalDeletePage = gtk_menu_item_new_with_mnemonic ("Delete Page"); + gtk_widget_show (journalDeletePage); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), journalDeletePage); + + separator7 = gtk_separator_menu_item_new (); + gtk_widget_show (separator7); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), separator7); + gtk_widget_set_sensitive (separator7, FALSE); + + journalNewLayer = gtk_menu_item_new_with_mnemonic ("New Layer"); + gtk_widget_show (journalNewLayer); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), journalNewLayer); + + journalDeleteLayer = gtk_menu_item_new_with_mnemonic ("Delete Layer"); + gtk_widget_show (journalDeleteLayer); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), journalDeleteLayer); + + journalFlatten = gtk_menu_item_new_with_mnemonic ("Flatten"); + gtk_widget_show (journalFlatten); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), journalFlatten); + + separator8 = gtk_separator_menu_item_new (); + gtk_widget_show (separator8); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), separator8); + gtk_widget_set_sensitive (separator8, FALSE); + + journalPaperSize = gtk_menu_item_new_with_mnemonic ("Paper Size"); + gtk_widget_show (journalPaperSize); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), journalPaperSize); + + journalPaperColor = gtk_menu_item_new_with_mnemonic ("Paper Color"); + gtk_widget_show (journalPaperColor); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), journalPaperColor); + + journalPaperColor_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (journalPaperColor), journalPaperColor_menu); + + papercolorWhite = gtk_radio_menu_item_new_with_mnemonic (papercolorWhite_group, "white paper"); + papercolorWhite_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (papercolorWhite)); + gtk_widget_show (papercolorWhite); + gtk_container_add (GTK_CONTAINER (journalPaperColor_menu), papercolorWhite); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (papercolorWhite), TRUE); + + papercolorYellow = gtk_radio_menu_item_new_with_mnemonic (papercolorWhite_group, "yellow paper"); + papercolorWhite_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (papercolorYellow)); + gtk_widget_show (papercolorYellow); + gtk_container_add (GTK_CONTAINER (journalPaperColor_menu), papercolorYellow); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (papercolorYellow), TRUE); + + papercolorPink = gtk_radio_menu_item_new_with_mnemonic (papercolorWhite_group, "pink paper"); + papercolorWhite_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (papercolorPink)); + gtk_widget_show (papercolorPink); + gtk_container_add (GTK_CONTAINER (journalPaperColor_menu), papercolorPink); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (papercolorPink), TRUE); + + papercolorOrange = gtk_radio_menu_item_new_with_mnemonic (papercolorWhite_group, "orange paper"); + papercolorWhite_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (papercolorOrange)); + gtk_widget_show (papercolorOrange); + gtk_container_add (GTK_CONTAINER (journalPaperColor_menu), papercolorOrange); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (papercolorOrange), TRUE); + + papercolorBlue = gtk_radio_menu_item_new_with_mnemonic (papercolorWhite_group, "blue paper"); + papercolorWhite_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (papercolorBlue)); + gtk_widget_show (papercolorBlue); + gtk_container_add (GTK_CONTAINER (journalPaperColor_menu), papercolorBlue); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (papercolorBlue), TRUE); + + papercolorGreen = gtk_radio_menu_item_new_with_mnemonic (papercolorWhite_group, "green paper"); + papercolorWhite_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (papercolorGreen)); + gtk_widget_show (papercolorGreen); + gtk_container_add (GTK_CONTAINER (journalPaperColor_menu), papercolorGreen); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (papercolorGreen), TRUE); + + papercolorOther = gtk_radio_menu_item_new_with_mnemonic (papercolorWhite_group, "other..."); + papercolorWhite_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (papercolorOther)); + gtk_widget_show (papercolorOther); + gtk_container_add (GTK_CONTAINER (journalPaperColor_menu), papercolorOther); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (papercolorOther), TRUE); + + papercolorNA = gtk_radio_menu_item_new_with_mnemonic (papercolorWhite_group, "NA"); + papercolorWhite_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (papercolorNA)); + gtk_container_add (GTK_CONTAINER (journalPaperColor_menu), papercolorNA); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (papercolorNA), TRUE); + + journalPaperStyle = gtk_menu_item_new_with_mnemonic ("Paper Style"); + gtk_widget_show (journalPaperStyle); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), journalPaperStyle); + + journalPaperStyle_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (journalPaperStyle), journalPaperStyle_menu); + + paperstylePlain = gtk_radio_menu_item_new_with_mnemonic (paperstylePlain_group, "plain"); + paperstylePlain_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (paperstylePlain)); + gtk_widget_show (paperstylePlain); + gtk_container_add (GTK_CONTAINER (journalPaperStyle_menu), paperstylePlain); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (paperstylePlain), TRUE); + + paperstyleLined = gtk_radio_menu_item_new_with_mnemonic (paperstylePlain_group, "lined"); + paperstylePlain_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (paperstyleLined)); + gtk_widget_show (paperstyleLined); + gtk_container_add (GTK_CONTAINER (journalPaperStyle_menu), paperstyleLined); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (paperstyleLined), TRUE); + + paperstyleRuled = gtk_radio_menu_item_new_with_mnemonic (paperstylePlain_group, "ruled"); + paperstylePlain_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (paperstyleRuled)); + gtk_widget_show (paperstyleRuled); + gtk_container_add (GTK_CONTAINER (journalPaperStyle_menu), paperstyleRuled); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (paperstyleRuled), TRUE); + + paperstyleGraph = gtk_radio_menu_item_new_with_mnemonic (paperstylePlain_group, "graph"); + paperstylePlain_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (paperstyleGraph)); + gtk_widget_show (paperstyleGraph); + gtk_container_add (GTK_CONTAINER (journalPaperStyle_menu), paperstyleGraph); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (paperstyleGraph), TRUE); + + paperstyleNA = gtk_radio_menu_item_new_with_mnemonic (paperstylePlain_group, "NA"); + paperstylePlain_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (paperstyleNA)); + gtk_container_add (GTK_CONTAINER (journalPaperStyle_menu), paperstyleNA); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (paperstyleNA), TRUE); + + journalLoadBackground = gtk_image_menu_item_new_with_mnemonic ("Load Background"); + gtk_widget_show (journalLoadBackground); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), journalLoadBackground); + + image509 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_MENU); + gtk_widget_show (image509); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (journalLoadBackground), image509); + + journalScreenshot = gtk_menu_item_new_with_mnemonic ("Background Screenshot"); + gtk_widget_show (journalScreenshot); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), journalScreenshot); + + journalApplyAllPages = gtk_menu_item_new_with_mnemonic ("Apply To All Pages"); + gtk_widget_show (journalApplyAllPages); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), journalApplyAllPages); + + separator19 = gtk_separator_menu_item_new (); + gtk_widget_show (separator19); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), separator19); + gtk_widget_set_sensitive (separator19, FALSE); + + journalDefaultBackground = gtk_menu_item_new_with_mnemonic ("Default Paper"); + gtk_widget_show (journalDefaultBackground); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), journalDefaultBackground); + + journalSetAsDefault = gtk_menu_item_new_with_mnemonic ("Set As Default"); + gtk_widget_show (journalSetAsDefault); + gtk_container_add (GTK_CONTAINER (menuJournal_menu), journalSetAsDefault); + + menuTools = gtk_menu_item_new_with_mnemonic ("_Tools"); + gtk_widget_show (menuTools); + gtk_container_add (GTK_CONTAINER (menubar), menuTools); + + menuTools_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuTools), menuTools_menu); + + toolsPen = gtk_radio_menu_item_new_with_mnemonic (toolsPen_group, "_Pen"); + toolsPen_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (toolsPen)); + gtk_widget_show (toolsPen); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsPen); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (toolsPen), TRUE); + + toolsEraser = gtk_radio_menu_item_new_with_mnemonic (toolsPen_group, "_Eraser"); + toolsPen_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (toolsEraser)); + gtk_widget_show (toolsEraser); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsEraser); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (toolsEraser), TRUE); + + toolsHighlighter = gtk_radio_menu_item_new_with_mnemonic (toolsPen_group, "_Highlighter"); + toolsPen_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (toolsHighlighter)); + gtk_widget_show (toolsHighlighter); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsHighlighter); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (toolsHighlighter), TRUE); + + toolsText = gtk_radio_menu_item_new_with_mnemonic (toolsPen_group, "_Text"); + toolsPen_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (toolsText)); + gtk_widget_show (toolsText); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsText); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (toolsText), TRUE); + + separator9 = gtk_separator_menu_item_new (); + gtk_widget_show (separator9); + gtk_container_add (GTK_CONTAINER (menuTools_menu), separator9); + gtk_widget_set_sensitive (separator9, FALSE); + + toolsSelectRegion = gtk_radio_menu_item_new_with_mnemonic (toolsPen_group, "_Select Region"); + toolsPen_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (toolsSelectRegion)); + gtk_widget_show (toolsSelectRegion); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsSelectRegion); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (toolsSelectRegion), TRUE); + + toolsSelectRectangle = gtk_radio_menu_item_new_with_mnemonic (toolsPen_group, "Select Rectangle"); + toolsPen_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (toolsSelectRectangle)); + gtk_widget_show (toolsSelectRectangle); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsSelectRectangle); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (toolsSelectRectangle), TRUE); + + toolsVerticalSpace = gtk_radio_menu_item_new_with_mnemonic (toolsPen_group, "Vertical Space"); + toolsPen_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (toolsVerticalSpace)); + gtk_widget_show (toolsVerticalSpace); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsVerticalSpace); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (toolsVerticalSpace), TRUE); + + separator16 = gtk_separator_menu_item_new (); + gtk_widget_show (separator16); + gtk_container_add (GTK_CONTAINER (menuTools_menu), separator16); + gtk_widget_set_sensitive (separator16, FALSE); + + toolsColor = gtk_image_menu_item_new_with_mnemonic ("_Color"); + gtk_widget_show (toolsColor); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsColor); + + image510 = gtk_image_new_from_stock ("gtk-select-color", GTK_ICON_SIZE_MENU); + gtk_widget_show (image510); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (toolsColor), image510); + + toolsColor_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (toolsColor), toolsColor_menu); + + colorBlack = gtk_radio_menu_item_new_with_mnemonic (colorBlack_group, "black"); + colorBlack_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (colorBlack)); + gtk_widget_show (colorBlack); + gtk_container_add (GTK_CONTAINER (toolsColor_menu), colorBlack); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (colorBlack), TRUE); + + colorBlue = gtk_radio_menu_item_new_with_mnemonic (colorBlack_group, "blue"); + colorBlack_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (colorBlue)); + gtk_widget_show (colorBlue); + gtk_container_add (GTK_CONTAINER (toolsColor_menu), colorBlue); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (colorBlue), TRUE); + + colorRed = gtk_radio_menu_item_new_with_mnemonic (colorBlack_group, "red"); + colorBlack_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (colorRed)); + gtk_widget_show (colorRed); + gtk_container_add (GTK_CONTAINER (toolsColor_menu), colorRed); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (colorRed), TRUE); + + colorGreen = gtk_radio_menu_item_new_with_mnemonic (colorBlack_group, "green"); + colorBlack_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (colorGreen)); + gtk_widget_show (colorGreen); + gtk_container_add (GTK_CONTAINER (toolsColor_menu), colorGreen); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (colorGreen), TRUE); + + colorGray = gtk_radio_menu_item_new_with_mnemonic (colorBlack_group, "gray"); + colorBlack_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (colorGray)); + gtk_widget_show (colorGray); + gtk_container_add (GTK_CONTAINER (toolsColor_menu), colorGray); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (colorGray), TRUE); + + separator17 = gtk_separator_menu_item_new (); + gtk_widget_show (separator17); + gtk_container_add (GTK_CONTAINER (toolsColor_menu), separator17); + gtk_widget_set_sensitive (separator17, FALSE); + + colorLightBlue = gtk_radio_menu_item_new_with_mnemonic (colorBlack_group, "light blue"); + colorBlack_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (colorLightBlue)); + gtk_widget_show (colorLightBlue); + gtk_container_add (GTK_CONTAINER (toolsColor_menu), colorLightBlue); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (colorLightBlue), TRUE); + + colorLightGreen = gtk_radio_menu_item_new_with_mnemonic (colorBlack_group, "light green"); + colorBlack_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (colorLightGreen)); + gtk_widget_show (colorLightGreen); + gtk_container_add (GTK_CONTAINER (toolsColor_menu), colorLightGreen); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (colorLightGreen), TRUE); + + colorMagenta = gtk_radio_menu_item_new_with_mnemonic (colorBlack_group, "magenta"); + colorBlack_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (colorMagenta)); + gtk_widget_show (colorMagenta); + gtk_container_add (GTK_CONTAINER (toolsColor_menu), colorMagenta); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (colorMagenta), TRUE); + + colorOrange = gtk_radio_menu_item_new_with_mnemonic (colorBlack_group, "orange"); + colorBlack_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (colorOrange)); + gtk_widget_show (colorOrange); + gtk_container_add (GTK_CONTAINER (toolsColor_menu), colorOrange); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (colorOrange), TRUE); + + colorYellow = gtk_radio_menu_item_new_with_mnemonic (colorBlack_group, "yellow"); + colorBlack_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (colorYellow)); + gtk_widget_show (colorYellow); + gtk_container_add (GTK_CONTAINER (toolsColor_menu), colorYellow); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (colorYellow), TRUE); + + colorWhite = gtk_radio_menu_item_new_with_mnemonic (colorBlack_group, "white"); + colorBlack_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (colorWhite)); + gtk_widget_show (colorWhite); + gtk_container_add (GTK_CONTAINER (toolsColor_menu), colorWhite); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (colorWhite), TRUE); + + colorOther = gtk_radio_menu_item_new_with_mnemonic (colorBlack_group, "other..."); + colorBlack_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (colorOther)); + gtk_widget_show (colorOther); + gtk_container_add (GTK_CONTAINER (toolsColor_menu), colorOther); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (colorOther), TRUE); + + colorNA = gtk_radio_menu_item_new_with_mnemonic (colorBlack_group, "NA"); + colorBlack_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (colorNA)); + gtk_container_add (GTK_CONTAINER (toolsColor_menu), colorNA); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (colorNA), TRUE); + + toolsPenOptions = gtk_menu_item_new_with_mnemonic ("Pen _Options"); + gtk_widget_show (toolsPenOptions); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsPenOptions); + + toolsPenOptions_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (toolsPenOptions), toolsPenOptions_menu); + + penthicknessVeryFine = gtk_radio_menu_item_new_with_mnemonic (penthicknessVeryFine_group, "very fine"); + penthicknessVeryFine_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (penthicknessVeryFine)); + gtk_widget_show (penthicknessVeryFine); + gtk_container_add (GTK_CONTAINER (toolsPenOptions_menu), penthicknessVeryFine); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (penthicknessVeryFine), TRUE); + + penthicknessFine = gtk_radio_menu_item_new_with_mnemonic (penthicknessVeryFine_group, "fine"); + penthicknessVeryFine_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (penthicknessFine)); + gtk_widget_show (penthicknessFine); + gtk_container_add (GTK_CONTAINER (toolsPenOptions_menu), penthicknessFine); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (penthicknessFine), TRUE); + + penthicknessMedium = gtk_radio_menu_item_new_with_mnemonic (penthicknessVeryFine_group, "medium"); + penthicknessVeryFine_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (penthicknessMedium)); + gtk_widget_show (penthicknessMedium); + gtk_container_add (GTK_CONTAINER (toolsPenOptions_menu), penthicknessMedium); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (penthicknessMedium), TRUE); + + penthicknessThick = gtk_radio_menu_item_new_with_mnemonic (penthicknessVeryFine_group, "thick"); + penthicknessVeryFine_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (penthicknessThick)); + gtk_widget_show (penthicknessThick); + gtk_container_add (GTK_CONTAINER (toolsPenOptions_menu), penthicknessThick); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (penthicknessThick), TRUE); + + penthicknessVeryThick = gtk_radio_menu_item_new_with_mnemonic (penthicknessVeryFine_group, "very thick"); + penthicknessVeryFine_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (penthicknessVeryThick)); + gtk_widget_show (penthicknessVeryThick); + gtk_container_add (GTK_CONTAINER (toolsPenOptions_menu), penthicknessVeryThick); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (penthicknessVeryThick), TRUE); + + toolsEraserOptions = gtk_menu_item_new_with_mnemonic ("Eraser Options"); + gtk_widget_show (toolsEraserOptions); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsEraserOptions); + + toolsEraserOptions_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (toolsEraserOptions), toolsEraserOptions_menu); + + eraserFine = gtk_radio_menu_item_new_with_mnemonic (eraserFine_group, "fine"); + eraserFine_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (eraserFine)); + gtk_widget_show (eraserFine); + gtk_container_add (GTK_CONTAINER (toolsEraserOptions_menu), eraserFine); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (eraserFine), TRUE); + + eraserMedium = gtk_radio_menu_item_new_with_mnemonic (eraserFine_group, "medium"); + eraserFine_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (eraserMedium)); + gtk_widget_show (eraserMedium); + gtk_container_add (GTK_CONTAINER (toolsEraserOptions_menu), eraserMedium); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (eraserMedium), TRUE); + + eraserThick = gtk_radio_menu_item_new_with_mnemonic (eraserFine_group, "thick"); + eraserFine_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (eraserThick)); + gtk_widget_show (eraserThick); + gtk_container_add (GTK_CONTAINER (toolsEraserOptions_menu), eraserThick); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (eraserThick), TRUE); + + separator14 = gtk_separator_menu_item_new (); + gtk_widget_show (separator14); + gtk_container_add (GTK_CONTAINER (toolsEraserOptions_menu), separator14); + gtk_widget_set_sensitive (separator14, FALSE); + + eraserStandard = gtk_radio_menu_item_new_with_mnemonic (eraserStandard_group, "standard"); + eraserStandard_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (eraserStandard)); + gtk_widget_show (eraserStandard); + gtk_container_add (GTK_CONTAINER (toolsEraserOptions_menu), eraserStandard); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (eraserStandard), TRUE); + + eraserWhiteout = gtk_radio_menu_item_new_with_mnemonic (eraserStandard_group, "whiteout"); + eraserStandard_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (eraserWhiteout)); + gtk_widget_show (eraserWhiteout); + gtk_container_add (GTK_CONTAINER (toolsEraserOptions_menu), eraserWhiteout); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (eraserWhiteout), TRUE); + + eraserDeleteStrokes = gtk_radio_menu_item_new_with_mnemonic (eraserStandard_group, "delete strokes"); + eraserStandard_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (eraserDeleteStrokes)); + gtk_widget_show (eraserDeleteStrokes); + gtk_container_add (GTK_CONTAINER (toolsEraserOptions_menu), eraserDeleteStrokes); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (eraserDeleteStrokes), TRUE); + + toolsHighlighterOptions = gtk_menu_item_new_with_mnemonic ("Highlighter Options"); + gtk_widget_show (toolsHighlighterOptions); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsHighlighterOptions); + + toolsHighlighterOptions_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (toolsHighlighterOptions), toolsHighlighterOptions_menu); + + highlighterFine = gtk_radio_menu_item_new_with_mnemonic (highlighterFine_group, "fine"); + highlighterFine_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (highlighterFine)); + gtk_widget_show (highlighterFine); + gtk_container_add (GTK_CONTAINER (toolsHighlighterOptions_menu), highlighterFine); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (highlighterFine), TRUE); + + highlighterMedium = gtk_radio_menu_item_new_with_mnemonic (highlighterFine_group, "medium"); + highlighterFine_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (highlighterMedium)); + gtk_widget_show (highlighterMedium); + gtk_container_add (GTK_CONTAINER (toolsHighlighterOptions_menu), highlighterMedium); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (highlighterMedium), TRUE); + + highlighterThick = gtk_radio_menu_item_new_with_mnemonic (highlighterFine_group, "thick"); + highlighterFine_group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (highlighterThick)); + gtk_widget_show (highlighterThick); + gtk_container_add (GTK_CONTAINER (toolsHighlighterOptions_menu), highlighterThick); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (highlighterThick), TRUE); + + toolsTextFont = gtk_image_menu_item_new_with_mnemonic ("Text Font"); + gtk_widget_show (toolsTextFont); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsTextFont); + + image511 = gtk_image_new_from_stock ("gtk-select-font", GTK_ICON_SIZE_MENU); + gtk_widget_show (image511); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (toolsTextFont), image511); + + separator10 = gtk_separator_menu_item_new (); + gtk_widget_show (separator10); + gtk_container_add (GTK_CONTAINER (menuTools_menu), separator10); + gtk_widget_set_sensitive (separator10, FALSE); + + toolsDefaultPen = gtk_menu_item_new_with_mnemonic ("Default Pen"); + gtk_widget_show (toolsDefaultPen); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsDefaultPen); + + toolsDefaultEraser = gtk_menu_item_new_with_mnemonic ("Default Eraser"); + gtk_widget_show (toolsDefaultEraser); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsDefaultEraser); + + toolsDefaultHighlighter = gtk_menu_item_new_with_mnemonic ("Default Highlighter"); + gtk_widget_show (toolsDefaultHighlighter); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsDefaultHighlighter); + + toolsDefaultText = gtk_menu_item_new_with_mnemonic ("Default Text"); + gtk_widget_show (toolsDefaultText); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsDefaultText); + + toolsSetAsDefault = gtk_menu_item_new_with_mnemonic ("Set As Default"); + gtk_widget_show (toolsSetAsDefault); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsSetAsDefault); + + separator15 = gtk_separator_menu_item_new (); + gtk_widget_show (separator15); + gtk_container_add (GTK_CONTAINER (menuTools_menu), separator15); + gtk_widget_set_sensitive (separator15, FALSE); + + toolsRuler = gtk_check_menu_item_new_with_mnemonic ("Ruler"); + gtk_widget_show (toolsRuler); + gtk_container_add (GTK_CONTAINER (menuTools_menu), toolsRuler); + + menuOptions = gtk_menu_item_new_with_mnemonic ("_Options"); + gtk_widget_show (menuOptions); + gtk_container_add (GTK_CONTAINER (menubar), menuOptions); + + menuOptions_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuOptions), menuOptions_menu); + + optionsUseXInput = gtk_check_menu_item_new_with_mnemonic ("Use XInput"); + gtk_widget_show (optionsUseXInput); + gtk_container_add (GTK_CONTAINER (menuOptions_menu), optionsUseXInput); + + optionsEmulateEraser = gtk_check_menu_item_new_with_mnemonic ("Emulate Eraser"); + gtk_widget_show (optionsEmulateEraser); + gtk_container_add (GTK_CONTAINER (menuOptions_menu), optionsEmulateEraser); + + separator18 = gtk_separator_menu_item_new (); + gtk_widget_show (separator18); + gtk_container_add (GTK_CONTAINER (menuOptions_menu), separator18); + gtk_widget_set_sensitive (separator18, FALSE); + + optionsAntialiasBG = gtk_check_menu_item_new_with_mnemonic ("Antialiased Bitmaps"); + gtk_widget_show (optionsAntialiasBG); + gtk_container_add (GTK_CONTAINER (menuOptions_menu), optionsAntialiasBG); + + optionsProgressiveBG = gtk_check_menu_item_new_with_mnemonic ("Progressive Backgrounds"); + gtk_widget_show (optionsProgressiveBG); + gtk_container_add (GTK_CONTAINER (menuOptions_menu), optionsProgressiveBG); + + separator21 = gtk_separator_menu_item_new (); + gtk_widget_show (separator21); + gtk_container_add (GTK_CONTAINER (menuOptions_menu), separator21); + gtk_widget_set_sensitive (separator21, FALSE); + + optionsSavePreferences = gtk_menu_item_new_with_mnemonic ("Save Preferences"); + gtk_widget_show (optionsSavePreferences); + gtk_container_add (GTK_CONTAINER (menuOptions_menu), optionsSavePreferences); + + menuHelp = gtk_menu_item_new_with_mnemonic ("_Help"); + gtk_widget_show (menuHelp); + gtk_container_add (GTK_CONTAINER (menubar), menuHelp); + + menuHelp_menu = gtk_menu_new (); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuHelp), menuHelp_menu); + + helpIndex = gtk_image_menu_item_new_from_stock ("gtk-index", accel_group); + gtk_widget_show (helpIndex); + gtk_container_add (GTK_CONTAINER (menuHelp_menu), helpIndex); + + helpAbout = gtk_menu_item_new_with_mnemonic ("_About"); + gtk_widget_show (helpAbout); + gtk_container_add (GTK_CONTAINER (menuHelp_menu), helpAbout); + + toolbarMain = gtk_toolbar_new (); + gtk_widget_show (toolbarMain); + gtk_box_pack_start (GTK_BOX (vboxMain), toolbarMain, FALSE, FALSE, 0); + gtk_toolbar_set_style (GTK_TOOLBAR (toolbarMain), GTK_TOOLBAR_ICONS); + tmp_toolbar_icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbarMain)); + + saveButton = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-save"); + gtk_widget_show (saveButton); + gtk_container_add (GTK_CONTAINER (toolbarMain), saveButton); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (saveButton), tooltips, "Save", NULL); + + toolitem11 = (GtkWidget*) gtk_tool_item_new (); + gtk_widget_show (toolitem11); + gtk_container_add (GTK_CONTAINER (toolbarMain), toolitem11); + + vseparator1 = gtk_vseparator_new (); + gtk_widget_show (vseparator1); + gtk_container_add (GTK_CONTAINER (toolitem11), vseparator1); + + buttonCut = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-cut"); + gtk_widget_show (buttonCut); + gtk_container_add (GTK_CONTAINER (toolbarMain), buttonCut); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonCut), tooltips, "Cut", NULL); + + buttonCopy = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-copy"); + gtk_widget_show (buttonCopy); + gtk_container_add (GTK_CONTAINER (toolbarMain), buttonCopy); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonCopy), tooltips, "Copy", NULL); + + buttonPaste = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-paste"); + gtk_widget_show (buttonPaste); + gtk_container_add (GTK_CONTAINER (toolbarMain), buttonPaste); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonPaste), tooltips, "Paste", NULL); + + toolitem12 = (GtkWidget*) gtk_tool_item_new (); + gtk_widget_show (toolitem12); + gtk_container_add (GTK_CONTAINER (toolbarMain), toolitem12); + + vseparator2 = gtk_vseparator_new (); + gtk_widget_show (vseparator2); + gtk_container_add (GTK_CONTAINER (toolitem12), vseparator2); + + buttonUndo = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-undo"); + gtk_widget_show (buttonUndo); + gtk_container_add (GTK_CONTAINER (toolbarMain), buttonUndo); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonUndo), tooltips, "Undo", NULL); + + buttonRedo = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-redo"); + gtk_widget_show (buttonRedo); + gtk_container_add (GTK_CONTAINER (toolbarMain), buttonRedo); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonRedo), tooltips, "Redo", NULL); + + toolitem13 = (GtkWidget*) gtk_tool_item_new (); + gtk_widget_show (toolitem13); + gtk_container_add (GTK_CONTAINER (toolbarMain), toolitem13); + + vseparator3 = gtk_vseparator_new (); + gtk_widget_show (vseparator3); + gtk_container_add (GTK_CONTAINER (toolitem13), vseparator3); + + buttonFirstPage = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-goto-first"); + gtk_widget_show (buttonFirstPage); + gtk_container_add (GTK_CONTAINER (toolbarMain), buttonFirstPage); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonFirstPage), tooltips, "First Page", NULL); + + buttonPreviousPage = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-go-back"); + gtk_widget_show (buttonPreviousPage); + gtk_container_add (GTK_CONTAINER (toolbarMain), buttonPreviousPage); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonPreviousPage), tooltips, "Previous Page", NULL); + + buttonNextPage = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-go-forward"); + gtk_widget_show (buttonNextPage); + gtk_container_add (GTK_CONTAINER (toolbarMain), buttonNextPage); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonNextPage), tooltips, "Next Page", NULL); + + buttonLastPage = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-goto-last"); + gtk_widget_show (buttonLastPage); + gtk_container_add (GTK_CONTAINER (toolbarMain), buttonLastPage); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonLastPage), tooltips, "Last Page", NULL); + + toolitem14 = (GtkWidget*) gtk_tool_item_new (); + gtk_widget_show (toolitem14); + gtk_container_add (GTK_CONTAINER (toolbarMain), toolitem14); + + vseparator4 = gtk_vseparator_new (); + gtk_widget_show (vseparator4); + gtk_container_add (GTK_CONTAINER (toolitem14), vseparator4); + + buttonZoomOut = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-zoom-out"); + gtk_widget_show (buttonZoomOut); + gtk_container_add (GTK_CONTAINER (toolbarMain), buttonZoomOut); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonZoomOut), tooltips, "Zoom Out", NULL); + + buttonPageWidth = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-zoom-fit"); + gtk_widget_show (buttonPageWidth); + gtk_container_add (GTK_CONTAINER (toolbarMain), buttonPageWidth); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonPageWidth), tooltips, "Page Width", NULL); + gtk_tool_item_set_visible_vertical (GTK_TOOL_ITEM (buttonPageWidth), FALSE); + + buttonZoomIn = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-zoom-in"); + gtk_widget_show (buttonZoomIn); + gtk_container_add (GTK_CONTAINER (toolbarMain), buttonZoomIn); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonZoomIn), tooltips, "Zoom In", NULL); + + buttonNormalSize = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-zoom-100"); + gtk_widget_show (buttonNormalSize); + gtk_container_add (GTK_CONTAINER (toolbarMain), buttonNormalSize); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonNormalSize), tooltips, "Normal Size", NULL); + + buttonFullscreen = (GtkWidget*) gtk_toggle_tool_button_new (); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonFullscreen), ""); + tmp_image = create_pixmap (winMain, "fullscreen.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonFullscreen), tmp_image); + gtk_widget_show (buttonFullscreen); + gtk_container_add (GTK_CONTAINER (toolbarMain), buttonFullscreen); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonFullscreen), tooltips, "Toggle Fullscreen", NULL); + + toolbarPen = gtk_toolbar_new (); + gtk_widget_show (toolbarPen); + gtk_box_pack_start (GTK_BOX (vboxMain), toolbarPen, FALSE, FALSE, 0); + gtk_toolbar_set_style (GTK_TOOLBAR (toolbarPen), GTK_TOOLBAR_ICONS); + tmp_toolbar_icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbarPen)); + + buttonPen = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonPen), "Pencil"); + tmp_image = create_pixmap (winMain, "pencil.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonPen), tmp_image); + gtk_widget_show (buttonPen); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonPen); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonPen), tooltips, "Pen", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonPen), buttonPen_group); + buttonPen_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonPen)); + + buttonEraser = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonEraser), "Eraser"); + tmp_image = create_pixmap (winMain, "eraser.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonEraser), tmp_image); + gtk_widget_show (buttonEraser); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonEraser); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonEraser), tooltips, "Eraser", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonEraser), buttonPen_group); + buttonPen_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonEraser)); + + buttonHighlighter = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonHighlighter), "Highlighter"); + tmp_image = create_pixmap (winMain, "highlighter.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonHighlighter), tmp_image); + gtk_widget_show (buttonHighlighter); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonHighlighter); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonHighlighter), tooltips, "Highlighter", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonHighlighter), buttonPen_group); + buttonPen_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonHighlighter)); + + buttonText = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonText), "Text"); + tmp_image = create_pixmap (winMain, "text-tool.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonText), tmp_image); + gtk_widget_show (buttonText); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonText); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonText), tooltips, "Text", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonText), buttonPen_group); + buttonPen_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonText)); + + buttonRuler = (GtkWidget*) gtk_toggle_tool_button_new (); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonRuler), "Ruler"); + tmp_image = create_pixmap (winMain, "ruler.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonRuler), tmp_image); + gtk_widget_show (buttonRuler); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonRuler); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonRuler), tooltips, "Ruler", NULL); + + toolitem15 = (GtkWidget*) gtk_tool_item_new (); + gtk_widget_show (toolitem15); + gtk_container_add (GTK_CONTAINER (toolbarPen), toolitem15); + + vseparator5 = gtk_vseparator_new (); + gtk_widget_show (vseparator5); + gtk_container_add (GTK_CONTAINER (toolitem15), vseparator5); + + buttonSelectRegion = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonSelectRegion), "Select Region"); + tmp_image = create_pixmap (winMain, "lasso.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonSelectRegion), tmp_image); + gtk_widget_show (buttonSelectRegion); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonSelectRegion); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonSelectRegion), tooltips, "Select Region", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonSelectRegion), buttonPen_group); + buttonPen_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonSelectRegion)); + + buttonSelectRectangle = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonSelectRectangle), "Select Rectangle"); + tmp_image = create_pixmap (winMain, "rect-select.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonSelectRectangle), tmp_image); + gtk_widget_show (buttonSelectRectangle); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonSelectRectangle); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonSelectRectangle), tooltips, "Select Rectangle", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonSelectRectangle), buttonPen_group); + buttonPen_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonSelectRectangle)); + + buttonVerticalSpace = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonVerticalSpace), "Vertical Space"); + tmp_image = create_pixmap (winMain, "stretch.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonVerticalSpace), tmp_image); + gtk_widget_show (buttonVerticalSpace); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonVerticalSpace); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonVerticalSpace), tooltips, "Vertical Space", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonVerticalSpace), buttonPen_group); + buttonPen_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonVerticalSpace)); + + toolitem16 = (GtkWidget*) gtk_tool_item_new (); + gtk_widget_show (toolitem16); + gtk_container_add (GTK_CONTAINER (toolbarPen), toolitem16); + + vseparator6 = gtk_vseparator_new (); + gtk_widget_show (vseparator6); + gtk_container_add (GTK_CONTAINER (toolitem16), vseparator6); + + tmp_image = create_pixmap (winMain, "recycled.png"); + gtk_widget_show (tmp_image); + buttonToolDefault = (GtkWidget*) gtk_tool_button_new (tmp_image, "Default"); + gtk_widget_show (buttonToolDefault); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (buttonToolDefault), FALSE); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonToolDefault); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonToolDefault), tooltips, "Default", NULL); + + tmp_image = create_pixmap (winMain, "default-pen.png"); + gtk_widget_show (tmp_image); + buttonDefaultPen = (GtkWidget*) gtk_tool_button_new (tmp_image, "Default Pen"); + gtk_widget_show (buttonDefaultPen); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonDefaultPen); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonDefaultPen), tooltips, "Default Pen", NULL); + + toolitem18 = (GtkWidget*) gtk_tool_item_new (); + gtk_widget_show (toolitem18); + gtk_container_add (GTK_CONTAINER (toolbarPen), toolitem18); + + vseparator8 = gtk_vseparator_new (); + gtk_widget_show (vseparator8); + gtk_container_add (GTK_CONTAINER (toolitem18), vseparator8); + + buttonFine = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonFine), "Fine"); + tmp_image = create_pixmap (winMain, "thin.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonFine), tmp_image); + gtk_widget_show (buttonFine); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (buttonFine), FALSE); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonFine); + gtk_widget_set_size_request (buttonFine, 24, -1); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonFine), tooltips, "Fine", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonFine), buttonFine_group); + buttonFine_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonFine)); + + buttonMedium = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonMedium), "Medium"); + tmp_image = create_pixmap (winMain, "medium.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonMedium), tmp_image); + gtk_widget_show (buttonMedium); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (buttonMedium), FALSE); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonMedium); + gtk_widget_set_size_request (buttonMedium, 24, -1); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonMedium), tooltips, "Medium", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonMedium), buttonFine_group); + buttonFine_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonMedium)); + + buttonThick = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonThick), "Thick"); + tmp_image = create_pixmap (winMain, "thick.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonThick), tmp_image); + gtk_widget_show (buttonThick); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (buttonThick), FALSE); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonThick); + gtk_widget_set_size_request (buttonThick, 24, -1); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonThick), tooltips, "Thick", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonThick), buttonFine_group); + buttonFine_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonThick)); + + buttonThicknessOther = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonThicknessOther), ""); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonThicknessOther); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonThicknessOther), buttonFine_group); + buttonFine_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonThicknessOther)); + + toolitem17 = (GtkWidget*) gtk_tool_item_new (); + gtk_widget_show (toolitem17); + gtk_container_add (GTK_CONTAINER (toolbarPen), toolitem17); + + vseparator7 = gtk_vseparator_new (); + gtk_widget_show (vseparator7); + gtk_container_add (GTK_CONTAINER (toolitem17), vseparator7); + + buttonBlack = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonBlack), "Black"); + tmp_image = create_pixmap (winMain, "black.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonBlack), tmp_image); + gtk_widget_show (buttonBlack); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (buttonBlack), FALSE); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonBlack); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonBlack), tooltips, "Black", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonBlack), buttonBlack_group); + buttonBlack_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonBlack)); + + buttonBlue = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonBlue), "Blue"); + tmp_image = create_pixmap (winMain, "blue.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonBlue), tmp_image); + gtk_widget_show (buttonBlue); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (buttonBlue), FALSE); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonBlue); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonBlue), tooltips, "Blue", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonBlue), buttonBlack_group); + buttonBlack_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonBlue)); + + buttonRed = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonRed), "Red"); + tmp_image = create_pixmap (winMain, "red.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonRed), tmp_image); + gtk_widget_show (buttonRed); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (buttonRed), FALSE); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonRed); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonRed), tooltips, "Red", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonRed), buttonBlack_group); + buttonBlack_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonRed)); + + buttonGreen = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonGreen), "Green"); + tmp_image = create_pixmap (winMain, "green.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonGreen), tmp_image); + gtk_widget_show (buttonGreen); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (buttonGreen), FALSE); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonGreen); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonGreen), tooltips, "Green", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonGreen), buttonBlack_group); + buttonBlack_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonGreen)); + + buttonGray = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonGray), "Gray"); + tmp_image = create_pixmap (winMain, "gray.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonGray), tmp_image); + gtk_widget_show (buttonGray); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (buttonGray), FALSE); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonGray); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonGray), tooltips, "Gray", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonGray), buttonBlack_group); + buttonBlack_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonGray)); + + buttonLightBlue = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonLightBlue), "Light Blue"); + tmp_image = create_pixmap (winMain, "lightblue.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonLightBlue), tmp_image); + gtk_widget_show (buttonLightBlue); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (buttonLightBlue), FALSE); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonLightBlue); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonLightBlue), tooltips, "Light Blue", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonLightBlue), buttonBlack_group); + buttonBlack_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonLightBlue)); + + buttonLightGreen = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonLightGreen), "Light Green"); + tmp_image = create_pixmap (winMain, "lightgreen.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonLightGreen), tmp_image); + gtk_widget_show (buttonLightGreen); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (buttonLightGreen), FALSE); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonLightGreen); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonLightGreen), tooltips, "Light Green", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonLightGreen), buttonBlack_group); + buttonBlack_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonLightGreen)); + + buttonMagenta = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonMagenta), "Magenta"); + tmp_image = create_pixmap (winMain, "magenta.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonMagenta), tmp_image); + gtk_widget_show (buttonMagenta); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (buttonMagenta), FALSE); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonMagenta); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonMagenta), tooltips, "Magenta", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonMagenta), buttonBlack_group); + buttonBlack_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonMagenta)); + + buttonOrange = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonOrange), "Orange"); + tmp_image = create_pixmap (winMain, "orange.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonOrange), tmp_image); + gtk_widget_show (buttonOrange); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (buttonOrange), FALSE); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonOrange); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonOrange), tooltips, "Orange", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonOrange), buttonBlack_group); + buttonBlack_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonOrange)); + + buttonYellow = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonYellow), "Yellow"); + tmp_image = create_pixmap (winMain, "yellow.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonYellow), tmp_image); + gtk_widget_show (buttonYellow); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (buttonYellow), FALSE); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonYellow); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonYellow), tooltips, "Yellow", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonYellow), buttonBlack_group); + buttonBlack_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonYellow)); + + buttonWhite = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonWhite), "White"); + tmp_image = create_pixmap (winMain, "white.png"); + gtk_widget_show (tmp_image); + gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (buttonWhite), tmp_image); + gtk_widget_show (buttonWhite); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (buttonWhite), FALSE); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonWhite); + gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (buttonWhite), tooltips, "White", NULL); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonWhite), buttonBlack_group); + buttonBlack_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonWhite)); + + buttonColorOther = (GtkWidget*) gtk_radio_tool_button_new (NULL); + gtk_tool_button_set_label (GTK_TOOL_BUTTON (buttonColorOther), ""); + gtk_container_add (GTK_CONTAINER (toolbarPen), buttonColorOther); + gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (buttonColorOther), buttonBlack_group); + buttonBlack_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (buttonColorOther)); + + scrolledwindowMain = gtk_scrolled_window_new (NULL, NULL); + gtk_widget_show (scrolledwindowMain); + gtk_box_pack_start (GTK_BOX (vboxMain), scrolledwindowMain, TRUE, TRUE, 0); + + hbox1 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox1); + gtk_box_pack_start (GTK_BOX (vboxMain), hbox1, FALSE, FALSE, 0); + + labelPage = gtk_label_new (" Page "); + gtk_widget_show (labelPage); + gtk_box_pack_start (GTK_BOX (hbox1), labelPage, FALSE, FALSE, 0); + + spinPageNo_adj = gtk_adjustment_new (1, 1, 1, 1, 1, 1); + spinPageNo = gtk_spin_button_new (GTK_ADJUSTMENT (spinPageNo_adj), 1, 0); + gtk_widget_show (spinPageNo); + gtk_box_pack_start (GTK_BOX (hbox1), spinPageNo, FALSE, TRUE, 0); + gtk_widget_set_size_request (spinPageNo, 39, -1); + gtk_tooltips_set_tip (tooltips, spinPageNo, "Set page number", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinPageNo), TRUE); + gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (spinPageNo), TRUE); + + labelNumpages = gtk_label_new (" of n"); + gtk_widget_show (labelNumpages); + gtk_box_pack_start (GTK_BOX (hbox1), labelNumpages, FALSE, FALSE, 0); + + vseparator9 = gtk_vseparator_new (); + gtk_widget_show (vseparator9); + gtk_box_pack_start (GTK_BOX (hbox1), vseparator9, FALSE, TRUE, 6); + + labelLayer = gtk_label_new (" Layer: "); + gtk_widget_show (labelLayer); + gtk_box_pack_start (GTK_BOX (hbox1), labelLayer, FALSE, FALSE, 0); + + comboLayer = gtk_combo_box_new_text (); + gtk_widget_show (comboLayer); + gtk_box_pack_start (GTK_BOX (hbox1), comboLayer, FALSE, TRUE, 4); + + statusbar = gtk_statusbar_new (); + gtk_widget_show (statusbar); + gtk_box_pack_start (GTK_BOX (hbox1), statusbar, TRUE, TRUE, 0); + + g_signal_connect ((gpointer) winMain, "delete_event", + G_CALLBACK (on_winMain_delete_event), + NULL); + g_signal_connect ((gpointer) fileNew, "activate", + G_CALLBACK (on_fileNew_activate), + NULL); + g_signal_connect ((gpointer) fileNewBackground, "activate", + G_CALLBACK (on_fileNewBackground_activate), + NULL); + g_signal_connect ((gpointer) fileOpen, "activate", + G_CALLBACK (on_fileOpen_activate), + NULL); + g_signal_connect ((gpointer) fileSave, "activate", + G_CALLBACK (on_fileSave_activate), + NULL); + g_signal_connect ((gpointer) fileSaveAs, "activate", + G_CALLBACK (on_fileSaveAs_activate), + NULL); + g_signal_connect ((gpointer) filePrintOptions, "activate", + G_CALLBACK (on_filePrintOptions_activate), + NULL); + g_signal_connect ((gpointer) filePrint, "activate", + G_CALLBACK (on_filePrint_activate), + NULL); + g_signal_connect ((gpointer) filePrintPDF, "activate", + G_CALLBACK (on_filePrintPDF_activate), + NULL); + g_signal_connect ((gpointer) fileQuit, "activate", + G_CALLBACK (on_fileQuit_activate), + NULL); + g_signal_connect ((gpointer) editUndo, "activate", + G_CALLBACK (on_editUndo_activate), + NULL); + g_signal_connect ((gpointer) editRedo, "activate", + G_CALLBACK (on_editRedo_activate), + NULL); + g_signal_connect ((gpointer) editCut, "activate", + G_CALLBACK (on_editCut_activate), + NULL); + g_signal_connect ((gpointer) editCopy, "activate", + G_CALLBACK (on_editCopy_activate), + NULL); + g_signal_connect ((gpointer) editPaste, "activate", + G_CALLBACK (on_editPaste_activate), + NULL); + g_signal_connect ((gpointer) editDelete, "activate", + G_CALLBACK (on_editDelete_activate), + NULL); + g_signal_connect ((gpointer) viewContinuous, "toggled", + G_CALLBACK (on_viewContinuous_activate), + NULL); + g_signal_connect ((gpointer) viewOnePage, "toggled", + G_CALLBACK (on_viewOnePage_activate), + NULL); + g_signal_connect ((gpointer) viewFullscreen, "activate", + G_CALLBACK (on_viewFullscreen_activate), + NULL); + g_signal_connect ((gpointer) viewZoomIn, "activate", + G_CALLBACK (on_viewZoomIn_activate), + NULL); + g_signal_connect ((gpointer) viewZoomOut, "activate", + G_CALLBACK (on_viewZoomOut_activate), + NULL); + g_signal_connect ((gpointer) viewNormalSize, "activate", + G_CALLBACK (on_viewNormalSize_activate), + NULL); + g_signal_connect ((gpointer) viewPageWidth, "activate", + G_CALLBACK (on_viewPageWidth_activate), + NULL); + g_signal_connect ((gpointer) viewFirstPage, "activate", + G_CALLBACK (on_viewFirstPage_activate), + NULL); + g_signal_connect ((gpointer) viewPreviousPage, "activate", + G_CALLBACK (on_viewPreviousPage_activate), + NULL); + g_signal_connect ((gpointer) viewNextPage, "activate", + G_CALLBACK (on_viewNextPage_activate), + NULL); + g_signal_connect ((gpointer) viewLastPage, "activate", + G_CALLBACK (on_viewLastPage_activate), + NULL); + g_signal_connect ((gpointer) viewShowLayer, "activate", + G_CALLBACK (on_viewShowLayer_activate), + NULL); + g_signal_connect ((gpointer) viewHideLayer, "activate", + G_CALLBACK (on_viewHideLayer_activate), + NULL); + g_signal_connect ((gpointer) journalNewPageBefore, "activate", + G_CALLBACK (on_journalNewPageBefore_activate), + NULL); + g_signal_connect ((gpointer) journalNewPageAfter, "activate", + G_CALLBACK (on_journalNewPageAfter_activate), + NULL); + g_signal_connect ((gpointer) journalNewPageEnd, "activate", + G_CALLBACK (on_journalNewPageEnd_activate), + NULL); + g_signal_connect ((gpointer) journalDeletePage, "activate", + G_CALLBACK (on_journalDeletePage_activate), + NULL); + g_signal_connect ((gpointer) journalNewLayer, "activate", + G_CALLBACK (on_journalNewLayer_activate), + NULL); + g_signal_connect ((gpointer) journalDeleteLayer, "activate", + G_CALLBACK (on_journalDeleteLayer_activate), + NULL); + g_signal_connect ((gpointer) journalFlatten, "activate", + G_CALLBACK (on_journalFlatten_activate), + NULL); + g_signal_connect ((gpointer) journalPaperSize, "activate", + G_CALLBACK (on_journalPaperSize_activate), + NULL); + g_signal_connect ((gpointer) papercolorWhite, "toggled", + G_CALLBACK (on_papercolorWhite_activate), + NULL); + g_signal_connect ((gpointer) papercolorYellow, "toggled", + G_CALLBACK (on_papercolorYellow_activate), + NULL); + g_signal_connect ((gpointer) papercolorPink, "toggled", + G_CALLBACK (on_papercolorPink_activate), + NULL); + g_signal_connect ((gpointer) papercolorOrange, "toggled", + G_CALLBACK (on_papercolorOrange_activate), + NULL); + g_signal_connect ((gpointer) papercolorBlue, "toggled", + G_CALLBACK (on_papercolorBlue_activate), + NULL); + g_signal_connect ((gpointer) papercolorGreen, "toggled", + G_CALLBACK (on_papercolorGreen_activate), + NULL); + g_signal_connect ((gpointer) papercolorOther, "toggled", + G_CALLBACK (on_papercolorOther_activate), + NULL); + g_signal_connect ((gpointer) paperstylePlain, "toggled", + G_CALLBACK (on_paperstylePlain_activate), + NULL); + g_signal_connect ((gpointer) paperstyleLined, "toggled", + G_CALLBACK (on_paperstyleLined_activate), + NULL); + g_signal_connect ((gpointer) paperstyleRuled, "toggled", + G_CALLBACK (on_paperstyleRuled_activate), + NULL); + g_signal_connect ((gpointer) paperstyleGraph, "toggled", + G_CALLBACK (on_paperstyleGraph_activate), + NULL); + g_signal_connect ((gpointer) journalLoadBackground, "activate", + G_CALLBACK (on_journalLoadBackground_activate), + NULL); + g_signal_connect ((gpointer) journalScreenshot, "activate", + G_CALLBACK (on_journalScreenshot_activate), + NULL); + g_signal_connect ((gpointer) journalApplyAllPages, "activate", + G_CALLBACK (on_journalApplyAllPages_activate), + NULL); + g_signal_connect ((gpointer) journalDefaultBackground, "activate", + G_CALLBACK (on_journalDefaultBackground_activate), + NULL); + g_signal_connect ((gpointer) journalSetAsDefault, "activate", + G_CALLBACK (on_journalSetAsDefault_activate), + NULL); + g_signal_connect ((gpointer) toolsPen, "toggled", + G_CALLBACK (on_toolsPen_activate), + NULL); + g_signal_connect ((gpointer) toolsEraser, "toggled", + G_CALLBACK (on_toolsEraser_activate), + NULL); + g_signal_connect ((gpointer) toolsHighlighter, "toggled", + G_CALLBACK (on_toolsHighlighter_activate), + NULL); + g_signal_connect ((gpointer) toolsText, "toggled", + G_CALLBACK (on_toolsText_activate), + NULL); + g_signal_connect ((gpointer) toolsSelectRegion, "toggled", + G_CALLBACK (on_toolsSelectRegion_activate), + NULL); + g_signal_connect ((gpointer) toolsSelectRectangle, "toggled", + G_CALLBACK (on_toolsSelectRectangle_activate), + NULL); + g_signal_connect ((gpointer) toolsVerticalSpace, "toggled", + G_CALLBACK (on_toolsVerticalSpace_activate), + NULL); + g_signal_connect ((gpointer) colorBlack, "toggled", + G_CALLBACK (on_colorBlack_activate), + NULL); + g_signal_connect ((gpointer) colorBlue, "toggled", + G_CALLBACK (on_colorBlue_activate), + NULL); + g_signal_connect ((gpointer) colorRed, "toggled", + G_CALLBACK (on_colorRed_activate), + NULL); + g_signal_connect ((gpointer) colorGreen, "toggled", + G_CALLBACK (on_colorGreen_activate), + NULL); + g_signal_connect ((gpointer) colorGray, "toggled", + G_CALLBACK (on_colorGray_activate), + NULL); + g_signal_connect ((gpointer) colorLightBlue, "toggled", + G_CALLBACK (on_colorLightBlue_activate), + NULL); + g_signal_connect ((gpointer) colorLightGreen, "toggled", + G_CALLBACK (on_colorLightGreen_activate), + NULL); + g_signal_connect ((gpointer) colorMagenta, "toggled", + G_CALLBACK (on_colorMagenta_activate), + NULL); + g_signal_connect ((gpointer) colorOrange, "toggled", + G_CALLBACK (on_colorOrange_activate), + NULL); + g_signal_connect ((gpointer) colorYellow, "toggled", + G_CALLBACK (on_colorYellow_activate), + NULL); + g_signal_connect ((gpointer) colorWhite, "toggled", + G_CALLBACK (on_colorWhite_activate), + NULL); + g_signal_connect ((gpointer) colorOther, "toggled", + G_CALLBACK (on_colorOther_activate), + NULL); + g_signal_connect ((gpointer) penthicknessVeryFine, "toggled", + G_CALLBACK (on_penthicknessVeryFine_activate), + NULL); + g_signal_connect ((gpointer) penthicknessFine, "toggled", + G_CALLBACK (on_penthicknessFine_activate), + NULL); + g_signal_connect ((gpointer) penthicknessMedium, "toggled", + G_CALLBACK (on_penthicknessMedium_activate), + NULL); + g_signal_connect ((gpointer) penthicknessThick, "toggled", + G_CALLBACK (on_penthicknessThick_activate), + NULL); + g_signal_connect ((gpointer) penthicknessVeryThick, "toggled", + G_CALLBACK (on_penthicknessVeryThick_activate), + NULL); + g_signal_connect ((gpointer) eraserFine, "toggled", + G_CALLBACK (on_eraserFine_activate), + NULL); + g_signal_connect ((gpointer) eraserMedium, "toggled", + G_CALLBACK (on_eraserMedium_activate), + NULL); + g_signal_connect ((gpointer) eraserThick, "toggled", + G_CALLBACK (on_eraserThick_activate), + NULL); + g_signal_connect ((gpointer) eraserStandard, "toggled", + G_CALLBACK (on_eraserStandard_activate), + NULL); + g_signal_connect ((gpointer) eraserWhiteout, "toggled", + G_CALLBACK (on_eraserWhiteout_activate), + NULL); + g_signal_connect ((gpointer) eraserDeleteStrokes, "toggled", + G_CALLBACK (on_eraserDeleteStrokes_activate), + NULL); + g_signal_connect ((gpointer) highlighterFine, "toggled", + G_CALLBACK (on_highlighterFine_activate), + NULL); + g_signal_connect ((gpointer) highlighterMedium, "toggled", + G_CALLBACK (on_highlighterMedium_activate), + NULL); + g_signal_connect ((gpointer) highlighterThick, "toggled", + G_CALLBACK (on_highlighterThick_activate), + NULL); + g_signal_connect ((gpointer) toolsTextFont, "activate", + G_CALLBACK (on_toolsTextFont_activate), + NULL); + g_signal_connect ((gpointer) toolsDefaultPen, "activate", + G_CALLBACK (on_toolsDefaultPen_activate), + NULL); + g_signal_connect ((gpointer) toolsDefaultEraser, "activate", + G_CALLBACK (on_toolsDefaultEraser_activate), + NULL); + g_signal_connect ((gpointer) toolsDefaultHighlighter, "activate", + G_CALLBACK (on_toolsDefaultHighlighter_activate), + NULL); + g_signal_connect ((gpointer) toolsDefaultText, "activate", + G_CALLBACK (on_toolsDefaultText_activate), + NULL); + g_signal_connect ((gpointer) toolsSetAsDefault, "activate", + G_CALLBACK (on_toolsSetAsDefault_activate), + NULL); + g_signal_connect ((gpointer) toolsRuler, "toggled", + G_CALLBACK (on_toolsRuler_activate), + NULL); + g_signal_connect ((gpointer) optionsUseXInput, "toggled", + G_CALLBACK (on_optionsUseXInput_activate), + NULL); + g_signal_connect ((gpointer) optionsEmulateEraser, "activate", + G_CALLBACK (on_optionsEmulateEraser_activate), + NULL); + g_signal_connect ((gpointer) optionsAntialiasBG, "activate", + G_CALLBACK (on_optionsAntialiasBG_activate), + NULL); + g_signal_connect ((gpointer) optionsProgressiveBG, "activate", + G_CALLBACK (on_optionsProgressiveBG_activate), + NULL); + g_signal_connect ((gpointer) optionsSavePreferences, "activate", + G_CALLBACK (on_optionsSavePreferences_activate), + NULL); + g_signal_connect ((gpointer) helpIndex, "activate", + G_CALLBACK (on_helpIndex_activate), + NULL); + g_signal_connect ((gpointer) helpAbout, "activate", + G_CALLBACK (on_helpAbout_activate), + NULL); + g_signal_connect ((gpointer) saveButton, "clicked", + G_CALLBACK (on_fileSave_activate), + NULL); + g_signal_connect ((gpointer) buttonCut, "clicked", + G_CALLBACK (on_editCut_activate), + NULL); + g_signal_connect ((gpointer) buttonCopy, "clicked", + G_CALLBACK (on_editCopy_activate), + NULL); + g_signal_connect ((gpointer) buttonPaste, "clicked", + G_CALLBACK (on_editPaste_activate), + NULL); + g_signal_connect ((gpointer) buttonUndo, "clicked", + G_CALLBACK (on_editUndo_activate), + NULL); + g_signal_connect ((gpointer) buttonRedo, "clicked", + G_CALLBACK (on_editRedo_activate), + NULL); + g_signal_connect ((gpointer) buttonFirstPage, "clicked", + G_CALLBACK (on_viewFirstPage_activate), + NULL); + g_signal_connect ((gpointer) buttonPreviousPage, "clicked", + G_CALLBACK (on_viewPreviousPage_activate), + NULL); + g_signal_connect ((gpointer) buttonNextPage, "clicked", + G_CALLBACK (on_viewNextPage_activate), + NULL); + g_signal_connect ((gpointer) buttonLastPage, "clicked", + G_CALLBACK (on_viewLastPage_activate), + NULL); + g_signal_connect ((gpointer) buttonZoomOut, "clicked", + G_CALLBACK (on_viewZoomOut_activate), + NULL); + g_signal_connect ((gpointer) buttonPageWidth, "clicked", + G_CALLBACK (on_viewPageWidth_activate), + NULL); + g_signal_connect ((gpointer) buttonZoomIn, "clicked", + G_CALLBACK (on_viewZoomIn_activate), + NULL); + g_signal_connect ((gpointer) buttonNormalSize, "clicked", + G_CALLBACK (on_viewNormalSize_activate), + NULL); + g_signal_connect ((gpointer) buttonFullscreen, "toggled", + G_CALLBACK (on_viewFullscreen_activate), + NULL); + g_signal_connect ((gpointer) buttonPen, "toggled", + G_CALLBACK (on_toolsPen_activate), + NULL); + g_signal_connect ((gpointer) buttonEraser, "toggled", + G_CALLBACK (on_toolsEraser_activate), + NULL); + g_signal_connect ((gpointer) buttonHighlighter, "toggled", + G_CALLBACK (on_toolsHighlighter_activate), + NULL); + g_signal_connect ((gpointer) buttonText, "toggled", + G_CALLBACK (on_toolsText_activate), + NULL); + g_signal_connect ((gpointer) buttonRuler, "toggled", + G_CALLBACK (on_toolsRuler_activate), + NULL); + g_signal_connect ((gpointer) buttonSelectRegion, "toggled", + G_CALLBACK (on_toolsSelectRegion_activate), + NULL); + g_signal_connect ((gpointer) buttonSelectRectangle, "toggled", + G_CALLBACK (on_toolsSelectRectangle_activate), + NULL); + g_signal_connect ((gpointer) buttonVerticalSpace, "toggled", + G_CALLBACK (on_toolsVerticalSpace_activate), + NULL); + g_signal_connect ((gpointer) buttonToolDefault, "clicked", + G_CALLBACK (on_buttonToolDefault_clicked), + NULL); + g_signal_connect ((gpointer) buttonDefaultPen, "clicked", + G_CALLBACK (on_toolsDefaultPen_activate), + NULL); + g_signal_connect ((gpointer) buttonFine, "toggled", + G_CALLBACK (on_buttonFine_clicked), + NULL); + g_signal_connect ((gpointer) buttonMedium, "toggled", + G_CALLBACK (on_buttonMedium_clicked), + NULL); + g_signal_connect ((gpointer) buttonThick, "toggled", + G_CALLBACK (on_buttonThick_clicked), + NULL); + g_signal_connect ((gpointer) buttonBlack, "toggled", + G_CALLBACK (on_colorBlack_activate), + NULL); + g_signal_connect ((gpointer) buttonBlue, "toggled", + G_CALLBACK (on_colorBlue_activate), + NULL); + g_signal_connect ((gpointer) buttonRed, "toggled", + G_CALLBACK (on_colorRed_activate), + NULL); + g_signal_connect ((gpointer) buttonGreen, "toggled", + G_CALLBACK (on_colorGreen_activate), + NULL); + g_signal_connect ((gpointer) buttonGray, "toggled", + G_CALLBACK (on_colorGray_activate), + NULL); + g_signal_connect ((gpointer) buttonLightBlue, "toggled", + G_CALLBACK (on_colorLightBlue_activate), + NULL); + g_signal_connect ((gpointer) buttonLightGreen, "toggled", + G_CALLBACK (on_colorLightGreen_activate), + NULL); + g_signal_connect ((gpointer) buttonMagenta, "toggled", + G_CALLBACK (on_colorMagenta_activate), + NULL); + g_signal_connect ((gpointer) buttonOrange, "toggled", + G_CALLBACK (on_colorOrange_activate), + NULL); + g_signal_connect ((gpointer) buttonYellow, "toggled", + G_CALLBACK (on_colorYellow_activate), + NULL); + g_signal_connect ((gpointer) buttonWhite, "toggled", + G_CALLBACK (on_colorWhite_activate), + NULL); + g_signal_connect ((gpointer) spinPageNo, "value_changed", + G_CALLBACK (on_spinPageNo_value_changed), + NULL); + g_signal_connect ((gpointer) comboLayer, "changed", + G_CALLBACK (on_comboLayer_changed), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (winMain, winMain, "winMain"); + GLADE_HOOKUP_OBJECT (winMain, vboxMain, "vboxMain"); + GLADE_HOOKUP_OBJECT (winMain, menubar, "menubar"); + GLADE_HOOKUP_OBJECT (winMain, menuFile, "menuFile"); + GLADE_HOOKUP_OBJECT (winMain, menuFile_menu, "menuFile_menu"); + GLADE_HOOKUP_OBJECT (winMain, fileNew, "fileNew"); + GLADE_HOOKUP_OBJECT (winMain, fileNewBackground, "fileNewBackground"); + GLADE_HOOKUP_OBJECT (winMain, image500, "image500"); + GLADE_HOOKUP_OBJECT (winMain, fileOpen, "fileOpen"); + GLADE_HOOKUP_OBJECT (winMain, fileSave, "fileSave"); + GLADE_HOOKUP_OBJECT (winMain, fileSaveAs, "fileSaveAs"); + GLADE_HOOKUP_OBJECT (winMain, separator1, "separator1"); + GLADE_HOOKUP_OBJECT (winMain, filePrintOptions, "filePrintOptions"); + GLADE_HOOKUP_OBJECT (winMain, image501, "image501"); + GLADE_HOOKUP_OBJECT (winMain, filePrint, "filePrint"); + GLADE_HOOKUP_OBJECT (winMain, filePrintPDF, "filePrintPDF"); + GLADE_HOOKUP_OBJECT (winMain, separator2, "separator2"); + GLADE_HOOKUP_OBJECT (winMain, fileQuit, "fileQuit"); + GLADE_HOOKUP_OBJECT (winMain, menuEdit, "menuEdit"); + GLADE_HOOKUP_OBJECT (winMain, menuEdit_menu, "menuEdit_menu"); + GLADE_HOOKUP_OBJECT (winMain, editUndo, "editUndo"); + GLADE_HOOKUP_OBJECT (winMain, editRedo, "editRedo"); + GLADE_HOOKUP_OBJECT (winMain, separator3, "separator3"); + GLADE_HOOKUP_OBJECT (winMain, editCut, "editCut"); + GLADE_HOOKUP_OBJECT (winMain, editCopy, "editCopy"); + GLADE_HOOKUP_OBJECT (winMain, editPaste, "editPaste"); + GLADE_HOOKUP_OBJECT (winMain, editDelete, "editDelete"); + GLADE_HOOKUP_OBJECT (winMain, menuView, "menuView"); + GLADE_HOOKUP_OBJECT (winMain, menuView_menu, "menuView_menu"); + GLADE_HOOKUP_OBJECT (winMain, viewContinuous, "viewContinuous"); + GLADE_HOOKUP_OBJECT (winMain, viewOnePage, "viewOnePage"); + GLADE_HOOKUP_OBJECT (winMain, separator20, "separator20"); + GLADE_HOOKUP_OBJECT (winMain, viewFullscreen, "viewFullscreen"); + GLADE_HOOKUP_OBJECT (winMain, separator4, "separator4"); + GLADE_HOOKUP_OBJECT (winMain, viewZoomIn, "viewZoomIn"); + GLADE_HOOKUP_OBJECT (winMain, viewZoomOut, "viewZoomOut"); + GLADE_HOOKUP_OBJECT (winMain, viewNormalSize, "viewNormalSize"); + GLADE_HOOKUP_OBJECT (winMain, viewPageWidth, "viewPageWidth"); + GLADE_HOOKUP_OBJECT (winMain, image502, "image502"); + GLADE_HOOKUP_OBJECT (winMain, separator5, "separator5"); + GLADE_HOOKUP_OBJECT (winMain, viewFirstPage, "viewFirstPage"); + GLADE_HOOKUP_OBJECT (winMain, image503, "image503"); + GLADE_HOOKUP_OBJECT (winMain, viewPreviousPage, "viewPreviousPage"); + GLADE_HOOKUP_OBJECT (winMain, image504, "image504"); + GLADE_HOOKUP_OBJECT (winMain, viewNextPage, "viewNextPage"); + GLADE_HOOKUP_OBJECT (winMain, image505, "image505"); + GLADE_HOOKUP_OBJECT (winMain, viewLastPage, "viewLastPage"); + GLADE_HOOKUP_OBJECT (winMain, image506, "image506"); + GLADE_HOOKUP_OBJECT (winMain, separator6, "separator6"); + GLADE_HOOKUP_OBJECT (winMain, viewShowLayer, "viewShowLayer"); + GLADE_HOOKUP_OBJECT (winMain, image507, "image507"); + GLADE_HOOKUP_OBJECT (winMain, viewHideLayer, "viewHideLayer"); + GLADE_HOOKUP_OBJECT (winMain, image508, "image508"); + GLADE_HOOKUP_OBJECT (winMain, menuJournal, "menuJournal"); + GLADE_HOOKUP_OBJECT (winMain, menuJournal_menu, "menuJournal_menu"); + GLADE_HOOKUP_OBJECT (winMain, journalNewPageBefore, "journalNewPageBefore"); + GLADE_HOOKUP_OBJECT (winMain, journalNewPageAfter, "journalNewPageAfter"); + GLADE_HOOKUP_OBJECT (winMain, journalNewPageEnd, "journalNewPageEnd"); + GLADE_HOOKUP_OBJECT (winMain, journalDeletePage, "journalDeletePage"); + GLADE_HOOKUP_OBJECT (winMain, separator7, "separator7"); + GLADE_HOOKUP_OBJECT (winMain, journalNewLayer, "journalNewLayer"); + GLADE_HOOKUP_OBJECT (winMain, journalDeleteLayer, "journalDeleteLayer"); + GLADE_HOOKUP_OBJECT (winMain, journalFlatten, "journalFlatten"); + GLADE_HOOKUP_OBJECT (winMain, separator8, "separator8"); + GLADE_HOOKUP_OBJECT (winMain, journalPaperSize, "journalPaperSize"); + GLADE_HOOKUP_OBJECT (winMain, journalPaperColor, "journalPaperColor"); + GLADE_HOOKUP_OBJECT (winMain, journalPaperColor_menu, "journalPaperColor_menu"); + GLADE_HOOKUP_OBJECT (winMain, papercolorWhite, "papercolorWhite"); + GLADE_HOOKUP_OBJECT (winMain, papercolorYellow, "papercolorYellow"); + GLADE_HOOKUP_OBJECT (winMain, papercolorPink, "papercolorPink"); + GLADE_HOOKUP_OBJECT (winMain, papercolorOrange, "papercolorOrange"); + GLADE_HOOKUP_OBJECT (winMain, papercolorBlue, "papercolorBlue"); + GLADE_HOOKUP_OBJECT (winMain, papercolorGreen, "papercolorGreen"); + GLADE_HOOKUP_OBJECT (winMain, papercolorOther, "papercolorOther"); + GLADE_HOOKUP_OBJECT (winMain, papercolorNA, "papercolorNA"); + GLADE_HOOKUP_OBJECT (winMain, journalPaperStyle, "journalPaperStyle"); + GLADE_HOOKUP_OBJECT (winMain, journalPaperStyle_menu, "journalPaperStyle_menu"); + GLADE_HOOKUP_OBJECT (winMain, paperstylePlain, "paperstylePlain"); + GLADE_HOOKUP_OBJECT (winMain, paperstyleLined, "paperstyleLined"); + GLADE_HOOKUP_OBJECT (winMain, paperstyleRuled, "paperstyleRuled"); + GLADE_HOOKUP_OBJECT (winMain, paperstyleGraph, "paperstyleGraph"); + GLADE_HOOKUP_OBJECT (winMain, paperstyleNA, "paperstyleNA"); + GLADE_HOOKUP_OBJECT (winMain, journalLoadBackground, "journalLoadBackground"); + GLADE_HOOKUP_OBJECT (winMain, image509, "image509"); + GLADE_HOOKUP_OBJECT (winMain, journalScreenshot, "journalScreenshot"); + GLADE_HOOKUP_OBJECT (winMain, journalApplyAllPages, "journalApplyAllPages"); + GLADE_HOOKUP_OBJECT (winMain, separator19, "separator19"); + GLADE_HOOKUP_OBJECT (winMain, journalDefaultBackground, "journalDefaultBackground"); + GLADE_HOOKUP_OBJECT (winMain, journalSetAsDefault, "journalSetAsDefault"); + GLADE_HOOKUP_OBJECT (winMain, menuTools, "menuTools"); + GLADE_HOOKUP_OBJECT (winMain, menuTools_menu, "menuTools_menu"); + GLADE_HOOKUP_OBJECT (winMain, toolsPen, "toolsPen"); + GLADE_HOOKUP_OBJECT (winMain, toolsEraser, "toolsEraser"); + GLADE_HOOKUP_OBJECT (winMain, toolsHighlighter, "toolsHighlighter"); + GLADE_HOOKUP_OBJECT (winMain, toolsText, "toolsText"); + GLADE_HOOKUP_OBJECT (winMain, separator9, "separator9"); + GLADE_HOOKUP_OBJECT (winMain, toolsSelectRegion, "toolsSelectRegion"); + GLADE_HOOKUP_OBJECT (winMain, toolsSelectRectangle, "toolsSelectRectangle"); + GLADE_HOOKUP_OBJECT (winMain, toolsVerticalSpace, "toolsVerticalSpace"); + GLADE_HOOKUP_OBJECT (winMain, separator16, "separator16"); + GLADE_HOOKUP_OBJECT (winMain, toolsColor, "toolsColor"); + GLADE_HOOKUP_OBJECT (winMain, image510, "image510"); + GLADE_HOOKUP_OBJECT (winMain, toolsColor_menu, "toolsColor_menu"); + GLADE_HOOKUP_OBJECT (winMain, colorBlack, "colorBlack"); + GLADE_HOOKUP_OBJECT (winMain, colorBlue, "colorBlue"); + GLADE_HOOKUP_OBJECT (winMain, colorRed, "colorRed"); + GLADE_HOOKUP_OBJECT (winMain, colorGreen, "colorGreen"); + GLADE_HOOKUP_OBJECT (winMain, colorGray, "colorGray"); + GLADE_HOOKUP_OBJECT (winMain, separator17, "separator17"); + GLADE_HOOKUP_OBJECT (winMain, colorLightBlue, "colorLightBlue"); + GLADE_HOOKUP_OBJECT (winMain, colorLightGreen, "colorLightGreen"); + GLADE_HOOKUP_OBJECT (winMain, colorMagenta, "colorMagenta"); + GLADE_HOOKUP_OBJECT (winMain, colorOrange, "colorOrange"); + GLADE_HOOKUP_OBJECT (winMain, colorYellow, "colorYellow"); + GLADE_HOOKUP_OBJECT (winMain, colorWhite, "colorWhite"); + GLADE_HOOKUP_OBJECT (winMain, colorOther, "colorOther"); + GLADE_HOOKUP_OBJECT (winMain, colorNA, "colorNA"); + GLADE_HOOKUP_OBJECT (winMain, toolsPenOptions, "toolsPenOptions"); + GLADE_HOOKUP_OBJECT (winMain, toolsPenOptions_menu, "toolsPenOptions_menu"); + GLADE_HOOKUP_OBJECT (winMain, penthicknessVeryFine, "penthicknessVeryFine"); + GLADE_HOOKUP_OBJECT (winMain, penthicknessFine, "penthicknessFine"); + GLADE_HOOKUP_OBJECT (winMain, penthicknessMedium, "penthicknessMedium"); + GLADE_HOOKUP_OBJECT (winMain, penthicknessThick, "penthicknessThick"); + GLADE_HOOKUP_OBJECT (winMain, penthicknessVeryThick, "penthicknessVeryThick"); + GLADE_HOOKUP_OBJECT (winMain, toolsEraserOptions, "toolsEraserOptions"); + GLADE_HOOKUP_OBJECT (winMain, toolsEraserOptions_menu, "toolsEraserOptions_menu"); + GLADE_HOOKUP_OBJECT (winMain, eraserFine, "eraserFine"); + GLADE_HOOKUP_OBJECT (winMain, eraserMedium, "eraserMedium"); + GLADE_HOOKUP_OBJECT (winMain, eraserThick, "eraserThick"); + GLADE_HOOKUP_OBJECT (winMain, separator14, "separator14"); + GLADE_HOOKUP_OBJECT (winMain, eraserStandard, "eraserStandard"); + GLADE_HOOKUP_OBJECT (winMain, eraserWhiteout, "eraserWhiteout"); + GLADE_HOOKUP_OBJECT (winMain, eraserDeleteStrokes, "eraserDeleteStrokes"); + GLADE_HOOKUP_OBJECT (winMain, toolsHighlighterOptions, "toolsHighlighterOptions"); + GLADE_HOOKUP_OBJECT (winMain, toolsHighlighterOptions_menu, "toolsHighlighterOptions_menu"); + GLADE_HOOKUP_OBJECT (winMain, highlighterFine, "highlighterFine"); + GLADE_HOOKUP_OBJECT (winMain, highlighterMedium, "highlighterMedium"); + GLADE_HOOKUP_OBJECT (winMain, highlighterThick, "highlighterThick"); + GLADE_HOOKUP_OBJECT (winMain, toolsTextFont, "toolsTextFont"); + GLADE_HOOKUP_OBJECT (winMain, image511, "image511"); + GLADE_HOOKUP_OBJECT (winMain, separator10, "separator10"); + GLADE_HOOKUP_OBJECT (winMain, toolsDefaultPen, "toolsDefaultPen"); + GLADE_HOOKUP_OBJECT (winMain, toolsDefaultEraser, "toolsDefaultEraser"); + GLADE_HOOKUP_OBJECT (winMain, toolsDefaultHighlighter, "toolsDefaultHighlighter"); + GLADE_HOOKUP_OBJECT (winMain, toolsDefaultText, "toolsDefaultText"); + GLADE_HOOKUP_OBJECT (winMain, toolsSetAsDefault, "toolsSetAsDefault"); + GLADE_HOOKUP_OBJECT (winMain, separator15, "separator15"); + GLADE_HOOKUP_OBJECT (winMain, toolsRuler, "toolsRuler"); + GLADE_HOOKUP_OBJECT (winMain, menuOptions, "menuOptions"); + GLADE_HOOKUP_OBJECT (winMain, menuOptions_menu, "menuOptions_menu"); + GLADE_HOOKUP_OBJECT (winMain, optionsUseXInput, "optionsUseXInput"); + GLADE_HOOKUP_OBJECT (winMain, optionsEmulateEraser, "optionsEmulateEraser"); + GLADE_HOOKUP_OBJECT (winMain, separator18, "separator18"); + GLADE_HOOKUP_OBJECT (winMain, optionsAntialiasBG, "optionsAntialiasBG"); + GLADE_HOOKUP_OBJECT (winMain, optionsProgressiveBG, "optionsProgressiveBG"); + GLADE_HOOKUP_OBJECT (winMain, separator21, "separator21"); + GLADE_HOOKUP_OBJECT (winMain, optionsSavePreferences, "optionsSavePreferences"); + GLADE_HOOKUP_OBJECT (winMain, menuHelp, "menuHelp"); + GLADE_HOOKUP_OBJECT (winMain, menuHelp_menu, "menuHelp_menu"); + GLADE_HOOKUP_OBJECT (winMain, helpIndex, "helpIndex"); + GLADE_HOOKUP_OBJECT (winMain, helpAbout, "helpAbout"); + GLADE_HOOKUP_OBJECT (winMain, toolbarMain, "toolbarMain"); + GLADE_HOOKUP_OBJECT (winMain, saveButton, "saveButton"); + GLADE_HOOKUP_OBJECT (winMain, toolitem11, "toolitem11"); + GLADE_HOOKUP_OBJECT (winMain, vseparator1, "vseparator1"); + GLADE_HOOKUP_OBJECT (winMain, buttonCut, "buttonCut"); + GLADE_HOOKUP_OBJECT (winMain, buttonCopy, "buttonCopy"); + GLADE_HOOKUP_OBJECT (winMain, buttonPaste, "buttonPaste"); + GLADE_HOOKUP_OBJECT (winMain, toolitem12, "toolitem12"); + GLADE_HOOKUP_OBJECT (winMain, vseparator2, "vseparator2"); + GLADE_HOOKUP_OBJECT (winMain, buttonUndo, "buttonUndo"); + GLADE_HOOKUP_OBJECT (winMain, buttonRedo, "buttonRedo"); + GLADE_HOOKUP_OBJECT (winMain, toolitem13, "toolitem13"); + GLADE_HOOKUP_OBJECT (winMain, vseparator3, "vseparator3"); + GLADE_HOOKUP_OBJECT (winMain, buttonFirstPage, "buttonFirstPage"); + GLADE_HOOKUP_OBJECT (winMain, buttonPreviousPage, "buttonPreviousPage"); + GLADE_HOOKUP_OBJECT (winMain, buttonNextPage, "buttonNextPage"); + GLADE_HOOKUP_OBJECT (winMain, buttonLastPage, "buttonLastPage"); + GLADE_HOOKUP_OBJECT (winMain, toolitem14, "toolitem14"); + GLADE_HOOKUP_OBJECT (winMain, vseparator4, "vseparator4"); + GLADE_HOOKUP_OBJECT (winMain, buttonZoomOut, "buttonZoomOut"); + GLADE_HOOKUP_OBJECT (winMain, buttonPageWidth, "buttonPageWidth"); + GLADE_HOOKUP_OBJECT (winMain, buttonZoomIn, "buttonZoomIn"); + GLADE_HOOKUP_OBJECT (winMain, buttonNormalSize, "buttonNormalSize"); + GLADE_HOOKUP_OBJECT (winMain, buttonFullscreen, "buttonFullscreen"); + GLADE_HOOKUP_OBJECT (winMain, toolbarPen, "toolbarPen"); + GLADE_HOOKUP_OBJECT (winMain, buttonPen, "buttonPen"); + GLADE_HOOKUP_OBJECT (winMain, buttonEraser, "buttonEraser"); + GLADE_HOOKUP_OBJECT (winMain, buttonHighlighter, "buttonHighlighter"); + GLADE_HOOKUP_OBJECT (winMain, buttonText, "buttonText"); + GLADE_HOOKUP_OBJECT (winMain, buttonRuler, "buttonRuler"); + GLADE_HOOKUP_OBJECT (winMain, toolitem15, "toolitem15"); + GLADE_HOOKUP_OBJECT (winMain, vseparator5, "vseparator5"); + GLADE_HOOKUP_OBJECT (winMain, buttonSelectRegion, "buttonSelectRegion"); + GLADE_HOOKUP_OBJECT (winMain, buttonSelectRectangle, "buttonSelectRectangle"); + GLADE_HOOKUP_OBJECT (winMain, buttonVerticalSpace, "buttonVerticalSpace"); + GLADE_HOOKUP_OBJECT (winMain, toolitem16, "toolitem16"); + GLADE_HOOKUP_OBJECT (winMain, vseparator6, "vseparator6"); + GLADE_HOOKUP_OBJECT (winMain, buttonToolDefault, "buttonToolDefault"); + GLADE_HOOKUP_OBJECT (winMain, buttonDefaultPen, "buttonDefaultPen"); + GLADE_HOOKUP_OBJECT (winMain, toolitem18, "toolitem18"); + GLADE_HOOKUP_OBJECT (winMain, vseparator8, "vseparator8"); + GLADE_HOOKUP_OBJECT (winMain, buttonFine, "buttonFine"); + GLADE_HOOKUP_OBJECT (winMain, buttonMedium, "buttonMedium"); + GLADE_HOOKUP_OBJECT (winMain, buttonThick, "buttonThick"); + GLADE_HOOKUP_OBJECT (winMain, buttonThicknessOther, "buttonThicknessOther"); + GLADE_HOOKUP_OBJECT (winMain, toolitem17, "toolitem17"); + GLADE_HOOKUP_OBJECT (winMain, vseparator7, "vseparator7"); + GLADE_HOOKUP_OBJECT (winMain, buttonBlack, "buttonBlack"); + GLADE_HOOKUP_OBJECT (winMain, buttonBlue, "buttonBlue"); + GLADE_HOOKUP_OBJECT (winMain, buttonRed, "buttonRed"); + GLADE_HOOKUP_OBJECT (winMain, buttonGreen, "buttonGreen"); + GLADE_HOOKUP_OBJECT (winMain, buttonGray, "buttonGray"); + GLADE_HOOKUP_OBJECT (winMain, buttonLightBlue, "buttonLightBlue"); + GLADE_HOOKUP_OBJECT (winMain, buttonLightGreen, "buttonLightGreen"); + GLADE_HOOKUP_OBJECT (winMain, buttonMagenta, "buttonMagenta"); + GLADE_HOOKUP_OBJECT (winMain, buttonOrange, "buttonOrange"); + GLADE_HOOKUP_OBJECT (winMain, buttonYellow, "buttonYellow"); + GLADE_HOOKUP_OBJECT (winMain, buttonWhite, "buttonWhite"); + GLADE_HOOKUP_OBJECT (winMain, buttonColorOther, "buttonColorOther"); + GLADE_HOOKUP_OBJECT (winMain, scrolledwindowMain, "scrolledwindowMain"); + GLADE_HOOKUP_OBJECT (winMain, hbox1, "hbox1"); + GLADE_HOOKUP_OBJECT (winMain, labelPage, "labelPage"); + GLADE_HOOKUP_OBJECT (winMain, spinPageNo, "spinPageNo"); + GLADE_HOOKUP_OBJECT (winMain, labelNumpages, "labelNumpages"); + GLADE_HOOKUP_OBJECT (winMain, vseparator9, "vseparator9"); + GLADE_HOOKUP_OBJECT (winMain, labelLayer, "labelLayer"); + GLADE_HOOKUP_OBJECT (winMain, comboLayer, "comboLayer"); + GLADE_HOOKUP_OBJECT (winMain, statusbar, "statusbar"); + GLADE_HOOKUP_OBJECT_NO_REF (winMain, tooltips, "tooltips"); + + gtk_window_add_accel_group (GTK_WINDOW (winMain), accel_group); + + return winMain; +} + +GtkWidget* +create_fontDialog (void) +{ + GtkWidget *fontDialog; + GtkWidget *ok_button1; + GtkWidget *cancel_button1; + GtkWidget *apply_button1; + GtkWidget *font_selection1; + + fontDialog = gtk_font_selection_dialog_new ("Select Font"); + gtk_container_set_border_width (GTK_CONTAINER (fontDialog), 4); + gtk_window_set_type_hint (GTK_WINDOW (fontDialog), GDK_WINDOW_TYPE_HINT_DIALOG); + + ok_button1 = GTK_FONT_SELECTION_DIALOG (fontDialog)->ok_button; + gtk_widget_show (ok_button1); + GTK_WIDGET_SET_FLAGS (ok_button1, GTK_CAN_DEFAULT); + + cancel_button1 = GTK_FONT_SELECTION_DIALOG (fontDialog)->cancel_button; + gtk_widget_show (cancel_button1); + GTK_WIDGET_SET_FLAGS (cancel_button1, GTK_CAN_DEFAULT); + + apply_button1 = GTK_FONT_SELECTION_DIALOG (fontDialog)->apply_button; + gtk_widget_show (apply_button1); + GTK_WIDGET_SET_FLAGS (apply_button1, GTK_CAN_DEFAULT); + + font_selection1 = GTK_FONT_SELECTION_DIALOG (fontDialog)->fontsel; + gtk_widget_show (font_selection1); + gtk_container_set_border_width (GTK_CONTAINER (font_selection1), 4); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (fontDialog, fontDialog, "fontDialog"); + GLADE_HOOKUP_OBJECT_NO_REF (fontDialog, ok_button1, "ok_button1"); + GLADE_HOOKUP_OBJECT_NO_REF (fontDialog, cancel_button1, "cancel_button1"); + GLADE_HOOKUP_OBJECT_NO_REF (fontDialog, apply_button1, "apply_button1"); + GLADE_HOOKUP_OBJECT_NO_REF (fontDialog, font_selection1, "font_selection1"); + + return fontDialog; +} + +GtkWidget* +create_colorChooserDialog (void) +{ + GtkWidget *colorChooserDialog; + GtkWidget *ok_button2; + GtkWidget *cancel_button2; + GtkWidget *help_button1; + GtkWidget *color_selection1; + + colorChooserDialog = gtk_color_selection_dialog_new ("Select Color"); + gtk_window_set_resizable (GTK_WINDOW (colorChooserDialog), FALSE); + gtk_window_set_type_hint (GTK_WINDOW (colorChooserDialog), GDK_WINDOW_TYPE_HINT_DIALOG); + + ok_button2 = GTK_COLOR_SELECTION_DIALOG (colorChooserDialog)->ok_button; + gtk_widget_show (ok_button2); + GTK_WIDGET_SET_FLAGS (ok_button2, GTK_CAN_DEFAULT); + + cancel_button2 = GTK_COLOR_SELECTION_DIALOG (colorChooserDialog)->cancel_button; + gtk_widget_show (cancel_button2); + GTK_WIDGET_SET_FLAGS (cancel_button2, GTK_CAN_DEFAULT); + + help_button1 = GTK_COLOR_SELECTION_DIALOG (colorChooserDialog)->help_button; + gtk_widget_show (help_button1); + GTK_WIDGET_SET_FLAGS (help_button1, GTK_CAN_DEFAULT); + + color_selection1 = GTK_COLOR_SELECTION_DIALOG (colorChooserDialog)->colorsel; + gtk_widget_show (color_selection1); + gtk_color_selection_set_has_opacity_control (GTK_COLOR_SELECTION (color_selection1), FALSE); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (colorChooserDialog, colorChooserDialog, "colorChooserDialog"); + GLADE_HOOKUP_OBJECT_NO_REF (colorChooserDialog, ok_button2, "ok_button2"); + GLADE_HOOKUP_OBJECT_NO_REF (colorChooserDialog, cancel_button2, "cancel_button2"); + GLADE_HOOKUP_OBJECT_NO_REF (colorChooserDialog, help_button1, "help_button1"); + GLADE_HOOKUP_OBJECT_NO_REF (colorChooserDialog, color_selection1, "color_selection1"); + + return colorChooserDialog; +} + +GtkWidget* +create_papersizeDialog (void) +{ + GtkWidget *papersizeDialog; + GtkWidget *dialog_vbox1; + GtkWidget *hbox2; + GtkWidget *labelStdSizes; + GtkWidget *comboStdSizes; + GtkWidget *hbox3; + GtkWidget *labelWidth; + GtkWidget *entryWidth; + GtkWidget *labelHeight; + GtkWidget *entryHeight; + GtkWidget *comboUnit; + GtkWidget *dialog_action_area1; + GtkWidget *cancelbutton1; + GtkWidget *okbutton1; + + papersizeDialog = gtk_dialog_new (); + gtk_window_set_title (GTK_WINDOW (papersizeDialog), "Set Paper Size"); + gtk_window_set_modal (GTK_WINDOW (papersizeDialog), TRUE); + gtk_window_set_resizable (GTK_WINDOW (papersizeDialog), FALSE); + gtk_window_set_type_hint (GTK_WINDOW (papersizeDialog), GDK_WINDOW_TYPE_HINT_DIALOG); + + dialog_vbox1 = GTK_DIALOG (papersizeDialog)->vbox; + gtk_widget_show (dialog_vbox1); + + hbox2 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox2); + gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox2, TRUE, TRUE, 10); + + labelStdSizes = gtk_label_new ("Standard paper sizes:"); + gtk_widget_show (labelStdSizes); + gtk_box_pack_start (GTK_BOX (hbox2), labelStdSizes, FALSE, FALSE, 0); + gtk_misc_set_padding (GTK_MISC (labelStdSizes), 10, 0); + + comboStdSizes = gtk_combo_box_new_text (); + gtk_widget_show (comboStdSizes); + gtk_box_pack_start (GTK_BOX (hbox2), comboStdSizes, TRUE, TRUE, 5); + gtk_combo_box_append_text (GTK_COMBO_BOX (comboStdSizes), "A4"); + gtk_combo_box_append_text (GTK_COMBO_BOX (comboStdSizes), "A4 (landscape)"); + gtk_combo_box_append_text (GTK_COMBO_BOX (comboStdSizes), "US Letter"); + gtk_combo_box_append_text (GTK_COMBO_BOX (comboStdSizes), "US Letter (landscape)"); + gtk_combo_box_append_text (GTK_COMBO_BOX (comboStdSizes), "Custom"); + + hbox3 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox3); + gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox3, TRUE, TRUE, 8); + + labelWidth = gtk_label_new ("Width:"); + gtk_widget_show (labelWidth); + gtk_box_pack_start (GTK_BOX (hbox3), labelWidth, FALSE, FALSE, 10); + + entryWidth = gtk_entry_new (); + gtk_widget_show (entryWidth); + gtk_box_pack_start (GTK_BOX (hbox3), entryWidth, TRUE, TRUE, 0); + gtk_entry_set_width_chars (GTK_ENTRY (entryWidth), 5); + + labelHeight = gtk_label_new ("Height:"); + gtk_widget_show (labelHeight); + gtk_box_pack_start (GTK_BOX (hbox3), labelHeight, FALSE, FALSE, 10); + + entryHeight = gtk_entry_new (); + gtk_widget_show (entryHeight); + gtk_box_pack_start (GTK_BOX (hbox3), entryHeight, TRUE, TRUE, 0); + gtk_entry_set_width_chars (GTK_ENTRY (entryHeight), 5); + + comboUnit = gtk_combo_box_new_text (); + gtk_widget_show (comboUnit); + gtk_box_pack_start (GTK_BOX (hbox3), comboUnit, FALSE, TRUE, 8); + gtk_combo_box_append_text (GTK_COMBO_BOX (comboUnit), "cm"); + gtk_combo_box_append_text (GTK_COMBO_BOX (comboUnit), "in"); + gtk_combo_box_append_text (GTK_COMBO_BOX (comboUnit), "pixels"); + gtk_combo_box_append_text (GTK_COMBO_BOX (comboUnit), "points"); + + dialog_action_area1 = GTK_DIALOG (papersizeDialog)->action_area; + gtk_widget_show (dialog_action_area1); + gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); + + cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); + gtk_widget_show (cancelbutton1); + gtk_dialog_add_action_widget (GTK_DIALOG (papersizeDialog), cancelbutton1, GTK_RESPONSE_CANCEL); + GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); + + okbutton1 = gtk_button_new_from_stock ("gtk-ok"); + gtk_widget_show (okbutton1); + gtk_dialog_add_action_widget (GTK_DIALOG (papersizeDialog), okbutton1, GTK_RESPONSE_OK); + GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); + + g_signal_connect ((gpointer) comboStdSizes, "changed", + G_CALLBACK (on_comboStdSizes_changed), + NULL); + g_signal_connect ((gpointer) entryWidth, "changed", + G_CALLBACK (on_entryWidth_changed), + NULL); + g_signal_connect ((gpointer) entryHeight, "changed", + G_CALLBACK (on_entryHeight_changed), + NULL); + g_signal_connect ((gpointer) comboUnit, "changed", + G_CALLBACK (on_comboUnit_changed), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (papersizeDialog, papersizeDialog, "papersizeDialog"); + GLADE_HOOKUP_OBJECT_NO_REF (papersizeDialog, dialog_vbox1, "dialog_vbox1"); + GLADE_HOOKUP_OBJECT (papersizeDialog, hbox2, "hbox2"); + GLADE_HOOKUP_OBJECT (papersizeDialog, labelStdSizes, "labelStdSizes"); + GLADE_HOOKUP_OBJECT (papersizeDialog, comboStdSizes, "comboStdSizes"); + GLADE_HOOKUP_OBJECT (papersizeDialog, hbox3, "hbox3"); + GLADE_HOOKUP_OBJECT (papersizeDialog, labelWidth, "labelWidth"); + GLADE_HOOKUP_OBJECT (papersizeDialog, entryWidth, "entryWidth"); + GLADE_HOOKUP_OBJECT (papersizeDialog, labelHeight, "labelHeight"); + GLADE_HOOKUP_OBJECT (papersizeDialog, entryHeight, "entryHeight"); + GLADE_HOOKUP_OBJECT (papersizeDialog, comboUnit, "comboUnit"); + GLADE_HOOKUP_OBJECT_NO_REF (papersizeDialog, dialog_action_area1, "dialog_action_area1"); + GLADE_HOOKUP_OBJECT (papersizeDialog, cancelbutton1, "cancelbutton1"); + GLADE_HOOKUP_OBJECT (papersizeDialog, okbutton1, "okbutton1"); + + return papersizeDialog; +} + +GtkWidget* +create_aboutDialog (void) +{ + GtkWidget *aboutDialog; + GtkWidget *dialog_vbox2; + GtkWidget *image387; + GtkWidget *labelTitle; + GtkWidget *labelInfo; + GtkWidget *dialog_action_area2; + GtkWidget *closebutton1; + + aboutDialog = gtk_dialog_new (); + gtk_window_set_title (GTK_WINDOW (aboutDialog), "About Xournal"); + gtk_window_set_resizable (GTK_WINDOW (aboutDialog), FALSE); + gtk_window_set_type_hint (GTK_WINDOW (aboutDialog), GDK_WINDOW_TYPE_HINT_DIALOG); + + dialog_vbox2 = GTK_DIALOG (aboutDialog)->vbox; + gtk_widget_show (dialog_vbox2); + + image387 = create_pixmap (aboutDialog, "notepad.png"); + gtk_widget_show (image387); + gtk_box_pack_start (GTK_BOX (dialog_vbox2), image387, FALSE, TRUE, 12); + + labelTitle = gtk_label_new ("Xournal"); + gtk_widget_show (labelTitle); + gtk_box_pack_start (GTK_BOX (dialog_vbox2), labelTitle, FALSE, FALSE, 3); + gtk_label_set_justify (GTK_LABEL (labelTitle), GTK_JUSTIFY_CENTER); + + labelInfo = gtk_label_new ("Written by Denis Auroux\nhttp://math.mit.edu/~auroux/software/xournal/"); + gtk_widget_show (labelInfo); + gtk_box_pack_start (GTK_BOX (dialog_vbox2), labelInfo, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (labelInfo), GTK_JUSTIFY_CENTER); + gtk_misc_set_padding (GTK_MISC (labelInfo), 20, 10); + + dialog_action_area2 = GTK_DIALOG (aboutDialog)->action_area; + gtk_widget_show (dialog_action_area2); + gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area2), GTK_BUTTONBOX_END); + + closebutton1 = gtk_button_new_from_stock ("gtk-close"); + gtk_widget_show (closebutton1); + gtk_dialog_add_action_widget (GTK_DIALOG (aboutDialog), closebutton1, GTK_RESPONSE_CLOSE); + GTK_WIDGET_SET_FLAGS (closebutton1, GTK_CAN_DEFAULT); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (aboutDialog, aboutDialog, "aboutDialog"); + GLADE_HOOKUP_OBJECT_NO_REF (aboutDialog, dialog_vbox2, "dialog_vbox2"); + GLADE_HOOKUP_OBJECT (aboutDialog, image387, "image387"); + GLADE_HOOKUP_OBJECT (aboutDialog, labelTitle, "labelTitle"); + GLADE_HOOKUP_OBJECT (aboutDialog, labelInfo, "labelInfo"); + GLADE_HOOKUP_OBJECT_NO_REF (aboutDialog, dialog_action_area2, "dialog_action_area2"); + GLADE_HOOKUP_OBJECT (aboutDialog, closebutton1, "closebutton1"); + + return aboutDialog; +} + diff --git a/src/xo-interface.h b/src/xo-interface.h new file mode 100644 index 0000000..aeebce4 --- /dev/null +++ b/src/xo-interface.h @@ -0,0 +1,9 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +GtkWidget* create_winMain (void); +GtkWidget* create_fontDialog (void); +GtkWidget* create_colorChooserDialog (void); +GtkWidget* create_papersizeDialog (void); +GtkWidget* create_aboutDialog (void); diff --git a/src/xo-support.c b/src/xo-support.c new file mode 100644 index 0000000..aaa8f1f --- /dev/null +++ b/src/xo-support.c @@ -0,0 +1,144 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include +#include +#include + +#include + +#include "xo-support.h" + +GtkWidget* +lookup_widget (GtkWidget *widget, + const gchar *widget_name) +{ + GtkWidget *parent, *found_widget; + + for (;;) + { + if (GTK_IS_MENU (widget)) + parent = gtk_menu_get_attach_widget (GTK_MENU (widget)); + else + parent = widget->parent; + if (!parent) + parent = (GtkWidget*) g_object_get_data (G_OBJECT (widget), "GladeParentKey"); + if (parent == NULL) + break; + widget = parent; + } + + found_widget = (GtkWidget*) g_object_get_data (G_OBJECT (widget), + widget_name); + if (!found_widget) + g_warning ("Widget not found: %s", widget_name); + return found_widget; +} + +static GList *pixmaps_directories = NULL; + +/* Use this function to set the directory containing installed pixmaps. */ +void +add_pixmap_directory (const gchar *directory) +{ + pixmaps_directories = g_list_prepend (pixmaps_directories, + g_strdup (directory)); +} + +/* This is an internally used function to find pixmap files. */ +static gchar* +find_pixmap_file (const gchar *filename) +{ + GList *elem; + + /* We step through each of the pixmaps directory to find it. */ + elem = pixmaps_directories; + while (elem) + { + gchar *pathname = g_strdup_printf ("%s%s%s", (gchar*)elem->data, + G_DIR_SEPARATOR_S, filename); + if (g_file_test (pathname, G_FILE_TEST_EXISTS)) + return pathname; + g_free (pathname); + elem = elem->next; + } + return NULL; +} + +/* This is an internally used function to create pixmaps. */ +GtkWidget* +create_pixmap (GtkWidget *widget, + const gchar *filename) +{ + gchar *pathname = NULL; + GtkWidget *pixmap; + + if (!filename || !filename[0]) + return gtk_image_new (); + + pathname = find_pixmap_file (filename); + + if (!pathname) + { + g_warning ("Couldn't find pixmap file: %s", filename); + return gtk_image_new (); + } + + pixmap = gtk_image_new_from_file (pathname); + g_free (pathname); + return pixmap; +} + +/* This is an internally used function to create pixmaps. */ +GdkPixbuf* +create_pixbuf (const gchar *filename) +{ + gchar *pathname = NULL; + GdkPixbuf *pixbuf; + GError *error = NULL; + + if (!filename || !filename[0]) + return NULL; + + pathname = find_pixmap_file (filename); + + if (!pathname) + { + g_warning ("Couldn't find pixmap file: %s", filename); + return NULL; + } + + pixbuf = gdk_pixbuf_new_from_file (pathname, &error); + if (!pixbuf) + { + fprintf (stderr, "Failed to load pixbuf file: %s: %s\n", + pathname, error->message); + g_error_free (error); + } + g_free (pathname); + return pixbuf; +} + +/* This is used to set ATK action descriptions. */ +void +glade_set_atk_action_description (AtkAction *action, + const gchar *action_name, + const gchar *description) +{ + gint n_actions, i; + + n_actions = atk_action_get_n_actions (action); + for (i = 0; i < n_actions; i++) + { + if (!strcmp (atk_action_get_name (action, i), action_name)) + atk_action_set_description (action, i, description); + } +} + diff --git a/src/xo-support.h b/src/xo-support.h new file mode 100644 index 0000000..2dea079 --- /dev/null +++ b/src/xo-support.h @@ -0,0 +1,44 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include + +/* + * Public Functions. + */ + +/* + * This function returns a widget in a component created by Glade. + * Call it with the toplevel widget in the component (i.e. a window/dialog), + * or alternatively any widget in the component, and the name of the widget + * you want returned. + */ +GtkWidget* lookup_widget (GtkWidget *widget, + const gchar *widget_name); + + +/* Use this function to set the directory containing installed pixmaps. */ +void add_pixmap_directory (const gchar *directory); + + +/* + * Private Functions. + */ + +/* This is used to create the pixmaps used in the interface. */ +GtkWidget* create_pixmap (GtkWidget *widget, + const gchar *filename); + +/* This is used to create the pixbufs used in the interface. */ +GdkPixbuf* create_pixbuf (const gchar *filename); + +/* This is used to set ATK action descriptions. */ +void glade_set_atk_action_description (AtkAction *action, + const gchar *action_name, + const gchar *description); + diff --git a/src/xournal.h b/src/xournal.h new file mode 100644 index 0000000..0b94190 --- /dev/null +++ b/src/xournal.h @@ -0,0 +1,279 @@ +#include +#include + +// DATA STRUCTURES AND CONSTANTS + +#define PIXEL_MOTION_THRESHOLD 0.3 +#define MAX_AXES 12 +#define EPSILON 1E-7 +#define MAX_ZOOM 20 +#define DEFAULT_ZOOM 1.3333333333 +#define MIN_ZOOM 0.2 + +/* a string (+ aux data) that maintains a refcount */ + +typedef struct Refstring { + int nref; + char *s; + gpointer aux; +} Refstring; + + +/* The journal is mostly a list of pages. Each page is a list of layers, + and a background. Each layer is a list of items, from bottom to top. +*/ + +typedef struct Background { + int type; + GnomeCanvasItem *canvas_item; + int color_no; + guint color_rgba; + int ruling; + GdkPixbuf *pixbuf; + Refstring *filename; + int file_domain; + int file_page_seq; + int pixbuf_dpi; // for PDF only - the *current* dpi value + double pixbuf_scale; // for PIXMAP, this is the *current* zoom value + // for PDF, this is the *requested* zoom value +} Background; + +#define BG_SOLID 0 +#define BG_PIXMAP 1 +#define BG_PDF 2 // not implemented yet + +#define RULING_NONE 0 +#define RULING_LINED 1 +#define RULING_RULED 2 +#define RULING_GRAPH 3 + +#define DOMAIN_ABSOLUTE 0 +#define DOMAIN_ATTACH 1 +#define DOMAIN_CLONE 2 // only while loading file + +typedef struct Brush { + int tool_type; + int color_no; + guint color_rgba; + int thickness_no; + double thickness; + int tool_options; +} Brush; + +#define COLOR_BLACK 0 +#define COLOR_BLUE 1 +#define COLOR_RED 2 +#define COLOR_GREEN 3 +#define COLOR_GRAY 4 +#define COLOR_LIGHTBLUE 5 +#define COLOR_LIGHTGREEN 6 +#define COLOR_MAGENTA 7 +#define COLOR_ORANGE 8 +#define COLOR_YELLOW 9 +#define COLOR_WHITE 10 +#define COLOR_OTHER -1 +#define COLOR_MAX 11 + +extern guint predef_colors_rgba[COLOR_MAX]; +extern guint predef_bgcolors_rgba[COLOR_MAX]; + +#define THICKNESS_VERYFINE 0 +#define THICKNESS_FINE 1 +#define THICKNESS_MEDIUM 2 +#define THICKNESS_THICK 3 +#define THICKNESS_VERYTHICK 4 +#define THICKNESS_MAX 5 + +#define TOOL_PEN 0 +#define TOOL_ERASER 1 +#define TOOL_HIGHLIGHTER 2 +#define TOOL_TEXT 3 +#define TOOL_SELECTREGION 4 +#define TOOL_SELECTRECT 5 +#define TOOL_VERTSPACE 6 +#define NUM_STROKE_TOOLS 3 + +#define TOOLOPT_ERASER_STANDARD 0 +#define TOOLOPT_ERASER_WHITEOUT 1 +#define TOOLOPT_ERASER_STROKES 2 + +#define HILITER_ALPHA_MASK 0xffffff80 + +extern double predef_thickness[NUM_STROKE_TOOLS][THICKNESS_MAX]; + +typedef struct BBox { + double left, right, top, bottom; +} BBox; + +struct UndoErasureData; + +typedef struct Item { + int type; + struct Brush brush; // the brush to use, if ITEM_STROKE + GnomeCanvasPoints *path; + GnomeCanvasItem *canvas_item; // the corresponding canvas item, or NULL + struct BBox bbox; + struct UndoErasureData *erasure; // for temporary use during erasures +} Item; + +// item type values for Item.type, UndoItem.type, ui.cur_item_type ... +// (not all are valid in all places) +#define ITEM_NONE -1 +#define ITEM_STROKE 0 +#define ITEM_TEMP_STROKE 1 +#define ITEM_ERASURE 2 +#define ITEM_SELECTRECT 3 +#define ITEM_MOVESEL 4 +#define ITEM_PASTE 5 +#define ITEM_NEW_LAYER 6 +#define ITEM_DELETE_LAYER 7 +#define ITEM_NEW_BG_ONE 8 +#define ITEM_NEW_BG_RESIZE 9 +#define ITEM_PAPER_RESIZE 10 +#define ITEM_NEW_DEFAULT_BG 11 +#define ITEM_NEW_PAGE 13 +#define ITEM_DELETE_PAGE 14 + +typedef struct Layer { + GList *items; // the items on the layer, from bottom to top + int nitems; + GnomeCanvasGroup *group; +} Layer; + +typedef struct Page { + GList *layers; // the layers on the page + int nlayers; + double height, width; + double hoffset, voffset; // offsets of canvas group rel. to canvas root + struct Background *bg; + GnomeCanvasGroup *group; +} Page; + +typedef struct Journal { + GList *pages; // the pages in the journal + int npages; + int last_attach_no; // for naming of attached backgrounds +} Journal; + +typedef struct Selection { + int type; + BBox bbox; // the rectangle bbox of the selection + struct Layer *layer; // the layer on which the selection lives + double anchor_x, anchor_y, last_x, last_y; // for selection motion + GnomeCanvasItem *canvas_item; // if the selection box is on screen + GList *items; // the selected items (a list of struct Item) +} Selection; + +typedef struct UIData { + int pageno, layerno; // the current page and layer + struct Page *cur_page; + struct Layer *cur_layer; + int toolno; // the number of the currently selected tool + gboolean saved; // is file saved ? + struct Brush *cur_brush; // the brush in use (one of brushes[...]) + struct Brush brushes[NUM_STROKE_TOOLS]; // the current pen, eraser, hiliter + struct Brush default_brushes[NUM_STROKE_TOOLS]; // the default ones + gboolean ruler; // whether we're in ruler mode + struct Page default_page; // the model for the default page + int layerbox_length; // the number of entries registered in the layers combo-box + struct Item *cur_item; // the item being drawn, or NULL + int cur_item_type; + GnomeCanvasPoints cur_path; // the path being drawn + int cur_path_storage_alloc; + int which_mouse_button; // the mouse button drawing the current path + int saved_toolno; // while using an eraser device + gboolean saved_ruler; + double zoom; // zoom factor, in pixels per pt + gboolean use_xinput; // use input devices instead of core pointer + gboolean allow_xinput; // allow use of xinput ? + int screen_width, screen_height; // initial screen size, for XInput events + char *filename; + gboolean view_continuous, fullscreen; + gboolean in_update_page_stuff; // semaphore to avoid scrollbar retroaction + struct Selection *selection; + GdkCursor *cursor; + gboolean emulate_eraser; + gboolean antialias_bg; // bilinear interpolation on bg pixmaps + gboolean progressive_bg; // rescale bg's one at a time +} UIData; + +typedef struct UndoErasureData { + struct Item *item; // the item that got erased + int npos; // its position in its layer + int nrepl; // the number of replacement items + GList *replacement_items; +} UndoErasureData; + +typedef struct UndoItem { + int type; + struct Item *item; // for ITEM_STROKE + struct Layer *layer; // for ITEM_STROKE, ITEM_ERASURE, ITEM_PASTE, ITEM_NEW_LAYER, ITEM_DELETE_LAYER + struct Layer *layer2; // for ITEM_DELETE_LAYER with val=-1 + struct Page *page; // for ITEM_NEW_BG_ONE/RESIZE, ITEM_NEW_PAGE, ITEM_NEW_LAYER, ITEM_DELETE_LAYER, ITEM_DELETE_PAGE + GList *erasurelist; // for ITEM_ERASURE + GList *itemlist; // for ITEM_MOVESEL, ITEM_PASTE + struct Background *bg; // for ITEM_NEW_BG_ONE/RESIZE, ITEM_NEW_DEFAULT_BG + int val; // for ITEM_NEW_PAGE, ITEM_NEW_LAYER, ITEM_DELETE_LAYER, ITEM_DELETE_PAGE + double val_x, val_y; // for ITEM_MOVESEL, ITEM_NEW_BG_RESIZE, ITEM_PAPER_RESIZE, ITEM_NEW_DEFAULT_BG + struct UndoItem *next; + int multiop; +} UndoItem; + +#define MULTIOP_CONT_REDO 1 // not the last in a multiop, so keep redoing +#define MULTIOP_CONT_UNDO 2 // not the first in a multiop, so keep undoing + + +typedef struct BgPdfRequest { + int pageno; + int dpi; + gboolean initial_request; // if so, loop over page numbers + gboolean is_printing; // this is for printing, not for display +} BgPdfRequest; + +typedef struct BgPdfPage { + int dpi; + GdkPixbuf *pixbuf; +} BgPdfPage; + +typedef struct BgPdf { + int status; // the rest only makes sense if this is not STATUS_NOT_INIT + int pid; // PID of the converter process + Refstring *filename; + int file_domain; + gchar *tmpfile_copy; // the temporary work copy of the file (in tmpdir) + int npages; + GList *pages; // a list of BgPdfPage structures + GList *requests; // a list of BgPdfRequest structures + gchar *tmpdir; // where to look for pages coming from pdf converter + gboolean create_pages; // create journal pages as we find stuff in PDF + gboolean has_failed; // has failed in the past... +} BgPdf; + +#define STATUS_NOT_INIT 0 +#define STATUS_IDLE 1 +#define STATUS_RUNNING 2 // currently running child process on head(requests) +#define STATUS_ABORTED 3 // child process running, but head(requests) aborted +#define STATUS_SHUTDOWN 4 // waiting for child process to shut down + +// UTILITY MACROS + +// getting a component of the interface by name +#define GET_COMPONENT(a) GTK_WIDGET (g_object_get_data(G_OBJECT (winMain), a)) + +// the margin between consecutive pages in continuous view +#define VIEW_CONTINUOUS_SKIP 20.0 + + +// GLOBAL VARIABLES + +// the main window and the canvas + +extern GtkWidget *winMain; +extern GnomeCanvas *canvas; + +// the data + +extern struct Journal journal; +extern struct UIData ui; +extern struct BgPdf bgpdf; +extern struct UndoItem *undo, *redo; diff --git a/xournal.glade b/xournal.glade new file mode 100644 index 0000000..c7ea714 --- /dev/null +++ b/xournal.glade @@ -0,0 +1,3045 @@ + + + + + + + True + Xournal + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + False + True + False + True + False + False + GDK_WINDOW_TYPE_HINT_NORMAL + GDK_GRAVITY_NORTH_WEST + True + + + + + True + False + 0 + + + + True + + + + True + _File + True + + + + + + + True + gtk-new + True + + + + + + + True + Annotate PDF + True + + + + + True + gtk-open + 1 + 0.5 + 0.5 + 0 + 0 + + + + + + + + True + gtk-open + True + + + + + + + True + gtk-save + True + + + + + + + True + gtk-save-as + True + + + + + + + True + + + + + + True + Print Options + True + + + + + True + gtk-preferences + 1 + 0.5 + 0.5 + 0 + 0 + + + + + + + + True + gtk-print + True + + + + + + + True + Print to PDF + True + + + + + + + True + + + + + + True + gtk-quit + True + + + + + + + + + + + True + _Edit + True + + + + + + + True + gtk-undo + True + + + + + + + True + gtk-redo + True + + + + + + + True + + + + + + True + gtk-cut + True + + + + + + + True + gtk-copy + True + + + + + + + True + gtk-paste + True + + + + + + + True + gtk-delete + True + + + + + + + + + + + True + _View + True + + + + + + + True + Continuous + True + True + + + + + + + True + One Page + True + True + viewContinuous + + + + + + + True + + + + + + True + Full Screen + True + False + + + + + + + True + + + + + + True + gtk-zoom-in + True + + + + + + + True + gtk-zoom-out + True + + + + + + + True + gtk-zoom-100 + True + + + + + + + True + Page Width + True + + + + + True + gtk-zoom-fit + 1 + 0.5 + 0.5 + 0 + 0 + + + + + + + + True + + + + + + True + First Page + True + + + + + True + gtk-goto-first + 1 + 0.5 + 0.5 + 0 + 0 + + + + + + + + True + Previous Page + True + + + + + True + gtk-go-back + 1 + 0.5 + 0.5 + 0 + 0 + + + + + + + + True + Next Page + True + + + + + True + gtk-media-forward + 1 + 0.5 + 0.5 + 0 + 0 + + + + + + + + True + Last Page + True + + + + + True + gtk-goto-last + 1 + 0.5 + 0.5 + 0 + 0 + + + + + + + + True + + + + + + True + Show Layer + True + + + + + True + gtk-add + 1 + 0.5 + 0.5 + 0 + 0 + + + + + + + + True + Hide Layer + True + + + + + True + gtk-remove + 1 + 0.5 + 0.5 + 0 + 0 + + + + + + + + + + + + True + _Journal + True + + + + + + + True + New Page Before + True + + + + + + + True + New Page After + True + + + + + + + True + New Page At End + True + + + + + + + True + Delete Page + True + + + + + + + True + + + + + + True + New Layer + True + + + + + + + True + Delete Layer + True + + + + + + + True + Flatten + True + + + + + + + True + + + + + + True + Paper Size + True + + + + + + + True + Paper Color + True + + + + + + + True + white paper + True + True + + + + + + + True + yellow paper + True + True + papercolorWhite + + + + + + + True + pink paper + True + True + papercolorWhite + + + + + + + True + orange paper + True + True + papercolorWhite + + + + + + + True + blue paper + True + True + papercolorWhite + + + + + + + True + green paper + True + True + papercolorWhite + + + + + + + True + other... + True + True + papercolorWhite + + + + + + + NA + True + True + papercolorWhite + + + + + + + + + + True + Paper Style + True + + + + + + + True + plain + True + True + + + + + + + True + lined + True + True + paperstylePlain + + + + + + + True + ruled + True + True + paperstylePlain + + + + + + + True + graph + True + True + paperstylePlain + + + + + + + NA + True + True + paperstylePlain + + + + + + + + + + True + Load Background + True + + + + + True + gtk-open + 1 + 0.5 + 0.5 + 0 + 0 + + + + + + + + True + Background Screenshot + True + + + + + + + True + Apply To All Pages + True + + + + + + + True + + + + + + True + Default Paper + True + + + + + + + True + Set As Default + True + + + + + + + + + + + True + _Tools + True + + + + + + + True + _Pen + True + True + + + + + + + True + _Eraser + True + True + toolsPen + + + + + + + True + _Highlighter + True + True + toolsPen + + + + + + + True + _Text + True + True + toolsPen + + + + + + + True + + + + + + True + _Select Region + True + True + toolsPen + + + + + + + True + Select Rectangle + True + True + toolsPen + + + + + + + True + Vertical Space + True + True + toolsPen + + + + + + + True + + + + + + True + _Color + True + + + + True + gtk-select-color + 1 + 0.5 + 0.5 + 0 + 0 + + + + + + + + + True + black + True + True + + + + + + + True + blue + True + True + colorBlack + + + + + + + True + red + True + True + colorBlack + + + + + + + True + green + True + True + colorBlack + + + + + + + True + gray + True + True + colorBlack + + + + + + + True + + + + + + True + light blue + True + True + colorBlack + + + + + + + True + light green + True + True + colorBlack + + + + + + + True + magenta + True + True + colorBlack + + + + + + + True + orange + True + True + colorBlack + + + + + + + True + yellow + True + True + colorBlack + + + + + + + True + white + True + True + colorBlack + + + + + + + True + other... + True + True + colorBlack + + + + + + + NA + True + True + colorBlack + + + + + + + + + + True + Pen _Options + True + + + + + + + True + very fine + True + True + + + + + + + True + fine + True + True + penthicknessVeryFine + + + + + + + True + medium + True + True + penthicknessVeryFine + + + + + + + True + thick + True + True + penthicknessVeryFine + + + + + + + True + very thick + True + True + penthicknessVeryFine + + + + + + + + + + + True + Eraser Options + True + + + + + + + True + fine + True + True + + + + + + + True + medium + True + True + eraserFine + + + + + + + True + thick + True + True + eraserFine + + + + + + + True + + + + + + True + standard + True + True + + + + + + + True + whiteout + True + True + eraserStandard + + + + + + + True + delete strokes + True + True + eraserStandard + + + + + + + + + + + True + Highlighter Options + True + + + + + + + True + fine + True + True + + + + + + + True + medium + True + True + highlighterFine + + + + + + + True + thick + True + True + highlighterFine + + + + + + + + + + + True + Text Font + True + + + + + True + gtk-select-font + 1 + 0.5 + 0.5 + 0 + 0 + + + + + + + + True + + + + + + True + Default Pen + True + + + + + + + True + Default Eraser + True + + + + + + + True + Default Highlighter + True + + + + + + + True + Default Text + True + + + + + + + True + Set As Default + True + + + + + + + True + + + + + + True + Ruler + True + False + + + + + + + + + + + True + _Options + True + + + + + + + True + Use XInput + True + False + + + + + + + True + Emulate Eraser + True + False + + + + + + + True + + + + + + True + Antialiased Bitmaps + True + False + + + + + + + True + Progressive Backgrounds + True + False + + + + + + + True + + + + + + True + Save Preferences + True + + + + + + + + + + + True + _Help + True + + + + + + + True + gtk-index + True + + + + + + + True + _About + True + + + + + + + + + + 0 + False + False + + + + + + True + GTK_ORIENTATION_HORIZONTAL + GTK_TOOLBAR_ICONS + True + True + + + + True + Save + gtk-save + True + True + False + + + + False + True + + + + + + True + True + True + False + + + + True + + + + + False + False + + + + + + True + Cut + gtk-cut + True + True + False + + + + False + True + + + + + + True + Copy + gtk-copy + True + True + False + + + + False + True + + + + + + True + Paste + gtk-paste + True + True + False + + + + False + True + + + + + + True + True + True + False + + + + True + + + + + False + False + + + + + + True + Undo + gtk-undo + True + True + False + + + + False + True + + + + + + True + Redo + gtk-redo + True + True + False + + + + False + True + + + + + + True + True + True + False + + + + True + + + + + False + False + + + + + + True + First Page + gtk-goto-first + True + True + False + + + + False + True + + + + + + True + Previous Page + gtk-go-back + True + True + False + + + + False + True + + + + + + True + Next Page + gtk-go-forward + True + True + False + + + + False + True + + + + + + True + Last Page + gtk-goto-last + True + True + False + + + + False + True + + + + + + True + True + True + False + + + + True + + + + + False + False + + + + + + True + Zoom Out + gtk-zoom-out + True + True + False + + + + False + True + + + + + + True + Page Width + gtk-zoom-fit + True + False + False + + + + False + True + + + + + + True + Zoom In + gtk-zoom-in + True + True + False + + + + False + True + + + + + + True + Normal Size + gtk-zoom-100 + True + True + False + + + + False + True + + + + + + True + Toggle Fullscreen + + True + fullscreen.png + True + True + False + False + + + + False + True + + + + + 0 + False + False + + + + + + True + GTK_ORIENTATION_HORIZONTAL + GTK_TOOLBAR_ICONS + True + True + + + + True + Pen + Pencil + True + pencil.png + True + True + False + False + + + + False + True + + + + + + True + Eraser + Eraser + True + eraser.png + True + True + False + False + buttonPen + + + + False + True + + + + + + True + Highlighter + Highlighter + True + highlighter.png + True + True + False + False + buttonPen + + + + False + True + + + + + + True + Text + Text + True + text-tool.png + True + True + False + False + buttonPen + + + + False + True + + + + + + True + Ruler + Ruler + True + ruler.png + True + True + False + False + + + + False + True + + + + + + True + True + True + False + + + + True + + + + + False + False + + + + + + True + Select Region + Select Region + True + lasso.png + True + True + False + False + buttonPen + + + + False + True + + + + + + True + Select Rectangle + Select Rectangle + True + rect-select.png + True + True + False + False + buttonPen + + + + False + True + + + + + + True + Vertical Space + Vertical Space + True + stretch.png + True + True + False + False + buttonPen + + + + False + True + + + + + + True + True + True + False + + + + True + + + + + False + False + + + + + + True + Default + Default + True + recycled.png + True + True + False + + + + False + False + + + + + + True + Default Pen + Default Pen + True + default-pen.png + True + True + False + + + + False + True + + + + + + True + True + True + False + + + + True + + + + + False + False + + + + + + 24 + True + Fine + Fine + True + thin.png + True + True + False + False + + + + False + False + + + + + + 24 + True + Medium + Medium + True + medium.png + True + True + False + False + buttonFine + + + + False + False + + + + + + 24 + True + Thick + Thick + True + thick.png + True + True + False + False + buttonFine + + + + False + False + + + + + + + True + True + True + False + False + buttonFine + + + False + True + + + + + + True + True + True + False + + + + True + + + + + False + False + + + + + + True + Black + Black + True + black.png + True + True + False + False + + + + False + False + + + + + + True + Blue + Blue + True + blue.png + True + True + False + False + buttonBlack + + + + False + False + + + + + + True + Red + Red + True + red.png + True + True + False + False + buttonBlack + + + + False + False + + + + + + True + Green + Green + True + green.png + True + True + False + False + buttonBlack + + + + False + False + + + + + + True + Gray + Gray + True + gray.png + True + True + False + False + buttonBlack + + + + False + False + + + + + + True + Light Blue + Light Blue + True + lightblue.png + True + True + False + False + buttonBlack + + + + False + False + + + + + + True + Light Green + Light Green + True + lightgreen.png + True + True + False + False + buttonBlack + + + + False + False + + + + + + True + Magenta + Magenta + True + magenta.png + True + True + False + False + buttonBlack + + + + False + False + + + + + + True + Orange + Orange + True + orange.png + True + True + False + False + buttonBlack + + + + False + False + + + + + + True + Yellow + Yellow + True + yellow.png + True + True + False + False + buttonBlack + + + + False + False + + + + + + True + White + White + True + white.png + True + True + False + False + buttonBlack + + + + False + False + + + + + + + True + True + True + False + False + buttonBlack + + + False + True + + + + + 0 + False + False + + + + + + True + True + GTK_POLICY_ALWAYS + GTK_POLICY_ALWAYS + GTK_SHADOW_NONE + GTK_CORNER_TOP_LEFT + + + + + + + 0 + True + True + + + + + + True + False + 0 + + + + True + Page + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + + 39 + True + Set page number + True + 1 + 0 + True + GTK_UPDATE_ALWAYS + True + False + 1 1 1 1 1 1 + + + + 0 + False + True + + + + + + True + of n + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + + True + + + 6 + False + True + + + + + + True + Layer: + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + + True + False + True + + + + 4 + False + True + + + + + + True + True + + + 0 + True + True + + + + + 0 + False + False + + + + + + + + 4 + True + Select Font + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + False + True + False + True + False + False + GDK_WINDOW_TYPE_HINT_DIALOG + GDK_GRAVITY_NORTH_WEST + True + + + + True + True + True + GTK_RELIEF_NORMAL + True + + + + + + True + True + True + GTK_RELIEF_NORMAL + True + + + + + + True + True + True + GTK_RELIEF_NORMAL + True + + + + + + 4 + True + abcdefghijk ABCDEFGHIJK + + + 0 + True + True + + + + + + True + Select Color + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + False + False + False + True + False + False + GDK_WINDOW_TYPE_HINT_DIALOG + GDK_GRAVITY_NORTH_WEST + True + + + + True + True + True + GTK_RELIEF_NORMAL + True + + + + + + True + True + True + GTK_RELIEF_NORMAL + True + + + + + + True + True + True + GTK_RELIEF_NORMAL + True + + + + + + True + False + False + + + + + + True + Set Paper Size + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + True + False + False + True + False + False + GDK_WINDOW_TYPE_HINT_DIALOG + GDK_GRAVITY_NORTH_WEST + True + True + + + + True + False + 0 + + + + True + GTK_BUTTONBOX_END + + + + True + True + True + gtk-cancel + True + GTK_RELIEF_NORMAL + True + -6 + + + + + + True + True + True + gtk-ok + True + GTK_RELIEF_NORMAL + True + -5 + + + + + 0 + False + True + GTK_PACK_END + + + + + + True + False + 0 + + + + True + Standard paper sizes: + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 10 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + + True + A4 +A4 (landscape) +US Letter +US Letter (landscape) +Custom + False + True + + + + 5 + True + True + + + + + 10 + True + True + + + + + + True + False + 0 + + + + True + Width: + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 10 + False + False + + + + + + True + True + True + True + 0 + + True + * + False + 5 + + + + 0 + True + True + + + + + + True + Height: + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 10 + False + False + + + + + + True + True + True + True + 0 + + True + * + False + 5 + + + + 0 + True + True + + + + + + True + cm +in +pixels +points + False + True + + + + 8 + False + True + + + + + 8 + True + True + + + + + + + + True + About Xournal + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + False + False + False + True + False + False + GDK_WINDOW_TYPE_HINT_DIALOG + GDK_GRAVITY_NORTH_WEST + True + True + + + + True + False + 0 + + + + True + GTK_BUTTONBOX_END + + + + True + True + True + gtk-close + True + GTK_RELIEF_NORMAL + True + -7 + + + + + 0 + False + True + GTK_PACK_END + + + + + + True + notepad.png + 0.5 + 0.5 + 0 + 0 + + + 12 + False + True + + + + + + True + Xournal + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 3 + False + False + + + + + + True + Written by Denis Auroux +http://math.mit.edu/~auroux/software/xournal/ + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 20 + 10 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + False + False + + + + + + + diff --git a/xournal.gladep b/xournal.gladep new file mode 100644 index 0000000..c5d37e7 --- /dev/null +++ b/xournal.gladep @@ -0,0 +1,16 @@ + + + + + Xournal + xournal + FALSE + FALSE + TRUE + xo-interface.c + xo-interface.h + xo-callbacks.c + xo-callbacks.h + xo-support.c + xo-support.h + -- 2.39.2