sd_interface.c - gscreendump - Screenshot taking application.

Source path: svn/ trunk/ src/ sd_interface.c

‹r104

r134

/* gscreendump: sd_interface.c
 * 
 * Copyright (c) Linux community repr. by <osmoma@online.no>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include "sd_callbacks.h"
#include "sd_interface.h"
#include "sd_support.h"
#include "sd_pixbuf.h"
#include "sd_thumb_view.h"
#include "sd_folder_widget.h"
#include "sd_canvas.h"
#include "sd_dialogs.h"

/* Include user interface (ui) XML for menu and toolbar */
#include "sd_menu_ui.h"

/* Top level menu. These are always open/enabled */
static GtkActionEntry main_entries[] = 
{
  { "FileMenuAction", NULL,  N_("_File") },
  { "EditMenuAction", NULL,  N_("_Edit") },
  { "ViewMenuAction", NULL,  N_("_View") },
  { "ImageMenuAction",NULL,  N_("_Image") },
  { "HelpMenuAction", NULL,  N_("_Help") },
  { "ViewToolbarsMenuAction", NULL, N_("_Toolbars") },

  { "ToolbarWindowMenuAction", NULL, N_("Window list") },
};

static guint n_main_entries = G_N_ELEMENTS(main_entries);

/* "Open" type menu selectons. These are always open/available */
static GtkActionEntry open_entries[] = 
{
  { "FileNewMenuAction", GTK_STOCK_NEW, 
     N_("_New Capture"), ""},
	
  { "FileNewWindowAction", NULL, 
    N_("_Window"), "<control>1",
    N_("Take a screenshot of a selected window."),
    G_CALLBACK(on_m_new_window_activate_cb)},

  { "FileNewSelectionAction", NULL, 
    N_("_Selection"), "<control>2",
    N_("Take a screenshot of a selected area of the desktop."), 
    G_CALLBACK(on_m_new_select_activate_cb)},

  { "FileNewDesktopAction", NULL, 
    N_("_Desktop"), "<control>3",
    N_("Take a screenshot of the entire desktop."),
    G_CALLBACK(on_m_new_desktop_activate_cb)},

  { "FileNewWindowItemAction", NULL, 
    N_("Window _item"),"<control>4",
    N_("Select and take a screenshot of a single window component."),
    G_CALLBACK(on_m_new_item_activate_cb)},

  { "FileNewWebpageAction", NULL, 
    N_("Web_page"), "<control>5",
    N_("Create a screenshot image of a given webpage."),
    G_CALLBACK(on_m_new_webpage_activate_cb)},

  { "OpenAction", GTK_STOCK_OPEN, 
    N_("_Open"), "<control>O",
    N_("Open and import a file (image) to this program."),
    G_CALLBACK(on_m_open_activate_cb)},

  { "ImportFolderAction", NULL, 
    N_("_Import Folder"), "<control>I",
    N_("Import and attach a directory to this program."),
    G_CALLBACK(on_m_import_activate_cb)},

  { "SelectAllAction", GTK_STOCK_SELECT_ALL,
    NULL, NULL,
    N_("Select all images."),
    G_CALLBACK(on_m_select_all_activate_cb) },
    
  { "QuitAction", GTK_STOCK_QUIT,
    N_("_Quit"), "<control>Q",
    N_("Exit application"),
    G_CALLBACK(on_m_quit_activate_cb) },

  { "FullscreenAction", GTK_STOCK_FULLSCREEN,
     NULL, NULL,
    N_("Fullscreen window"),
    G_CALLBACK(gui_show_fullscreen) },

  { "HelpAction", GTK_STOCK_HELP,
     NULL, NULL, 
    N_("Help about this application."),
    G_CALLBACK(on_m_help_help_activate_cb) },

  { "TranslateAction", NULL,
    N_("_Translate this application"), NULL, 
    N_("Translate this application."),
    G_CALLBACK(on_m_help_translate_activate_cb) },

  { "AboutAction", GTK_STOCK_ABOUT,
    NULL, NULL,
    N_("About this application."),
    G_CALLBACK(on_m_help_about_activate_cb) }
};

static guint n_open_entries = G_N_ELEMENTS(open_entries);

/* "Save" type menu selectons. These are open/enabled when there's an image on the display */
static GtkActionEntry save_entries[] = 
{
  { "SaveAsAction", GTK_STOCK_SAVE_AS, 
    NULL, NULL,
    N_("Save current image to a different name/file type."),
    G_CALLBACK(on_m_save_as_activate_cb)},

  { "CopyImageAction", GTK_STOCK_COPY, 
    N_("Copy image"), "",
    N_("Copy image."),
    G_CALLBACK(on_m_copy_image_activate_cb)},

  { "CopyLocationAction", GTK_STOCK_COPY, 
    N_("Copy filename"), NULL,
    N_("Copy image location/filename."),
    G_CALLBACK(on_m_copy_location_activate_cb)},

  { "DuplicateAction", NULL, 
    N_("_Duplicate"), "<control>D",
    N_("Duplicate current image."),
    G_CALLBACK(on_m_duplicate_activate_cb)},

  { "DeleteAction", GTK_STOCK_DELETE, 
    NULL, NULL,
    N_("Delete current images."),
    G_CALLBACK(on_m_delete_activate_cb)},

  { "OpenImageAction", NULL, 
    N_("_Open image with"), NULL,
    NULL, NULL}, /* We will put a sub menu here */

  { "RotateRightAction", "object-rotate-right",
    N_("_Rotate right"), "<control>R",
    N_("Rotate image right."),
    G_CALLBACK(on_rotate_image_right_cb)},

  { "RotateLeftAction", "object-rotate-left",
    N_("Rotate _left"), "<control>L",
    N_("Rotate image left."),
    G_CALLBACK(on_rotate_image_left_cb)},

  { "FlipHorizontalAction", "object-flip-horizontal",
    N_("Flip _horizontally"), NULL,
    N_("Flip image horizontally."),
     G_CALLBACK(on_flip_image_horizontally_cb)},

  { "FlipVerticalAction", "object-flip-vertical",
    N_("Flip _vertically"), NULL,
    N_("Flip image vertically."),
    G_CALLBACK(on_flip_image_vertically_cb)},

  { "ZoomInAction", GTK_STOCK_ZOOM_IN,
    NULL, NULL, 
    N_("Zoom in."),
    G_CALLBACK(on_m_zoom_in_activate_cb)}, 

  { "ZoomOutAction", GTK_STOCK_ZOOM_OUT,
    NULL, NULL, 
    N_("Zoom out."),
    G_CALLBACK(on_m_zoom_out_activate_cb)}, 

  { "ZoomNormalAction", GTK_STOCK_ZOOM_100,
    NULL, NULL, 
    N_("Set zoom to natural size of the image."),
    G_CALLBACK(on_m_zoom_100_activate_cb)}, 

  { "ZoomBestFitAction", GTK_STOCK_ZOOM_FIT,
    NULL, NULL, 
    N_("Adapt zoom to fit the image to window."),
    G_CALLBACK(on_m_zoom_fit_activate_cb)}, 
};

static guint n_save_entries = G_N_ELEMENTS(save_entries);

/* Menu selection "paste" is active when clipboard has relevant data */ 
static GtkActionEntry paste_entries[] = 
{
  { "PasteAction", GTK_STOCK_PASTE, 
    NULL, NULL,
    N_("Paste image or image name/URL."),
    G_CALLBACK(on_m_paste_activate_cb)}
};

static guint n_paste_entries = G_N_ELEMENTS(paste_entries);

/* These are enabled when the selected image has older revisions (able to undo)*/
static GtkActionEntry undo_entries[] = 
{
  { "UndoAction", GTK_STOCK_UNDO, 
    NULL, NULL,
    N_("Undo last operation."),
    G_CALLBACK(on_m_undo_activate_cb)}
};

static guint n_undo_entries = G_N_ELEMENTS(undo_entries);

/* These are enabled to allow "undo on all selected images" */
static GtkActionEntry undo_all_entries[] = 
{
  { "UndoAllAction", NULL, 
    N_("Undo _all selected"), NULL,
    N_("Undo last operation on all selected images."),
    G_CALLBACK(on_m_undo_all_activate_cb)}
};

static guint n_undo_all_entries = G_N_ELEMENTS(undo_all_entries);

/* These are always enabled */
static GtkRadioActionEntry toolbar_style[] = 
{
  { "ToolbarShowIconAction", NULL, 
    N_("Show _icon"), NULL,
    N_("Show icon only."), GTK_TOOLBAR_ICONS/*Show icons only*/ },

  { "ToolbarShowLabelAction", NULL, 
    N_("Show _label"), NULL,
    N_("Show label only."), GTK_TOOLBAR_TEXT/*Show label only*/ },

  { "ToolbarShowAllAction", NULL, 
    N_("Show icon _and label"), NULL,
    N_("Show both icon and label."), GTK_TOOLBAR_BOTH/*Show both label and icon*/}
};

static guint n_toolbar_style_entries = G_N_ELEMENTS(toolbar_style);

/* These are always enabled */
static GtkToggleActionEntry show_toolbar[] = 
{
  { "ToolbarStandardAction", NULL, 
    N_("Standard"), NULL,
    N_("Show standard toolbar."), 
    G_CALLBACK(on_m_toolbar_show), FALSE}
};

static guint n_show_toolbar_entries = G_N_ELEMENTS(show_toolbar);

/* These are always enabled */
static GtkActionEntry standard_toolbar_entries[] = 
{
  /* How to add this toolbar button to the XML/UI manager?
	 This button is of type GTK_TYPE_MENU_TOOL_BUTTON.

	{ "CaptureSelectionAction", NULL,
	  NULL, NULL, 
	  "Take a screenshot of selected window.",
	  G_CALLBACK(lookup_character_action) }
  */
  { "CaptureSelectionAction", NULL,
    N_("Selection"), "<control>2", 
    N_("Take a screenshot of a selected area of the desktop."),
    G_CALLBACK(on_m_new_select_activate_cb)},

  { "CaptureDesktopAction", NULL,
    N_("Desktop"), "<control>3", 
    N_("Take a screenshot of the entire desktop."),
    G_CALLBACK(on_m_new_desktop_activate_cb)}

};

static guint n_standard_toolbar_entries = G_N_ELEMENTS(standard_toolbar_entries);

/* These are enabled/active when user has selected one or more images */
static GtkToggleActionEntry toggle_toolbutton_entries[] = 
{
  { "PanImageAction", NULL, 
    N_("Pan"), NULL,
    N_("Pan and move the picture."),
    G_CALLBACK(on_toolbar_pan_image_activate_cb), FALSE},

  { "CropImageAction", NULL, 
    N_("Crop"), NULL,
    N_("Crop/scale/rotate and flip the image."),
    G_CALLBACK(on_toolbar_crop_image_activate_cb), FALSE},

  { "IMagickAction", NULL, 
    N_("IMagick"), NULL,
    N_("Manipulate images with ImageMagick and other tools."), 
    G_CALLBACK(on_toolbar_imagick_tools_activate_cb), FALSE}
};

static guint n_toggle_toolbutton_entries = G_N_ELEMENTS(toggle_toolbutton_entries);

static GtkWidget *vbox0;

void create_main_window(void)
{
	/* Create the main_window with menubar, menus, toolbars and treeviews + the client area for the image */
	GtkWidget *menu;
	GtkWidget *menu_item;

	/* Accelerator keys in the main_window.
	g_main_accel_group = gtk_accel_group_new();
	*/

	/* Main window */
	g_main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(g_main_window), _("Gscreendump"));

	guint screen_width = gdk_screen_get_width(gdk_screen_get_default());
	guint win_width;
	if (MAIN_WINDOW_WIDTH > screen_width)
		win_width = screen_width - 70;
	else
		win_width = MAIN_WINDOW_WIDTH;

	gtk_window_set_default_size(GTK_WINDOW(g_main_window), win_width, MAIN_WINDOW_HEIGHT);

	/* Set icon */
	gchar *file = find_pixmap_file("gscreendump.svg");
	GdkPixbuf *pixbuf = get_pixbuf_from_file(file, FALSE/*no errors*/);
	gtk_window_set_icon(GTK_WINDOW(g_main_window), pixbuf);
	if (GDK_IS_PIXBUF(pixbuf))
		g_object_unref(pixbuf);
	g_free(file);

	/* Events on main_window */
	g_signal_connect_swapped(G_OBJECT(g_main_window), "destroy", G_CALLBACK(cb_main_window_destroy), NULL);
	g_signal_connect_swapped(G_OBJECT(g_main_window), "delete-event", G_CALLBACK(cb_main_window_delete_event), NULL);

	vbox0 = gtk_vbox_new (FALSE, 0);
	gtk_widget_show(vbox0);
	gtk_container_add(GTK_CONTAINER(g_main_window), vbox0);

	/* User interface with menu and toolbar */
	g_ui_manager = gtk_ui_manager_new();

	GtkActionGroup *open_action_group = gtk_action_group_new("AlwaysOpenActions");
	gtk_action_group_set_translation_domain(open_action_group, GETTEXT_PACKAGE);
	gtk_action_group_add_actions(open_action_group, open_entries, n_open_entries, NULL);
	gtk_ui_manager_insert_action_group(g_ui_manager, open_action_group, 0);

	/* Active when there is an image in the display */
	g_save_action_group = gtk_action_group_new("SaveActions");
	gtk_action_group_set_translation_domain(g_save_action_group, GETTEXT_PACKAGE);
	gtk_action_group_add_actions(g_save_action_group, save_entries, n_save_entries, NULL);
	gtk_ui_manager_insert_action_group(g_ui_manager, g_save_action_group, 0);

	GtkActionGroup *main_action_group = gtk_action_group_new("MainActions");
	gtk_action_group_set_translation_domain(main_action_group, GETTEXT_PACKAGE);
	gtk_action_group_add_actions(main_action_group, main_entries, n_main_entries, NULL);
	gtk_ui_manager_insert_action_group(g_ui_manager, main_action_group, 0);

	g_undo_action_group = gtk_action_group_new("UndoActions");
	gtk_action_group_set_translation_domain(g_undo_action_group, GETTEXT_PACKAGE);
	gtk_action_group_add_actions(g_undo_action_group, undo_entries, n_undo_entries, NULL);
	gtk_ui_manager_insert_action_group(g_ui_manager, g_undo_action_group, 0);

	g_undo_all_action_group = gtk_action_group_new("UndoAllActions");
	gtk_action_group_set_translation_domain(g_undo_all_action_group, GETTEXT_PACKAGE);
	gtk_action_group_add_actions(g_undo_all_action_group, undo_all_entries, n_undo_all_entries, NULL);
	gtk_ui_manager_insert_action_group(g_ui_manager, g_undo_all_action_group, 0);

	g_paste_action_group = gtk_action_group_new("PasteActions");
	gtk_action_group_set_translation_domain(g_paste_action_group, GETTEXT_PACKAGE);
	gtk_action_group_add_actions(g_paste_action_group, paste_entries, n_paste_entries, NULL);
	gtk_ui_manager_insert_action_group(g_ui_manager, g_paste_action_group, 0);

	GtkActionGroup *toolbar_style_action_group = gtk_action_group_new("ToolbarStyleGroup");
	gtk_action_group_set_translation_domain(toolbar_style_action_group, GETTEXT_PACKAGE);
	gtk_action_group_add_radio_actions(toolbar_style_action_group, toolbar_style, n_toolbar_style_entries, 0, G_CALLBACK(on_m_toolbar_style_set), NULL);
	gtk_ui_manager_insert_action_group(g_ui_manager, toolbar_style_action_group, 0);

	GtkActionGroup *show_toolbar_group = gtk_action_group_new("ShowToolbarGroup");
	gtk_action_group_set_translation_domain(show_toolbar_group, GETTEXT_PACKAGE);
	gtk_action_group_add_toggle_actions(show_toolbar_group, show_toolbar, n_show_toolbar_entries, NULL);
	gtk_ui_manager_insert_action_group(g_ui_manager, show_toolbar_group, 0);

	GtkActionGroup *standard_toolbar_group  = gtk_action_group_new("StandardToolbarGroup");
	gtk_action_group_set_translation_domain(standard_toolbar_group, GETTEXT_PACKAGE);
	gtk_action_group_add_actions(standard_toolbar_group, standard_toolbar_entries, n_standard_toolbar_entries, NULL);
	gtk_ui_manager_insert_action_group(g_ui_manager, standard_toolbar_group, 0);

	/* Add three toggle type toolbar buttons for Pan, Crop and IMagick */
	GtkActionGroup *toggle_toolbutton_group = gtk_action_group_new("ToggleToolbuttonGroup");
	gtk_action_group_set_translation_domain(toggle_toolbutton_group, GETTEXT_PACKAGE);
	gtk_action_group_add_toggle_actions(toggle_toolbutton_group, toggle_toolbutton_entries, n_toggle_toolbutton_entries, NULL);
	gtk_ui_manager_insert_action_group(g_ui_manager, toggle_toolbutton_group, 0);

	/* Read in user interface for menu and toolbar */
	GError *error = NULL;
	gtk_ui_manager_add_ui_from_string(g_ui_manager, ui_xml, -1, &error);
	if (error)
	{
		g_message(_("User interface definition has errors. Cannot create menu or toolbar. %s.") , error->message);
		g_error_free(error);
	}
    
	/* Get the menubar and the toolbar and put them in the vertical packing box (vbox0) */
	GtkWidget *menubar = gtk_ui_manager_get_widget(g_ui_manager, "/MainMenu");
	gtk_box_pack_start(GTK_BOX(vbox0), menubar, FALSE, FALSE, 0);

	/* Create a handlebox so the toolbar becomes detachable/moveable */
	h_toolbar_standard = gtk_handle_box_new();

	/* Show/hide the toolbar (and toolbar handle) */
	if (g_settings.toolbar_standard_show)
		gtk_widget_show(h_toolbar_standard);
	else
		gtk_widget_hide(h_toolbar_standard);

	gtk_box_pack_start(GTK_BOX(vbox0), h_toolbar_standard, FALSE, FALSE, 0);

	/* Attach toolbar to the handle */
	GtkWidget *toolbar = gtk_ui_manager_get_widget(g_ui_manager, "/MainToolbar");

	gtk_widget_set_size_request(toolbar, 750, -1);
	gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL);
	gtk_container_add(GTK_CONTAINER(h_toolbar_standard), toolbar);

	/* Set toolbar style */ 
	gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), g_settings.toolbar_style);
	GtkAction *radio_action = gtk_action_group_get_action(toolbar_style_action_group, "ToolbarShowLabelAction");
	gtk_radio_action_set_current_value(GTK_RADIO_ACTION(radio_action), g_settings.toolbar_style);

	/* Make sure that the accelerators work */
	gtk_window_add_accel_group(GTK_WINDOW(g_main_window),  gtk_ui_manager_get_accel_group(g_ui_manager));
	/* ------------------------------------------------ */

	/* Set menu selection View -> Toolbars -> Standard  */
	menu_item = gtk_ui_manager_get_widget(g_ui_manager, "/MainMenu/ViewMenu/ViewToolbarsMenu/ToolbarStandard");
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item), g_settings.toolbar_standard_show);
	/* ------------------------------------------------ */

	/* Add sub menu and entries to Image/Open With... menu */
	menu = gtk_ui_manager_get_widget(g_ui_manager, "/MainMenu/ImageMenu/OpenImage");
	GtkWidget *menu1 = gtk_menu_new ();
	gtk_widget_show(menu1);
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu), menu1);

	/* Find all programs that can open/run mime-type "image/png".
	   Add programs to Image -> "Open with..." menu.
	*/
	const gchar *mime_type = "image/png";

	/* Get list ofg image programs/apps for mime_type */
	g_canvas.image_applications = g_app_info_get_all_for_type(mime_type);

	GList *iter;
	for (iter = g_canvas.image_applications; iter; iter = iter->next) 
	{
		GAppInfo *app = iter->data;

		/* Label and tip text */
		gchar *label = g_strdup_printf (_("Open with \"%s\""), g_app_info_get_name(app));
		gchar *tip = g_strdup_printf (_("Use \"%s\" to open the selected image"), g_app_info_get_name(app));

		/* Show application icon */
		GtkWidget *icon_widget = NULL;

#if GTK_CHECK_VERSION(2,14,4)
		GIcon *icon = g_app_info_get_icon(app);
		icon_widget = gtk_image_new_from_gicon(icon, GTK_ICON_SIZE_MENU);
		g_object_unref(icon);
#else
		/* Older GTK+ version does not have gtk_image_new_from_gicon() function. */
#endif 
		menu_item = gtk_image_menu_item_new_with_label(label);
		if (icon_widget)
		{
			gtk_widget_show(icon_widget);
			gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item), icon_widget);
		}

		gtk_widget_show(menu_item);
		gtk_widget_set_tooltip_text(menu_item, tip);
		gtk_container_add (GTK_CONTAINER(menu1), menu_item);
		g_signal_connect((gpointer)menu_item, "activate", G_CALLBACK(on_menu_open_with_app_cb), (gpointer)app);

		g_free (label);
		g_free (tip); 
	}
	/* ------------------------------------------------ */

	/* I do not know how to add GTK_TYPE_MENU_TOOL_BUTTON with XML/UI manager so I hard-code it here.

	   Add toolbar button "Capture Window".
	   This button has a drop-down menu for window names + IDs.
	*/
	file = find_pixmap_file ("sd_capture_window.png");
	GtkWidget *icon_widget = gtk_image_new_from_file(file);
	g_free(file);
	gtk_widget_show(icon_widget);

	GtkWidget *tool_item = (GtkWidget*)gtk_menu_tool_button_new(icon_widget, _("Window"));
	gtk_widget_show(GTK_WIDGET(tool_item));
	g_signal_connect(tool_item, "clicked", G_CALLBACK(on_m_new_window_activate_cb), NULL);
	gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(tool_item), _("Take a screenshot of a selected window."));

	/* Create an empty menu and attach it to the tool_item.
	   The menu is populated with application (window) names just before the menu is shown.
	*/
	menu = gtk_menu_new();
	gtk_widget_show(menu);

	/* Add a dummy menu item */
	menu_item = gtk_image_menu_item_new_with_label("empty");
	gtk_widget_show(menu_item);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);

	/* Attach menu to the toolbar button */
	gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(tool_item), menu);

	g_signal_connect(menu, "map", G_CALLBACK(on_show_capture_window_menu_cb), NULL);
	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(tool_item), 5);

	/* Save ref. to this toolbar button */
	g_toolitem_capture_window =  GTK_TOOL_ITEM(tool_item);
	/* ------------------------------------------------ */

	/* Set icon on toolbar button "/MainToolbar/ToolItems/CaptureSelection" */
	tool_item = gtk_ui_manager_get_widget(g_ui_manager, "/MainToolbar/ToolItems/CaptureSelection");
	file = find_pixmap_file ("sd_capture_selection.png");
	icon_widget = gtk_image_new_from_file(file);
	g_free(file);
	gtk_widget_show(icon_widget);
	gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(tool_item), icon_widget);
	/* ------------------------------------------------ */

	/* Set icon on toolbar button "/MainToolbar/ToolItems/CaptureDesktop" */
	tool_item = gtk_ui_manager_get_widget(g_ui_manager, "/MainToolbar/ToolItems/CaptureDesktop");
	file = find_pixmap_file ("sd_capture_desktop.png");
	icon_widget = gtk_image_new_from_file(file);
	g_free(file);
	gtk_widget_show(icon_widget);
	gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(tool_item), icon_widget);
	/* ------------------------------------------------ */

	/* Set icon for toolbar button "/MainMenu/EditMenu/UndoAll" */
	menu_item = gtk_ui_manager_get_widget(g_ui_manager, "/MainMenu/EditMenu/UndoAll");
	file = find_pixmap_file ("sd_undo_all.png");
	icon_widget = gtk_image_new_from_file(file);
	g_free(file);
	gtk_widget_show(icon_widget);
	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item), icon_widget);
	/* ------------------------------------------------ */

	/* I do not know how to add GTK_TYPE_MENU_TOOL_BUTTON with XML/UI manager so I hard-code it here.

	   This toolbar button has a menu with 3 selections: Zoom Normal, Zoom Fit and Fullscreen.
		  zoom-best-fit.png
		  zoom-normal.png
		  zoom-fullscreen.png  
	*/
	GtkAction *action = gtk_action_new("zoom-*", NULL,  _("Adapt zoom to fit the image to window"), GTK_STOCK_ZOOM_FIT);
	tool_item = GTK_WIDGET(gtk_menu_tool_button_new_from_stock(GTK_STOCK_ZOOM_FIT));
	gtk_widget_show(GTK_WIDGET(tool_item));

	/* Create an empty menu and attach it to the toolbar button. */
	menu = gtk_menu_new();
	gtk_widget_show(menu);
	/* Add 3 items to the menu */
	{
		menu_item = gtk_menu_item_new_with_label(_("Best Fit"));
		gtk_widget_show (menu_item);
		g_signal_connect(menu_item, "activate", G_CALLBACK(on_toolbar_set_zoom_activate_cb), GINT_TO_POINTER('b'));
		gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);

		menu_item = gtk_menu_item_new_with_label(_("Normal Size"));
		gtk_widget_show (menu_item);
		g_signal_connect(menu_item, "activate", G_CALLBACK(on_toolbar_set_zoom_activate_cb), GINT_TO_POINTER('n'));
		gtk_menu_shell_append (GTK_MENU_SHELL(menu), menu_item);

		menu_item = gtk_menu_item_new_with_label(_("Fullscreen"));
		gtk_widget_show (menu_item);
		g_signal_connect (menu_item, "activate", G_CALLBACK(on_toolbar_set_zoom_activate_cb), GINT_TO_POINTER('f'));
		gtk_menu_shell_append (GTK_MENU_SHELL(menu), menu_item);
	}

	gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(tool_item), menu);

	/* Connect button to action */
	gtk_action_connect_proxy(action, tool_item);
	/* Add action to the g_save_action_group */
	gtk_action_group_add_action(g_save_action_group, action);
	/* Set current selection */
	gtk_object_set_user_data(GTK_OBJECT(tool_item), (gpointer)'b');
	g_signal_connect (tool_item, "clicked", G_CALLBACK(on_toolbar_zoom_clicked_cb), NULL);
	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(tool_item), 12);

	/* Save this toolbar item */
	g_toolitem_zoom_x = GTK_TOOL_ITEM(tool_item);
	/* ------------------------------------------------ */

	/* Set icon on toolbar button "/MainToolbar/ToolItems/PanImage" */
	tool_item = gtk_ui_manager_get_widget(g_ui_manager, "/MainToolbar/ToolItems/PanImage");
	file = find_pixmap_file ("sd_pan_move.png");
	icon_widget = gtk_image_new_from_file(file);
	g_free(file);
	gtk_widget_show(icon_widget);
	gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(tool_item), icon_widget);

	/* Set icon on toolbar button "/MainToolbar/ToolItems/CropImage" */
	tool_item = gtk_ui_manager_get_widget(g_ui_manager, "/MainToolbar/ToolItems/CropImage");
	file = find_pixmap_file ("sd_crop_image.png");
	icon_widget = gtk_image_new_from_file(file);
	g_free(file);
	gtk_widget_show(icon_widget);
	gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(tool_item), icon_widget);

	/* Set icon on toolbar button "/MainToolbar/ToolItems/IMagick" */
	tool_item = gtk_ui_manager_get_widget(g_ui_manager, "/MainToolbar/ToolItems/IMagick");
	file = find_pixmap_file ("sd_imagick_tools.png");
	icon_widget = gtk_image_new_from_file(file);
	g_free(file);
	gtk_widget_show(icon_widget);
	gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(tool_item), icon_widget);
	/* ------------------------------------------------ */

    /* gtk_window_add_accel_group(GTK_WINDOW (main_window), g_main_accel_group); */

    /*******************/
    /* Client area     */
    /*******************/
    /************************************************/
    /* Horizontal divider (hpaned) on the left side */
    /************************************************/

	GtkWidget *hpaned1 = gtk_hpaned_new();
	gtk_widget_show(hpaned1);
	gtk_box_pack_start(GTK_BOX(vbox0), hpaned1, TRUE, TRUE, 0);

	/* Check position */
	if (g_settings.thumb_view_width > MAIN_WINDOW_WIDTH / 2)
	{
		g_settings.thumb_view_width = MAIN_WINDOW_WIDTH / 4;
	}
	gtk_paned_set_position(GTK_PANED(hpaned1), g_settings.thumb_view_width);
	g_signal_connect(GTK_PANED(hpaned1), "size-request", G_CALLBACK(on_hpaned_moved_cb), NULL);

	GtkWidget *vpaned_upper = gtk_vpaned_new();
	gtk_widget_show(vpaned_upper);
	gtk_paned_pack1(GTK_PANED(hpaned1), vpaned_upper, FALSE, TRUE);

	/* Check height of the thumbview (position of vpaned_upper pane). */
	if (g_settings.thumb_view_height > MAIN_WINDOW_HEIGHT / 2)
	{
		g_settings.thumb_view_height = MAIN_WINDOW_HEIGHT / 3;
	}
	gtk_paned_set_position(GTK_PANED(vpaned_upper), g_settings.thumb_view_height);

	g_signal_connect(GTK_PANED(vpaned_upper), "size-request", G_CALLBACK(on_vpaned_moved_cb), NULL);

	GtkWidget *scrolledwindow_upper = gtk_scrolled_window_new(NULL, NULL);
	gtk_widget_show(scrolledwindow_upper);
	gtk_paned_pack1(GTK_PANED(vpaned_upper), scrolledwindow_upper, FALSE, TRUE);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow_upper), GTK_SHADOW_IN);

	/* *************************** */
	/* Create g_folder_view widget */
	/* *************************** */
	folder_widget_create();
	gtk_container_add(GTK_CONTAINER(scrolledwindow_upper), GTK_WIDGET(g_folder_treeview));

	GtkWidget *scrolledwindow_lower;
	scrolledwindow_lower = gtk_scrolled_window_new(NULL, NULL);
	gtk_paned_pack2(GTK_PANED(vpaned_upper), scrolledwindow_lower, FALSE, TRUE);
	gtk_widget_show(scrolledwindow_lower);

	/* *************************** */
	/* Create g_thumb_view widget */
	/* *************************** */
	GtkListStore *model;

	/* Create a simple list (non hierarcical structure) */
	model = gtk_list_store_new(N_THUMB_COLUMNS, G_TYPE_STRING  /* Filename */,
                                              	G_TYPE_STRING  /* The entire path + filename */, 
                                            	GDK_TYPE_PIXBUF/* Thumbnail image */, 
                                              	G_TYPE_ULONG   /* File date */, 
                                             	G_TYPE_ULONG   /* File size */,
                                             	G_TYPE_INT     /* Flags */);

	g_thumb_view = gtk_icon_view_new_with_model(GTK_TREE_MODEL(model));
	gtk_widget_show(g_thumb_view);
	gtk_container_add(GTK_CONTAINER(scrolledwindow_lower), GTK_WIDGET(g_thumb_view));

	gtk_icon_view_set_tooltip_column(GTK_ICON_VIEW(g_thumb_view), COL_THUMB_FILENAME);
	gtk_icon_view_set_text_column(GTK_ICON_VIEW(g_thumb_view), COL_THUMB_FILENAME);
	gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(g_thumb_view), COL_THUMB_PIXBUF);

	/* Set default sort order: Descrending on Filename. (newest/latest screenshots on top) */
	gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), COL_THUMB_FILENAME, GTK_SORT_DESCENDING);

	gulong handler_id = g_signal_connect(g_thumb_view, "selection-changed", G_CALLBACK (on_thumb_view_selection_changed), NULL);

	/* Save handler_id on g_thumb_view */
	g_object_set_data(G_OBJECT(g_thumb_view), "selection-changed-signal", GINT_TO_POINTER(handler_id));

	/* Show popup-menu on right-mouse-button */
	g_signal_connect(G_OBJECT(g_thumb_view), "button_press_event", G_CALLBACK(on_thumb_view_button_press_cb), NULL); 

	/* Aktive drag & drop */
	thumb_view_init_drag_drop();

	/* Allow multiple selection */
	gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(g_thumb_view), GTK_SELECTION_MULTIPLE);

	GtkWidget *vbox2 = gtk_vbox_new (FALSE, 0);
	gtk_widget_show(vbox2);
	gtk_paned_pack2(GTK_PANED(hpaned1), vbox2, TRUE, TRUE);


	GtkWidget *hbox2 = gtk_hbox_new(FALSE, 0);
	gtk_widget_show(hbox2);
	gtk_box_pack_start(GTK_BOX(vbox2), hbox2, FALSE, TRUE, 0);

	GtkWidget *scrolledwindowTop = gtk_scrolled_window_new (NULL, NULL);
	gtk_widget_show(scrolledwindowTop);
	gtk_box_pack_start(GTK_BOX(hbox2), scrolledwindowTop, TRUE, TRUE, 0);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindowTop), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindowTop), GTK_SHADOW_IN);

	GtkWidget *viewport1 = gtk_viewport_new (NULL, NULL);
	gtk_widget_show(viewport1);
	gtk_container_add(GTK_CONTAINER(scrolledwindowTop), viewport1);

	g_hbox_sel_list = gtk_hbutton_box_new();
	gtk_widget_show(g_hbox_sel_list);
	gtk_widget_set_size_request(g_hbox_sel_list, -1, g_settings.selection_box_height/*around 45 pixels*/);
	gtk_container_add(GTK_CONTAINER(viewport1), g_hbox_sel_list);
	gtk_button_box_set_layout(GTK_BUTTON_BOX(g_hbox_sel_list), GTK_BUTTONBOX_START);

#if 0 
	Unneccessary feature.
	I removed advanced-selection-mode from Gscreendump v0.2. 

	/* Push-pin images to show red(active) and green(deactive) push-pins.
	   Red/active pin means that g_settings.advanced_selection_mode = TRUE.
	   Green push-pin means it is OFF/FALSE.
	*/
	file = find_pixmap_file("sd_green_pin_up.png");
	GtkWidget *push_pin = gtk_image_new_from_file(file);
	g_free(file);
	gtk_widget_show(push_pin);

	/* GtkImage is not a window and therefore cannot receive events.
	   Solve situation with GtkEventBox.
	*/
	GtkWidget *event_box = gtk_event_box_new();
	gtk_widget_show(event_box);
	gtk_container_add(GTK_CONTAINER(event_box), push_pin);

	gtk_widget_set_events (event_box, GDK_BUTTON_PRESS_MASK);
	g_signal_connect(G_OBJECT(event_box),  "button_press_event", G_CALLBACK(canvas_push_pin_clicked_cb),  push_pin);

	/* Set initial status; advanced_selection_mode=FALSE. */
	g_object_set_data(G_OBJECT(push_pin), "push-pin-status", GINT_TO_POINTER(0));

	gtk_widget_set_tooltip_text(push_pin, "Activate/deactivate advanced selection mode.\nAdvanced mode allows you to select images from several directories.");

	gtk_box_pack_start(GTK_BOX(hbox2), event_box, FALSE, TRUE, 0);
#endif

	/*****************************/
	/* The GtkImageView widget   */
	/* g_canvas.imageview        */
	/*****************************/

	g_canvas.imageview = GTK_IMAGE_VIEW(gtk_image_view_new());
	g_signal_connect(g_canvas.imageview, "pixbuf-changed", G_CALLBACK(canvas_image_changed_cb), NULL);

	/* Make g_canvas.imageview DnD source and target */
	canvas_init_drag_drop();

	gtk_widget_show(GTK_WIDGET(g_canvas.imageview));
	
	GtkWidget *scrolledwindow = gtk_image_scroll_win_new(GTK_IMAGE_VIEW(g_canvas.imageview));
	gtk_widget_show(scrolledwindow);
	gtk_box_pack_start(GTK_BOX(vbox2), scrolledwindow, TRUE, TRUE, 0); 

	/* Show popup-menu on right-mouse-button */
	g_signal_connect(G_OBJECT(g_canvas.imageview), "button_press_event", G_CALLBACK(canvas_imageview_button_press_cb), NULL); 
	

	/* GtkImageView tools; Dragger, selector and painter (painter not used yet) */
	g_canvas.dragger_tool = gtk_image_tool_dragger_new(GTK_IMAGE_VIEW(g_canvas.imageview));
	g_canvas.selector_tool = gtk_image_tool_selector_new(GTK_IMAGE_VIEW(g_canvas.imageview));
	g_canvas.painter_tool = gtk_image_tool_painter_new(GTK_IMAGE_VIEW(g_canvas.imageview));
	g_canvas.selected_tool = NULL;

	/*************/
	/* Statusbar */
	/*************/
	g_statusbar = gtk_statusbar_new ();
	gtk_widget_show(g_statusbar);

	GtkWidget *sel_info_frame = gtk_frame_new(NULL);
	gtk_widget_show(sel_info_frame);
	gtk_frame_set_shadow_type(GTK_FRAME(sel_info_frame), GTK_SHADOW_IN);

	GtkWidget *sel_info_label = gtk_label_new("");
	gtk_widget_show(sel_info_label);
	gtk_container_add(GTK_CONTAINER(sel_info_frame), sel_info_label);

	g_signal_connect(G_OBJECT(g_canvas.selector_tool), "selection_changed", G_CALLBACK(canvas_drag_selection_changed_cb), sel_info_label);

	gtk_box_pack_start(GTK_BOX(g_statusbar), sel_info_frame, FALSE, FALSE, 0);

	GtkWidget *zoom_info_frame = gtk_frame_new(NULL);
	gtk_widget_show(zoom_info_frame);
	gtk_frame_set_shadow_type (GTK_FRAME(zoom_info_frame), GTK_SHADOW_IN);

	GtkWidget *zoom_info_label = gtk_label_new ("100%");
	gtk_widget_show(zoom_info_label);
	gtk_container_add (GTK_CONTAINER (zoom_info_frame), zoom_info_label);

	g_signal_connect(G_OBJECT(g_canvas.imageview), "zoom_changed", G_CALLBACK(canvas_zoom_factor_changed_cb), zoom_info_label);

	gtk_box_pack_start(GTK_BOX(g_statusbar), zoom_info_frame, FALSE, FALSE, 0);
	
	gtk_box_pack_end(GTK_BOX(vbox0), g_statusbar, FALSE, FALSE, 0);
}

Show details Hide details

Change log

r107 by osmoma on Apr 19, 2009 Diff

Improved mechanism to run image
manipulation commands via bash -c. Scripts
can now use the positional parameters
$0...$n. Started work to add UI for the
"output filename=" field in "Ad-hoc
commands" tab-page.

Go to:

Project members, sign in to write a code review

Older revisions

r104 by osmoma on Apr 13, 2009 Diff

Gscreendump should now compile and run
on Ubuntu 8.04. Ubuntu 8.04 has
GTK+/GDK version 2.12.9 while some
functions require GTK+ 2.14.0 or
later. Some issues remain unsolved:
...

r102 by osmoma on Apr 12, 2009 Diff

New import after accidental delete

All revisions of this file

File info

Size: 32926 bytes, 834 lines

View raw file