#! /usr/bin/perl

###################################################
#
#  Copyright (C) Mario Kemper 2008 <mario.kemper@googlemail.com>
#
#  This file is part of GScrot.
#
#  GScrot is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 3 of the License, or
#  (at your option) any later version.
#
#  GScrot 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 General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with GScrot; if not, write to the Free Software
#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
###################################################

#modules
#--------------------------------------
use utf8;
use strict;
use warnings;

#Gtk2
use Gtk2 '-init';
use Gtk2::Gdk::Keysyms;
use Gtk2::Pango;

#GConf - used for metacity keybindings
use Gnome2::GConf;

#Image operations
use Image::Magick;

#File operations
use File::Copy;
use File::Basename;

#Gettext and filename parsing
use POSIX qw/setlocale strftime/;
use Locale::gettext;

#handle upload responses properly
use HTTP::Status;

#load and save settings
use XML::Simple;

#internal use
use FindBin '$Bin';

#--------------------------------------

#define constants
#--------------------------------------
use constant TRUE                => 1;
use constant FALSE               => 0;
use constant REV                 => "Rev.315";
use constant PPA_VERSION         => "ppa10";
use constant GSCROT_NAME         => "GScrot";
use constant GSCROT_VERSION      => "v0.64";
use constant GSCROT_VERSION_FULL => REV . " - " . PPA_VERSION;

#--------------------------------------

#configure path settings
#--------------------------------------
$Bin =~ m/(.*)\//;
my $gscrot_root = $1;
my $gscrot_path = $Bin . "/gscrot";
$ENV{'GSCROT_ROOT'} = $gscrot_root;    #used by some plugins

#--------------------------------------

#custom modules load at runtime
#--------------------------------------
require lib;
import lib "$gscrot_root/share/gscrot/resources/modules";

#gscrot app classes
require GScrot::App::Common;
require GScrot::App::SimpleDialogs;
require GScrot::App::HelperFunctions;

#drawing classes
require GScrot::Draw::DrawingTool;

#screenshot classes
require GScrot::Screenshot::SelectorAdvanced;
require GScrot::Screenshot::SelectorSimple;
require GScrot::Screenshot::Workspace;
require GScrot::Screenshot::Web;
require GScrot::Screenshot::Window;

#upload classes
require GScrot::Upload::ImageBanana;
require GScrot::Upload::UbuntuPics;
require GScrot::Upload::ImageShack;
require GScrot::Upload::FTP;

#--------------------------------------

#main window
#--------------------------------------
my $window = Gtk2::Window->new('toplevel');

#--------------------------------------

#create app objects
#--------------------------------------
my $gscrot_common = GScrot::App::Common->new($gscrot_root);
$gscrot_common->set_mainwindow($window);
my $gscrot_hfunct = GScrot::App::HelperFunctions->new($gscrot_common);
my $gscrot_dialog = GScrot::App::SimpleDialogs->new($window);

#--------------------------------------

#optional components
#--------------------------------------
my $gnome_web_photo = TRUE;
my $gtklp           = TRUE;
my $gtkimageview    = TRUE;
my $goocanvas       = TRUE;
&fct_init_optional;

#--------------------------------------

#data structures
#--------------------------------------
my %gm_programs;    #hash to store program infos
my %plugins;        #hash to store plugin infos
my %accounts;       #hash to store account infos
my %settings;       #hash to store settings
&fct_init;
&fct_init_framework_versions;
&fct_check_installed_programs;
&fct_load_accounts;

#--------------------------------------

#signal-handler
$SIG{RTMIN} = sub { &evt_take_screenshot( 'global_keybinding', 'select' ) };
$SIG{USR1}  = sub { &evt_take_screenshot( 'global_keybinding', 'raw' ) };
$SIG{USR2}  = sub { &evt_take_screenshot( 'global_keybinding', 'window' ) };
$SIG{RTMAX} = sub { &evt_take_screenshot( 'global_keybinding', 'section' ) };

#hash of screenshots during session
my %session_screens;
my %session_start_screen;

#Clipboard
my $clipboard = Gtk2::Clipboard->get( Gtk2::Gdk->SELECTION_CLIPBOARD );

#Tooltips
my $tooltips = $gscrot_common->get_tooltips;

#main window gui
#--------------------------------------
$window->set_title( GSCROT_NAME . " " . GSCROT_VERSION );
$window->set_default_icon(
	Gtk2::Gdk::Pixbuf->new_from_file_at_size( "$gscrot_root/share/pixmaps/gscrot.svg", 100, 100 ) );
$window->signal_connect( 'delete-event' => \&evt_delete_window );
$window->set_border_width(0);
$window->set_resizable(1);
$window->set_position('center');
$window->set_default_size( 650, 500 );
$window->set_size_request( -1, 450 );

#tray icon
my $icon                 = undef;
my $current_profile_indx = 0;
my $is_in_tray           = TRUE;

my $accel_group = Gtk2::AccelGroup->new;
$window->add_accel_group($accel_group);

my $notebook = Gtk2::Notebook->new;
$notebook->set( homogeneous => 1 );

#create first page etc.
&fct_create_session_notebook;

my $statusbar = Gtk2::Statusbar->new;

#arrange settings in notebook
my $notebook_settings = Gtk2::Notebook->new;
my $settings_dialog   = Gtk2::Dialog->new(
	GSCROT_NAME . " - " . $gscrot_common->get_gettext->get("Preferences"),
	$window,
	[qw/modal destroy-with-parent/],
	'gtk-close' => 'close'
);

my $vbox                = Gtk2::VBox->new( FALSE, 0 );
my $vbox_settings       = Gtk2::VBox->new( FALSE, 10 );
my $vbox_basic          = Gtk2::VBox->new( FALSE, 10 );
my $vbox_extras         = Gtk2::VBox->new( FALSE, 10 );
my $vbox_behavior       = Gtk2::VBox->new( FALSE, 10 );
my $vbox_plugins        = Gtk2::VBox->new( FALSE, 10 );
my $vbox_accounts       = Gtk2::VBox->new( FALSE, 10 );
my $file_vbox           = Gtk2::VBox->new( FALSE, 0 );
my $save_vbox           = Gtk2::VBox->new( FALSE, 0 );
my $behavior_vbox       = Gtk2::VBox->new( FALSE, 0 );
my $keybinding_vbox     = Gtk2::VBox->new( FALSE, 0 );
my $keybinding_mode_box = Gtk2::HBox->new( TRUE,  0 );
my $actions_vbox        = Gtk2::VBox->new( FALSE, 0 );
my $capture_vbox        = Gtk2::VBox->new( FALSE, 0 );
my $effects_vbox        = Gtk2::VBox->new( FALSE, 0 );
my $accounts_hbox       = Gtk2::HBox->new( TRUE,  0 );
my $accounts_vbox       = Gtk2::VBox->new( TRUE,  0 );
my $ftp_hbox1           = Gtk2::HBox->new( TRUE,  0 );
my $ftp_hbox2           = Gtk2::HBox->new( TRUE,  0 );
my $ftp_hbox3           = Gtk2::HBox->new( TRUE,  0 );
my $ftp_hbox4           = Gtk2::HBox->new( TRUE,  0 );
my $ftp_vbox            = Gtk2::VBox->new( TRUE,  0 );
my $profiles_box        = Gtk2::HBox->new( FALSE, 0 );
my $scale_box           = Gtk2::HBox->new( TRUE,  0 );
my $delay_box           = Gtk2::HBox->new( TRUE,  0 );
my $delay_box2          = Gtk2::HBox->new( FALSE, 0 );
my $thumbnail_box       = Gtk2::HBox->new( TRUE,  0 );
my $thumbnail_box2      = Gtk2::HBox->new( FALSE, 0 );
my $resize_operator_box = Gtk2::HBox->new( TRUE,  0 );
my $filename_box        = Gtk2::HBox->new( TRUE,  0 );
my $progname_box        = Gtk2::HBox->new( TRUE,  0 );
my $progname_box2       = Gtk2::HBox->new( FALSE, 0 );
my $im_colors_box       = Gtk2::HBox->new( TRUE,  0 );
my $im_colors_box2      = Gtk2::HBox->new( FALSE, 0 );
my $filetype_box        = Gtk2::HBox->new( TRUE,  0 );
my $saveDir_box         = Gtk2::HBox->new( TRUE,  0 );
my $key_box             = Gtk2::HBox->new( TRUE,  0 );
my $key_box2            = Gtk2::HBox->new( FALSE, 0 );
my $key_sel_box         = Gtk2::HBox->new( TRUE,  0 );
my $key_sel_box2        = Gtk2::HBox->new( FALSE, 0 );
my $border_box          = Gtk2::HBox->new( TRUE,  0 );
my $cursor_box          = Gtk2::HBox->new( TRUE,  0 );

$window->add($vbox);

#--------------------------------------

#load settings
my $settings_xml = &fct_load_settings( "start", "start" );

#load last profile
if ( defined $settings_xml->{'general'}->{'last_profile'} ) {
	if ( $settings_xml->{'general'}->{'last_profile'} != -1 ) {
		$settings_xml = &fct_load_settings( "start", "start",
			$settings_xml->{'general'}->{'last_profile_name'} );
	}
}

#menu
#--------------------------------------
my $menubar = Gtk2::MenuBar->new();

#file
my $menu_file     = Gtk2::Menu->new();
my $menuitem_file = Gtk2::MenuItem->new_with_mnemonic( $gscrot_common->get_gettext->get("_File") );
my $menuitem_open = Gtk2::ImageMenuItem->new_from_stock('gtk-open');
$menuitem_open->add_accelerator( "activate", $accel_group, $Gtk2::Gdk::Keysyms{O}, qw/control-mask/,
	qw/visible/ );
$menu_file->append($menuitem_open);
$menuitem_open->signal_connect( "activate", \&evt_open, 'menu_open' );

$menu_file->append( Gtk2::SeparatorMenuItem->new );

my $menuitem_save_as = Gtk2::ImageMenuItem->new_from_stock('gtk-save-as');
$menuitem_save_as->set_sensitive(FALSE);
$menuitem_save_as->add_accelerator( "activate", $accel_group,
	Gtk2::Accelerator->parse("<Shift><Control>S"), qw/visible/ );
$menu_file->append($menuitem_save_as);
$menuitem_save_as->signal_connect( "activate", \&evt_save_as, 'menu_save_as' );

$menu_file->append( Gtk2::SeparatorMenuItem->new );

my $menuitem_close = Gtk2::ImageMenuItem->new_from_stock('gtk-close');
$menuitem_close->set_sensitive(FALSE);
$menuitem_close->add_accelerator( "activate", $accel_group, Gtk2::Accelerator->parse("<Control>W"),
	qw/visible/ );
$menu_file->append($menuitem_close);
$menuitem_close->signal_connect( "activate", \&evt_close, 'menu_close' );

my $menuitem_close_all
	= Gtk2::ImageMenuItem->new_with_mnemonic( $gscrot_common->get_gettext->get("C_lose all") );
$menuitem_close_all->set_image( Gtk2::Image->new_from_stock( 'gtk-close', 'menu' ) );
$menuitem_close_all->add_accelerator( "activate", $accel_group,
	Gtk2::Accelerator->parse("<Shift><Control>W"), qw/visible/ );
$menu_file->append($menuitem_close_all);
$menuitem_close_all->signal_connect( "activate", \&evt_close_all, 'menu_close_all' );

$menu_file->append( Gtk2::SeparatorMenuItem->new );

my $menuitem_quit = Gtk2::ImageMenuItem->new_from_stock('gtk-quit');
$menuitem_quit->add_accelerator( "activate", $accel_group, $Gtk2::Gdk::Keysyms{Q}, qw/control-mask/,
	qw/visible/ );
$menu_file->append($menuitem_quit);
$menuitem_quit->signal_connect( "activate", \&evt_delete_window, 'menu_quit' );

$menuitem_file->set_submenu($menu_file);
$menubar->append($menuitem_file);

#end file
#edit
my $menu_edit = Gtk2::Menu->new();
my $menuitem_quicks
	= Gtk2::MenuItem->new_with_label( $gscrot_common->get_gettext->get("Quick select") );
$menu_edit->append($menuitem_quicks);
$menu_edit->append( Gtk2::SeparatorMenuItem->new );

my $menuitem_settings = Gtk2::ImageMenuItem->new_from_stock('gtk-preferences');
$menuitem_settings->add_accelerator( "activate", $accel_group, $Gtk2::Gdk::Keysyms{P},
	qw/mod1-mask/, qw/visible/ );
$menu_edit->append($menuitem_settings);

$menuitem_settings->signal_connect( "activate", \&evt_show_settings, 'exp_settings_menu' );
my $menuitem_edit = Gtk2::MenuItem->new_with_mnemonic( $gscrot_common->get_gettext->get("_Edit") );
$menuitem_edit->set_submenu($menu_edit);
$menubar->append($menuitem_edit);

#end edit
#actions
my $menu_actions       = Gtk2::Menu->new();
my $menuitem_selection = Gtk2::ImageMenuItem->new( $gscrot_common->get_gettext->get("Selection") );
$menuitem_selection->set_image(
	Gtk2::Image->new_from_pixbuf(
		Gtk2::Gdk::Pixbuf->new_from_file_at_size(
			"$gscrot_root/share/gscrot/resources/icons/selection.svg",
			Gtk2::IconSize->lookup('menu')
		)
	)
);
$menuitem_selection->add_accelerator( "activate", $accel_group, $Gtk2::Gdk::Keysyms{S},
	qw/mod1-mask/, qw/visible/ );
$menu_actions->append($menuitem_selection);
$menuitem_selection->signal_connect( "activate", \&evt_take_screenshot, 'select' );
$menu_actions->append( Gtk2::SeparatorMenuItem->new );
my $menuitem_raw = Gtk2::ImageMenuItem->new( $gscrot_common->get_gettext->get("Full Screen") );
$menuitem_raw->set_image(
	Gtk2::Image->new_from_pixbuf(
		Gtk2::Gdk::Pixbuf->new_from_file_at_size(
			"$gscrot_root/share/gscrot/resources/icons/fullscreen.svg",
			Gtk2::IconSize->lookup('menu')
		)
	)
);
$menuitem_raw->add_accelerator( "activate", $accel_group, $Gtk2::Gdk::Keysyms{F}, qw/mod1-mask/,
	qw/visible/ );
$menu_actions->append($menuitem_raw);
$menuitem_raw->signal_connect( "activate", \&evt_take_screenshot, 'raw' );
$menu_actions->append( Gtk2::SeparatorMenuItem->new );
my $menuitem_window = Gtk2::ImageMenuItem->new( $gscrot_common->get_gettext->get("Window") );
$menuitem_window->set_image(
	Gtk2::Image->new_from_pixbuf(
		Gtk2::Gdk::Pixbuf->new_from_file_at_size(
			"$gscrot_root/share/gscrot/resources/icons/sel_window.svg",
			Gtk2::IconSize->lookup('menu')
		)
	)
);
$menuitem_window->add_accelerator( "activate", $accel_group, $Gtk2::Gdk::Keysyms{W}, qw/mod1-mask/,
	qw/visible/ );
$menu_actions->append($menuitem_window);
$menuitem_window->signal_connect( "activate", \&evt_take_screenshot, 'window' );
my $menuitem_window_sect = Gtk2::ImageMenuItem->new( $gscrot_common->get_gettext->get("Section") );
$menuitem_window_sect->set_image(
	Gtk2::Image->new_from_pixbuf(
		Gtk2::Gdk::Pixbuf->new_from_file_at_size(
			"$gscrot_root/share/gscrot/resources/icons/sel_window_section.svg",
			Gtk2::IconSize->lookup('menu')
		)
	)
);
$menuitem_window_sect->add_accelerator( "activate", $accel_group, $Gtk2::Gdk::Keysyms{S},
	qw/shift-mask/, qw/visible/ );
$menu_actions->append($menuitem_window_sect);
$menuitem_window_sect->signal_connect( "activate", \&evt_take_screenshot, 'section' );
$menu_actions->append( Gtk2::SeparatorMenuItem->new );
my $menuitem_web = Gtk2::ImageMenuItem->new( $gscrot_common->get_gettext->get("Web") );
$menuitem_web->set_sensitive($gnome_web_photo);
$menuitem_web->set_image(
	Gtk2::Image->new_from_pixbuf(
		Gtk2::Gdk::Pixbuf->new_from_file_at_size(
			"$gscrot_root/share/gscrot/resources/icons/web_image.svg",
			Gtk2::IconSize->lookup('menu')
		)
	)
);
$menuitem_web->add_accelerator( "activate", $accel_group, $Gtk2::Gdk::Keysyms{W}, qw/shift-mask/,
	qw/visible/ );
$menu_actions->append($menuitem_web);
$menuitem_web->signal_connect( "activate", \&evt_take_screenshot, 'web' );
my $menuitem_action
	= Gtk2::MenuItem->new_with_mnemonic( $gscrot_common->get_gettext->get("_Screenshot") );
$menuitem_action->set_submenu($menu_actions);
$menubar->append($menuitem_action);

#end actions
#session
my $menu_session = Gtk2::Menu->new();

my $menuitem_back = Gtk2::ImageMenuItem->new_from_stock('gtk-go-back');
$menuitem_back->add_accelerator( "activate", $accel_group, $Gtk2::Gdk::Keysyms{Left},
	qw/mod1-mask/, qw/visible/ );
$menu_session->append($menuitem_back);
$menuitem_back->signal_connect( "activate", \&evt_navigate, 'previous' );
my $menuitem_forward = Gtk2::ImageMenuItem->new_from_stock('gtk-go-forward');
$menuitem_forward->add_accelerator( "activate", $accel_group, $Gtk2::Gdk::Keysyms{Right},
	qw/mod1-mask/, qw/visible/ );
$menu_session->append($menuitem_forward);
$menuitem_forward->signal_connect( "activate", \&evt_navigate, 'forward' );

$menu_session->append( Gtk2::SeparatorMenuItem->new );

my $menuitem_first = Gtk2::ImageMenuItem->new_from_stock('gtk-goto-first');
$menuitem_first->add_accelerator( "activate", $accel_group, $Gtk2::Gdk::Keysyms{Home},
	qw/mod1-mask/, qw/visible/ );
$menu_session->append($menuitem_first);
$menuitem_first->signal_connect( "activate", \&evt_navigate, 'first' );

my $menuitem_last = Gtk2::ImageMenuItem->new_from_stock('gtk-goto-last');
$menuitem_last->add_accelerator( "activate", $accel_group, $Gtk2::Gdk::Keysyms{End},
	qw/mod1-mask/, qw/visible/ );
$menu_session->append($menuitem_last);
$menuitem_last->signal_connect( "activate", \&evt_navigate, 'last' );

my $menuitem_session = Gtk2::MenuItem->new_with_mnemonic( $gscrot_common->get_gettext->get("_Go") );
$menuitem_session->set_submenu($menu_session);
$menubar->append($menuitem_session);

#end session
#help
my $menu_help = Gtk2::Menu->new();
my $menuitem_question
	= Gtk2::ImageMenuItem->new( $gscrot_common->get_gettext->get("Get Help Online ...") );
$menuitem_question->set_image(
	Gtk2::Image->new_from_pixbuf(
		Gtk2::Gdk::Pixbuf->new_from_file_at_size(
			"$gscrot_root/share/gscrot/resources/icons/lpi-help.png",
			Gtk2::IconSize->lookup('menu')
		)
	)
);

$menu_help->append($menuitem_question);

my $menuitem_translate = Gtk2::ImageMenuItem->new(
	$gscrot_common->get_gettext->get("Translate this Application ...") );
$menuitem_translate->set_image(
	Gtk2::Image->new_from_pixbuf(
		Gtk2::Gdk::Pixbuf->new_from_file_at_size(
			"$gscrot_root/share/gscrot/resources/icons/lpi-translate.png",
			Gtk2::IconSize->lookup('menu')
		)
	)
);

$menu_help->append($menuitem_translate);
$menuitem_translate->signal_connect( "activate", \&evt_translate, $window );

$menuitem_question->signal_connect( "activate", \&evt_question, $window );
my $menuitem_bug = Gtk2::ImageMenuItem->new( $gscrot_common->get_gettext->get("Report a Problem") );
$menuitem_bug->set_image(
	Gtk2::Image->new_from_pixbuf(
		Gtk2::Gdk::Pixbuf->new_from_file_at_size(
			"$gscrot_root/share/gscrot/resources/icons/lpi-bug.png",
			Gtk2::IconSize->lookup('menu')
		)
	)
);

$menu_help->append($menuitem_bug);
$menuitem_bug->signal_connect( "activate", \&evt_bug, $window );

$menu_help->append( Gtk2::SeparatorMenuItem->new );
my $menuitem_about = Gtk2::ImageMenuItem->new_from_stock('gtk-about');

$menuitem_about->add_accelerator( "activate", $accel_group, $Gtk2::Gdk::Keysyms{I},
	qw/control-mask/, qw/visible/ );
$menu_help->append($menuitem_about);
$menuitem_about->signal_connect( "activate", \&evt_about, $window );
my $menuitem_help = Gtk2::MenuItem->new_with_mnemonic( $gscrot_common->get_gettext->get("_Help") );
$menuitem_help->set_submenu($menu_help);
$menubar->append($menuitem_help);

#help
$vbox->pack_start( $menubar, FALSE, TRUE, 0 );

#--------------------------------------

#button selection
#--------------------------------------
my $image_select = Gtk2::Image->new_from_pixbuf(
	Gtk2::Gdk::Pixbuf->new_from_file_at_size(
		"$gscrot_root/share/gscrot/resources/icons/selection.svg",
		Gtk2::IconSize->lookup('large-toolbar')
	)
);
my $button_select_menu
	= Gtk2::MenuToolButton->new( $image_select, $gscrot_common->get_gettext->get("Selection") );
$button_select_menu->signal_connect(
	'clicked' => \&evt_take_screenshot,
	'select'
);

my ( $tool_advanced, $tool_simple ) = undef;
my $zoom_active = undef;
my ( $zoom_size1, $zoom_size2, $zoom_size3 ) = undef;
$button_select_menu->set_menu(&fct_ret_sel_menu);

$tooltips->set_tip(
	$button_select_menu,
	$gscrot_common->get_gettext->get(
		"Draw a rectangular capture area with your mouse\nto select a specified screen area")
);

$button_select_menu->set_arrow_tooltip( $tooltips,
	$gscrot_common->get_gettext->get("Choose selection tool"), 'arrow' );

#--------------------------------------

#button full screen
#--------------------------------------
my $image_raw = Gtk2::Image->new_from_pixbuf(
	Gtk2::Gdk::Pixbuf->new_from_file_at_size(
		"$gscrot_root/share/gscrot/resources/icons/fullscreen.svg",
		Gtk2::IconSize->lookup('large-toolbar')
	)
);
my $button_raw_menu
	= Gtk2::MenuToolButton->new( $image_raw, $gscrot_common->get_gettext->get("Full Screen") );

$button_raw_menu->signal_connect( 'clicked' => \&evt_take_screenshot, 'raw' );

#$button_raw_menu->signal_connect(
#	'clicked' => sub {
#
#		for ( my $i = 0; $i < 50; $i++ ) {
#
#			&evt_take_screenshot( undef, 'raw' );
#
#		}
#
#	},
#	'raw'
#);
my $current_monitor_active = undef;
$button_raw_menu->set_menu( &fct_ret_workspace_menu(TRUE) );
$button_raw_menu->signal_connect( 'show-menu' => sub { &fct_ret_workspace_menu(FALSE) } );
$tooltips->set_tip( $button_raw_menu,
	$gscrot_common->get_gettext->get("Take a screenshot of your whole desktop") );
$button_raw_menu->set_arrow_tooltip( $tooltips,
	$gscrot_common->get_gettext->get("Capture a specific workspace"), 'arrow' );

#--------------------------------------

#button window
#--------------------------------------
my $image_window = Gtk2::Image->new_from_pixbuf(
	Gtk2::Gdk::Pixbuf->new_from_file_at_size(
		"$gscrot_root/share/gscrot/resources/icons/sel_window.svg",
		Gtk2::IconSize->lookup('large-toolbar')
	)
);
my $button_window_menu
	= Gtk2::MenuToolButton->new( $image_window, $gscrot_common->get_gettext->get("Window") );
$button_window_menu->signal_connect(
	'clicked' => \&evt_take_screenshot,
	'window'
);
$button_window_menu->set_menu(&fct_ret_window_menu);
$button_window_menu->signal_connect( 'show-menu' => \&fct_ret_window_menu );
$tooltips->set_tip( $button_window_menu,
	$gscrot_common->get_gettext->get("Select a window with your mouse") );
$button_window_menu->set_arrow_tooltip( $tooltips,
	$gscrot_common->get_gettext->get("Take a screenshot of a specific window"), 'arrow' );

#--------------------------------------

#button section
#--------------------------------------
my $image_window_sect = Gtk2::Image->new_from_pixbuf(
	Gtk2::Gdk::Pixbuf->new_from_file_at_size(
		"$gscrot_root/share/gscrot/resources/icons/sel_window_section.svg",
		Gtk2::IconSize->lookup('large-toolbar')
	)
);
my $button_window_sect
	= Gtk2::ToolButton->new( $image_window_sect, $gscrot_common->get_gettext->get("Section") );
$button_window_sect->signal_connect(
	'clicked' => \&evt_take_screenshot,
	'section'
);
$tooltips->set_tip(
	$button_window_sect,
	$gscrot_common->get_gettext->get(
		"Captures only a section of the window. You will be able to select any child window by moving the mouse over it"
	)
);

#--------------------------------------

#button web
#--------------------------------------
my $image_web = Gtk2::Image->new_from_pixbuf(
	Gtk2::Gdk::Pixbuf->new_from_file_at_size(
		"$gscrot_root/share/gscrot/resources/icons/web_image.svg",
		Gtk2::IconSize->lookup('large-toolbar')
	)
);
my $button_web_menu
	= Gtk2::MenuToolButton->new( $image_web, $gscrot_common->get_gettext->get("Web") );
$button_web_menu->signal_connect( 'clicked' => \&evt_take_screenshot, 'web' );
$button_web_menu->set_menu(&fct_ret_web_menu);
$button_web_menu->signal_connect( 'show-menu' => \&fct_ret_web_menu );

if ($gnome_web_photo) {
	$tooltips->set_tip( $button_web_menu,
		$gscrot_common->get_gettext->get("Take a screenshot of a website") );
	$button_web_menu->set_arrow_tooltip( Gtk2::Tooltips->new,
		$gscrot_common->get_gettext->get("Set up a connection timeout (seconds)"), 'arrow' );
} else {
	$tooltips->set_tip( $button_web_menu,
		$gscrot_common->get_gettext->get("gnome-web-photo needs to be installed for this feature")
	);
	$button_web_menu->set_arrow_tooltip(
		$tooltips,
		$gscrot_common->get_gettext->get("gnome-web-photo needs to be installed for this feature"),
		'arrow'
	);
	$button_web_menu->set_sensitive($gnome_web_photo);
}

#--------------------------------------

#create the toolbar
my $toolbar = Gtk2::Toolbar->new;
$toolbar->set_show_arrow(TRUE);
$toolbar->set_style('both');
$toolbar->set_icon_size('large-toolbar');
$toolbar->insert( $button_select_menu,          -1 );
$toolbar->insert( Gtk2::SeparatorToolItem->new, -1 );
$toolbar->insert( $button_raw_menu,             -1 );
$toolbar->insert( Gtk2::SeparatorToolItem->new, -1 );
$toolbar->insert( $button_window_menu,          -1 );
$toolbar->insert( $button_window_sect,          -1 );
$toolbar->insert( Gtk2::SeparatorToolItem->new, -1 );
$toolbar->insert( $button_web_menu,             -1 );
$toolbar->set_size_request( 450, -1 );

#a detachable toolbar
my $handlebox = Gtk2::HandleBox->new;
$handlebox->add($toolbar);
$vbox->pack_start( $handlebox, FALSE, TRUE, 0 );

#trayicon
#--------------------------------------
#command line param set to disable tray icon?
unless ( $gscrot_common->get_disable_systray ) {

	if ( Gtk2->CHECK_VERSION( 2, 10, 0 ) ) {
		$icon = Gtk2::StatusIcon->new();
		$icon->set_from_file("$gscrot_root/share/pixmaps/gscrot.svg");
		$icon->set_visible(1);
		$icon->signal_connect(
			'popup-menu' => sub { &evt_show_systray_statusicon; },
			$icon
		);
		$icon->signal_connect(
			'activate' => sub {
				&evt_activate_systray_statusicon;
				$icon;
			},
			$icon
		);
		$icon->set_tooltip( GSCROT_NAME . " " . GSCROT_VERSION );
	} else {
		require Gtk2::TrayIcon;
		$icon = Gtk2::Image->new_from_pixbuf(
			Gtk2::Gdk::Pixbuf->new_from_file_at_size(
				"$gscrot_root/share/pixmaps/gscrot.svg",
				24, 24
			)
		);
		my $eventbox = Gtk2::EventBox->new;
		$eventbox->add($icon);
		my $tray = Gtk2::TrayIcon->new('gscrot TrayIcon');
		$tray->add($eventbox);
		$tooltips->set_tip( $tray, GSCROT_NAME . " " . GSCROT_VERSION );
		$eventbox->signal_connect( 'button_release_event', \&evt_show_systray );
		$tray->show_all;
	}

}

#--------------------------------------

#settings
#--------------------------------------
my $profiles_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("Profile") . " :" );

my $combobox_settings_profiles = Gtk2::ComboBox->new_text;
my @saved_profiles             = glob("$ENV{'HOME'}/.gscrot/profiles/*.xml");
my @current_profiles;
my $current_index = 0;
foreach ( sort @saved_profiles ) {
	utf8::decode $_;
	next
		if $_ =~ /\_accounts.xml/;    #accounts file - we are looking for "real" profiles
	$_ =~ /.*\/(.*)\.xml/;            #get profiles name
	my $last_profile_name = $1;
	$combobox_settings_profiles->append_text($last_profile_name);

	#set active profile
	if ( exists $settings_xml->{'general'}->{'last_profile_name'} ) {
		if ( $settings_xml->{'general'}->{'last_profile_name'} eq $last_profile_name ) {
			$combobox_settings_profiles->set_active($current_index);
			$current_profile_indx = $current_index;
		}
	}

	push( @current_profiles, $last_profile_name );
	$current_index++;
}
$tooltips->set_tip( $combobox_settings_profiles,
	$gscrot_common->get_gettext->get("Choose a profile") );

#set 0 if nothing is selected yet
if ( !$combobox_settings_profiles->get_active_text ) {
	$combobox_settings_profiles->set_active(0);
	$current_profile_indx = 0;
}

#populate quick selector as well
$menuitem_quicks->set_submenu(
	fct_ret_profile_menu( $combobox_settings_profiles, \@current_profiles ) );

my $button_profile_save = Gtk2::Button->new;
$button_profile_save->signal_connect(
	'clicked' => sub {
		my $widget = shift;
		&evt_save_profile( $widget, $combobox_settings_profiles, \@current_profiles );
	}
);
$button_profile_save->set_image( Gtk2::Image->new_from_stock( 'gtk-save', 'button' ) );
$tooltips->set_tip( $button_profile_save,
	$gscrot_common->get_gettext->get("Save configuration as profile") );

my $button_profile_delete = Gtk2::Button->new;
$button_profile_delete->signal_connect(
	'clicked' => sub {
		my $widget = shift;
		&evt_delete_profile( $widget, $combobox_settings_profiles, \@current_profiles );
	}
);
$button_profile_delete->set_image( Gtk2::Image->new_from_stock( 'gtk-delete', 'button' ) );
$tooltips->set_tip( $button_profile_delete, $gscrot_common->get_gettext->get("Delete profile") );
my $button_profile_apply = Gtk2::Button->new;
$button_profile_apply->signal_connect(
	'clicked' => sub {
		my $widget = shift;
		&evt_apply_profile( $widget, $combobox_settings_profiles, \@current_profiles );
	}
);
$button_profile_apply->set_image( Gtk2::Image->new_from_stock( 'gtk-apply', 'button' ) );
$tooltips->set_tip( $button_profile_apply,
	$gscrot_common->get_gettext->get("Set profile for current configuration") );

my $file_frame_label = Gtk2::Label->new;
$file_frame_label->set_markup( $gscrot_common->get_gettext->get("Image format") );
my $file_frame = Gtk2::Frame->new();
$file_frame->set_label_widget($file_frame_label);
my $save_frame_label = Gtk2::Label->new;
$save_frame_label->set_markup( $gscrot_common->get_gettext->get("Save") );
my $save_frame = Gtk2::Frame->new();
$save_frame->set_label_widget($save_frame_label);
my $behavior_frame_label = Gtk2::Label->new;
$behavior_frame_label->set_markup( $gscrot_common->get_gettext->get("Behavior") );
my $behavior_frame = Gtk2::Frame->new();
$behavior_frame->set_label_widget($behavior_frame_label);
my $keybinding_frame_label = Gtk2::Label->new;
$keybinding_frame_label->set_markup( $gscrot_common->get_gettext->get("Gnome-Keybinding") );
my $keybinding_frame = Gtk2::Frame->new();
$keybinding_frame->set_label_widget($keybinding_frame_label);
my $actions_frame_label = Gtk2::Label->new;
$actions_frame_label->set_markup( $gscrot_common->get_gettext->get("Actions") );
my $actions_frame = Gtk2::Frame->new();
$actions_frame->set_label_widget($actions_frame_label);
my $capture_frame_label = Gtk2::Label->new;
$capture_frame_label->set_markup( $gscrot_common->get_gettext->get("Capture") );
my $capture_frame = Gtk2::Frame->new();
$capture_frame->set_label_widget($capture_frame_label);
my $accounts_frame_label = Gtk2::Label->new;
$accounts_frame_label->set_markup( $gscrot_common->get_gettext->get("Accounts") );
my $accounts_frame = Gtk2::Frame->new();
$accounts_frame->set_label_widget($accounts_frame_label);
my $ftp_frame_label = Gtk2::Label->new;
$ftp_frame_label->set_markup( $gscrot_common->get_gettext->get("File Transfer Protocol (FTP)") );
my $ftp_frame = Gtk2::Frame->new();
$ftp_frame->set_label_widget($ftp_frame_label);

#delay
my $delay_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("Delay") );
my $delay = Gtk2::HScale->new_with_range( 1, 10, 1 );
$delay->signal_connect(
	'value-changed' => \&evt_value_changed,
	'delay_changed'
);
$delay->set_value_pos('right');

if ( defined $settings_xml->{'general'}->{'delay'} ) {
	$delay->set_value( $settings_xml->{'general'}->{'delay'} );
} else {
	$delay->set_value(0);
}
my $delay_active = Gtk2::CheckButton->new;
$delay_active->signal_connect(
	'toggled' => \&evt_value_changed,
	'delay_toggled'
);
$delay_active->set_active(TRUE);

if ( defined $settings_xml->{'general'}->{'delay_active'} ) {
	$delay_active->set_active( $settings_xml->{'general'}->{'delay_active'} );
} else {
	$delay_active->set_active(FALSE);
}
$tooltips->set_tip( $delay,
	$gscrot_common->get_gettext->get("Wait n seconds before taking a screenshot") );
$tooltips->set_tip( $delay_active,
	$gscrot_common->get_gettext->get("Wait n seconds before taking a screenshot") );
$tooltips->set_tip( $delay_label,
	$gscrot_common->get_gettext->get("Wait n seconds before taking a screenshot") );
$delay_box->pack_start( $delay_label, FALSE, TRUE, 10 );
$delay_box2->pack_start( $delay_active, FALSE, FALSE, 0 );
$delay_box2->pack_start( $delay,        TRUE,  TRUE,  0 );
$delay_box->pack_start( $delay_box2, TRUE, TRUE, 10 );

#end - delay
#operator
my $combobox_thumb_operator = Gtk2::ComboBox->new_text;
$combobox_thumb_operator->insert_text( 0,
	"Resize" . " (" . $gscrot_common->get_gettext->get("Recommended") . ")" );
$combobox_thumb_operator->insert_text( 1, "Thumbnail" );
$combobox_thumb_operator->insert_text( 2, "Sample" );
$combobox_thumb_operator->insert_text( 3, "Scale" );
$combobox_thumb_operator->insert_text( 4, "AdaptiveResize" );

if ( defined $settings_xml->{'general'}->{'resize_operator'} ) {
	$combobox_thumb_operator->set_active( $settings_xml->{'general'}->{'resize_operator'} );
} else {
	$combobox_thumb_operator->set_active(0);
}
$tooltips->set_tip(
	$combobox_thumb_operator,
	$gscrot_common->get_gettext->get(
		"Select resize operator\nSee http://www.imagemagick.org/Usage/resize/ for help")
);
$resize_operator_box->pack_start( Gtk2::Label->new,         FALSE, FALSE, 0 );
$resize_operator_box->pack_start( $combobox_thumb_operator, TRUE,  TRUE,  10 );

#operator
#thumbnail
my $thumbnail_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("Thumbnail") );
my $thumbnail = Gtk2::HScale->new_with_range( 1, 100, 1 );
$thumbnail->signal_connect(
	'value-changed' => \&evt_value_changed,
	'thumbnail_changed'
);
$thumbnail->set_value_pos('right');

if ( defined $settings_xml->{'general'}->{'thumbnail'} ) {
	$thumbnail->set_value( $settings_xml->{'general'}->{'thumbnail'} );
} else {
	$thumbnail->set_value(50);
}
my $thumbnail_active = Gtk2::CheckButton->new;
$thumbnail_active->signal_connect(
	'toggled' => \&evt_value_changed,
	'thumbnail_toggled'
);
$thumbnail_active->set_active(TRUE);

if ( defined $settings_xml->{'general'}->{'thumbnail_active'} ) {
	$thumbnail_active->set_active( $settings_xml->{'general'}->{'thumbnail_active'} );
} else {
	$thumbnail_active->set_active(FALSE);
}
$tooltips->set_tip(
	$thumbnail,
	$gscrot_common->get_gettext->get(
		"Generate thumbnail too.\nselect the percentage of the original size for the thumbnail to be"
	)
);
$tooltips->set_tip(
	$thumbnail_active,
	$gscrot_common->get_gettext->get(
		"Generate thumbnail too.\nselect the percentage of the original size for the thumbnail to be"
	)
);
$tooltips->set_tip(
	$thumbnail_label,
	$gscrot_common->get_gettext->get(
		"Generate thumbnail too.\nselect the percentage of the original size for the thumbnail to be"
	)
);
$thumbnail_box->pack_start( $thumbnail_label, FALSE, TRUE, 10 );
$thumbnail_box2->pack_start( $thumbnail_active, FALSE, FALSE, 0 );
$thumbnail_box2->pack_start( $thumbnail,        TRUE,  TRUE,  0 );
$thumbnail_box->pack_start( $thumbnail_box2, TRUE, TRUE, 10 );

#end - thumbnail
#filename
my $filename = Gtk2::Entry->new;
if ( defined $settings_xml->{'general'}->{'filename'} ) {
	$filename->set_text( $settings_xml->{'general'}->{'filename'} );
} else {
	$filename->set_text("screenshot_\%NN");
}
my $filename_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("Filename") );
$tooltips->set_tip(
	$filename,
	$gscrot_common->get_gettext->get(
		"There are several wild-cards available, like\n%Y = year\n%m = month\n%d = day\n%T = time\n\$w = width\n\$h = height\n%NN = counter"
	)
);
$tooltips->set_tip(
	$filename_label,
	$gscrot_common->get_gettext->get(
		"There are several wild-cards available, like\n%Y = year\n%m = month\n%d = day\n%T = time\n\$w = width\n\$h = height\n%NN = counter"
	)
);
$filename_box->pack_start( $filename_label, FALSE, TRUE, 10 );
$filename_box->pack_start( $filename,       TRUE,  TRUE, 10 );

#end - filename
#filetype and scale
my $scale         = Gtk2::HScale->new_with_range( 0, 9, 1 );
my $scale_label   = Gtk2::Label->new( $gscrot_common->get_gettext->get("Compression") );
my $combobox_type = Gtk2::ComboBox->new_text;
$combobox_type->insert_text( 0, "jpeg" );
$combobox_type->insert_text( 1, "png" );
$combobox_type->signal_connect(
	'changed' => \&evt_value_changed,
	'type_changed'
);

if ( defined $settings_xml->{'general'}->{'filetype'} ) {
	$combobox_type->set_active( $settings_xml->{'general'}->{'filetype'} );
} else {
	$combobox_type->set_active(1);
}
my $filetype_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("Image format") );
$tooltips->set_tip( $combobox_type,  $gscrot_common->get_gettext->get("Select a file format") );
$tooltips->set_tip( $filetype_label, $gscrot_common->get_gettext->get("Select a file format") );
$filetype_box->pack_start( $filetype_label, FALSE, TRUE, 10 );
$filetype_box->pack_start( $combobox_type,  TRUE,  TRUE, 10 );
$scale->signal_connect(
	'value-changed' => \&evt_value_changed,
	'quality_changed'
);
$scale->set_value_pos('right');
$scale->set_value(1);

if ( defined $settings_xml->{'general'}->{'quality'} ) {
	$scale->set_value( $settings_xml->{'general'}->{'quality'} );
} else {
	$scale->set_value(9);
}
$tooltips->set_tip(
	$scale,
	$gscrot_common->get_gettext->get(
		"Quality/Compression:\nHigh value means high size / high compression\n(depending on file format chosen)"
	)
);
$tooltips->set_tip(
	$scale_label,
	$gscrot_common->get_gettext->get(
		"Quality/Compression:\nHigh value means high size / high compression\n(depending on file format chosen)"
	)
);
$scale_box->pack_start( $scale_label, FALSE, TRUE, 10 );
$scale_box->pack_start( $scale,       TRUE,  TRUE, 10 );

#end - filetype and scale
#saveDir
my $saveDir_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("Directory") );
my $saveDir_button
	= Gtk2::FileChooserButton->new( "GScrot - " . $gscrot_common->get_gettext->get("Choose folder"),
	'select-folder' );
$saveDir_button->set_width_chars(10);

if ( defined $settings_xml->{'general'}->{'folder'} ) {
	$saveDir_button->set_current_folder( $settings_xml->{'general'}->{'folder'} );
} else {
	$saveDir_button->set_current_folder( $ENV{'HOME'} );
}

$tooltips->set_tip( $saveDir_button,
	$gscrot_common->get_gettext->get("Your screenshots will be saved\nto this directory") );
$tooltips->set_tip( $saveDir_label,
	$gscrot_common->get_gettext->get("Your screenshots will be saved\nto this directory") );
$saveDir_box->pack_start( $saveDir_label,  FALSE, TRUE, 10 );
$saveDir_box->pack_start( $saveDir_button, TRUE,  TRUE, 10 );

#end - saveDir
#behavior
my $capture_key = Gtk2::Entry->new;
if ( defined $settings_xml->{'general'}->{'capture_key'} ) {
	$capture_key->set_text( $settings_xml->{'general'}->{'capture_key'} );
} else {
	$capture_key->set_text("Print");
}
my $capture_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("Capture") );
$tooltips->set_tip(
	$capture_key,
	$gscrot_common->get_gettext->get(
		"Configure global keybinding for capture\nThe format looks like \"<Control>a\" or \"<Shift><Alt>F1\". The parser is fairly liberal and allows lower or upper case, and also abbreviations such as \"<Ctl>\" and \"<Ctrl>\". If you set the option to the special string \"disabled\", then there will be no keybinding for this action. "
	)
);
$tooltips->set_tip(
	$capture_label,
	$gscrot_common->get_gettext->get(
		"Configure global keybinding for capture\nThe format looks like \"<Control>a\" or \"<Shift><Alt>F1\". The parser is fairly liberal and allows lower or upper case, and also abbreviations such as \"<Ctl>\" and \"<Ctrl>\". If you set the option to the special string \"disabled\", then there will be no keybinding for this action. "
	)
);
my $capture_sel_key = Gtk2::Entry->new;

if ( defined $settings_xml->{'general'}->{'capture_sel_key'} ) {
	$capture_sel_key->set_text( $settings_xml->{'general'}->{'capture_sel_key'} );
} else {
	$capture_sel_key->set_text("<Alt>Print");
}

my $capture_sel_label
	= Gtk2::Label->new( $gscrot_common->get_gettext->get("Capture with selection") );
$tooltips->set_tip(
	$capture_sel_key,
	$gscrot_common->get_gettext->get(
		"Configure global keybinding for capture with selection\nThe format looks like \"<Control>a\" or \"<Shift><Alt>F1\". The parser is fairly liberal and allows lower or upper case, and also abbreviations such as \"<Ctl>\" and \"<Ctrl>\". If you set the option to the special string \"disabled\", then there will be no keybinding for this action. "
	)
);
$tooltips->set_tip(
	$capture_sel_label,
	$gscrot_common->get_gettext->get(
		"Configure global keybinding for capture with selection\nThe format looks like \"<Control>a\" or \"<Shift><Alt>F1\". The parser is fairly liberal and allows lower or upper case, and also abbreviations such as \"<Ctl>\" and \"<Ctrl>\". If you set the option to the special string \"disabled\", then there will be no keybinding for this action. "
	)
);

#keybinding_mode
my $combobox_keybinding_mode = Gtk2::ComboBox->new_text;
$combobox_keybinding_mode->insert_text( 0, $gscrot_common->get_gettext->get("Selection") );
$combobox_keybinding_mode->insert_text( 1, $gscrot_common->get_gettext->get("Window") );
$combobox_keybinding_mode->insert_text( 2, $gscrot_common->get_gettext->get("Section") );

if ( defined $settings_xml->{'general'}->{'keybinding_mode'} ) {
	$combobox_keybinding_mode->set_active( $settings_xml->{'general'}->{'keybinding_mode'} );
} else {
	$combobox_keybinding_mode->set_active(1);
}
$tooltips->set_tip(
	$combobox_keybinding_mode,
	$gscrot_common->get_gettext->get(
		"Configure global keybinding for capture with selection\nThe format looks like \"<Control>a\" or \"<Shift><Alt>F1\". The parser is fairly liberal and allows lower or upper case, and also abbreviations such as \"<Ctl>\" and \"<Ctrl>\". If you set the option to the special string \"disabled\", then there will be no keybinding for this action. "
	)
);
$combobox_keybinding_mode->signal_connect(
	'changed' => \&evt_behavior_handle,
	'keybinding_sel_toggled'
);

$keybinding_mode_box->pack_start( Gtk2::Label->new,          FALSE, FALSE, 0 );
$keybinding_mode_box->pack_start( $combobox_keybinding_mode, FALSE, TRUE,  10 );

#keybindings
my $keybinding_active = Gtk2::CheckButton->new;
$keybinding_active->signal_connect(
	'toggled' => \&evt_behavior_handle,
	'keybinding_toggled'
);
my $keybinding_sel_active = Gtk2::CheckButton->new;
$keybinding_sel_active->signal_connect(
	'toggled' => \&evt_behavior_handle,
	'keybinding_sel_toggled'
);
$key_box->pack_start( $capture_label, FALSE, TRUE, 10 );
$key_box2->pack_start( $keybinding_active, FALSE, FALSE, 0 );
$key_box2->pack_start( $capture_key,       TRUE,  TRUE,  0 );
$key_box->pack_start( $key_box2, TRUE, TRUE, 10 );
$key_sel_box->pack_start( $capture_sel_label, FALSE, TRUE, 10 );
$key_sel_box2->pack_start( $keybinding_sel_active, FALSE, FALSE, 0 );
$key_sel_box2->pack_start( $capture_sel_key,       TRUE,  TRUE,  0 );
$key_sel_box->pack_start( $key_sel_box2, TRUE, TRUE, 10 );
$keybinding_active->set_active(TRUE);

if ( defined $settings_xml->{'general'}->{'keybinding'} ) {
	$keybinding_active->set_active( $settings_xml->{'general'}->{'keybinding'} );
} else {
	$keybinding_active->set_active(FALSE);
}
$keybinding_sel_active->set_active(TRUE);
if ( defined $settings_xml->{'general'}->{'keybinding_sel'} ) {
	$keybinding_sel_active->set_active( $settings_xml->{'general'}->{'keybinding_sel'} );
} else {
	$keybinding_sel_active->set_active(FALSE);
}
my $hide_active = Gtk2::CheckButton->new_with_label(
	$gscrot_common->get_gettext->get("Autohide GScrot Window when taking a screenshot") );
my $autocopy_active = Gtk2::CheckButton->new_with_label(
	$gscrot_common->get_gettext->get("Automatically copy screenshot to clipboard") );
my $close_at_close_active = Gtk2::CheckButton->new_with_label(
	$gscrot_common->get_gettext->get("Minimize to tray when closing main window") );
my $save_at_close_active = Gtk2::CheckButton->new_with_label(
	$gscrot_common->get_gettext->get("Save settings when exiting") );

$hide_active->signal_connect(
	'toggled' => \&evt_behavior_handle,
	'hide_toggled'
);

if ( defined $settings_xml->{'general'}->{'autohide'} ) {
	$hide_active->set_active( $settings_xml->{'general'}->{'autohide'} );
} else {
	$hide_active->set_active(TRUE);
}
$tooltips->set_tip( $hide_active,
	$gscrot_common->get_gettext->get("Automatically hide GScrot Window when taking a screenshot") );
$autocopy_active->signal_connect(
	'toggled' => \&evt_behavior_handle,
	'autocopy_toggled'
);

if ( defined $settings_xml->{'general'}->{'autocopy'} ) {
	$autocopy_active->set_active( $settings_xml->{'general'}->{'autocopy'} );
} else {
	$autocopy_active->set_active(TRUE);
}
$tooltips->set_tip( $autocopy_active,
	$gscrot_common->get_gettext->get("Automatically copy screenshot to clipboard") );
$close_at_close_active->signal_connect(
	'toggled' => \&evt_behavior_handle,
	'close_at_close_toggled'
);

if ( defined $settings_xml->{'general'}->{'close_at_close'} ) {
	$close_at_close_active->set_active( $settings_xml->{'general'}->{'close_at_close'} );
} else {
	$close_at_close_active->set_active(TRUE);
}
$tooltips->set_tip( $close_at_close_active,
	$gscrot_common->get_gettext->get("Minimize to tray when closing main window") );
$save_at_close_active->signal_connect(
	'toggled' => \&evt_behavior_handle,
	'save_at_close_toggled'
);

if ( defined $settings_xml->{'general'}->{'save_at_close'} ) {
	$save_at_close_active->set_active( $settings_xml->{'general'}->{'save_at_close'} );
} else {
	$save_at_close_active->set_active(TRUE);
}
$tooltips->set_tip( $save_at_close_active,
	$gscrot_common->get_gettext->get("Save settings automatically when exiting GScrot") );

#end - behavior
#program
my $model        = &fct_get_program_model;
my $progname     = Gtk2::ComboBox->new($model);
my $renderer_pix = Gtk2::CellRendererPixbuf->new;
$progname->pack_start( $renderer_pix, FALSE );
$progname->add_attribute( $renderer_pix, pixbuf => 0 );
my $renderer_text = Gtk2::CellRendererText->new;
$progname->pack_start( $renderer_text, FALSE );
$progname->add_attribute( $renderer_text, text => 1 );

#try to set the saved value
if ( defined $settings_xml->{'general'}->{'prog'} ) {
	$model->foreach( \&fct_iter_programs, $settings_xml->{'general'}->{'prog'} );
} else {
	$progname->set_active(0);
}

#nothing has been set
if ( $progname->get_active == -1 ) {
	$progname->set_active(0);
}

my $progname_active = Gtk2::CheckButton->new;
$progname_active->signal_connect(
	'toggled' => \&evt_value_changed,
	'progname_toggled'
);
if ( defined $settings_xml->{'general'}->{'prog_active'} ) {
	$progname_active->set_active( $settings_xml->{'general'}->{'prog_active'} );
} else {
	$progname_active->set_active(FALSE);
}
my $progname_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("Open with") );
$tooltips->set_tip( $progname,
	$gscrot_common->get_gettext->get("Open your screenshot\nwith this program after capturing") );
$tooltips->set_tip( $progname_active,
	$gscrot_common->get_gettext->get("Open your screenshot\nwith this program after capturing") );
$tooltips->set_tip( $progname_label,
	$gscrot_common->get_gettext->get("Open your screenshot\nwith this program after capturing") );
$progname_box->pack_start( $progname_label, TRUE, TRUE, 10 );
$progname_box2->pack_start( $progname_active, FALSE, TRUE, 0 );
$progname_box2->pack_start( $progname,        TRUE,  TRUE, 0 );
$progname_box->pack_start( $progname_box2, TRUE, TRUE, 10 );

#end - program
#im_colors
my $combobox_im_colors = Gtk2::ComboBox->new_text;
$combobox_im_colors->insert_text( 0, $gscrot_common->get_gettext->get("16 colors   - (4bit) ") );
$combobox_im_colors->insert_text( 1, $gscrot_common->get_gettext->get("64 colors   - (6bit) ") );
$combobox_im_colors->insert_text( 2, $gscrot_common->get_gettext->get("256 colors  - (8bit) ") );
$combobox_im_colors->signal_connect(
	'changed' => \&evt_value_changed,
	'border_changed'
);

if ( defined $settings_xml->{'general'}->{'im_colors'} ) {
	$combobox_im_colors->set_active( $settings_xml->{'general'}->{'im_colors'} );
} else {
	$combobox_im_colors->set_active(2);
}
my $im_colors_active = Gtk2::CheckButton->new;
$im_colors_active->signal_connect(
	'toggled' => \&evt_value_changed,
	'im_colors_toggled'
);
$im_colors_active->set_active(TRUE);

if ( defined $settings_xml->{'general'}->{'im_colors_active'} ) {
	$im_colors_active->set_active( $settings_xml->{'general'}->{'im_colors_active'} );
} else {
	$im_colors_active->set_active(FALSE);
}
my $im_colors_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("Reduce colors") );
$tooltips->set_tip( $combobox_im_colors,
	$gscrot_common->get_gettext->get("Automatically reduce colors \nafter taking a screenshot") );
$tooltips->set_tip( $im_colors_active,
	$gscrot_common->get_gettext->get("Automatically reduce colors \nafter taking a screenshot") );
$tooltips->set_tip( $im_colors_label,
	$gscrot_common->get_gettext->get("Automatically reduce colors \nafter taking a screenshot") );
$im_colors_box->pack_start( $im_colors_label, TRUE, TRUE, 10 );
$im_colors_box2->pack_start( $im_colors_active,   FALSE, TRUE, 0 );
$im_colors_box2->pack_start( $combobox_im_colors, TRUE,  TRUE, 0 );
$im_colors_box->pack_start( $im_colors_box2, TRUE, TRUE, 10 );

#end - colors
#border
my $combobox_border = Gtk2::ComboBox->new_text;
$combobox_border->insert_text( 1, $gscrot_common->get_gettext->get("activate") );
$combobox_border->insert_text( 0, $gscrot_common->get_gettext->get("deactivate") );
$combobox_border->signal_connect(
	'changed' => \&evt_value_changed,
	'border_changed'
);

if ( defined $settings_xml->{'general'}->{'border'} ) {
	$combobox_border->set_active( $settings_xml->{'general'}->{'border'} );
} else {
	$combobox_border->set_active(TRUE);
}
my $border_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("Window border") );
$tooltips->set_tip( $combobox_border,
	$gscrot_common->get_gettext->get("Include wm border when selecting a window") );
$tooltips->set_tip( $border_label,
	$gscrot_common->get_gettext->get("Include wm border when selecting a window") );
$border_box->pack_start( $border_label,    FALSE, TRUE, 10 );
$border_box->pack_start( $combobox_border, TRUE,  TRUE, 10 );

#end - border

#cursor
my $combobox_cursor = Gtk2::ComboBox->new_text;
$combobox_cursor->insert_text( 1, $gscrot_common->get_gettext->get("activate") );
$combobox_cursor->insert_text( 0, $gscrot_common->get_gettext->get("deactivate") );
$combobox_cursor->signal_connect(
	'changed' => \&evt_value_changed,
	'cursor_changed'
);

if ( defined $settings_xml->{'general'}->{'cursor'} ) {
	$combobox_cursor->set_active( $settings_xml->{'general'}->{'cursor'} );
} else {
	$combobox_cursor->set_active(0);
}
my $cursor_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("Include cursor") );
$tooltips->set_tip( $combobox_cursor,
	$gscrot_common->get_gettext->get("Include cursor when taking a screenshot") );
$tooltips->set_tip( $cursor_label,
	$gscrot_common->get_gettext->get("Include cursor when taking a screenshot") );
$cursor_box->pack_start( $cursor_label,    FALSE, TRUE, 10 );
$cursor_box->pack_start( $combobox_cursor, TRUE,  TRUE, 10 );

#end - cursor

#accounts
#--------------------------------------
my $accounts_model = undef;
&fct_load_accounts_tree;

my $accounts_tree = Gtk2::TreeView->new_with_model($accounts_model);
$tooltips->set_tip(
	$accounts_tree,
	$gscrot_common->get_gettext->get(
		"Entering your Accounts for specific hosting-sites is optional. If entered it will give you the same benefits as the upload on the website. If you leave these fields empty you will be able to upload to the specific hosting-partner as a guest."
	)
);

$accounts_tree->signal_connect(
	'row-activated' => \&evt_accounts,
	'row_activated'
);

&fct_set_model_accounts($accounts_tree);

#ftp uri
my $ftp_entry_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("URI") );

$ftp_hbox1->pack_start( $ftp_entry_label, TRUE, TRUE, 10 );

my $ftp_remote_entry = Gtk2::Entry->new;
if ( defined $settings_xml->{'general'}->{'ftp_uri'} ) {
	$ftp_remote_entry->set_text( $settings_xml->{'general'}->{'ftp_uri'} );
} else {
	$ftp_remote_entry->set_text("ftp://host:port/path");
}

$tooltips->set_tip( $ftp_entry_label,
	$gscrot_common->get_gettext->get("URI\nExample: ftp://host:port/path") );

$tooltips->set_tip( $ftp_remote_entry,
	$gscrot_common->get_gettext->get("URI\nExample: ftp://host:port/path") );

$ftp_hbox1->pack_start( $ftp_remote_entry, TRUE, TRUE, 10 );

#connection mode
my $ftp_mode_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("Connection mode") );

$ftp_hbox2->pack_start( $ftp_mode_label, TRUE, TRUE, 10 );

my $ftp_mode_combo = Gtk2::ComboBox->new_text;
$ftp_mode_combo->insert_text( 0, $gscrot_common->get_gettext->get("Active mode") );
$ftp_mode_combo->insert_text( 1, $gscrot_common->get_gettext->get("Passive mode") );
if ( defined $settings_xml->{'general'}->{'ftp_mode'} ) {
	$ftp_mode_combo->set_active( $settings_xml->{'general'}->{'ftp_mode'} );
} else {
	$ftp_mode_combo->set_active(0);
}

$tooltips->set_tip( $ftp_mode_label, $gscrot_common->get_gettext->get("Connection mode") );

$tooltips->set_tip( $ftp_mode_combo, $gscrot_common->get_gettext->get("Connection mode") );

$ftp_hbox2->pack_start( $ftp_mode_combo, TRUE, TRUE, 10 );

#username
my $ftp_username_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("Username") );
$ftp_hbox3->pack_start( $ftp_username_label, TRUE, TRUE, 10 );

my $ftp_username_entry = Gtk2::Entry->new;
if ( defined $settings_xml->{'general'}->{'ftp_username'} ) {
	$ftp_username_entry->set_text( $settings_xml->{'general'}->{'ftp_username'} );
} else {
	$ftp_username_entry->set_text("");
}

$tooltips->set_tip( $ftp_username_label, $gscrot_common->get_gettext->get("Username") );

$tooltips->set_tip( $ftp_username_entry, $gscrot_common->get_gettext->get("Username") );

$ftp_hbox3->pack_start( $ftp_username_entry, TRUE, TRUE, 10 );

#password
my $ftp_password_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("Password") );
$ftp_hbox4->pack_start( $ftp_password_label, TRUE, TRUE, 10 );

my $ftp_password_entry = Gtk2::Entry->new;
$ftp_password_entry->set_invisible_char("*");
$ftp_password_entry->set_visibility(FALSE);
if ( defined $settings_xml->{'general'}->{'ftp_password'} ) {
	$ftp_password_entry->set_text( $settings_xml->{'general'}->{'ftp_password'} );
} else {
	$ftp_password_entry->set_text("");
}

$tooltips->set_tip( $ftp_password_label, $gscrot_common->get_gettext->get("Password") );

$tooltips->set_tip( $ftp_password_entry, $gscrot_common->get_gettext->get("Password") );

$ftp_hbox4->pack_start( $ftp_password_entry, TRUE, TRUE, 10 );

#--------------------------------------

#plugins
#--------------------------------------
my $effects_model = undef;
&fct_load_plugin_tree;

my $effects_tree = Gtk2::TreeView->new_with_model($effects_model);
$effects_tree->signal_connect(
	'row-activated' => \&evt_plugins,
	'row_activated'
);

&fct_set_model_plugins($effects_tree);

#--------------------------------------

#packing
#--------------------------------------

#settings main tab
my $label_basic = Gtk2::Label->new;
$label_basic->set_markup( $gscrot_common->get_gettext->get("<i>Main</i>") );

$file_vbox->pack_start( $scale_box,    TRUE,  TRUE, 5 );
$file_vbox->pack_start( $filetype_box, FALSE, TRUE, 5 );
$file_frame->add($file_vbox);

$save_vbox->pack_start( $filename_box, TRUE,  TRUE, 5 );
$save_vbox->pack_start( $saveDir_box,  FALSE, TRUE, 5 );
$save_frame->add($save_vbox);

$vbox_basic->pack_start( $file_frame, FALSE, TRUE, 5 );
$vbox_basic->pack_start( $save_frame, FALSE, TRUE, 5 );
$vbox_basic->set_border_width(5);

#settings advanced tab
my $label_extras = Gtk2::Label->new;
$label_extras->set_markup( $gscrot_common->get_gettext->get("<i>Advanced</i>") );

$actions_vbox->pack_start( $progname_box,        FALSE, TRUE, 5 );
$actions_vbox->pack_start( $im_colors_box,       FALSE, TRUE, 5 );
$actions_vbox->pack_start( $thumbnail_box,       FALSE, TRUE, 5 );
$actions_vbox->pack_start( $resize_operator_box, FALSE, TRUE, 5 );
$actions_frame->add($actions_vbox);

$capture_vbox->pack_start( $delay_box,  FALSE, TRUE, 5 );
$capture_vbox->pack_start( $border_box, FALSE, TRUE, 5 );
$capture_vbox->pack_start( $cursor_box, FALSE, TRUE, 5 );
$capture_frame->add($capture_vbox);

$vbox_extras->pack_start( $actions_frame, FALSE, TRUE, 1 );
$vbox_extras->pack_start( $capture_frame, FALSE, TRUE, 1 );
$vbox_extras->set_border_width(5);

#settings behavior tab
my $label_behavior = Gtk2::Label->new;
$label_behavior->set_markup( $gscrot_common->get_gettext->get("<i>Behavior</i>") );

$behavior_vbox->pack_start( $autocopy_active,       TRUE, TRUE, 5 );
$behavior_vbox->pack_start( $hide_active,           TRUE, TRUE, 5 );
$behavior_vbox->pack_start( $close_at_close_active, TRUE, TRUE, 5 );
$behavior_vbox->pack_start( $save_at_close_active,  TRUE, TRUE, 5 );
$behavior_frame->add($behavior_vbox);

$keybinding_vbox->pack_start( $key_box,             FALSE, TRUE, 5 );
$keybinding_vbox->pack_start( $key_sel_box,         FALSE, TRUE, 5 );
$keybinding_vbox->pack_start( $keybinding_mode_box, FALSE, TRUE, 5 );
$keybinding_frame->add($keybinding_vbox);

$vbox_behavior->pack_start( $behavior_frame,   FALSE, TRUE, 1 );
$vbox_behavior->pack_start( $keybinding_frame, FALSE, TRUE, 1 );
$vbox_behavior->set_border_width(5);

#settings upload tab
my $label_accounts = Gtk2::Label->new;
$label_accounts->set_markup( "<i>" . $gscrot_common->get_gettext->get("Upload") . "</i>" );

my $scrolled_accounts_window = Gtk2::ScrolledWindow->new;
$scrolled_accounts_window->set_policy( 'automatic', 'automatic' );
$scrolled_accounts_window->add($accounts_tree);
$accounts_hbox->pack_start( $scrolled_accounts_window, FALSE, TRUE, 5 );
$accounts_vbox->pack_start( $accounts_hbox,            FALSE, TRUE, 5 );
$accounts_frame->add($accounts_vbox);

$ftp_vbox->pack_start( $ftp_hbox1, FALSE, TRUE, 1 );
$ftp_vbox->pack_start( $ftp_hbox2, FALSE, TRUE, 1 );
$ftp_vbox->pack_start( $ftp_hbox3, FALSE, TRUE, 1 );
$ftp_vbox->pack_start( $ftp_hbox4, FALSE, TRUE, 1 );
$ftp_frame->add($ftp_vbox);

$vbox_accounts->pack_start( $accounts_frame, TRUE,  TRUE, 1 );
$vbox_accounts->pack_start( $ftp_frame,      FALSE, TRUE, 1 );
$vbox_accounts->set_border_width(5);

#append pages to notebook
my $notebook_settings_first  = $notebook_settings->append_page( $vbox_basic,    $label_basic );
my $notebook_settings_second = $notebook_settings->append_page( $vbox_extras,   $label_extras );
my $notebook_settings_third  = $notebook_settings->append_page( $vbox_behavior, $label_behavior );
my $notebook_settings_fourth = $notebook_settings->append_page( $vbox_accounts, $label_accounts );

#plugins
if ( keys(%plugins) > 0 ) {
	my $scrolled_plugins_window = Gtk2::ScrolledWindow->new;
	$scrolled_plugins_window->set_policy( 'automatic', 'automatic' );
	$scrolled_plugins_window->add($effects_tree);
	my $label_plugins = Gtk2::Label->new;
	$label_plugins->set_markup( $gscrot_common->get_gettext->get("<i>Plugins</i>") );
	$effects_vbox->pack_start( $scrolled_plugins_window, TRUE, TRUE, 1 );
	$vbox_plugins->pack_start( $effects_vbox,            TRUE, TRUE, 1 );
	$vbox_plugins->set_border_width(5);
	my $notebook_settings_fifth = $notebook_settings->append_page( $vbox_plugins, $label_plugins );
}

#profiles
$profiles_box->pack_start( $profiles_label,             FALSE, TRUE, 1 );
$profiles_box->pack_start( $combobox_settings_profiles, TRUE,  TRUE, 1 );
$profiles_box->pack_start( $button_profile_save,        FALSE, TRUE, 1 );
$profiles_box->pack_start( $button_profile_delete,      FALSE, TRUE, 1 );
$profiles_box->pack_start( $button_profile_apply,       FALSE, TRUE, 1 );

$vbox_settings->pack_start( $profiles_box,      FALSE, TRUE, 1 );
$vbox_settings->pack_start( $notebook_settings, TRUE,  TRUE, 1 );

#settings
$settings_dialog->vbox->add($vbox_settings);
$settings_dialog->set_default_response('apply');

#main app
$vbox->pack_start( $notebook,  TRUE,  TRUE,  0 );
$vbox->pack_start( $statusbar, FALSE, FALSE, 0 );

#--------------------------------------

#restore session
&fct_load_session;

#start minimized?
unless ( $gscrot_common->get_min ) {
	$window->show_all;
	$is_in_tray = FALSE;
} else {
	$window->hide;
	$is_in_tray = TRUE;
}

#load saved settings
my $folder_to_save = $settings_xml->{'general'}->{'folder'}
	|| $ENV{'HOME'};
if ( $gscrot_common->get_start_with && $folder_to_save ) {
	if ( $gscrot_common->get_start_with eq "raw" ) {
		&evt_take_screenshot( 'global_keybinding', "raw", $folder_to_save );
	} elsif ( $gscrot_common->get_start_with eq "select" ) {
		&evt_take_screenshot( 'global_keybinding', "select", $folder_to_save );
	} elsif ( $gscrot_common->get_start_with eq "window" ) {
		&evt_take_screenshot( 'global_keybinding', "window", $folder_to_save );
	} elsif ( $gscrot_common->get_start_with eq "section" ) {
		&evt_take_screenshot( 'global_keybinding', "section", $folder_to_save );
	}
}

Gtk2->main;

0;

#events
#--------------------------------------
sub evt_navigate {
	my ( $widget, $data ) = @_;
	print "\n$data was emitted by widget $widget\n" if $gscrot_common->get_debug;
	if ( $data eq "first" ) {
		$notebook->set_current_page(0);
	} elsif ( $data eq "last" ) {
		$notebook->set_current_page( $notebook->get_n_pages - 1 );
	} elsif ( $data eq "previous" ) {
		$notebook->prev_page;
	} elsif ( $data eq "forward" ) {
		$notebook->next_page;
	}
	return 1;
}

sub evt_value_changed {
	my ( $widget, $data ) = @_;
	print "\n$data was emitted by widget $widget\n" if $gscrot_common->get_debug;

	return FALSE unless $data;

	#checkbox for "open with" -> entry active/inactive
	if ( $data eq "progname_toggled" ) {
		if ( $progname_active->get_active ) {
			$progname->set_sensitive(TRUE);
		} else {
			$progname->set_sensitive(FALSE);
		}
	}

	#checkbox for "color depth" -> entry active/inactive
	if ( $data eq "im_colors_toggled" ) {
		if ( $im_colors_active->get_active ) {
			$combobox_im_colors->set_sensitive(TRUE);
		} else {
			$combobox_im_colors->set_sensitive(FALSE);
		}
	}

	#checkbox for "delay" -> HScale active/inactive
	if ( $data eq "delay_toggled" ) {
		if ( $delay_active->get_active ) {
			$delay->set_sensitive(TRUE);
		} else {
			$delay->set_sensitive(FALSE);
		}
	}

	#checkbox for "thumbnail" -> HScale active/inactive
	if ( $data eq "thumbnail_toggled" ) {
		if ( $thumbnail_active->get_active ) {
			$thumbnail->set_sensitive(TRUE);
			$combobox_thumb_operator->set_sensitive(TRUE);
		} else {
			$thumbnail->set_sensitive(FALSE);
			$combobox_thumb_operator->set_sensitive(FALSE);
		}
	}

	#filetype changed
	if ( $data eq "type_changed" ) {
		if ( $combobox_type->get_active_text eq "jpeg" ) {
			$scale->set_range( 1, 100 );
			$scale->set_value(90);
			$scale_label->set_text( $gscrot_common->get_gettext->get("Quality") );
		} elsif ( $combobox_type->get_active_text eq "png" ) {
			$scale->set_range( 0, 9 );
			$scale->set_value(9);
			$scale_label->set_text( $gscrot_common->get_gettext->get("Compression") );
		}
	}

	return TRUE;
}

sub evt_take_screenshot {
	my ( $widget, $data, $folder_from_config ) = @_;

	#disable signal-handler
	$SIG{USR1}  = 'IGNORE';
	$SIG{USR2}  = 'IGNORE';
	$SIG{RTMIN} = 'IGNORE';
	$SIG{RTMAX} = 'IGNORE';

	my $quality_value             = undef;
	my $delay_value               = undef;
	my $thumbnail_value           = undef;
	my $progname_value            = undef;
	my $im_colors_value           = undef;
	my $filename_value            = undef;
	my $filetype_value            = undef;
	my $folder                    = undef;
	my $screenshot                = undef;
	my $screenshot_name           = undef;
	my $screenshot_thumbnail      = undef;
	my $screenshot_thumbnail_name = undef;
	my $thumbnail_ending          = "thumb";
	print "\n$data was emitted by widget $widget\n" if $gscrot_common->get_debug;
	&fct_set_toolbar_sensitive( FALSE, $data );

	#get xid if any window was selected from the submenu...
	my $selfcapture = FALSE;
	if ( $data =~ /^gscrot_window_direct(.*)/ ) {
		my $xid = $1;
		$selfcapture = TRUE if $xid == $window->window->XID;
	}

	#determine current file type
	$filetype_value = $combobox_type->get_active_text;

	#determine folder to save
	$folder = $saveDir_button->get_filename || $folder_from_config;
	utf8::decode $folder;

	if ( $filetype_value eq "jpeg" ) {
		$quality_value = $scale->get_value();
	} elsif ( $filetype_value eq "png" ) {
		$quality_value = $scale->get_value * 10 + 5;
	}
	if ( $delay_active->get_active ) {
		$delay_value = $delay->get_value;
	} else {
		$delay_value = 0;
	}
	if ( $thumbnail_active->get_active ) {
		$thumbnail_value = $thumbnail->get_value;
	}

	#prepare filename, parse wild-cards
	$filename_value = $filename->get_text();
	utf8::decode $filename_value;
	$filename_value = strftime $filename_value , localtime;
	$filename_value = &fct_get_next_filename( $filename_value, $folder, $filetype_value );

	#hide mainwindow
	if (   $hide_active->get_active
		&& ( $data ne "web" && $data ne "tray_web" )
		&& !$is_in_tray
		&& !$selfcapture )
	{
		$window->iconify;
		$window->hide;
		Gtk2::Gdk->flush;
		$is_in_tray = TRUE;
	}

	#fullscreen screenshot
	if ( $data eq "raw" || $data eq "tray_raw" ) {
		my $wnck_screen = Gnome2::Wnck::Screen->get_default;
		unless ( $filename_value =~ /[a-zA-Z0-9]+/
			&& defined($folder)
			&& defined($filetype_value) )
		{
			&dlg_error_message( $gscrot_common->get_gettext->get("No valid filename specified") );
			&fct_set_toolbar_sensitive( TRUE, $data );
			return FALSE;
		}

		my $screenshooter = GScrot::Screenshot::Workspace->new(
			$gscrot_common, $combobox_cursor->get_active,
			$delay_value, $wnck_screen->get_active_workspace,
			undef, undef, $current_monitor_active->get_active
		);
		$screenshot = $screenshooter->workspace();

		#window
	} elsif ( $data eq "window"
		|| $data eq "tray_window"
		|| $data eq "section"
		|| $data eq "tray_section" )
	{
		unless ( $filename_value =~ /[a-zA-Z0-9]+/ ) {
			&dlg_error_message( $gscrot_common->get_gettext->get("No valid filename specified") );
			&fct_set_toolbar_sensitive( TRUE, $data );
			return FALSE;
		}

		my $screenshooter = GScrot::Screenshot::Window->new(
			$gscrot_common, $combobox_cursor->get_active,
			$delay_value, $combobox_border->get_active,
			undef, $data, $window, $is_in_tray
		);
		$screenshot = $screenshooter->window_select();

		#selection
	} elsif ( $data eq "select" || $data eq "tray_select" ) {
		unless ( $filename_value =~ /[a-zA-Z0-9]+/ ) {
			&dlg_error_message( $gscrot_common->get_gettext->get("No valid filename specified") );
			&fct_set_toolbar_sensitive( TRUE, $data );
			return FALSE;
		}
		if ( $tool_advanced->get_active ) {
			my $screenshooter = GScrot::Screenshot::SelectorAdvanced->new( $gscrot_common,
				$combobox_cursor->get_active, $delay_value );
			$screenshot = $screenshooter->select_advanced();

		} else {
			my $zoom_size_factor = 1;
			$zoom_size_factor = 2 if ( $zoom_size2->get_active );
			$zoom_size_factor = 3 if ( $zoom_size3->get_active );
			my $screenshooter
				= GScrot::Screenshot::SelectorSimple->new( $gscrot_common,
				$combobox_cursor->get_active,
				$delay_value, $zoom_size_factor, $zoom_active->get_active );
			$screenshot = $screenshooter->select_simple();
		}

		#web
	} elsif ( $data eq "web" || $data eq "tray_web" ) {
		$screenshot = &dlg_website( $folder, $filename_value, $filetype_value, $quality_value );

		if ($screenshot) {
			unless ( $screenshot->Get('width') ) {
				&dlg_error_message(
					$gscrot_common->get_gettext->get("Unable to capture website") . "!" );
				&dlg_status_message( 1,
					$gscrot_common->get_gettext->get("Unable to capture website") . "!" );
				&fct_set_toolbar_sensitive( TRUE, $data );
				return FALSE;
			}
		} else {
			&fct_set_toolbar_sensitive( TRUE, $data );
			return FALSE;
		}

	} elsif ( $data =~ /^gscrot_window_direct(.*)/ ) {
		my $xid = $1;
		print "Selected xid: $xid\n" if $gscrot_common->get_debug;
		unless ( $filename_value =~ /[a-zA-Z0-9]+/ ) {
			&dlg_error_message( $gscrot_common->get_gettext->get("No valid filename specified") );
			&fct_set_toolbar_sensitive( TRUE, $data );
			return FALSE;
		}
		my $screenshooter
			= GScrot::Screenshot::Window->new( $gscrot_common, $combobox_cursor->get_active,
			$delay_value, $combobox_border->get_active, $xid );
		$screenshot = $screenshooter->window_by_xid();

	} elsif ( $data =~ /^gscrot_wrksp_direct/ ) {

		#we need to handle different wm, e.g. metacity, compiz here

		my $selected_workspace = undef;
		my $vpx                = undef;
		my $vpy                = undef;

		#compiz
		if ( $data =~ /compiz(\d*)x(\d*)/ ) {
			$vpx = $1;
			$vpy = $2;
			print "Sel. Viewport: $vpx, $vpy\n" if $gscrot_common->get_debug;

			#metacity etc.
		} elsif ( $data =~ /gscrot_wrksp_direct(.*)/ ) {
			$selected_workspace = $1;
			print "Sel. Workspace: $selected_workspace\n" if $gscrot_common->get_debug;
		}

		unless ( $filename_value =~ /[a-zA-Z0-9]+/ ) {
			&dlg_error_message( $gscrot_common->get_gettext->get("No valid filename specified") );
			&fct_set_toolbar_sensitive( TRUE, $data );
			return FALSE;
		}
		my $screenshooter
			= GScrot::Screenshot::Workspace->new( $gscrot_common, $combobox_cursor->get_active,
			$delay_value, $selected_workspace, $vpx, $vpy, $current_monitor_active->get_active );
		$screenshot = $screenshooter->workspace();
	}

	#screenshot was taken at this stage...
	#start postprocessing here

	#check if file already exists
	if ( $gscrot_hfunct->file_exists("$folder/$filename_value.$filetype_value")
		&& ( $data ne "web" && $data ne "tray_web" ) )
	{
		unless (
			$gscrot_dialog->dlg_question_message(
				$gscrot_common->get_gettext->get(
					"File already exists.\nDo you want to overwrite it?")
			)
			)
		{
			$screenshot = 5;
		}
	}

	#...successfully???
	unless ($screenshot) {
		&dlg_error_message(
			$gscrot_common->get_gettext->get(
				"Screenshot failed!\nMaybe mouse pointer could not be grabbed or the selected area is invalid."
			)
		);
		print "Screenshot failed!" if $gscrot_common->get_debug;
		&dlg_status_message( 1, $gscrot_common->get_gettext->get("Screenshot failed!") );
		&fct_set_toolbar_sensitive( TRUE, $data );

		#focus window after taking a screenshot
		$window->show_all;
		$is_in_tray = FALSE;

		return FALSE;
	} else {

		#user aborted screenshot
		if ( $screenshot == 5 ) {
			&dlg_status_message( 1, $gscrot_common->get_gettext->get("Capture aborted by user") );
			&fct_set_toolbar_sensitive( TRUE, $data );

			#focus window after taking a screenshot
			$window->show_all;
			$is_in_tray = FALSE;

			return FALSE;
		}

		#quantize
		if ( $im_colors_active->get_active ) {
			$im_colors_value = $combobox_im_colors->get_active_text();
			$im_colors_value =~ /.*\(([0-9]*).*\)/;
			$screenshot->Quantize( colors => 2**$1 );
		}

		#generate the thumbnail
		if ( $thumbnail_active->get_active ) {

			#copy orig image object
			$screenshot_thumbnail = $screenshot->copy;

			#calculate size
			my $twidth  = int( $screenshot_thumbnail->Get('columns') * ( $thumbnail_value / 100 ) );
			my $theight = int( $screenshot_thumbnail->Get('rows') *    ( $thumbnail_value / 100 ) );

			#resize it
			&fct_resize_imagemagick_object( \$screenshot_thumbnail, $twidth, $theight );

			#save path of thumbnail
			$screenshot_thumbnail_name
				= "$folder/$filename_value-$thumbnail_ending.$filetype_value";

			#parse wild cards
			$screenshot_thumbnail_name =~ s/\$w/$twidth/g;
			$screenshot_thumbnail_name =~ s/\$h/$theight/g;
			print "Trying to save file to $screenshot_thumbnail_name\n"
				if $gscrot_common->get_debug;

			#finally save it to disk
			$screenshot_thumbnail->Write(
				filename => $screenshot_thumbnail_name,
				quality  => $quality_value
			);
			unless ( $gscrot_hfunct->file_exists($screenshot_thumbnail_name) ) {
				&dlg_error_message(
					$$gscrot_common->get_gettext->get("Could not generate thumbnail") );
				undef $screenshot_thumbnail;
				&fct_set_toolbar_sensitive( TRUE, $data );
				return 0;
			}
		}

		#and save the filename
		$screenshot_name = "$folder/$filename_value.$filetype_value";
		my $swidth  = $screenshot->Get('columns');
		my $sheight = $screenshot->Get('rows');

		#parse wild cards
		$screenshot_name =~ s/\$w/$swidth/g;
		$screenshot_name =~ s/\$h/$sheight/g;
		print "Trying to save file to $screenshot_name\n" if $gscrot_common->get_debug;

		#save orig file to disk
		$screenshot->Write(
			filename => $screenshot_name,
			quality  => $quality_value
		);
	}    #end screenshot successfull
	if ( $gscrot_hfunct->file_exists($screenshot_name) ) {

		#integrate it into the notebook
		my $new_key_screenshot = &fct_integrate_screenshot_in_notebook($screenshot_name);

		#thumbnail as well if present
		my $new_key_screenshot_thumbnail
			= &fct_integrate_screenshot_in_notebook($screenshot_thumbnail_name)
			if $thumbnail_active->get_active;

		#autocopy to clipboard if configured
		if ( $autocopy_active->get_active() ) {
			my $pixbuf = Gtk2::Gdk::Pixbuf->new_from_file(
				$session_screens{$new_key_screenshot}->{'long'} );
			$clipboard->set_image($pixbuf);
		}

		#open screenshot with configured program
		if ( $progname_active->get_active ) {
			my $model         = $progname->get_model();
			my $progname_iter = $progname->get_active_iter();
			if ($progname_iter) {
				$progname_value = $model->get_value( $progname_iter, 2 );
			}
			&fct_open_with_program($progname_value);
		}
		print "screenshot successfully saved to $screenshot_name!\n"
			if $gscrot_common->get_debug;
		&dlg_status_message( 1,
			"$session_screens{$new_key_screenshot}->{'short'} "
				. $gscrot_common->get_gettext->get("saved") );
	} else {
		&dlg_error_message(
			$gscrot_common->get_gettext->get(
				"Screenshot failed!\nMaybe mouse pointer could not be grabbed or the selected area is invalid."
			)
		);
		print "Screenshot failed!" if $gscrot_common->get_debug;
		&dlg_status_message( 1, $gscrot_common->get_gettext->get("Screenshot failed!") );
	}

	#destroy the imagemagick objects and free memory
	undef $screenshot;
	undef $screenshot_thumbnail;
	&fct_set_toolbar_sensitive( TRUE, $data );

	#focus window after taking a screenshot
	$window->deiconify;
	$window->show_all;
	$is_in_tray = FALSE;

	#attach signal-handler again
	$SIG{USR1}  = sub { &evt_take_screenshot( 'global_keybinding', 'raw' ) };
	$SIG{USR2}  = sub { &evt_take_screenshot( 'global_keybinding', 'window' ) };
	$SIG{RTMIN} = sub { &evt_take_screenshot( 'global_keybinding', 'select' ) };
	$SIG{RTMAX} = sub { &evt_take_screenshot( 'global_keybinding', 'section' ) };

	return TRUE;
}

sub evt_behavior_handle {
	my ( $widget, $data ) = @_;
	print "\n$data was emitted by widget $widget\n" if $gscrot_common->get_debug;

	#checkbox for "keybinding" -> entry active/inactive
	if ( $data eq "keybinding_toggled" ) {
		if ( $keybinding_active->get_active ) {
			$capture_key->set_sensitive(TRUE);
		} else {
			$capture_key->set_sensitive(FALSE);
		}
	}

	#checkbox for "keybinding_sel" -> entry active/inactive
	if ( $data eq "keybinding_sel_toggled" ) {
		if ( $keybinding_sel_active->get_active ) {
			$capture_sel_key->set_sensitive(TRUE);
			$combobox_keybinding_mode->set_sensitive(TRUE);
		} else {
			$capture_sel_key->set_sensitive(FALSE);
			$combobox_keybinding_mode->set_sensitive(FALSE);
		}
	}

	&fct_save_bindings();

	return TRUE;
}

sub evt_notebook_switch {
	my ( $widget, $pointer, $int ) = @_;
	if ( $menuitem_save_as && $menuitem_close && $menuitem_close_all ) {
		if ( $int == 0 ) {
			$menuitem_save_as->set_sensitive(FALSE);
			$menuitem_close->set_sensitive(FALSE);
		} else {
			$menuitem_save_as->set_sensitive(TRUE);
			$menuitem_close->set_sensitive(TRUE);
		}
	}

	&fct_update_tab_plugins(&fct_get_current_file($int));    #update attached plugins (may have changed)

	&fct_update_first_tab();                           #update first tab for information
}

sub evt_delete_window {
	my ( $widget, $data ) = @_;
	print "\n$data was emitted by widget $widget\n" if $gscrot_common->get_debug;

	if ( $data ne "menu_quit" && $close_at_close_active->get_active ) {
		$window->hide;
		$is_in_tray = TRUE;
		return TRUE;
	}

	if ( $save_at_close_active->get_active ) {
		&fct_save_settings(undef);
		&fct_save_settings( $combobox_settings_profiles->get_active_text )
			if $combobox_settings_profiles->get_active != -1;
	}

	Gtk2->main_quit;
	return FALSE;
}

sub evt_bug {
	$gscrot_hfunct->gnome_open( undef, "https://bugs.launchpad.net/gscrot", undef );
}

sub evt_question {
	$gscrot_hfunct->gnome_open( undef, "https://answers.launchpad.net/gscrot", undef );
}

sub evt_translate {
	$gscrot_hfunct->gnome_open( undef, "https://translations.launchpad.net/gscrot", undef );
}

sub evt_about {
	my ( $widget, $data ) = @_;
	if ( $gscrot_common->get_debug ) {
		print "\n$data was emitted by widget $widget\n";
	}
	open( GPL_HINT, "$gscrot_root/share/gscrot/resources/license/gplv3_hint" )
		or die "ERROR--> Failed to open copyright-file!";
	my @copyright_hint = <GPL_HINT>;
	close(GPL_HINT);
	open( GPL, "$gscrot_root/share/gscrot/resources/license/gplv3" )
		or die "ERROR--> Failed to open license-file!";
	my @copyright = <GPL>;
	close(GPL);
	open( GPL, "$gscrot_root/share/gscrot/resources/pofiles/credits" )
		or die "ERROR--> Failed to open credits-file!";
	my @translators = <GPL>;
	close(GPL);
	my $all_lines = "";

	foreach my $line (@copyright) {
		utf8::decode $line;
		$all_lines = $all_lines . $line;
	}
	my $all_hints = "";
	foreach my $hint (@copyright_hint) {
		utf8::decode $hint;
		$all_hints = $all_hints . $hint;
	}
	my $all_translators = "";
	foreach my $translator (@translators) {
		utf8::decode $translator;
		$all_translators = $all_translators . $translator;
	}
	my $website = "http://launchpad.net/gscrot";
	my $about   = Gtk2::AboutDialog->new;
	my $logo    = Gtk2::Gdk::Pixbuf->new_from_file_at_size( "$gscrot_root/share/pixmaps/gscrot.svg",
		150, 150 );
	$about->set_logo($logo);
	$about->set_name(GSCROT_NAME) unless Gtk2->CHECK_VERSION( 2, 12, 0 );
	$about->set_program_name(GSCROT_NAME) if Gtk2->CHECK_VERSION( 2, 12, 0 );
	$about->set_version(GSCROT_VERSION);
	$about->set_url_hook( sub { $gscrot_hfunct->gnome_open(@_) } );
	$about->set_website_label($website);
	$about->set_website($website);
	$about->set_email_hook( sub { $gscrot_hfunct->gnome_open_mail(@_) } );
	$about->set_authors(
		"Development:\nMario Kemper <mario.kemper\@googlemail.com>\nRene Hennig <Rene.Hennig\@my-united.net>\n\n"
			. "Patches:\nFranco Zeoli\n\n"
			. "Plugins:\nMartin Rabeneck (cornix) <martinrabeneck\@gmx.net>\nEdwood Ocasio <edwood.ocasio\@gmail.com> \n\n"
			. "ubuntu-pics.de:\nRene Hennig <Rene.Hennig\@my-united.net>" );
	$about->set_artists( "Pascal Grochol <pg0803\@gmail.com>", "Arne Weinberg" );
	$about->set_translator_credits($all_translators);
	$about->set_copyright($all_hints);
	$about->set_license($all_lines);
	$about->set_comments(GSCROT_VERSION_FULL);
	$about->show_all;
	$about->signal_connect( 'response' => sub { $about->destroy } );
}

sub evt_show_systray {
	my ( $widget, $data ) = @_;
	if ( $gscrot_common->get_debug ) {
		print "\n$data was emitted by widget $widget\n";
	}

	#left button (mouse)
	if ( $_[1]->button == 1 ) {
		if ( $window->visible ) {
			$window->hide;
			$is_in_tray = TRUE;
		} else {
			$window->show_all;
			$is_in_tray = FALSE;
		}
	}

	#right button (mouse)
	elsif ( $_[1]->button == 3 ) {

		my $tray_menu = &fct_ret_tray_menu;

		$tray_menu->popup(
			undef,    # parent menu shell
			undef,    # parent menu item
			undef,    # menu pos func
			undef,    # data
			$data->button,
			$data->time
		);
	}
	return TRUE;
}

sub evt_show_systray_statusicon {
	my ( $widget, $button, $time, $icon ) = @_;
	if ( $gscrot_common->get_debug ) {
		print "\n$button, $time was emitted by widget $widget\n";
	}

	my $tray_menu = &fct_ret_tray_menu;

	$tray_menu->popup(
		undef,    # parent menu shell
		undef,    # parent menu item
		sub {
			return Gtk2::StatusIcon::position_menu( $tray_menu, 0, 0, $icon );
		},        # menu pos func
		undef,    # data
		$time ? $button : 0,
		$time
	);
	return TRUE;
}

sub evt_activate_systray_statusicon {
	my ( $widget, $data, $icon ) = @_;
	if ( $gscrot_common->get_debug ) {
		print "\n$data was emitted by widget $widget\n";
	}

	if ( $window->visible ) {
		$window->hide;
		$is_in_tray = TRUE;
	} else {
		$window->show_all;
		$is_in_tray = FALSE;
	}

	return TRUE;
}

sub evt_plugins {
	my ( $tree, $path, $column ) = @_;

	#nothing to do here right now...
	return TRUE;
}

sub evt_accounts {
	my ( $tree, $path, $column ) = @_;

	#open browser if register url is clicked
	if ( $column->get_title eq $gscrot_common->get_gettext->get("Register") ) {
		my $model         = $tree->get_model();
		my $account_iter  = $model->get_iter($path);
		my $account_value = $model->get_value( $account_iter, 3 );
		$gscrot_hfunct->gnome_open( undef, $account_value, undef );
	}
	return TRUE;
}

sub evt_plugins_toolbar {
	my ( $renderer, $index, $model ) = @_;

	print "\n$renderer, $index, $model\n" if $gscrot_common->get_debug;

	my $path = Gtk2::TreePath->new_from_string($index);
	my $iter = $model->get_iter($path);

	if ( $renderer->get_active ) {
		$model->set( $iter, 0, FALSE );
		$plugins{ $model->get_value( $iter, 9 ) }->{'menu'} = FALSE;
	} else {
		$model->set( $iter, 0, TRUE );
		$plugins{ $model->get_value( $iter, 9 ) }->{'menu'} = TRUE;
	}

	return TRUE;
}

sub evt_iconview_sel_changed {
	my ( $iconview, $data ) = @_;

	my @sel_items = $iconview->get_selected_items;

	foreach ( keys %{ $session_start_screen{'first_page'} } ) {
		$session_start_screen{'first_page'}->{$_}->set_sensitive( ( scalar @sel_items > 0 ) )
			if $session_start_screen{'first_page'}->{$_} =~ /button/i;
	}

	return TRUE;
}

sub evt_iconview_item_activated {
	my ( $iconview, $path, $data ) = @_;

	my $iter = $session_start_screen{'first_page'}->{'model'}->get_iter($path);
	my $key = $session_start_screen{'first_page'}->{'model'}->get_value( $iter, 2 );

	$notebook->set_current_page( $notebook->page_num( $session_screens{$key}->{'tab_child'} ) );

	return TRUE;
}

sub evt_show_settings {
	&fct_check_installed_programs;

	$settings_dialog->show_all;
	my $settings_dialog_response = $settings_dialog->run;
	if ( $settings_dialog_response eq "close" ) {

		&fct_post_settings($settings_dialog);

		return TRUE;
	} else {

		&fct_post_settings($settings_dialog);

		return FALSE;
	}
}

sub fct_post_settings {
	my $settings_dialog = shift;

	#unset profile combobox when profile was not applied
	if ( $current_profile_indx != $combobox_settings_profiles->get_active ) {
		$combobox_settings_profiles->set_active($current_profile_indx);
	}

	$settings_dialog->hide();
	&fct_update_tab_plugins(&fct_get_current_file(undef));    #update attached plugins (may have changed)
	&fct_update_first_tab;

	return TRUE;
}

sub evt_open {
	my ( $widget, $data ) = @_;
	print "\n$data was emitted by widget $widget\n" if $gscrot_common->get_debug;

	my $fs = Gtk2::FileChooserDialog->new(
		$gscrot_common->get_gettext->get("Choose file to open"), $window, 'open',
		'gtk-cancel' => 'reject',
		'gtk-open'   => 'accept'
	);
	$fs->set_select_multiple(TRUE);
	my $filter = Gtk2::FileFilter->new;
	$filter->set_name("*.png / *.jpeg");
	$filter->add_pattern("*.png");
	$filter->add_pattern("*.jpeg");
	$fs->add_filter($filter);

	my $key = &fct_get_current_file(undef);
	if ($key) {
		$fs->set_current_folder( $session_screens{$key}->{'folder'} );
	} elsif ( $ENV{'HOME'} ) {
		$fs->set_current_folder( $saveDir_button->get_filename() );
	}
	my $fs_resp = $fs->run;

	my @new_files;
	if ( $fs_resp eq "accept" ) {
		@new_files = $fs->get_filenames;
		$fs->destroy();
	} else {
		$fs->destroy();
	}

	#call function to open files - with progress bar etc.
	&fct_open_files(@new_files);

	return TRUE;
}

sub evt_close {
	my ( $widget, $data ) = @_;
	print "\n$data was emitted by widget $widget\n" if $gscrot_common->get_debug;

	my $key = &fct_get_current_file(undef);
	$notebook->remove_page( $notebook->page_num( $session_screens{$key}->{'tab_child'} ) );
	&dlg_status_message( 1,
		      $session_screens{$key}->{'filename'} . " "
			. $gscrot_common->get_gettext->get("removed from session") )
		if defined( $session_screens{$key}->{'filename'} );
	delete( $session_screens{$key} );    # delete from hash
	&fct_update_first_tab();
	$window->show_all unless $is_in_tray;

	return TRUE;
}

sub evt_close_all {
	my ( $widget, $data ) = @_;
	print "\n$data was emitted by widget $widget\n" if $gscrot_common->get_debug;

	foreach my $key ( keys %session_screens ) {
		$notebook->remove_page( $notebook->page_num( $session_screens{$key}->{'tab_child'} ) );
		delete( $session_screens{$key} );
	}
	&dlg_status_message( 1, $gscrot_common->get_gettext->get("All screenshots removed") );
	&fct_update_first_tab;
	$window->show_all unless $is_in_tray;

	return TRUE;
}

sub evt_save_as {
	my ( $widget, $data ) = @_;
	print "\n$data was emitted by widget $widget\n" if $gscrot_common->get_debug;

	my $fs = Gtk2::FileChooserDialog->new(
		$gscrot_common->get_gettext->get("Choose a location to save to"), $window, 'save',
		'gtk-cancel' => 'reject',
		'gtk-save'   => 'accept'
	);

	#determine current tab >> filename
	my $key = &fct_get_current_file(undef);
	$fs->set_current_folder( $session_screens{$key}->{'folder'} );
	$fs->set_current_name( $session_screens{$key}->{'short'} );

	my $extra_hbox = Gtk2::HBox->new;

	my $label_save_as_type
		= Gtk2::Label->new( $gscrot_common->get_gettext->get("Image format") . ":" );

	my $combobox_save_as_type = Gtk2::ComboBox->new_text;

	$combobox_save_as_type->insert_text( 0, "JPEG Image - jpeg" );
	$combobox_save_as_type->insert_text( 1, "PNG Image - png" );

	if ( $session_screens{$key}->{'filetype'} eq "jpeg" ) {
		$combobox_save_as_type->set_active(0);
	} elsif ( $session_screens{$key}->{'filetype'} eq "png" ) {
		$combobox_save_as_type->set_active(1);
	} else {
		$combobox_save_as_type->set_active(1);
	}

	$combobox_save_as_type->signal_connect(
		'changed' => sub {
			my $filename = $fs->get_filename;

			my $choosen_format = $combobox_save_as_type->get_active_text;
			$choosen_format =~ s/.*\- //;    #get png or jpeg

			unless ( $filename =~ /.*\.$choosen_format$/ ) {
				$filename =~ s/\..*$/\.$choosen_format/;
			}

			#parse filename
			my ( $short, $folder, $ext ) = fileparse( $filename, '\..*' );

			$fs->set_current_name( $short . $ext );
		}
	);

	$extra_hbox->pack_start( $label_save_as_type,    FALSE, FALSE, 5 );
	$extra_hbox->pack_start( $combobox_save_as_type, FALSE, FALSE, 5 );

	my $align_save_as_type = Gtk2::Alignment->new( 1, 0, 0, 0 );

	$align_save_as_type->add($extra_hbox);
	$align_save_as_type->show_all;

	$fs->set_extra_widget($align_save_as_type);

	my $fs_resp = $fs->run;

	if ( $fs_resp eq "accept" ) {
		my $filename = $fs->get_filename;

		#handle file format
		my $choosen_format = $combobox_save_as_type->get_active_text;
		$choosen_format =~ s/.*\- //;    #get png or jpeg

		unless ( $filename =~ /.*\.$choosen_format$/ ) {
			$filename .= "." . $choosen_format;
		}

		unless ( $gscrot_hfunct->file_exists($filename) ) {
			&fct_imagemagick_perform( "save", $session_screens{$key}->{'long'}, $filename );
		} else {

			if ($gscrot_dialog->dlg_question_message(
					$filename . "\n\n"
						. $gscrot_common->get_gettext->get(
						"File already exists.\nDo you want to overwrite it?")
				)
				)
			{
				&fct_imagemagick_perform( "save", $session_screens{$key}->{'long'}, $filename );
				$session_screens{$key}->{'filename'} = $filename;
				&fct_create_thumbnail_and_fileinfos( $filename, $key );
				&fct_update_tab($key);

				&dlg_status_message( 1,
					"$session_screens{ $key }->{ 'short' } "
						. $gscrot_common->get_gettext->get("saved") );

				$fs->destroy();
				return TRUE;
			}
			$fs->destroy();
			return FALSE;
		}
		$session_screens{$key}->{'filename'} = $filename;
		&fct_create_thumbnail_and_fileinfos( $filename, $key );
		&fct_update_tab($key);

		&dlg_status_message( 1,
			"$session_screens{ $key }->{ 'short' } " . $gscrot_common->get_gettext->get("saved") );

		$fs->destroy();
		return TRUE;
	} else {
		$fs->destroy();
		return FALSE;
	}
}

sub evt_save_profile {
	my ( $widget, $combobox_settings_profiles, $current_profiles_ref ) = @_;
	my $curr_profile_name = $combobox_settings_profiles->get_active_text
		|| "";
	my $new_profile_name = &dlg_profile_name( $curr_profile_name, $combobox_settings_profiles );

	if ($new_profile_name) {
		if ( $curr_profile_name ne $new_profile_name ) {
			$combobox_settings_profiles->prepend_text($new_profile_name);
			$combobox_settings_profiles->set_active(0);
			$current_profile_indx = 0;

			#unshift to array as well
			unshift( @{$current_profiles_ref}, $new_profile_name );

			#populate quick selector as well
			$menuitem_quicks->set_submenu(
				fct_ret_profile_menu( $combobox_settings_profiles, $current_profiles_ref ) );
		}
		&fct_save_settings($new_profile_name);
	}
	return TRUE;
}

sub evt_delete_profile {
	my ( $widget, $combobox_settings_profiles, $current_profiles_ref ) = @_;
	if ( $combobox_settings_profiles->get_active_text ) {
		my $active_text  = $combobox_settings_profiles->get_active_text;
		my $active_index = $combobox_settings_profiles->get_active;
		unlink( "$ENV{'HOME'}/.gscrot/profiles/" . $active_text . ".xml" );
		unlink( "$ENV{'HOME'}/.gscrot/profiles/" . $active_text . "_accounts.xml" );

		unless (
			$gscrot_hfunct->file_exists( "$ENV{'HOME'}/.gscrot/profiles/" . $active_text . ".xml" )
			|| $gscrot_hfunct->file_exists(
				"$ENV{'HOME'}/.gscrot/profiles/" . $active_text . "_accounts.xml"
			)
			)
		{
			$combobox_settings_profiles->remove_text($active_index);
			$combobox_settings_profiles->set_active( $combobox_settings_profiles->get_active + 1 );
			$current_profile_indx = $combobox_settings_profiles->get_active;

			#remove from array as well
			splice( @{$current_profiles_ref}, $active_index, 1 );

			#populate quick selector as well
			$menuitem_quicks->set_submenu(
				fct_ret_profile_menu( $combobox_settings_profiles, $current_profiles_ref ) );

			&dlg_status_message( 1, $gscrot_common->get_gettext->get("Profile deleted") );
		} else {
			&dlg_error_message( $gscrot_common->get_gettext->get("Profile could not be deleted") );
			&dlg_status_message( 1,
				$gscrot_common->get_gettext->get("Profile could not be deleted") );
		}
	}
	return TRUE;
}

sub evt_apply_profile {
	my ( $widget, $combobox_settings_profiles, $current_profiles_ref ) = @_;

	if ( $combobox_settings_profiles->get_active_text ) {
		$settings_xml = &fct_load_settings( undef, 'profile_load',
			$combobox_settings_profiles->get_active_text );
		$current_profile_indx = $combobox_settings_profiles->get_active;

		#populate quick selector as well
		$menuitem_quicks->set_submenu(
			fct_ret_profile_menu( $combobox_settings_profiles, $current_profiles_ref ) );

		&fct_update_first_tab;
	}
	return TRUE;
}

#--------------------------------------

#functions
#--------------------------------------

sub fct_create_session_notebook {
	$notebook->set_scrollable(TRUE);
	$notebook->signal_connect(
		'switch-page' => \&evt_notebook_switch,
		'tab-switched'
	);
	$notebook->set_size_request( 430, 320 );
	my $hbox_first_label = Gtk2::HBox->new( FALSE, 0 );
	my $thumb_first_icon = Gtk2::Image->new_from_pixbuf(
		Gtk2::Gdk::Pixbuf->new_from_file_at_scale(
			"$gscrot_root/share/gscrot/resources/icons/session.svg",
			Gtk2::IconSize->lookup('menu'), TRUE
		)
	);
	my $tab_first_label = Gtk2::Label->new( $gscrot_common->get_gettext->get("Session") );
	$hbox_first_label->pack_start( $thumb_first_icon, FALSE, TRUE, 1 );
	$hbox_first_label->pack_start( $tab_first_label,  TRUE,  TRUE, 1 );
	$hbox_first_label->show_all;
	my $first_page = $notebook->append_page( fct_create_tab( "", TRUE ), $hbox_first_label );
	return 1;
}

sub fct_integrate_screenshot_in_notebook {
	my ($filename) = @_;

	#append a page to notebook using with label == filename
	my ( $second, $minute, $hour ) = localtime();
	my $theTime = "$hour:$minute:$second";
	my $key     = "[" . &fct_get_latest_tab_key . "] - $theTime";

	#create thumbnail for gui
	if ( &fct_create_thumbnail_and_fileinfos( $filename, $key ) ) {

		#build hash of screenshots during session
		$session_screens{$key}->{'filename'} = $filename;

		my $hbox_tab_label = Gtk2::HBox->new( FALSE, 0 );
		my $close_icon = Gtk2::Image->new_from_icon_name( 'gtk-close', 'menu' );
		print "Trying to create tab icon for $filename ...\n"
			if $gscrot_common->get_debug;
		$session_screens{$key}->{'tab_icon'}
			= Gtk2::Image->new_from_pixbuf( $session_screens{$key}->{'thumb'}
				->scale_simple( Gtk2::IconSize->lookup('menu'), 'tiles' ) );
		print "...tab icon for $filename created!\n" if $gscrot_common->get_debug;
		my $tab_close_button = Gtk2::Button->new;
		$tab_close_button->set_relief('none');
		$tab_close_button->set_image($close_icon);
		my $tab_label = Gtk2::Label->new($key);
		$hbox_tab_label->pack_start( $session_screens{$key}->{'tab_icon'}, FALSE, TRUE, 1 );
		$hbox_tab_label->pack_start( $tab_label,                           TRUE,  TRUE, 1 );
		$hbox_tab_label->pack_start( $tab_close_button,                    FALSE, TRUE, 1 );
		$hbox_tab_label->show_all;

		#and append page with label == key
		my $new_index = $notebook->append_page( fct_create_tab( $key, FALSE ), $hbox_tab_label );
		$session_screens{$key}->{'tab_child'} = $notebook->get_nth_page($new_index);
		$tab_close_button->signal_connect( clicked => sub { &fct_remove($key); } );

		$notebook->set_current_page($new_index);

		unless ($is_in_tray) {
			$window->show_all;
			&fct_update_gui;
		}
	}

	return $key;
}

sub fct_set_toolbar_sensitive {
	my ( $set, $data ) = @_;

	#set all buttons insensitive/sensitive
	$button_select_menu->set_sensitive($set);
	$button_raw_menu->set_sensitive($set);
	$button_window_menu->set_sensitive($set);
	$button_window_sect->set_sensitive($set);
	$button_web_menu->set_sensitive($set) if ($gnome_web_photo);

	if ( $hide_active->get_active && ( $data ne "web" && $data ne "tray_web" ) && !$is_in_tray ) {
		$window->show_all;
		&fct_update_gui;
		Gtk2::Gdk->flush;
		$is_in_tray = FALSE;
	}

	return 1;
}

sub fct_create_tab {
	my ( $key, $is_all ) = @_;

	my $vbox              = Gtk2::VBox->new( FALSE, 0 );
	my $vbox_tab          = Gtk2::VBox->new( FALSE, 0 );
	my $hbox_tab          = Gtk2::HBox->new( FALSE, 0 );
	my $vbox_all          = Gtk2::VBox->new( FALSE, 0 );
	my $hbox_all          = Gtk2::HBox->new( FALSE, 0 );
	my $vbox_all2         = Gtk2::VBox->new( FALSE, 0 );
	my $vbox_fileinfos    = Gtk2::VBox->new( FALSE, 0 );
	my $vbox_fileinfos2   = Gtk2::VBox->new( FALSE, 0 );
	my $hbox_tab_file     = Gtk2::HBox->new( FALSE, 0 );
	my $hbox_tab_actions  = Gtk2::HBox->new( FALSE, 0 );
	my $hbox_tab_actions2 = Gtk2::HBox->new( FALSE, 0 );

	my $tabtoolbar = Gtk2::Toolbar->new;
	$tabtoolbar->set_orientation('horizontal');
	$tabtoolbar->set_show_arrow(TRUE);
	$tabtoolbar->set_style('icons');
	$tabtoolbar->set_icon_size('button');

	#keep number (1 = single tab, 2 = session tab) for translation
	my $number = 1;
	$number = 2 if $is_all;

	my $button_delete
		= Gtk2::ToolButton->new( Gtk2::Image->new_from_icon_name( 'gtk-delete', 'button' ), undef );
	$button_delete->signal_connect( 'clicked' => sub { &fct_delete(); } );
	$tooltips->set_tip( $button_delete,
		$gscrot_common->get_gettext->nget( "Delete file", "Delete files", $number ) );

	my $button_clipboard
		= Gtk2::ToolButton->new( Gtk2::Image->new_from_icon_name( 'gtk-copy', 'button' ), undef );
	$button_clipboard->signal_connect( 'clicked' => sub { &fct_clipboard(); } );
	$tooltips->set_tip( $button_clipboard,
		$gscrot_common->get_gettext->get("Copy file to clipboard") );

	my $button_reopen
		= Gtk2::MenuToolButton->new( Gtk2::Image->new_from_icon_name( 'gtk-open', 'button' ),
		undef );
	$button_reopen->signal_connect( 'clicked' => sub { &fct_open_with_program(); } );
	$button_reopen->signal_connect( 'show-menu' => \&fct_ret_program_menu );
	$tooltips->set_tip( $button_reopen,
		$gscrot_common->get_gettext->nget( "Open file", "Open files", $number ) );
	$button_reopen->set_menu( &fct_ret_program_menu($button_reopen) );
	$button_reopen->set_arrow_tooltip(
		$tooltips,
		$gscrot_common->get_gettext->nget(
			"Choose a program to open the file with",
			"Choose a program to open the files with",
			$number
		),
		'arrow'
	);

	my $button_upload
		= Gtk2::ToolButton->new( Gtk2::Image->new_from_icon_name( 'gtk-go-up', 'button' ), undef );
	$button_upload->signal_connect( 'clicked' => sub { &fct_upload(); } );
	$tooltips->set_tip( $button_upload,
		$gscrot_common->get_gettext->nget( "Upload file", "Upload files", $number ) );

	my $button_rename
		= Gtk2::ToolButton->new( Gtk2::Image->new_from_icon_name( 'gtk-edit', 'button' ), undef );
	$button_rename->signal_connect( 'clicked' => sub { &fct_rename(); } );
	$tooltips->set_tip( $button_rename, $gscrot_common->get_gettext->get("Rename file") );

	my $button_plugin
		= Gtk2::ToolButton->new( Gtk2::Image->new_from_icon_name( 'gtk-execute', 'button' ),
		undef );
	$button_plugin->signal_connect( 'clicked' => sub { &fct_plugin(); } );
	$tooltips->set_tip( $button_plugin, $gscrot_common->get_gettext->get("Execute a plugin") );

	my $button_draw = Gtk2::ToolButton->new(
		Gtk2::Image->new_from_pixbuf(
			Gtk2::Gdk::Pixbuf->new_from_file_at_size(
				"$gscrot_root/share/gscrot/resources/icons/draw.svg",
				Gtk2::IconSize->lookup('button')
			)
		),
		undef
	);
	$button_draw->signal_connect( 'clicked' => sub { &fct_draw(); } );

	#maybe lib is not installed
	if ( !$goocanvas ) {
		$button_draw->set_sensitive(FALSE);
		$tooltips->set_tip( $button_draw,
			$gscrot_common->get_gettext->get("Goo::Canvas needs to be installed for this feature")
		);
	} else {
		$tooltips->set_tip( $button_draw, $gscrot_common->get_gettext->get("Edit screenshot") );
	}

	my $button_print
		= Gtk2::ToolButton->new( Gtk2::Image->new_from_icon_name( 'gtk-print', 'button' ), undef );
	$button_print->signal_connect( 'clicked' => sub { &fct_print(); } );

	if ($gtklp) {
		$tooltips->set_tip( $button_print,
			$gscrot_common->get_gettext->nget( "Print file", "Print files", $number ) );
	} else {
		$tooltips->set_tip( $button_print,
			$gscrot_common->get_gettext->get("gtklp needs to be installed for this feature") );
		$button_print->set_sensitive($gtklp);
	}

	unless ($is_all) {
		my $filename_label = Gtk2::Label->new;
		$filename_label->set_markup(
			"<b>" . $gscrot_common->get_gettext->get("Filename") . "</b>" );
		$session_screens{$key}->{'filename_label'}
			= Gtk2::Label->new( $session_screens{$key}->{'short'} );
		$session_screens{$key}->{'filename_label'}->set_line_wrap(TRUE);
		$session_screens{$key}->{'filename_label'}->set_single_line_mode(FALSE);
		$tooltips->set_tip( $session_screens{$key}->{'filename_label'},
			$session_screens{$key}->{'long'} );
		my $folder_label = Gtk2::Label->new;
		$folder_label->set_markup( "<b>" . $gscrot_common->get_gettext->get("Directory") . "</b>" );
		$session_screens{$key}->{'folder_label'}
			= Gtk2::Label->new( $session_screens{$key}->{'folder'} );
		$session_screens{$key}->{'folder_label'}->set_line_wrap(TRUE);
		$session_screens{$key}->{'folder_label'}->set_single_line_mode(FALSE);
		$tooltips->set_tip( $session_screens{$key}->{'folder_label'},
			$session_screens{$key}->{'long'} );
		my $mime_type_label = Gtk2::Label->new;
		$mime_type_label->set_markup(
			"<b>" . $gscrot_common->get_gettext->get("Mime-Type") . "</b>" );
		$session_screens{$key}->{'mime_type_label'}
			= Gtk2::Label->new( $session_screens{$key}->{'mime_type'} );
		my $size_label = Gtk2::Label->new;
		$size_label->set_markup( "<b>" . $gscrot_common->get_gettext->get("Filesize") . "</b>" );
		$session_screens{$key}->{'size_label'} = Gtk2::Label->new(
			sprintf( "%.2f", $session_screens{$key}->{'size'} / 1024 ) . " KB" );
		my $geometry_label = Gtk2::Label->new;
		$geometry_label->set_markup(
			"<b>" . $gscrot_common->get_gettext->get("Geometry") . "</b>" );
		$session_screens{$key}->{'geometry_label'} = Gtk2::Label->new(
			$session_screens{$key}->{'width'} . "x" . $session_screens{$key}->{'height'} );

		if ( $gscrot_hfunct->file_exists( $session_screens{$key}->{'filename'} ) ) {
			$session_screens{$key}->{'image'}
				= Gtk2::Image->new_from_pixbuf( $session_screens{$key}->{'thumb'} );
		} else {
			$session_screens{$key}->{'image'} = Gtk2::Image->new_from_pixbuf(
				Gtk2::Gdk::Pixbuf->new_from_file_at_size(
					"$gscrot_root/share/gscrot/resources/icons/Image-missing.svg",
					Gtk2::IconSize->lookup('dialog')
				)
			);
		}
		$session_screens{$key}->{'image'}->{'current_width'}
			= $session_screens{$key}->{'image'}->get_pixbuf->get_width;
		$session_screens{$key}->{'image'}->{'current_height'}
			= $session_screens{$key}->{'image'}->get_pixbuf->get_height;
		$session_screens{$key}->{'image'}->{'aspect_ratio'}
			= $session_screens{$key}->{'image'}->{'current_width'}
			/ $session_screens{$key}->{'image'}->{'current_height'};
		$session_screens{$key}->{'image'}
			->signal_connect_after( 'expose-event', \&fct_resize_thumb, $key )
			unless ($is_all);

		#packing
		my $tab_infos_sizegroup = Gtk2::SizeGroup->new('vertical');
		$tab_infos_sizegroup->add_widget( $session_screens{$key}->{'filename_label'} );
		$tab_infos_sizegroup->add_widget( $session_screens{$key}->{'folder_label'} );
		$tab_infos_sizegroup->add_widget( $session_screens{$key}->{'size_label'} );
		$tab_infos_sizegroup->add_widget( $session_screens{$key}->{'mime_type_label'} );
		$tab_infos_sizegroup->add_widget( $session_screens{$key}->{'geometry_label'} );

		$vbox_fileinfos->pack_start( $filename_label,                             FALSE, TRUE, 5 );
		$vbox_fileinfos->pack_start( $session_screens{$key}->{'filename_label'},  FALSE, TRUE, 2 );
		$vbox_fileinfos->pack_start( $folder_label,                               FALSE, TRUE, 5 );
		$vbox_fileinfos->pack_start( $session_screens{$key}->{'folder_label'},    FALSE, TRUE, 2 );
		$vbox_fileinfos->pack_start( $size_label,                                 FALSE, TRUE, 10 );
		$vbox_fileinfos->pack_start( $session_screens{$key}->{'size_label'},      FALSE, TRUE, 2 );
		$vbox_fileinfos->pack_start( $mime_type_label,                            FALSE, TRUE, 10 );
		$vbox_fileinfos->pack_start( $session_screens{$key}->{'mime_type_label'}, FALSE, TRUE, 2 );
		$vbox_fileinfos->pack_start( $geometry_label,                             FALSE, TRUE, 10 );
		$vbox_fileinfos->pack_start( $session_screens{$key}->{'geometry_label'},  FALSE, TRUE, 2 );

		$session_screens{$key}->{'btn_delete'}    = $button_delete;
		$session_screens{$key}->{'btn_reopen'}    = $button_reopen;
		$session_screens{$key}->{'btn_upload'}    = $button_upload;
		$session_screens{$key}->{'btn_print'}     = $button_print;
		$session_screens{$key}->{'btn_rename'}    = $button_rename;
		$session_screens{$key}->{'btn_plugin'}    = $button_plugin;
		$session_screens{$key}->{'btn_draw'}      = $button_draw;
		$session_screens{$key}->{'btn_clipboard'} = $button_clipboard;

		$tabtoolbar->insert( $button_reopen,               -1 );
		$tabtoolbar->insert( $button_rename,               -1 );
		$tabtoolbar->insert( Gtk2::SeparatorToolItem->new, -1 );
		$tabtoolbar->insert( $button_clipboard,            -1 );
		$tabtoolbar->insert( $button_print,                -1 );
		$tabtoolbar->insert( $button_upload,               -1 );
		$tabtoolbar->insert( Gtk2::SeparatorToolItem->new, -1 );
		$tabtoolbar->insert( $button_plugin,               -1 );
		$tabtoolbar->insert( $button_draw,                 -1 );
		$tabtoolbar->insert( Gtk2::SeparatorToolItem->new, -1 );
		$tabtoolbar->insert( $button_delete,               -1 );

		#add plugins to toolbar
		foreach ( sort keys %plugins ) {
			next unless $plugins{$_}->{'binary'};
			next unless $plugins{$_}->{'pixbuf'};
			my $btn = Gtk2::ToolButton->new(
				Gtk2::Image->new_from_pixbuf(
					Gtk2::Gdk::Pixbuf->new_from_file_at_size(
						$plugins{$_}->{'pixbuf'},
						Gtk2::IconSize->lookup('button')
					)
				),
				undef
			);
			my $data = [
				$plugins{$_}->{'binary'}, $plugins{$_}->{'name'}, $plugins{$_}->{'lang'},
				$key,                     undef
			];
			$tooltips->set_tip( $btn, $plugins{$_}->{'tooltip'} );
			$btn->signal_connect( 'clicked', \&fct_execute_plugin, $data );

			$tabtoolbar->insert( $btn, $tabtoolbar->get_n_items - 2 );
			$session_screens{$key}->{$btn} = $btn;

			#disable button if filetype is not supported
			$btn->set_sensitive(FALSE)
				unless $plugins{$_}->{'ext'} =~ /$session_screens{$key}->{'filetype'}/;

			#store btn to hash to manipulate it later
			$session_screens{$key}->{$_} = $btn;

			#only activated buttons are visible
			if ( $plugins{$_}->{'menu'} ) {
				$btn->show;
			} else {
				$btn->hide;
				$btn->set_no_show_all(TRUE);
			}
		}

		$vbox_tab->pack_start( $tabtoolbar, FALSE, TRUE, 0 );

		$hbox_tab_file->pack_start( $session_screens{$key}->{'image'}, TRUE,  TRUE, 10 );
		$hbox_tab_file->pack_start( $vbox_fileinfos,                   FALSE, TRUE, 1 );
		$hbox_tab_file->pack_start( $vbox_fileinfos2,                  FALSE, TRUE, 1 );

		$vbox_tab->pack_start( $hbox_tab_file, TRUE, TRUE, 0 );

	} else {
		my $stats_label = Gtk2::Label->new;
		$stats_label->set_markup( "<b>" . $gscrot_common->get_gettext->get("Statistic") . "</b>" );
		$session_start_screen{'first_page'}->{'statistics_counter'} = Gtk2::Label->new(
			$notebook->get_n_pages . " "
				. $gscrot_common->get_gettext->nget(
				"screenshot during this session",
				"screenshots during this session",
				$notebook->get_n_pages
				)
		);
		$session_start_screen{'first_page'}->{'size_counter'} = Gtk2::Label->new("0.00 KB");
		$vbox_all->pack_start( $stats_label, FALSE, TRUE, 1 );
		$vbox_all->pack_start( $session_start_screen{'first_page'}->{'statistics_counter'},
			FALSE, TRUE, 1 );
		$vbox_all->pack_start( $session_start_screen{'first_page'}->{'size_counter'},
			FALSE, TRUE, 1 );

		$session_start_screen{'first_page'}->{'settings_label'} = Gtk2::Label->new;
		$session_start_screen{'first_page'}->{'settings_label'}->set_markup(
			"<b>" . $gscrot_common->get_gettext->get("Current Preferences") . "</b>" );
		$vbox_all2->pack_start_defaults( $session_start_screen{'first_page'}->{'settings_label'} );
		$session_start_screen{'first_page'}->{'filename_label'}
			= Gtk2::Label->new( $gscrot_common->get_gettext->get("Filename") . ": " );
		$session_start_screen{'first_page'}->{'folder_label'}
			= Gtk2::Label->new( $gscrot_common->get_gettext->get("Directory") . ": " );

		my $tab_all_sizegroup = Gtk2::SizeGroup->new('vertical');
		$tab_all_sizegroup->add_widget( $session_start_screen{'first_page'}->{'filename_label'} );
		$tab_all_sizegroup->add_widget( $session_start_screen{'first_page'}->{'folder_label'} );

		$vbox_all2->pack_start_defaults( $session_start_screen{'first_page'}->{'filename_label'} );
		$vbox_all2->pack_start_defaults( $session_start_screen{'first_page'}->{'folder_label'} );

		#create iconview for session
		my $viewmodel = Gtk2::ListStore->new( 'Gtk2::Gdk::Pixbuf', 'Glib::String', 'Glib::String' );
		foreach ( keys %session_screens ) {
			$viewmodel->set(
				$viewmodel->append, 0, $session_screens{$_}->{'thumb'},
				1, $session_screens{$_}->{'short'},
				2, $_
			);
		}
		my $view = Gtk2::IconView->new_with_model($viewmodel);
		$view->set_orientation('horizontal');
		$view->set_pixbuf_column(0);
		$view->set_text_column(1);
		$view->set_selection_mode('multiple');
		$view->set_columns(0);
		$view->signal_connect( 'selection-changed', \&evt_iconview_sel_changed, 'sel_changed' );
		$view->signal_connect( 'item-activated', \&evt_iconview_item_activated, 'item_activated' );
		$session_start_screen{'first_page'}->{'view'}       = $view;
		$session_start_screen{'first_page'}->{'model'}      = $viewmodel;
		$session_start_screen{'first_page'}->{'btn_reopen'} = $button_reopen;
		$session_start_screen{'first_page'}->{'btn_print'}  = $button_print;
		$session_start_screen{'first_page'}->{'btn_upload'} = $button_upload;
		$session_start_screen{'first_page'}->{'btn_delete'} = $button_delete;

		#all buttons start insensitive
		foreach ( keys %{ $session_start_screen{'first_page'} } ) {
			$session_start_screen{'first_page'}->{$_}->set_sensitive(FALSE)
				if $session_start_screen{'first_page'}->{$_} =~ /button/i;
		}

		$tabtoolbar->insert( $button_reopen,               -1 );
		$tabtoolbar->insert( Gtk2::SeparatorToolItem->new, -1 );
		$tabtoolbar->insert( $button_print,                -1 );
		$tabtoolbar->insert( $button_upload,               -1 );
		$tabtoolbar->insert( Gtk2::SeparatorToolItem->new, -1 );
		$tabtoolbar->insert( $button_delete,               -1 );

		$vbox_tab->pack_start( $tabtoolbar, FALSE, TRUE, 0 );
		$hbox_all->pack_start_defaults($vbox_all);
		$hbox_all->pack_start_defaults($vbox_all2);
		$vbox_tab->pack_start( $hbox_all, FALSE, TRUE, 0 );

		my $scrolled_window_view = Gtk2::ScrolledWindow->new;
		$scrolled_window_view->set_policy( 'automatic', 'automatic' );
		$scrolled_window_view->set_shadow_type('in');
		$scrolled_window_view->add($view);

		$vbox_tab->pack_start( $scrolled_window_view, TRUE, TRUE, 0 );

	}

	$vbox->pack_start_defaults($vbox_tab);
	$vbox->show_all;

	return $vbox;
}

sub fct_resize_thumb {
	my ( $widget, $event, $key ) = @_;
	print "\n$event was emitted by widget $widget\n" if $gscrot_common->get_debug;
	if ( defined $widget ) {
		my $image = undef;
		my $thumb = undef;
		my $space = 0;
		unless ( $key eq 'is_all' ) {
			$image = $session_screens{$key}->{'image'};
			$thumb = $session_screens{$key}->{'thumb'};
			$space = 50;
		} else {
			$image = $session_start_screen{'first_page'}->{'image'};
			$thumb = $session_start_screen{'first_page'}->{'thumb'};
			$space = 100;
		}
		my $old_width  = $image->{'current_width'};
		my $old_height = $image->{'current_height'};
		$image->{'current_height'} = $widget->allocation->height - $space;
		$image->{'current_width'}  = $image->{'current_height'} * $image->{'aspect_ratio'};

		while ( $image->{'current_width'} >= $widget->allocation->width ) {
			$image->{'current_height'} -= 20;
			$image->{'current_width'} = $image->{'current_height'} * $image->{'aspect_ratio'};
		}
		if ($old_width != $image->{'current_width'}
			&& (   $image->{'current_width'} > 0
				&& $image->{'current_height'} > 0 )
			)
		{
			$image->set_from_pixbuf(
				$thumb->scale_simple(
					$image->{'current_width'},
					$image->{'current_height'}, 'tiles'
				)
			);
		}
	}
	return FALSE;
}

sub fct_save_settings {
	my ($profilename) = @_;

	#settings file
	my $settingsfile = "$ENV{ HOME }/.gscrot/settings.xml";
	if ( defined $profilename ) {
		$settingsfile = "$ENV{ HOME }/.gscrot/profiles/$profilename.xml"
			if ( $profilename ne "" );
	}

	#session file
	my $sessionfile = "$ENV{ HOME }/.gscrot/session.xml";

	#accounts file
	my $accountsfile = "$ENV{ HOME }/.gscrot/accounts.xml";
	if ( defined $profilename ) {
		$accountsfile = "$ENV{ HOME }/.gscrot/profiles/$profilename\_accounts.xml"
			if ( $profilename ne "" );
	}

	open( SETTFILE, ">$settingsfile" )
		or &dlg_error_message( $gscrot_common->get_gettext->get("Settings could not be saved!") );

	$settings{'general'}->{'last_profile'}      = $combobox_settings_profiles->get_active;
	$settings{'general'}->{'last_profile_name'} = $combobox_settings_profiles->get_active_text
		|| "";

	utf8::encode $settings{'general'}->{'last_profile_name'};

	$settings{'general'}->{'filetype'} = $combobox_type->get_active;
	$settings{'general'}->{'quality'}  = $scale->get_value();
	$settings{'general'}->{'filename'} = $filename->get_text();

	utf8::encode $settings{'general'}->{'filename'};

	$settings{'general'}->{'folder'} = $saveDir_button->get_filename();

	utf8::encode $settings{'general'}->{'folder'};

	#wrksp -> submenu
	$settings{'general'}->{'current_monitor_active'} = $current_monitor_active->get_active;

	$settings{'general'}->{'selection_tool'} = 1
		if $tool_advanced->get_active;
	$settings{'general'}->{'selection_tool'} = 2
		if $tool_simple->get_active;

	$settings{'general'}->{'zoom_active'} = $zoom_active->get_active();
	$settings{'general'}->{'zoom_size'}   = 1
		if ( $zoom_size1->get_active );
	$settings{'general'}->{'zoom_size'} = 2
		if ( $zoom_size2->get_active );
	$settings{'general'}->{'zoom_size'} = 3
		if ( $zoom_size3->get_active );

	#determining timeout
	my $web_menu = $button_web_menu->get_menu;
	my @timeouts = $web_menu->get_children;
	my $timeout  = undef;
	foreach (@timeouts) {

		if ( $_->get_active ) {
			$timeout = $_->get_children->get_text;
			$timeout =~ /([0-9]+)/;
			$timeout = $1;
		}
	}
	$settings{'general'}->{'web_timeout'} = $timeout;

	my $model         = $progname->get_model();
	my $progname_iter = $progname->get_active_iter();

	if ( defined $progname_iter ) {
		my $progname_value = $model->get_value( $progname_iter, 2 );
		$settings{'general'}->{'prog'} = $progname_value;
		utf8::encode $settings{'general'}->{'prog'};
	}

	$settings{'general'}->{'prog_active'}      = $progname_active->get_active();
	$settings{'general'}->{'im_colors'}        = $combobox_im_colors->get_active();
	$settings{'general'}->{'im_colors_active'} = $im_colors_active->get_active();
	$settings{'general'}->{'delay'}            = $delay->get_value();
	$settings{'general'}->{'delay_active'}     = $delay_active->get_active();
	$settings{'general'}->{'resize_operator'}  = $combobox_thumb_operator->get_active();
	$settings{'general'}->{'thumbnail'}        = $thumbnail->get_value();
	$settings{'general'}->{'thumbnail_active'} = $thumbnail_active->get_active();
	$settings{'general'}->{'border'}           = $combobox_border->get_active();
	$settings{'general'}->{'cursor'}           = $combobox_cursor->get_active();
	$settings{'general'}->{'autohide'}         = $hide_active->get_active();
	$settings{'general'}->{'autocopy'}         = $autocopy_active->get_active();
	$settings{'general'}->{'close_at_close'}   = $close_at_close_active->get_active();
	$settings{'general'}->{'save_at_close'}    = $save_at_close_active->get_active();
	$settings{'general'}->{'keybinding'}       = $keybinding_active->get_active();
	$settings{'general'}->{'keybinding_sel'}   = $keybinding_sel_active->get_active();
	$settings{'general'}->{'keybinding_mode'}  = $combobox_keybinding_mode->get_active();
	$settings{'general'}->{'capture_key'}      = $capture_key->get_text();
	$settings{'general'}->{'capture_sel_key'}  = $capture_sel_key->get_text();

	#ftp upload
	$settings{'general'}->{'ftp_uri'}      = $ftp_remote_entry->get_text();
	$settings{'general'}->{'ftp_mode'}     = $ftp_mode_combo->get_active();
	$settings{'general'}->{'ftp_username'} = $ftp_username_entry->get_text();
	$settings{'general'}->{'ftp_password'} = $ftp_password_entry->get_text();

	#plugins
	foreach my $plugin_key ( sort keys %plugins ) {
		$settings{'plugins'}->{$plugin_key}->{'name'}        = $plugin_key;
		$settings{'plugins'}->{$plugin_key}->{'binary'}      = $plugins{$plugin_key}->{'binary'};
		$settings{'plugins'}->{$plugin_key}->{'name_plugin'} = $plugins{$plugin_key}->{'name'};
		$settings{'plugins'}->{$plugin_key}->{'menu'}        = $plugins{$plugin_key}->{'menu'};
		$settings{'plugins'}->{$plugin_key}->{'category'}    = $plugins{$plugin_key}->{'category'};
		$settings{'plugins'}->{$plugin_key}->{'tooltip'}     = $plugins{$plugin_key}->{'tooltip'};
		$settings{'plugins'}->{$plugin_key}->{'ext'}         = $plugins{$plugin_key}->{'ext'};
		$settings{'plugins'}->{$plugin_key}->{'lang'}        = $plugins{$plugin_key}->{'lang'};
		utf8::encode $settings{'plugins'}->{$plugin_key}->{'name'};
		utf8::encode $settings{'plugins'}->{$plugin_key}->{'binary'};
		utf8::encode $settings{'plugins'}->{$plugin_key}->{'name_plugin'};
		utf8::encode $settings{'plugins'}->{$plugin_key}->{'category'};
		utf8::encode $settings{'plugins'}->{$plugin_key}->{'tooltip'};
		utf8::encode $settings{'plugins'}->{$plugin_key}->{'ext'};
		utf8::encode $settings{'plugins'}->{$plugin_key}->{'lang'};
	}

	#settings
	print SETTFILE XMLout( \%settings );

	close(SETTFILE)
		or &dlg_error_message( $gscrot_common->get_gettext->get("Settings could not be saved!") );

	&dlg_status_message( 1, $gscrot_common->get_gettext->get("Settings saved successfully!") );

	#session
	open( SESS_FILE, ">$sessionfile" )
		or &dlg_error_message( $gscrot_common->get_gettext->get("Session could not be saved!") );

	#we need to clean the hashkeys, so they become parseable
	my %clean_files;
	my $counter = 0;
	foreach ( sort keys %session_screens ) {

		#encode filename
		my $utf8_filename = $session_screens{$_}->{'long'};
		utf8::encode $utf8_filename;

		#8 leading zeros to counter
		$counter = sprintf( "%08d", $counter );
		if ( $gscrot_hfunct->file_exists( $session_screens{$_}->{'long'} ) ) {
			$clean_files{ "file" . $counter }{'filename'} = $utf8_filename;
			$counter++;
		}
	}

	print SESS_FILE XMLout( \%clean_files );

	close(SESS_FILE)
		or &dlg_error_message( $gscrot_common->get_gettext->get("Session could not be saved!") );

	#accounts
	open( ACC_FILE, ">$accountsfile" )
		or &dlg_error_message(
		$gscrot_common->get_gettext->get("Account-settings could not be saved!") );

	foreach ( keys %accounts ) {
		utf8::encode $accounts{$_}->{'password'};
		utf8::encode $accounts{$_}->{'username'};
		utf8::encode $accounts{$_}->{'register_text'};
		$accounts{$_}->{'password'} = ""
			if $accounts{$_}->{'host'} =~ /imageshack/i;
	}

	print ACC_FILE XMLout( \%accounts );

	close(ACC_FILE)
		or &dlg_error_message(
		$gscrot_common->get_gettext->get("Account-settings could not be saved!") );

	return TRUE;
}

sub fct_save_bindings {

	my $client        = Gnome2::GConf::Client->get_default;
	my $shortcut_full = "/apps/metacity/global_keybindings/run_command_screenshot";
	my $shortcut_sel  = "/apps/metacity/global_keybindings/run_command_window_screenshot";
	my $command_full  = "/apps/metacity/keybinding_commands/command_screenshot";
	my $command_sel   = "/apps/metacity/keybinding_commands/command_window_screenshot";

	#set gconf values
	if ( $keybinding_active->get_active() ) {
		$client->set( $command_full, { type => 'string', value => "$gscrot_path --full", } );
		$client->set(
			$shortcut_full,
			{   type  => 'string',
				value => $capture_key->get_text(),
			}
		);
	} else {
		$client->set( $command_full,  { type => 'string', value => 'gnome-screenshot', } );
		$client->set( $shortcut_full, { type => 'string', value => 'Print', } );
	}
	if ( $keybinding_sel_active->get_active() ) {
		my $mode = undef;
		if ( $combobox_keybinding_mode->get_active() == 0 ) {
			$mode = "--selection";
		} elsif ( $combobox_keybinding_mode->get_active() == 1 ) {
			$mode = "--window";
		} elsif ( $combobox_keybinding_mode->get_active() == 2 ) {
			$mode = "--section";
		} else {
			$mode = "--window";
		}
		$client->set(
			$command_sel,
			{   type  => 'string',
				value => "$gscrot_path $mode",
			}
		);
		$client->set(
			$shortcut_sel,
			{   type  => 'string',
				value => $capture_sel_key->get_text(),
			}
		);
	} else {
		$client->set(
			$command_sel,
			{   type  => 'string',
				value => 'gnome-screenshot --window',
			}
		);
		$client->set( $shortcut_sel, { type => 'string', value => '<Alt>Print', } );
	}

	return TRUE;
}

sub fct_load_settings {
	my ( $widget, $data, $profilename ) = @_;

	#settings file
	my $settingsfile = "$ENV{ HOME }/.gscrot/settings.xml";
	$settingsfile = "$ENV{ HOME }/.gscrot/profiles/$profilename.xml"
		if ( defined $profilename );

	my $settings_xml;
	if ( $gscrot_hfunct->file_exists($settingsfile) ) {
		eval {
			$settings_xml = XMLin($settingsfile);

			if ( $data eq 'profile_load' ) {

				#general settings
				$combobox_type->set_active( $settings_xml->{'general'}->{'filetype'} );
				$scale->set_value( $settings_xml->{'general'}->{'quality'} );
				utf8::decode $settings_xml->{'general'}->{'filename'};
				$filename->set_text( $settings_xml->{'general'}->{'filename'} );

				utf8::decode $settings_xml->{'general'}->{'folder'};
				$saveDir_button->set_current_folder( $settings_xml->{'general'}->{'folder'} );

				#FIXME
				#this is a dirty hack to force the setting to be enabled in session tab
				#at the moment i simply dont know why the filechooser "caches" the old value
				# => weird...
				$settings_xml->{'general'}->{'folder_force'} = TRUE;

				#wrksp -> submenu
				$current_monitor_active->set_active(
					$settings_xml->{'general'}->{'current_monitor_active'} );

				#selection tool -> submenu
				$tool_advanced->set_active(TRUE)
					if $settings_xml->{'general'}->{'selection_tool'} == 1;
				$tool_simple->set_active(TRUE)
					if $settings_xml->{'general'}->{'selection_tool'} == 2;
				$zoom_active->set_active( $settings_xml->{'general'}->{'zoom_active'} );
				$zoom_size1->set_active(TRUE)
					if $settings_xml->{'general'}->{'zoom_size'} == 1;
				$zoom_size2->set_active(TRUE)
					if $settings_xml->{'general'}->{'zoom_size'} == 2;
				$zoom_size3->set_active(TRUE)
					if $settings_xml->{'general'}->{'zoom_size'} == 3;

				#determining timeout
				my $web_menu = $button_web_menu->get_menu;
				my @timeouts = $web_menu->get_children;
				my $timeout  = undef;
				foreach (@timeouts) {
					$timeout = $_->get_children->get_text;
					$timeout =~ /([0-9]+)/;
					$timeout = $1;
					if ( $settings_xml->{'general'}->{'web_timeout'} == $timeout ) {
						$_->set_active(TRUE);
					}
				}

				#advanced settings
				my $model = $progname->get_model;
				utf8::decode $settings_xml->{'general'}->{'prog'};
				$model->foreach( \&fct_iter_programs, $settings_xml->{'general'}->{'prog'} );
				$progname_active->set_active( $settings_xml->{'general'}->{'prog_active'} );
				$im_colors_active->set_active( $settings_xml->{'general'}->{'im_colors_active'} );
				$combobox_im_colors->set_active( $settings_xml->{'general'}->{'im_colors'} );
				$delay->set_value( $settings_xml->{'general'}->{'delay'} );
				$delay_active->set_active( $settings_xml->{'general'}->{'delay_active'} );
				$combobox_thumb_operator->set_active(
					$settings_xml->{'general'}->{'resize_operator'} );
				$thumbnail->set_value( $settings_xml->{'general'}->{'thumbnail'} );
				$thumbnail_active->set_active( $settings_xml->{'general'}->{'thumbnail_active'} );
				$combobox_border->set_active( $settings_xml->{'general'}->{'border'} );
				$combobox_cursor->set_active( $settings_xml->{'general'}->{'cursor'} );

				#behavior
				$hide_active->set_active( $settings_xml->{'general'}->{'autohide'} );
				$autocopy_active->set_active( $settings_xml->{'general'}->{'autocopy'} );
				$close_at_close_active->set_active(
					$settings_xml->{'general'}->{'close_at_close'} );
				$save_at_close_active->set_active( $settings_xml->{'general'}->{'save_at_close'} );

				#keybindings
				$keybinding_active->set_active( $settings_xml->{'general'}->{'keybinding'} );
				$keybinding_sel_active->set_active(
					$settings_xml->{'general'}->{'keybinding_sel'} );
				$capture_key->set_text( $settings_xml->{'general'}->{'capture_key'} );
				$capture_sel_key->set_text( $settings_xml->{'general'}->{'capture_sel_key'} );
				$combobox_keybinding_mode->set_active(
					$settings_xml->{'general'}->{'keybinding_mode'} );

				#ftp_upload
				$ftp_remote_entry->set_text( $settings_xml->{'general'}->{'ftp_uri'} );
				$ftp_mode_combo->set_active( $settings_xml->{'general'}->{'ftp_mode'} );
				$ftp_username_entry->set_text( $settings_xml->{'general'}->{'ftp_username'} );
				$ftp_password_entry->set_text( $settings_xml->{'general'}->{'ftp_password'} );
			}

			#load account data
			&fct_load_accounts($profilename);
			if ( defined $accounts_tree ) {
				&fct_load_accounts_tree;
				$accounts_tree->set_model($accounts_model);
				&fct_set_model_accounts($accounts_tree);
			}

			&dlg_status_message( 1,
				$gscrot_common->get_gettext->get("Settings loaded successfully") );
			}

	}
	if ($@) {
		&dlg_error_message(
			$gscrot_common->get_gettext->get("Settings could not be restored!") . " : $@" );
		unlink $settingsfile;
	}

	#get plugins from cache unless param is set to ignore it
	if ( !$gscrot_common->get_clear_cache ) {

		foreach my $plugin_key ( sort keys %{ $settings_xml->{'plugins'} } ) {
			utf8::decode $settings_xml->{'plugins'}->{$plugin_key}->{'binary'};

			#check if plugin still exists in filesystem
			if ($gscrot_hfunct->file_exists(
					$settings_xml->{'plugins'}->{$plugin_key}->{'binary'}
				)
				)
			{
				utf8::decode $settings_xml->{'plugins'}->{$plugin_key}->{'name_plugin'};
				utf8::decode $settings_xml->{'plugins'}->{$plugin_key}->{'category'};
				utf8::decode $settings_xml->{'plugins'}->{$plugin_key}->{'tooltip'};
				utf8::decode $settings_xml->{'plugins'}->{$plugin_key}->{'ext'};
				utf8::decode $settings_xml->{'plugins'}->{$plugin_key}->{'lang'};
				$plugins{$plugin_key}->{'binary'}
					= $settings_xml->{'plugins'}->{$plugin_key}->{'binary'};
				$plugins{$plugin_key}->{'name'}
					= $settings_xml->{'plugins'}->{$plugin_key}->{'name_plugin'};
				$plugins{$plugin_key}->{'menu'}
					= $settings_xml->{'plugins'}->{$plugin_key}->{'menu'};
				$plugins{$plugin_key}->{'category'}
					= $settings_xml->{'plugins'}->{$plugin_key}->{'category'};
				$plugins{$plugin_key}->{'tooltip'}
					= $settings_xml->{'plugins'}->{$plugin_key}->{'tooltip'};
				$plugins{$plugin_key}->{'ext'} = $settings_xml->{'plugins'}->{$plugin_key}->{'ext'};
				$plugins{$plugin_key}->{'lang'}
					= $settings_xml->{'plugins'}->{$plugin_key}->{'lang'};
			} else {
				next;
			}
		}
	}

	#maybe there are new plugins...
	&fct_check_installed_plugins;

	if ( defined $effects_tree ) {
		&fct_load_plugin_tree;
		$effects_tree->set_model($effects_model);
		&fct_set_model_plugins($effects_tree);
	}

	return $settings_xml;
}

sub fct_get_program_model {
	my $model = Gtk2::ListStore->new( 'Gtk2::Gdk::Pixbuf', 'Glib::String', 'Glib::String' );
	foreach ( keys %gm_programs ) {

		if (   $gm_programs{$_}->{'binary'} ne ""
			&& $gm_programs{$_}->{'name'} ne "" )
		{
			my $pixbuf;
			if ( -f $gm_programs{$_}->{'pixmap'} ) {
				$pixbuf = Gtk2::Gdk::Pixbuf->new_from_file_at_size( $gm_programs{$_}->{'pixmap'},
					Gtk2::IconSize->lookup('menu') );
			} else {
				$pixbuf
					= Gtk2::Gdk::Pixbuf->new_from_file_at_size(
					"$gscrot_root/share/gscrot/resources/icons/executable.svg",
					Gtk2::IconSize->lookup('menu') );
			}
			$model->set( $model->append, 0, $pixbuf, 1, $gm_programs{$_}->{'name'}, 2, $_ );
		} else {
			print "WARNING: Program $_ is not configured properly, ignoring\n";
		}
	}
	return $model;
}

sub fct_load_accounts {
	my ($profilename) = @_;

	#accounts file
	my $accountsfile = "$ENV{ HOME }/.gscrot/accounts.xml";
	$accountsfile = "$ENV{ HOME }/.gscrot/profiles/$profilename\_accounts.xml"
		if ( defined $profilename );

	my $accounts_xml;
	eval { $accounts_xml = XMLin($accountsfile) if $gscrot_hfunct->file_exists($accountsfile); };

	if ($@) {
		&dlg_error_message(
			$gscrot_common->get_gettext->get("Account-settings could not be restored!") . " : $@" );
		unlink $accountsfile;
	}

	#account data, load defaults if nothing is set
	unless ( exists( $accounts_xml->{'ubuntu-pics.de'} ) ) {
		$accounts{'ubuntu-pics.de'}->{host}     = "ubuntu-pics.de";
		$accounts{'ubuntu-pics.de'}->{username} = "";
		$accounts{'ubuntu-pics.de'}->{password} = "";
	} else {
		$accounts{'ubuntu-pics.de'}->{host}     = $accounts_xml->{'ubuntu-pics.de'}->{host};
		$accounts{'ubuntu-pics.de'}->{username} = $accounts_xml->{'ubuntu-pics.de'}->{username};
		$accounts{'ubuntu-pics.de'}->{password} = $accounts_xml->{'ubuntu-pics.de'}->{password};
	}

	$accounts{'ubuntu-pics.de'}->{register} = "http://www.ubuntu-pics.de/registrieren.html";

	#account data, load defaults if nothing is set
	unless ( exists( $accounts_xml->{'imageshack.us'} ) ) {
		$accounts{'imageshack.us'}->{host}     = "imageshack.us";
		$accounts{'imageshack.us'}->{username} = "";
		$accounts{'imageshack.us'}->{password} = "";
	} else {
		$accounts{'imageshack.us'}->{host}     = $accounts_xml->{'imageshack.us'}->{host};
		$accounts{'imageshack.us'}->{username} = $accounts_xml->{'imageshack.us'}->{username};
		$accounts{'imageshack.us'}->{password} = $accounts_xml->{'imageshack.us'}->{password};
	}

	$accounts{'imageshack.us'}->{register} = "http://my.imageshack.us/registration/";

	unless ( exists( $accounts_xml->{'imagebanana.com'} ) ) {
		$accounts{'imagebanana.com'}->{host}     = "imagebanana.com";
		$accounts{'imagebanana.com'}->{username} = "";
		$accounts{'imagebanana.com'}->{password} = "";
	} else {
		$accounts{'imagebanana.com'}->{host}     = $accounts_xml->{'imagebanana.com'}->{host};
		$accounts{'imagebanana.com'}->{username} = $accounts_xml->{'imagebanana.com'}->{username};
		$accounts{'imagebanana.com'}->{password} = $accounts_xml->{'imagebanana.com'}->{password};
	}

	$accounts{'imagebanana.com'}->{register} = "http://www.imagebanana.com/myib/registrieren/";

	foreach ( keys %accounts ) {
		utf8::decode $accounts{$_}->{'username'};
		utf8::decode $accounts{$_}->{'password'};
		$accounts{$_}->{'register_color'} = "blue";
		$accounts{$_}->{'register_text'}  = $gscrot_common->get_gettext->get("click me");
	}

	return TRUE;
}

sub fct_open_files {
	my (@new_files) = @_;

	return FALSE if scalar(@new_files) < 1;

	my $open_dialog = Gtk2::MessageDialog->new( $window, [qw/modal destroy-with-parent/],
		'info', 'close', $gscrot_common->get_gettext->get("Loading files") );

	$open_dialog->set(
		'secondary-text' => $gscrot_common->get_gettext->get(
			"Please wait while your selected files\nare being integrated into GScrot")
			. "."
	);

	$open_dialog->signal_connect( response => sub { $_[0]->destroy } );

	my $open_progress = Gtk2::ProgressBar->new;
	$open_progress->set_no_show_all(TRUE);
	$open_progress->set_ellipsize('middle');
	$open_progress->set_orientation('left-to-right');
	$open_progress->set_fraction(0);

	$open_dialog->vbox->add($open_progress);

	#do not show when min at startup
	unless ( $gscrot_common->get_min ) {
		$open_progress->show;
		$open_dialog->show_all;
	}

	my $num_files = scalar(@new_files);
	my $count     = 0;
	foreach (@new_files) {

		#refresh the progressbar
		$count++;
		$open_progress->set_fraction( $count / $num_files );
		$open_progress->set_text($_);

		#refresh tray icon
		if ( $icon && $icon->isa('Gtk2::StatusIcon') ) {
			$icon->set_blinking(TRUE);
		}
		#refresh gui
		&fct_update_gui;

		#do the real work
		&fct_integrate_screenshot_in_notebook($_);
	}
	$open_dialog->response('ok');

	#refresh tray icon
	if ( $icon && $icon->isa('Gtk2::StatusIcon') ) {
		$icon->set_blinking(FALSE);
	}

	return TRUE;
}

sub fct_load_session {

	#session file
	my $sessionfile = "$ENV{ HOME }/.gscrot/session.xml";

	eval {
		my $session_xml = XMLin($sessionfile)
			if $gscrot_hfunct->file_exists($sessionfile);

		return FALSE if scalar( keys %{$session_xml} ) < 1;

		my $restore_dialog = Gtk2::MessageDialog->new( $window, [qw/modal destroy-with-parent/],
			'info', 'close', undef );

		$restore_dialog->set( 'text' => $gscrot_common->get_gettext->get("Restoring session") );

		$restore_dialog->set(
			'secondary-text' => $gscrot_common->get_gettext->get(
				"Please wait while your saved session\nis being restored")
				. "."
		);

		$restore_dialog->signal_connect( response => sub { $_[0]->destroy } );

		my $restore_progress = Gtk2::ProgressBar->new;
		$restore_progress->set_no_show_all(TRUE);
		$restore_progress->set_ellipsize('middle');
		$restore_progress->set_orientation('left-to-right');
		$restore_progress->set_fraction(0);

		$restore_dialog->vbox->add($restore_progress);

		#do not show when min at startup
		unless ( $gscrot_common->get_min ) {
			$restore_progress->show;
			$restore_dialog->show_all;
			$restore_progress->grab_focus;
		}

		my $num_files = scalar( keys %{$session_xml} );
		my $count     = 0;
		foreach ( sort keys %{$session_xml} ) {

			#refresh the progressbar
			$count++;
			$restore_progress->set_fraction( $count / $num_files );
			$restore_progress->set_text( ${$session_xml}{$_}{'filename'} );

			#refresh tray icon
			if ( $icon && $icon->isa('Gtk2::StatusIcon') ) {
				$icon->set_blinking(TRUE);
			}

			#refresh gui
			&fct_update_gui;

			#do the real work
			&fct_integrate_screenshot_in_notebook( ${$session_xml}{$_}{'filename'} );
		}
		$restore_dialog->response('ok');

		#refresh tray icon
		if ( $icon && $icon->isa('Gtk2::StatusIcon') ) {
			$icon->set_blinking(FALSE);
		}

	};
	if ($@) {
		&dlg_error_message(
			$gscrot_common->get_gettext->get("Session could not be restored!") . "\n : $@" );

		unlink $sessionfile;

		#refresh tray icon
		if ( $icon && $icon->isa('Gtk2::StatusIcon') ) {
			$icon->set_blinking(FALSE);
		}

	}

	&fct_update_first_tab;

	return TRUE;
}

sub fct_screenshot_exists {
	my ($key) = @_;

	#check if file still exists
	unless ( &fct_create_thumbnail_and_fileinfos( $session_screens{$key}->{'filename'}, $key ) ) {
		&dlg_status_message( 1,
			      $session_screens{$key}->{'filename'} . " "
				. $gscrot_common->get_gettext->get("not found") );
		&fct_update_tab($key);
		return FALSE;
	}
	return TRUE;
}

sub fct_delete {

	my $key = &fct_get_current_file(undef);

	#single file
	if ($key) {

		return FALSE unless &fct_screenshot_exists($key);

		unlink( $session_screens{$key}->{'long'} );               #delete file
		$notebook->remove_page( $notebook->get_current_page );    #delete tab
		&dlg_status_message( 1,
			      $session_screens{$key}->{'filename'} . " "
				. $gscrot_common->get_gettext->get("deleted") )
			if defined( $session_screens{$key}->{'filename'} );
		delete( $session_screens{$key} );                         # delete from hash
		&fct_update_first_tab();
		$window->show_all unless $is_in_tray;

		#session tab
	} else {

		$session_start_screen{'first_page'}->{'view'}->selected_foreach(
			sub {
				my ( $view, $path ) = @_;
				my $iter = $session_start_screen{'first_page'}->{'model'}->get_iter($path);
				if ( defined $iter ) {
					my $key = $session_start_screen{'first_page'}->{'model'}->get_value( $iter, 2 );
					$notebook->remove_page(
						$notebook->page_num( $session_screens{$key}->{'tab_child'} ) );
					unlink( $session_screens{$key}->{'long'} );
					delete( $session_screens{$key} );
				}
			},
			undef
		);

		&dlg_status_message( 1, $gscrot_common->get_gettext->get("All screenshots deleted") );
		&fct_update_first_tab;
		$window->show_all unless $is_in_tray;

	}
	return TRUE;
}

sub fct_remove {
	my ($key) = @_;

	$key = &fct_get_current_file(undef) unless $key;

	#single file
	if ($key) {

		$notebook->remove_page( $notebook->page_num( $session_screens{$key}->{'tab_child'} ) )
			;    #delete tab
		&dlg_status_message( 1,
			      $session_screens{$key}->{'filename'} . " "
				. $gscrot_common->get_gettext->get("removed from session") )
			if defined( $session_screens{$key}->{'filename'} );
		delete( $session_screens{$key} );    # delete from hash
		&fct_update_first_tab();
		$window->show_all unless $is_in_tray;

		#session tab
	} else {

		$session_start_screen{'first_page'}->{'view'}->selected_foreach(
			sub {
				my ( $view, $path ) = @_;
				my $iter = $session_start_screen{'first_page'}->{'model'}->get_iter($path);
				if ( defined $iter ) {
					my $key = $session_start_screen{'first_page'}->{'model'}->get_value( $iter, 2 );
					$notebook->remove_page(
						$notebook->page_num( $session_screens{$key}->{'tab_child'} ) );
					delete( $session_screens{$key} );
				}
			},
			undef
		);

		&dlg_status_message( 1, $gscrot_common->get_gettext->get("All screenshots removed") );
		&fct_update_first_tab;
		$window->show_all unless $is_in_tray;

	}
	return TRUE;
}

sub fct_update_gui {

	while ( Gtk2->events_pending ) {
		Gtk2->main_iteration;
	}
	Gtk2::Gdk->flush;

	return TRUE;
}

sub fct_clipboard {

	my $key = &fct_get_current_file(undef);

	#single file
	if ($key) {

		return FALSE unless &fct_screenshot_exists($key);

		my $pixbuf = Gtk2::Gdk::Pixbuf->new_from_file( $session_screens{$key}->{'long'} );
		$clipboard->set_image($pixbuf);
		&dlg_status_message( 1,
			      $session_screens{$key}->{'filename'} . " "
				. $gscrot_common->get_gettext->get("copied to clipboard") );

	}
	return TRUE;
}

sub fct_plugin {

	my $key = &fct_get_current_file(undef);

	#single file
	if ($key) {

		return FALSE unless &fct_screenshot_exists($key);

		unless ( keys %plugins > 0 ) {
			&dlg_error_message( $gscrot_common->get_gettext->get("No plugin installed") );
		} else {
			&dlg_plugin( $session_screens{$key}->{'filename'}, $key );
		}
		&fct_update_tab($key);

	}
	return TRUE;
}

sub fct_rename {

	my $key = &fct_get_current_file(undef);

	#single file
	if ($key) {

		return FALSE unless &fct_screenshot_exists($key);

		print "Renaming of file " . $session_screens{$key}->{'long'} . " started\n"
			if $gscrot_common->get_debug;
		&dlg_status_message( 1,
			      $session_screens{$key}->{'filename'} . " "
				. $gscrot_common->get_gettext->get("renamed") )
			if &dlg_rename( $session_screens{$key}->{'long'}, $key );
		&fct_update_tab($key);

	}
	return TRUE;
}

sub fct_draw {

	my $key = &fct_get_current_file(undef);

	#single file
	if ($key) {

		return FALSE unless &fct_screenshot_exists($key);

		my $drawing_tool = GScrot::Draw::DrawingTool->new($gscrot_common);
		$drawing_tool->show(
			$session_screens{$key}->{'long'},
			$session_screens{$key}->{'filetype'},
			\%session_screens
		);

		&fct_update_tab($key);

	}
	return TRUE;
}

sub fct_upload {

	my $key = &fct_get_current_file(undef);

	my @upload_array;

	#single file
	if ($key) {

		return FALSE unless &fct_screenshot_exists($key);
		push( @upload_array, $session_screens{$key}->{'filename'} );
		&dlg_upload(@upload_array);

		#session tab
	} else {

		$session_start_screen{'first_page'}->{'view'}->selected_foreach(
			sub {
				my ( $view, $path ) = @_;
				my $iter = $session_start_screen{'first_page'}->{'model'}->get_iter($path);
				if ( defined $iter ) {
					my $key = $session_start_screen{'first_page'}->{'model'}->get_value( $iter, 2 );
					return FALSE unless &fct_screenshot_exists($key);
					push( @upload_array, $session_screens{$key}->{'filename'} );
				}

			},
			undef
		);
		&dlg_upload(@upload_array);
	}
	return TRUE;
}

sub fct_print {

	my $key = &fct_get_current_file(undef);

	#single file
	if ($key) {

		return FALSE unless &fct_screenshot_exists($key);

		#everything is fine -> print it
		my $current_file = quotemeta $session_screens{$key}->{'long'};
		system("gtklp $current_file &");
		&dlg_status_message( 1,
			      $session_screens{$key}->{'filename'} . " "
				. $gscrot_common->get_gettext->get("will be printed") );

		#session tab
	} else {

		my $print_files = "";
		$session_start_screen{'first_page'}->{'view'}->selected_foreach(
			sub {
				my ( $view, $path ) = @_;
				my $iter = $session_start_screen{'first_page'}->{'model'}->get_iter($path);
				if ( defined $iter ) {
					my $key = $session_start_screen{'first_page'}->{'model'}->get_value( $iter, 2 );
					$print_files .= quotemeta $session_screens{$key}->{'long'};
					$print_files .= " ";
				}

			},
			undef
		);
		if ( $print_files ne "" ) {
			system("gtklp $print_files &");
			&dlg_status_message( 1, $gscrot_common->get_gettext->get("Printing all screenshots") );
		}

	}
	return TRUE;
}

sub fct_open_with_program {
	my $progname_value = shift;
	
	my $key = &fct_get_current_file(undef);

	#no program set - take default from settings
	unless ($progname_value) {
		my $model         = $progname->get_model();
		my $progname_iter = $progname->get_active_iter();

		if ($progname_iter) {
			$progname_value = $model->get_value( $progname_iter, 2 );
		}
	}

	#check if program still exists
	unless ( $progname_value =~ /[a-zA-Z0-9]+/ ) {
		&dlg_error_message(
			$gscrot_common->get_gettext->get("No application specified to open the screenshot")
				. "!" );
		return FALSE;
	}

	#single file
	if ($key) {

		return FALSE unless &fct_screenshot_exists($key);

		#everything is fine -> open it
		system("$progname_value '$session_screens{$key}->{'long'}' &");
		&dlg_status_message( 1,
			      $session_screens{$key}->{'filename'} . " "
				. $gscrot_common->get_gettext->get("opened with") . " "
				. $progname_value );

		#session tab
	} else {

		my $open_files = "";

		if ( $progname_value =~ /gimp/ || $progname_value =~ /postr/ ) {

			$session_start_screen{'first_page'}->{'view'}->selected_foreach(
				sub {
					my ( $view, $path ) = @_;
					my $iter = $session_start_screen{'first_page'}->{'model'}->get_iter($path);
					if ( defined $iter ) {
						my $key
							= $session_start_screen{'first_page'}->{'model'}->get_value( $iter, 2 );
						$open_files .= quotemeta $session_screens{$key}->{'long'};
						$open_files .= " ";
					}
				},
				undef
			);
			if ( $open_files ne "" ) {
				system("$progname_value $open_files &");
			}
		} else {

			$session_start_screen{'first_page'}->{'view'}->selected_foreach(
				sub {
					my ( $view, $path ) = @_;
					my $iter = $session_start_screen{'first_page'}->{'model'}->get_iter($path);
					if ( defined $iter ) {
						my $key
							= $session_start_screen{'first_page'}->{'model'}->get_value( $iter, 2 );
						system("$progname_value '$session_screens{$key}->{'long'}' &");
					}
				},
				undef
			);
		}
		&dlg_status_message( 1,
			$gscrot_common->get_gettext->get("Opened all files with") . " " . $progname_value );

	}
	return TRUE;
}

sub fct_execute_plugin {

	my $arrayref = $_[1];
	my ( $plugin_value, $plugin_name, $plugin_lang, $key, $plugin_dialog ) = @$arrayref;

	unless ( $gscrot_hfunct->file_exists( $session_screens{$key}->{'long'} ) ) {
		&fct_update_tab($key);
		return FALSE;
	}

	#if it is a native perl plugin, use a plug to integrate it properly
	if ( $plugin_lang eq "perl" ) {
		$plugin_dialog->hide if defined $plugin_dialog;

		#initiate the socket to draw the contents of the plugin to our dialog
		my $plugin_socket
			= Gtk2::Dialog->new( $plugin_name, $window, [qw/modal destroy-with-parent/] );
		my $socket = Gtk2::Socket->new;
		$plugin_socket->vbox->add($socket);
		$socket->signal_connect(
			'plug-removed' => sub {
				print STDERR "GtkPlug Disconnected\n" if $gscrot_common->get_debug;
				$plugin_socket->destroy();
				return TRUE;
				1;
			}
		);
		printf( "\n", $socket->get_id );
		my $pid = fork;
		if ( $pid < 0 ) {
			&dlg_error_message( $gscrot_common->get_gettext->get("Could not execute plugin") . ": "
					. $plugin_name );
		}
		if ( $pid == 0 ) {
			exec(
				sprintf(
					"$^X $plugin_value %d '$session_screens{$key}->{'long'}' $session_screens{$key}->{'width'} $session_screens{$key}->{'height'} $session_screens{$key}->{'filetype'}\n",
					$socket->get_id )
			);
		}
		$plugin_socket->show_all;
		$plugin_socket->run;

		&dlg_status_message( 1,
			      $gscrot_common->get_gettext->get("Successfully executed plugin") . ": "
				. $plugin_name );

		#...if not => simple execute the plugin via system (e.g. shell plugins)
	} else {
		print
			"$plugin_value $session_screens{$key}->{'long'} $session_screens{$key}->{'width'} $session_screens{$key}->{'height'} $session_screens{$key}->{'filetype'} submitted to plugin\n"
			if $gscrot_common->get_debug;
		if (system(
				"'$plugin_value' '$session_screens{$key}->{'long'}' '$session_screens{$key}->{'width'}' '$session_screens{$key}->{'height'}' '$session_screens{$key}->{'filetype'}' "
			) == 0
			)
		{
			&dlg_status_message( 1,
				      $gscrot_common->get_gettext->get("Successfully executed plugin") . ": "
					. $plugin_name );
		} else {
			&dlg_error_message( $gscrot_common->get_gettext->get("Could not execute plugin") . ": "
					. $plugin_name );
		}
	}
	&fct_update_tab($key);
	return TRUE;
}

sub fct_update_first_tab {
	$session_start_screen{'first_page'}->{'model'}->clear;
	foreach ( sort keys %session_screens ) {

		#determine size of thumbnail
		my $width = 48;
		my $height
			= $width / ( $session_screens{$_}->{'width'} / $session_screens{$_}->{'height'} );
		my $pixbuf = $session_screens{$_}->{'thumb'};

		if ( $height > 48 ) {
			$height = 48;
			$width
				= $height * ( $session_screens{$_}->{'width'} / $session_screens{$_}->{'height'} );
		}

		if ( $height < 10 || $width < 10 ) {
			$pixbuf = Gtk2::Gdk::Pixbuf->new_from_file(
				"$gscrot_root/share/gscrot/resources/icons/Image.svg");
			$width  = 48;
			$height = 48;
		}

		$session_start_screen{'first_page'}->{'model'}->set(
			$session_start_screen{'first_page'}->{'model'}->append,
			0, $pixbuf->scale_simple( $width, $height, 'tiles' ),
			1, $session_screens{$_}->{'short'},
			2, $_
		);
	}
	$session_start_screen{'first_page'}->{'view'}
		->set_model( $session_start_screen{'first_page'}->{'model'} );
	$session_start_screen{'first_page'}->{'statistics_counter'}->set_text(
		scalar( keys(%session_screens) ) . " "
			. $gscrot_common->get_gettext->nget(
			"screenshot during this session",
			"screenshots during this session",
			scalar( keys(%session_screens) )
			)
	);
	my $total_size = 0;

	foreach ( keys %session_screens ) {
		$total_size += $session_screens{$_}->{'size'};
	}
	$session_start_screen{'first_page'}->{'size_counter'}
		->set_text( $gscrot_common->get_gettext->get("Total size") . ": "
			. sprintf( "%.2f", $total_size / 1024 )
			. " KB" );

	#if size == 0 => no screenshot in session (handle menu entries properly)
	if ($menuitem_close_all) {
		if ( $total_size == 0 ) {
			$menuitem_close_all->set_sensitive(FALSE);
		} else {
			$menuitem_close_all->set_sensitive(TRUE);
		}
	}

	if ( $filename && $saveDir_button && $combobox_settings_profiles ) {

		if ( $combobox_settings_profiles->get_active_text ) {
			$session_start_screen{'first_page'}->{'settings_label'}->set_markup( "<b>"
					. $gscrot_common->get_gettext->get("Current Preferences") . "</b>" . " ("
					. $combobox_settings_profiles->get_active_text
					. ")" );
		} else {
			$session_start_screen{'first_page'}->{'settings_label'}->set_markup(
				"<b>" . $gscrot_common->get_gettext->get("Current Preferences") . "</b>" );
		}

		my $current_folder = $saveDir_button->get_filename;

		if ( $settings_xml->{'general'}->{'folder_force'} || !$current_folder ) {
			if ( exists $settings_xml->{'general'}->{'folder'} ) {
				$current_folder = $settings_xml->{'general'}->{'folder'};
			} else {
				$current_folder = $ENV{'HOME'};
			}
			$settings_xml->{'general'}->{'folder_force'} = FALSE;
		}

		if ( $filename->get_text ne "" ) {
			$session_start_screen{'first_page'}->{'filename_label'}->set_text(
				$gscrot_common->get_gettext->get("Filename") . ": " . $filename->get_text );
		} else {
			$session_start_screen{'first_page'}->{'filename_label'}
				->set_text( $gscrot_common->get_gettext->get("Filename") . ": -" );
		}

		$session_start_screen{'first_page'}->{'folder_label'}
			->set_text( $gscrot_common->get_gettext->get("Directory") . ": " . $current_folder );
	}

	return TRUE;
}

sub fct_get_current_file {
	my $index = shift;
	
	my $curr_page;
	if($index){
		$curr_page = $notebook->get_nth_page( $index );
	}else{
		$curr_page = $notebook->get_nth_page( $notebook->get_current_page );	
	}
	my $key       = undef;
	foreach ( keys %session_screens ) {
		if ( $session_screens{$_}->{'tab_child'} == $curr_page ) {
			$key = $_;
		}
	}
	return $key;
}

sub fct_update_tab_plugins {
	my ($key) = @_;

	return FALSE unless $key;

	#handle plugins (attached to toolbar)
	foreach ( sort keys %plugins ) {
		eval {

			#any plugins activated??
			if ( $plugins{$_}->{'menu'} ) {
				$session_screens{$key}->{$_}->set_no_show_all(FALSE);
				$session_screens{$key}->{$_}->show_all;
			} else {
				$session_screens{$key}->{$_}->hide;
				$session_screens{$key}->{$_}->set_no_show_all(TRUE);
			}
			if ( $session_screens{$key}->{$_} ) {

				#disable button if filetype is not supported
				if ( $plugins{$_}->{'ext'} =~ /$session_screens{$key}->{'filetype'}/ ) {
					$session_screens{$key}->{$_}->set_sensitive(TRUE);
				} else {
					$session_screens{$key}->{$_}->set_sensitive(FALSE);
				}
			}
		};
	}
	return TRUE;
}

sub fct_update_tab {
	my ($key) = @_;
	$key =~ /\[(.*)\]/;

	#update fileinfos
	if ( &fct_create_thumbnail_and_fileinfos( $session_screens{$key}->{'filename'}, $key ) ) {

		#update tab icon - maybe pic changed due to use of plugin or drawing tool
		$session_screens{$key}->{'tab_icon'}->set_from_pixbuf( $session_screens{$key}->{'thumb'}
				->scale_simple( Gtk2::IconSize->lookup('menu'), 'tiles' ) );
		$session_screens{$key}->{'image'}->set_from_pixbuf( $session_screens{$key}->{'thumb'} );
		$session_screens{$key}->{'filename_label'}->set_text( $session_screens{$key}->{'short'} );
		$session_screens{$key}->{'folder_label'}->set_text( $session_screens{$key}->{'folder'} );
		$tooltips->set_tip( $session_screens{$key}->{'filename_label'},
			$session_screens{$key}->{'filename'} );
		$session_screens{$key}->{'mime_type_label'}
			->set_text( $session_screens{$key}->{'mime_type'} );
		$session_screens{$key}->{'size_label'}
			->set_text( sprintf( "%.2f", $session_screens{$key}->{'size'} / 1024 ) . " KB" );
		$session_screens{$key}->{'geometry_label'}->set_text(
			$session_screens{$key}->{'width'} . "x" . $session_screens{$key}->{'height'} );

		&fct_update_tab_plugins($key);

	} else {

		#update tab icon - file is not existing anymore, maybe deleted manually
		$session_screens{$key}->{'thumb'}
			= Gtk2::Gdk::Pixbuf->new_from_file_at_scale(
			"$gscrot_root/share/gscrot/resources/icons/Image-missing.svg",
			400, 400, TRUE );
		$session_screens{$key}->{'tab_icon'}->set_from_pixbuf( $session_screens{$key}->{'thumb'}
				->scale_simple( Gtk2::IconSize->lookup('menu'), 'tiles' ) );
		$session_screens{$key}->{'image'}->set_from_pixbuf( $session_screens{$key}->{'thumb'} );

		foreach ( keys %{ $session_screens{$key} } ) {
			$session_screens{$key}->{$_}->set_sensitive(FALSE)
				if $session_screens{$key}->{$_} =~ /button/i;
			$session_screens{$key}->{$_}->set_text("-")
				if $session_screens{$key}->{$_} =~ /label/i;
		}

	}

	$session_screens{$key}->{'image'}->{'current_width'}
		= $session_screens{$key}->{'image'}->get_pixbuf->get_width;
	$session_screens{$key}->{'image'}->{'current_height'}
		= $session_screens{$key}->{'image'}->get_pixbuf->get_height;
	$session_screens{$key}->{'image'}->{'aspect_ratio'}
		= $session_screens{$key}->{'image'}->{'current_width'}
		/ $session_screens{$key}->{'image'}->{'current_height'};

	&fct_resize_thumb( $session_screens{$key}->{'image'}, undef, $key );

	return TRUE;
}

sub fct_get_latest_tab_key {
	my $max_key = 0;
	foreach my $key ( keys %session_screens ) {
		$key =~ /\[(.*)\]/;
		$max_key = $1 if ( $1 > $max_key );
	}
	return $max_key + 1;
}

sub fct_imagemagick_perform {
	my ( $function, $file, $data ) = @_;
	my $image = Image::Magick->new;
	$file = $gscrot_hfunct->switch_home_in_file($file);
	$image->ReadImage($file);

	if ( $function eq "reduce_colors" ) {
		$data =~ /.*\(([0-9]*).*\)/;
		$image->Quantize( colors => 2**$1 );
		$image->WriteImage( filename => $file, depth => 8 );
	} elsif ( $function eq "get_object" ) {
		return $image;
	} elsif ( $function eq "get_width" ) {
		return $image->Get('columns');
	} elsif ( $function eq "get_height" ) {
		return $image->Get('rows');
	} elsif ( $function eq "get_mime" ) {
		return $image->Get('mime');
	} elsif ( $function eq "resize" ) {
		$data =~ /(.*)x(.*)/;
		&fct_resize_imagemagick_object( \$image, $1, $2, undef );
		$image->WriteImage( filename => $file );
	} elsif ( $function eq "save" ) {
		$image->WriteImage( filename => $data, quality => 100 );    #$data is new filename
	}
	return TRUE;
}

sub fct_resize_imagemagick_object {

	#$image is a reference, so dereference it when using it
	my ( $image, $w, $h, $operator ) = @_;
	$operator = $combobox_thumb_operator->get_active
		unless defined $operator;
	if ( $operator == 0 ) {
		$$image->Resize( width => $w, height => $h );
	} elsif ( $operator == 1 ) {
		$$image->Thumbnail( width => $w, height => $h );
	} elsif ( $operator == 2 ) {
		$$image->Sample( width => $w, height => $h );
	} elsif ( $operator == 3 ) {
		$$image->Scale( width => $w, height => $h );
	} elsif ( $operator == 4 ) {
		$$image->AdaptiveResize( width => $w, height => $h );
	}
	return TRUE;
}

sub fct_check_installed_programs {

	%gm_programs = do "$gscrot_root/share/gscrot/resources/system/programs.conf";
	if ( $gscrot_hfunct->file_exists("$ENV{ 'HOME' }/.gscrot/programs.conf") ) {
		print
			"\nINFO: using custom program settings found at $ENV{ 'HOME' }/.gscrot/programs.conf\n";
		%gm_programs = do "$ENV{ 'HOME' }/.gscrot/programs.conf";
	}

	foreach ( keys %gm_programs ) {
		unless ( $gscrot_hfunct->file_exists( $gm_programs{$_}->{'binary'} ) ) {
			print " Could not detect binary for program $_, ignoring\n"
				if $gscrot_common->get_debug;
			delete $gm_programs{$_};
			next;
		} else {
			if ( $gscrot_common->get_debug ) {
				print "$gm_programs{$_}->{'name'} - $gm_programs{$_}->{'binary'}\n";
			}
		}
	}

	#update list of available programs in settings dialog as well
	if ($progname) {

		my $model         = $progname->get_model();
		my $progname_iter = $progname->get_active_iter();

		#get last prog
		my $progname_value;
		if ( defined $progname_iter ) {
			$progname_value = $model->get_value( $progname_iter, 2 );
			utf8::encode $progname_value;
		}

		#rebuild model with new hash of installed programs...
		$model = &fct_get_program_model;
		$progname->set_model($model);

		#...and try to set last	value
		if ($progname_value) {
			$model->foreach( \&fct_iter_programs, $progname_value );
		} else {
			$progname->set_active(0);
		}

		#nothing has been set
		if ( $progname->get_active == -1 ) {
			$progname->set_active(0);
		}
	}

	return TRUE;
}

sub fct_get_next_filename {

	my ( $filename_value, $folder, $filetype_value ) = @_;

	$filename_value =~ s/\\//g;

	#auto increment
	if ( $filename_value =~ /\%N{1,}/ ) {

		#how many Ns are used? (important for formatting)
		my $pos_proc = index( $filename_value, "%", 0 );
		my $n_counter = 0;
		$pos_proc++;

		while ( $pos_proc <= length($filename_value) ) {
			if ( index( $filename_value, "N", $pos_proc ) != -1 ) {
				$n_counter++;
				$pos_proc++;
			} else {
				last;
			}
		}
		print "$n_counter Ns used in wild-card\n" if $gscrot_common->get_debug;
		my $marks = "";
		my $i     = 0;

		while ( $i < $n_counter ) {
			$marks .= "?";
			$i++;
		}

		$filename_value =~ s/\%N{1,}/$marks/g;
		print "Searching for files with pattern: $filename_value.$filetype_value\n"
			if $gscrot_common->get_debug;
		my @files = glob("$folder/$filename_value.$filetype_value");
		@files = sort { $b cmp $a } @files;

		if ( $gscrot_common->get_debug ) {
			foreach (@files) {
				print $_. "\n";
			}
		}

		#check pos of %NN
		my $pos = index( "$folder/$filename_value.$filetype_value", "?", 0 );
		my $next_count = 0;
		unless ( $pos == -1 ) {

			foreach (@files) {
				$next_count = substr( $_, $pos, $n_counter );
				next unless $next_count =~ /^(\d+\.?\d*|\.\d+)$/;
				print "Counter at position $pos - $next_count is currently greatest value...\n"
					if $gscrot_common->get_debug;
				last;
			}
		}
		$next_count = 0 unless $next_count =~ /^(\d+\.?\d*|\.\d+)$/;
		$next_count = sprintf( "%0" . $n_counter . "d", $next_count + 1 );
		$marks = quotemeta $marks;
		$filename_value =~ s/$marks/$next_count/g;
	}

	#file already exists and user is not using ai
	if ( $gscrot_hfunct->file_exists("$folder/$filename_value.$filetype_value") ) {
		my $count             = 1;
		my $existing_filename = $filename_value;
		while ( $gscrot_hfunct->file_exists("$folder/$filename_value.$filetype_value") ) {
			$filename_value = $existing_filename . "(" . sprintf( "%03d", $count++ ) . ")";
		}
	}

	return $filename_value;
}

sub fct_check_installed_plugins {

	my @plugin_paths = (
		"$gscrot_root/share/gscrot/resources/system/plugins/*/*",
		"$ENV{'HOME'}/.gscrot/plugins/*/*"
	);

	foreach my $plugin_path (@plugin_paths) {
		my @plugins = glob($plugin_path);
		foreach (@plugins) {
			if ( -d $_ ) {
				my $dir_name = $_;

				#parse filename
				my ( $name, $folder, $type ) = fileparse( $dir_name, '\..*' );

				if ( $gscrot_hfunct->file_exists("$dir_name/$name") ) {

					unless ( $plugins{$_}->{'binary'}
						&& $plugins{$_}->{'name'}
						&& $plugins{$_}->{'category'}
						&& $plugins{$_}->{'tooltip'}
						&& $plugins{$_}->{'ext'}
						&& $plugins{$_}->{'lang'} )
					{

						print "\nINFO: new plugin information detected - $dir_name/$name\n";

						#path to executable
						$plugins{$_}->{'binary'} = "$dir_name/$name";

						#menu flag
						$plugins{$_}->{'menu'} = FALSE
							unless $plugins{$_}->{'menu'};

						#name
						$plugins{$_}->{'name'}
							= &fct_plugin_get_info( $plugins{$_}->{'binary'}, 'name' );

						#category
						$plugins{$_}->{'category'}
							= &fct_plugin_get_info( $plugins{$_}->{'binary'}, 'sort' );

						#tooltip
						$plugins{$_}->{'tooltip'}
							= &fct_plugin_get_info( $plugins{$_}->{'binary'}, 'tip' );

						#extensions
						$plugins{$_}->{'ext'}
							= &fct_plugin_get_info( $plugins{$_}->{'binary'}, 'ext' );

						#language (shell, perl etc.)
						$plugins{$_}->{'lang'}
							= &fct_plugin_get_info( $plugins{$_}->{'binary'}, 'lang' );

					}

					$plugins{$_}->{'lang'} = "shell"
						if $plugins{$_}->{'lang'} eq "";

					chomp( $plugins{$_}->{'name'} );
					chomp( $plugins{$_}->{'category'} );
					chomp( $plugins{$_}->{'tooltip'} );
					chomp( $plugins{$_}->{'ext'} );
					chomp( $plugins{$_}->{'lang'} );

					#check if plugin can handle png and/or jpeg
					$plugins{$_}->{'pixbuf_jpeg'} = 'gtk-no';
					$plugins{$_}->{'pixbuf_png'}  = 'gtk-no';
					$plugins{$_}->{'pixbuf_jpeg'} = 'gtk-yes'
						if ( $plugins{$_}->{'ext'} =~ /jpeg/ );
					$plugins{$_}->{'pixbuf_png'} = 'gtk-yes'
						if ( $plugins{$_}->{'ext'} =~ /png/ );

					#pixbuf
					$plugins{$_}->{'pixbuf'} = $plugins{$_}->{'binary'} . ".png"
						if ( $gscrot_hfunct->file_exists( $plugins{$_}->{'binary'} . ".png" ) );
					$plugins{$_}->{'pixbuf'} = $plugins{$_}->{'binary'} . ".svg"
						if ( $gscrot_hfunct->file_exists( $plugins{$_}->{'binary'} . ".svg" ) );

					if ( $gscrot_hfunct->file_exists( $plugins{$_}->{'pixbuf'} ) ) {
						$plugins{$_}->{'pixbuf_object'}
							= Gtk2::Gdk::Pixbuf->new_from_file_at_size( $plugins{$_}->{'pixbuf'},
							Gtk2::IconSize->lookup('menu') );
					} else {
						$plugins{$_}->{'pixbuf'}
							= "$gscrot_root/share/gscrot/resources/icons/executable.svg";
						$plugins{$_}->{'pixbuf_object'}
							= Gtk2::Gdk::Pixbuf->new_from_file_at_size( $plugins{$_}->{'pixbuf'},
							Gtk2::IconSize->lookup('menu') );
					}
					if ( $gscrot_common->get_debug ) {
						binmode( STDOUT, ":utf8" );
						print "$plugins{$_}->{'name'} - $plugins{$_}->{'binary'}\n";
					}
				} else {
					delete $plugins{$_};
				}    #endif binary exists
			}
		}
	}

	return TRUE;
}

sub fct_plugin_get_info {
	my ( $plugin, $info ) = @_;

	my $plugin_info = `$plugin $info`;
	utf8::decode $plugin_info;

	return $plugin_info;
}

sub fct_create_thumbnail_and_fileinfos {
	my ( $filename, $key ) = @_;
	return FALSE unless $gscrot_hfunct->file_exists($filename);
	$filename = $gscrot_hfunct->switch_home_in_file($filename);

	eval {
		$session_screens{$key}->{'thumb'}
			= Gtk2::Gdk::Pixbuf->new_from_file_at_scale( $filename, 400, 400, TRUE );
	};

	if ($@) {
		&dlg_error_message("$@");
		return FALSE;
	}

	unless ( defined $session_screens{$key}->{'thumb'} ) {
		eval {
			$session_screens{$key}->{'thumb'}
				= Gtk2::Gdk::Pixbuf->new_from_file_at_scale(
				"$gscrot_root/share/gscrot/resources/icons/Image-missing.svg",
				400, 400, TRUE );
		};
		if ($@) {
			&dlg_error_message("$@");
			return FALSE;
		}
	}

	$session_screens{$key}->{'mime_type'} = &fct_imagemagick_perform( "get_mime", $filename, "" );
	$session_screens{$key}->{'width'}  = &fct_imagemagick_perform( "get_width",  $filename, 0, "" );
	$session_screens{$key}->{'height'} = &fct_imagemagick_perform( "get_height", $filename, 0, "" );
	$session_screens{$key}->{'size'}   = -s $filename;

	#parse filename
	(   $session_screens{$key}->{'short'},
		$session_screens{$key}->{'folder'},
		$session_screens{$key}->{'filetype'}
	) = fileparse( $filename, '\..*' );

	$session_screens{$key}->{'short'} .= $session_screens{$key}->{'filetype'};
	$session_screens{$key}->{'filetype'} =~ s/\.//ig;

	#long filename
	$session_screens{$key}->{'long'} = $filename;

	return TRUE;
}

sub fct_iter_programs {
	my ( $model, $path, $iter, $search_for ) = @_;
	my $progname_value = $model->get_value( $iter, 2 );
	return FALSE if $search_for ne $progname_value;
	$progname->set_active_iter($iter);
	return TRUE;
}

sub fct_ret_workspace_menu {
	my $init = shift;

	my $menu_wrksp = Gtk2::Menu->new;

	my $screen = Gnome2::Wnck::Screen->get_default;
	$screen->force_update();

	my $wm_name = Gtk2::Gdk::Screen->get_default->get_window_manager_name;

	my $active_workspace = $screen->get_active_workspace;

	#we need to handle different window manager here because there are some different models related
	#to workspaces and viewports
	#	compiz uses "one workspace" - "multiple viewports" model for example
	#	default gnome wm metacity simply uses multiple workspaces
	#we will try to handle them by name

	#compiz
	if ( $wm_name =~ /compiz/ ) {

		#calculate viewports with size of workspace
		my $vpx = $active_workspace->get_viewport_x;
		my $vpy = $active_workspace->get_viewport_y;

		my $n_viewports_column = int( $active_workspace->get_width / $screen->get_width );
		my $n_viewports_rows   = int( $active_workspace->get_height / $screen->get_height );

		#rows
		for ( my $j = 0; $j < $n_viewports_rows; $j++ ) {

			#columns
			for ( my $i = 0; $i < $n_viewports_column; $i++ ) {
				my @vp = ( $i * $screen->get_width, $j * $screen->get_height );
				my $vp_name = "$wm_name x: $i y: $j";

				print "gscrot_wrksp_direct_compiz" . $vp[0] . "x" . $vp[1] . "\n"
					if $gscrot_common->get_debug;

				my $vp_item = Gtk2::MenuItem->new_with_label( ucfirst $vp_name );
				$vp_item->signal_connect(
					'activate' => \&evt_take_screenshot,
					"gscrot_wrksp_direct_compiz" . $vp[0] . "x" . $vp[1]
				);
				$menu_wrksp->append($vp_item);

				#do not offer current viewport
				if ( $vp[0] == $vpx && $vp[1] == $vpy ) {
					$vp_item->set_sensitive(FALSE);
				}
			}    #columns
		}    #rows

		#all other wm manager like metacity etc.
		#we could add more of them here if needed
	} else {

		my @workspaces = ();
		for ( my $wcount = 0; $wcount < $screen->get_workspace_count; $wcount++ ) {
			push( @workspaces, $screen->get_workspace($wcount) );
		}

		foreach my $space (@workspaces) {
			next unless defined $space;

			my $wrkspace_item = Gtk2::MenuItem->new_with_label( $space->get_name );
			$wrkspace_item->signal_connect(
				'activate' => \&evt_take_screenshot,
				"gscrot_wrksp_direct" . $space->get_number
			);
			$menu_wrksp->append($wrkspace_item);
			if ( $active_workspace->get_number == $space->get_number ) {
				$wrkspace_item->set_sensitive(FALSE);
			}
		}
	}

	my $n_mons = Gtk2::Gdk::Screen->get_default->get_n_monitors;

	#use only current monitore
	$menu_wrksp->append( Gtk2::SeparatorMenuItem->new );
	if ($init) {
		$current_monitor_active = Gtk2::CheckMenuItem->new_with_label(
			$gscrot_common->get_gettext->get("Limit to current monitor") );
		if ( defined $settings_xml->{'general'}->{'current_monitor_active'} ) {
			$current_monitor_active->set_active(
				$settings_xml->{'general'}->{'current_monitor_active'} );
		} else {
			$current_monitor_active->set_active(FALSE);
		}
		$menu_wrksp->append($current_monitor_active);
	} else {
		$current_monitor_active->reparent($menu_wrksp);
	}
	$tooltips->set_tip(
		$current_monitor_active,
		sprintf(
			$gscrot_common->get_gettext->nget(
				"This option is only useful when you are running a multi-monitor system (%d monitor detected).\nEnable it to capture only the current monitor.",
				"This option is only useful when you are running a multi-monitor system (%d monitors detected).\nEnable it to capture only the current monitor.",
				$n_mons
			),
			$n_mons
		)
	);
	if ( $n_mons > 1 ) {
		$current_monitor_active->set_sensitive(TRUE);
	} else {
		$current_monitor_active->set_active(FALSE);
		$current_monitor_active->set_sensitive(FALSE);
	}

	$button_raw_menu->set_menu($menu_wrksp);
	$menu_wrksp->show_all();
	return $menu_wrksp;
}

sub fct_ret_window_menu {
	my $screen = Gnome2::Wnck::Screen->get_default;
	$screen->force_update();

	my $menu_windows = Gtk2::Menu->new;
	foreach my $win ( $screen->get_windows ) {
		if ( $win->is_visible_on_workspace( $screen->get_active_workspace ) ) {
			my $window_item = Gtk2::ImageMenuItem->new_with_label( $win->get_name );
			$window_item->set_image( Gtk2::Image->new_from_pixbuf( $win->get_mini_icon ) );
			$window_item->signal_connect(
				'activate' => \&evt_take_screenshot,
				"gscrot_window_direct" . $win->get_xid
			);
			$menu_windows->append($window_item);
		}
	}
	$button_window_menu->set_menu($menu_windows);
	$menu_windows->show_all;
	return $menu_windows;
}

sub fct_ret_tray_menu {

	my $tray_menu       = Gtk2::Menu->new();
	my $menuitem_select = Gtk2::ImageMenuItem->new( $gscrot_common->get_gettext->get("Selection") );
	$menuitem_select->set_image(
		Gtk2::Image->new_from_pixbuf(
			Gtk2::Gdk::Pixbuf->new_from_file_at_size(
				"$gscrot_root/share/gscrot/resources/icons/selection.svg",
				Gtk2::IconSize->lookup('menu')
			)
		)
	);
	$menuitem_select->signal_connect(
		activate => \&evt_take_screenshot,
		'tray_select'
	);
	my $menuitem_raw = Gtk2::ImageMenuItem->new( $gscrot_common->get_gettext->get("Full Screen") );
	$menuitem_raw->set_image(
		Gtk2::Image->new_from_pixbuf(
			Gtk2::Gdk::Pixbuf->new_from_file_at_size(
				"$gscrot_root/share/gscrot/resources/icons/fullscreen.svg",
				Gtk2::IconSize->lookup('menu')
			)
		)
	);
	$menuitem_raw->signal_connect(
		activate => \&evt_take_screenshot,
		'tray_raw'
	);
	my $menuitem_window = Gtk2::ImageMenuItem->new( $gscrot_common->get_gettext->get("Window") );
	$menuitem_window->set_image(
		Gtk2::Image->new_from_pixbuf(
			Gtk2::Gdk::Pixbuf->new_from_file_at_size(
				"$gscrot_root/share/gscrot/resources/icons/sel_window.svg",
				Gtk2::IconSize->lookup('menu')
			)
		)
	);
	$menuitem_window->signal_connect(
		activate => \&evt_take_screenshot,
		'tray_window'
	);
	my $menuitem_window_sect
		= Gtk2::ImageMenuItem->new( $gscrot_common->get_gettext->get("Section") );
	$menuitem_window_sect->set_image(
		Gtk2::Image->new_from_pixbuf(
			Gtk2::Gdk::Pixbuf->new_from_file_at_size(
				"$gscrot_root/share/gscrot/resources/icons/sel_window_section.svg",
				Gtk2::IconSize->lookup('menu')
			)
		)
	);
	$menuitem_window_sect->signal_connect(
		activate => \&evt_take_screenshot,
		'tray_section'
	);
	my $menuitem_web = Gtk2::ImageMenuItem->new( $gscrot_common->get_gettext->get("Web") );
	$menuitem_web->set_sensitive($gnome_web_photo);
	$menuitem_web->set_image(
		Gtk2::Image->new_from_pixbuf(
			Gtk2::Gdk::Pixbuf->new_from_file_at_size(
				"$gscrot_root/share/gscrot/resources/icons/web_image.svg",
				Gtk2::IconSize->lookup('menu')
			)
		)
	);
	$menuitem_web->signal_connect(
		activate => \&evt_take_screenshot,
		'tray_web'
	);
	my $menuitem_info = Gtk2::ImageMenuItem->new( $gscrot_common->get_gettext->get("Info") );
	$menuitem_info->set_image( Gtk2::Image->new_from_icon_name( 'gtk-about', 'menu' ) );
	$menuitem_info->signal_connect( "activate", \&evt_about, $window );
	my $menuitem_quit = Gtk2::ImageMenuItem->new( $gscrot_common->get_gettext->get("Quit") );
	$menuitem_quit->set_image( Gtk2::Image->new_from_icon_name( 'gtk-quit', 'menu' ) );
	$menuitem_quit->signal_connect( "activate", \&evt_delete_window, 'menu_quit' );
	$tray_menu->append($menuitem_select);
	$tray_menu->append( Gtk2::SeparatorMenuItem->new );
	$tray_menu->append($menuitem_raw);
	$tray_menu->append( Gtk2::SeparatorMenuItem->new );
	$tray_menu->append($menuitem_window);
	$tray_menu->append($menuitem_window_sect);
	$tray_menu->append( Gtk2::SeparatorMenuItem->new );
	$tray_menu->append($menuitem_web);
	$tray_menu->append( Gtk2::SeparatorMenuItem->new );
	$tray_menu->append($menuitem_info);
	$tray_menu->append($menuitem_quit);
	$tray_menu->show_all;

	return $tray_menu;
}

sub fct_ret_sel_menu {

	#PREF MENU
	my $menu_settings = Gtk2::Menu->new;
	$zoom_active = Gtk2::CheckMenuItem->new_with_label(
		$gscrot_common->get_gettext->get("Enable zoom window") );
	if ( defined $settings_xml->{'general'}->{'zoom_active'} ) {
		$zoom_active->set_active( $settings_xml->{'general'}->{'zoom_active'} );
	} else {
		$zoom_active->set_active(TRUE);
	}

	my $menu_size
		= Gtk2::MenuItem->new_with_label( $gscrot_common->get_gettext->get("Size of zoom window") );
	my $menu_size2 = Gtk2::Menu->new;
	$zoom_size1 = Gtk2::RadioMenuItem->new( undef, $gscrot_common->get_gettext->get("Small") );
	$zoom_size2
		= Gtk2::RadioMenuItem->new( $zoom_size1, $gscrot_common->get_gettext->get("Medium") );
	$zoom_size3
		= Gtk2::RadioMenuItem->new( $zoom_size1, $gscrot_common->get_gettext->get("Large") );

	if ( defined $settings_xml->{'general'}->{'zoom_size'} ) {
		$zoom_size1->set_active(TRUE)
			if $settings_xml->{'general'}->{'zoom_size'} == 1;
		$zoom_size2->set_active(TRUE)
			if $settings_xml->{'general'}->{'zoom_size'} == 2;
		$zoom_size3->set_active(TRUE)
			if $settings_xml->{'general'}->{'zoom_size'} == 3;
	} else {
		$zoom_size1->set_active(TRUE);
	}

	#TOP MENU
	my $menu_sel = Gtk2::Menu->new;

	#advanced tool
	$tool_advanced = Gtk2::RadioMenuItem->new( undef,
		$gscrot_common->get_gettext->get("Advanced selection tool") );

	#simple tool
	$tool_simple = Gtk2::RadioMenuItem->new( $tool_advanced,
		$gscrot_common->get_gettext->get("Simple selection tool") );

	#and some more preferences
	my $advanced_settings
		= Gtk2::MenuItem->new_with_label( $gscrot_common->get_gettext->get("Preferences") );

	$menu_sel->append($tool_advanced);
	$menu_sel->append($tool_simple);
	$menu_sel->append($advanced_settings);

	$menu_size->set_submenu($menu_size2);
	$menu_size2->append($zoom_size1);
	$menu_size2->append($zoom_size2);
	$menu_size2->append($zoom_size3);

	$menu_settings->append($zoom_active);
	$menu_settings->append($menu_size);
	$advanced_settings->set_submenu($menu_settings);

	$tool_simple->signal_connect(
		'activate' => sub {
			my $widget = shift;
			if ( $widget->get_active ) {
				$advanced_settings->set_sensitive(TRUE);
			} else {
				$advanced_settings->set_sensitive(FALSE);
			}
		}
	);

	#set saved/default settings
	if ( defined $settings_xml->{'general'}->{'selection_tool'} ) {
		if ( $settings_xml->{'general'}->{'selection_tool'} == 1 ) {
			$tool_advanced->set_active(TRUE);
			$advanced_settings->set_sensitive(FALSE);
		} elsif ( $settings_xml->{'general'}->{'selection_tool'} == 2 ) {
			$tool_simple->set_active(TRUE);
			$advanced_settings->set_sensitive(TRUE);
		}
	} else {
		$tool_advanced->set_active(TRUE);
		$advanced_settings->set_sensitive(FALSE);
	}

	#check if Gtk2::ImageView is supported
	if ($gtkimageview) {
		$tooltips->set_tip(
			$tool_advanced,
			$gscrot_common->get_gettext->get(
				"The advanced selection tool allows you to enlarge/shrink or move your selected area\nuntil you finally take the screenshot."
			)
		);
	} else {
		$tool_advanced->set_sensitive(FALSE);
		$tooltips->set_tip(
			$tool_advanced,
			$gscrot_common->get_gettext->get(
				"Gtk2::ImageView needs to be installed for this feature")
		);

		#needs to be enabled by default now
		$tool_simple->set_active(TRUE);
		$advanced_settings->set_sensitive(TRUE);
	}

	$tooltips->set_tip(
		$tool_simple,
		$gscrot_common->get_gettext->get(
			"The simple selection tool is the fastest way of taking a screenshot.\nIt provides an optional zoom window for precise shots."
		)
	);

	$menu_sel->show_all;

	return $menu_sel;
}

sub fct_ret_program_menu {
	my ($button_program_menu) = @_;

	&fct_check_installed_programs;

	my $menu_programs = Gtk2::Menu->new;
	foreach my $program ( keys %gm_programs ) {
		if (   $gm_programs{$program}->{'binary'} ne ""
			&& $gm_programs{$program}->{'name'} ne "" )
		{
			my $pixbuf;
			if ( -f $gm_programs{$program}->{'pixmap'} ) {
				$pixbuf
					= Gtk2::Gdk::Pixbuf->new_from_file_at_size( $gm_programs{$program}->{'pixmap'},
					Gtk2::IconSize->lookup('menu') );
			} else {
				$pixbuf
					= Gtk2::Gdk::Pixbuf->new_from_file_at_size(
					"$gscrot_root/share/gscrot/resources/icons/executable.svg",
					Gtk2::IconSize->lookup('menu') );
			}
			my $program_item
				= Gtk2::ImageMenuItem->new_with_label( $gm_programs{$program}->{'name'} );
			$program_item->set_image( Gtk2::Image->new_from_pixbuf($pixbuf) );
			$program_item->signal_connect(
				'activate' => sub {
					&fct_open_with_program( $gm_programs{$program}->{'binary'} );
				}
			);
			$menu_programs->append($program_item);
		} else {
			print "WARNING: Program $_ is not configured properly, ignoring\n";
		}
	}

	$button_program_menu->set_menu($menu_programs);
	$menu_programs->show_all;
	return $menu_programs;
}

sub fct_ret_web_menu {
	my $menu_web = Gtk2::Menu->new;
	my $timeout1
		= Gtk2::RadioMenuItem->new( undef, $gscrot_common->get_gettext->get("Timeout") . ": 5" );
	my $timeout2 = Gtk2::RadioMenuItem->new( $timeout1,
		$gscrot_common->get_gettext->get("Timeout") . ": 10" );
	my $timeout3 = Gtk2::RadioMenuItem->new( $timeout1,
		$gscrot_common->get_gettext->get("Timeout") . ": 15" );
	$timeout2->set_active(TRUE);
	$menu_web->append($timeout1);
	$menu_web->append($timeout2);
	$menu_web->append($timeout3);

	if ( defined $settings_xml->{'general'}->{'web_timeout'} ) {

		#determining timeout
		my @timeouts = $menu_web->get_children;
		my $timeout  = undef;
		foreach (@timeouts) {
			$timeout = $_->get_children->get_text;
			$timeout =~ /([0-9]+)/;
			$timeout = $1;
			if ( $settings_xml->{'general'}->{'web_timeout'} == $timeout ) {
				$_->set_active(TRUE);
			}
		}
	}
	$menu_web->show_all;
	return $menu_web;
}

sub fct_ret_profile_menu {
	my $combobox_settings_profiles = shift;
	my $current_profiles_ref       = shift;

	my $menu_profile = Gtk2::Menu->new;

	my $group   = undef;
	my $counter = 0;
	foreach my $profile ( @{$current_profiles_ref} ) {
		my $profile_item = Gtk2::RadioMenuItem->new( $group, $profile );
		$profile_item->set_active(TRUE)
			if $profile eq $combobox_settings_profiles->get_active_text;
		$profile_item->signal_connect(
			'toggled' => sub {
				my $widget = shift;
				return TRUE unless $widget->get_active;

				for ( my $i = 0; $i < scalar @{$current_profiles_ref}; $i++ ) {
					$combobox_settings_profiles->set_active($i);
					$current_profile_indx = $i;
					if ( $profile eq $combobox_settings_profiles->get_active_text ) {
						&evt_apply_profile( $widget, $combobox_settings_profiles,
							$current_profiles_ref );

						#						&fct_update_first_tab;
						last;
					}
				}
			}
		);
		$group = $profile_item unless $group;
		$menu_profile->append($profile_item);
		$counter++;
	}

	$menu_profile->show_all;
	return $menu_profile;
}

sub fct_load_accounts_tree {

	$accounts_model = Gtk2::ListStore->new(
		'Glib::String', 'Glib::String', 'Glib::String', 'Glib::String',
		'Glib::String', 'Glib::String', 'Glib::String'
	);

	foreach ( keys %accounts ) {
		my $hidden_text = "";
		for ( my $i = 1; $i <= length( $accounts{$_}->{'password'} ); $i++ ) {
			$hidden_text .= '*';
		}
		$accounts_model->set(
			$accounts_model->append,     0, $accounts{$_}->{'host'},           1,
			$accounts{$_}->{'username'}, 2, $hidden_text,                      3,
			$accounts{$_}->{'register'}, 4, $accounts{$_}->{'register_color'}, 5,
			$accounts{$_}->{'register_text'}
		);
	}

	return TRUE;
}

sub fct_load_plugin_tree {

	$effects_model = Gtk2::ListStore->new(
		'Glib::Boolean', 'Gtk2::Gdk::Pixbuf', 'Glib::String', 'Glib::String',
		'Glib::String',  'Glib::String',      'Glib::String', 'Glib::String',
		'Glib::String',  'Glib::String'
	);
	foreach ( sort keys %plugins ) {
		if ( $plugins{$_}->{'binary'} ) {

			#check if plugin can handle png and/or jpeg
			$plugins{$_}->{'pixbuf_jpeg'} = 'gtk-no';
			$plugins{$_}->{'pixbuf_png'}  = 'gtk-no';
			$plugins{$_}->{'pixbuf_jpeg'} = 'gtk-yes'
				if ( $plugins{$_}->{'ext'} =~ /jpeg/ );
			$plugins{$_}->{'pixbuf_png'} = 'gtk-yes'
				if ( $plugins{$_}->{'ext'} =~ /png/ );

			#pixbuf
			$plugins{$_}->{'pixbuf'} = $plugins{$_}->{'binary'} . ".png"
				if ( $gscrot_hfunct->file_exists( $plugins{$_}->{'binary'} . ".png" ) );
			$plugins{$_}->{'pixbuf'} = $plugins{$_}->{'binary'} . ".svg"
				if ( $gscrot_hfunct->file_exists( $plugins{$_}->{'binary'} . ".svg" ) );

			if ( $gscrot_hfunct->file_exists( $plugins{$_}->{'pixbuf'} ) ) {
				$plugins{$_}->{'pixbuf_object'}
					= Gtk2::Gdk::Pixbuf->new_from_file_at_size( $plugins{$_}->{'pixbuf'},
					Gtk2::IconSize->lookup('menu') );
			} else {
				$plugins{$_}->{'pixbuf'}
					= "$gscrot_root/share/gscrot/resources/icons/executable.svg";
				$plugins{$_}->{'pixbuf_object'}
					= Gtk2::Gdk::Pixbuf->new_from_file_at_size( $plugins{$_}->{'pixbuf'},
					Gtk2::IconSize->lookup('menu') );
			}

			$effects_model->set(
				$effects_model->append,          0, $plugins{$_}->{'menu'},        1,
				$plugins{$_}->{'pixbuf_object'}, 2, $plugins{$_}->{'name'},        3,
				$plugins{$_}->{'category'},      4, $plugins{$_}->{'pixbuf_jpeg'}, 5,
				$plugins{$_}->{'pixbuf_png'},    6, $plugins{$_}->{'tooltip'},     7,
				$plugins{$_}->{'lang'},          8, $plugins{$_}->{'binary'},      9,
				$_,
			);
		} else {
			print "\nWARNING: Plugin $_ is not configured properly, ignoring\n";
			delete $plugins{$_};
		}
	}

	return TRUE;
}

sub fct_set_model_accounts {
	my $accounts_tree = $_[0];

	my @columns = $accounts_tree->get_columns;
	foreach (@columns) {
		$accounts_tree->remove_column($_);
	}

	#host
	my $tv_clmn_name_text = Gtk2::TreeViewColumn->new;
	$tv_clmn_name_text->set_title( $gscrot_common->get_gettext->get("Host") );
	my $renderer_name_accounts = Gtk2::CellRendererText->new;
	$tv_clmn_name_text->pack_start( $renderer_name_accounts, FALSE );
	$tv_clmn_name_text->set_attributes( $renderer_name_accounts, text => 0 );
	$accounts_tree->append_column($tv_clmn_name_text);

	my $renderer_username_accounts = Gtk2::CellRendererText->new;
	$renderer_username_accounts->set( editable => TRUE );
	$renderer_username_accounts->signal_connect(
		'editing-started' => sub {
			my ( $cell, $cell_editable, $text_path, $model ) = @_;
			my $path = Gtk2::TreePath->new_from_string($text_path);
			my $iter = $model->get_iter($path);
			if ( $model->get_value( $iter, 0 ) =~ /imageshack/i ) {
				$gscrot_dialog->dlg_info_message(
					$gscrot_common->get_gettext->get(
						"If you have registered with imageshack.us, you should have received an email with a link similar to\n\nhttp://reg.imageshack.us/setlogin.php?login=SOME_IDENTIFIER\n\nYou should pass either that link as the username or only the user_id (SOME_IDENTIFIER)\n\nYou do not have to provide a password."
					)
				);
			}
		},
		$accounts_model
	);
	$renderer_username_accounts->signal_connect(
		'edited' => sub {
			my ( $cell, $text_path, $new_text, $model ) = @_;
			my $path = Gtk2::TreePath->new_from_string($text_path);
			my $iter = $model->get_iter($path);

			#save entered username to the hash
			$accounts{ $model->get_value( $iter, 0 ) }->{'username'} = $new_text;

			if ( $model->get_value( $iter, 0 ) =~ /imageshack/i ) {

				#we catch the user-id when url is entered
				if ( $new_text =~ /^http.*login=(.*)/ ) {
					$new_text = $1;
				}

				#imageshack does not need a password
				$accounts{ $model->get_value( $iter, 0 ) }->{'password'} = $new_text;
			}

			$model->set( $iter, 1, $new_text );
		},
		$accounts_model
	);
	my $tv_clmn_username_text
		= Gtk2::TreeViewColumn->new_with_attributes( $gscrot_common->get_gettext->get("Username"),
		$renderer_username_accounts, text => 1 );
	$tv_clmn_username_text->set_max_width(100);
	$accounts_tree->append_column($tv_clmn_username_text);

	#password
	my $tv_clmn_password_text = Gtk2::TreeViewColumn->new;
	$tv_clmn_password_text->set_max_width(100);
	$tv_clmn_password_text->set_title( $gscrot_common->get_gettext->get("Password") );
	my $renderer_password_accounts = Gtk2::CellRendererText->new;
	$renderer_password_accounts->set( editable => TRUE );
	$renderer_password_accounts->signal_connect(
		'editing-started' => sub {
			my ( $cell, $cell_editable, $text_path, $model ) = @_;
			my $path = Gtk2::TreePath->new_from_string($text_path);
			my $iter = $model->get_iter($path);
			if ( $model->get_value( $iter, 0 ) =~ /imageshack/i ) {
				$gscrot_dialog->dlg_info_message(
					$gscrot_common->get_gettext->get(
						"If you have registered with imageshack.us, you should have received an email with a link similar to\n\nhttp://reg.imageshack.us/setlogin.php?login=SOME_IDENTIFIER\n\nYou should pass either that link as the username or only the user_id (SOME_IDENTIFIER)\n\nYou do not have to provide a password."
					)
				);
			}
		},
		$accounts_model
	);

	$renderer_password_accounts->signal_connect(
		edited => sub {
			my ( $cell, $text_path, $new_text, $model ) = @_;
			my $path        = Gtk2::TreePath->new_from_string($text_path);
			my $iter        = $model->get_iter($path);
			my $hidden_text = "";

			for ( my $i = 1; $i <= length($new_text); $i++ ) {
				$hidden_text .= '*';
			}
			unless ( $model->get_value( $iter, 0 ) =~ /imageshack/i ) {
				$accounts{ $model->get_value( $iter, 0 ) }->{'password'}
					= $new_text;    #save entered password to the hash
				$model->set( $iter, 2, $hidden_text );
			} else {
				$model->set( $iter, 2, "" );
			}
		},
		$accounts_model
	);

	$tv_clmn_password_text->pack_start( $renderer_password_accounts, FALSE );
	$tv_clmn_password_text->set_attributes( $renderer_password_accounts, text => 2 );
	$accounts_tree->append_column($tv_clmn_password_text);

	#register
	my $tv_clmn_pix_text = Gtk2::TreeViewColumn->new;
	$tv_clmn_pix_text->set_title( $gscrot_common->get_gettext->get("Register") );
	my $ren_text = Gtk2::CellRendererText->new();
	$tv_clmn_pix_text->pack_start( $ren_text, FALSE );
	$tv_clmn_pix_text->set_attributes( $ren_text, 'text', ( $gscrot_common->get_gettext->get(5) ),
		'foreground', 4 );
	$accounts_tree->append_column($tv_clmn_pix_text);

	return TRUE;
}

sub fct_set_model_plugins {
	my $effects_tree = $_[0];

	my @columns = $effects_tree->get_columns;
	foreach (@columns) {
		$effects_tree->remove_column($_);
	}

	#menu
	my $tv_clmn_toolbar_text = Gtk2::TreeViewColumn->new;
	$tv_clmn_toolbar_text->set_resizable(TRUE);
	$tv_clmn_toolbar_text->set_title( $gscrot_common->get_gettext->get("Toolbar") );
	my $renderer_toolbar_effects = Gtk2::CellRendererToggle->new;
	$tv_clmn_toolbar_text->pack_start( $renderer_toolbar_effects, FALSE );
	$tv_clmn_toolbar_text->set_attributes( $renderer_toolbar_effects, 'active' => 0 );
	$renderer_toolbar_effects->signal_connect(
		toggled => \&evt_plugins_toolbar,
		$effects_model
	);
	$effects_tree->append_column($tv_clmn_toolbar_text);

	#icon
	$effects_tree->set_tooltip_column(6)
		if Gtk2->CHECK_VERSION( 2, 11, 0 );
	my $tv_clmn_pix_text = Gtk2::TreeViewColumn->new;
	$tv_clmn_pix_text->set_resizable(TRUE);
	$tv_clmn_pix_text->set_title( $gscrot_common->get_gettext->get("Icon") );
	my $renderer_pix_effects = Gtk2::CellRendererPixbuf->new;
	$tv_clmn_pix_text->pack_start( $renderer_pix_effects, FALSE );
	$tv_clmn_pix_text->set_attributes( $renderer_pix_effects, pixbuf => 1 );
	$effects_tree->append_column($tv_clmn_pix_text);

	#name
	my $tv_clmn_text_text = Gtk2::TreeViewColumn->new;
	$tv_clmn_text_text->set_resizable(TRUE);
	$tv_clmn_text_text->set_title( $gscrot_common->get_gettext->get("Name") );
	my $renderer_text_effects = Gtk2::CellRendererText->new;
	$tv_clmn_text_text->pack_start( $renderer_text_effects, FALSE );
	$tv_clmn_text_text->set_attributes( $renderer_text_effects, text => 2 );

	$effects_tree->append_column($tv_clmn_text_text);

	#category
	my $tv_clmn_category_text = Gtk2::TreeViewColumn->new;
	$tv_clmn_category_text->set_resizable(TRUE);
	$tv_clmn_category_text->set_title( $gscrot_common->get_gettext->get("Category") );
	my $renderer_category_effects = Gtk2::CellRendererText->new;
	$tv_clmn_category_text->pack_start( $renderer_category_effects, FALSE );
	$tv_clmn_category_text->set_attributes( $renderer_category_effects, text => 3 );
	$effects_tree->append_column($tv_clmn_category_text);

	#jpeg
	my $tv_clmn_jpeg_text = Gtk2::TreeViewColumn->new;
	$tv_clmn_jpeg_text->set_resizable(TRUE);
	$tv_clmn_jpeg_text->set_title("jpeg");
	my $renderer_jpeg_effects = Gtk2::CellRendererPixbuf->new;
	$tv_clmn_jpeg_text->pack_start( $renderer_jpeg_effects, FALSE );
	$tv_clmn_jpeg_text->set_attributes( $renderer_jpeg_effects, stock_id => 4 );
	$effects_tree->append_column($tv_clmn_jpeg_text);

	#png
	my $tv_clmn_png_text = Gtk2::TreeViewColumn->new;
	$tv_clmn_png_text->set_resizable(TRUE);
	$tv_clmn_png_text->set_title("png");
	my $renderer_png_effects = Gtk2::CellRendererPixbuf->new;
	$tv_clmn_png_text->pack_start( $renderer_png_effects, FALSE );
	$tv_clmn_png_text->set_attributes( $renderer_png_effects, stock_id => 5 );
	$effects_tree->append_column($tv_clmn_png_text);

	#tooltip column
	unless ( Gtk2->CHECK_VERSION( 2, 12, 0 ) ) {
		my $tv_clmn_descr_text = Gtk2::TreeViewColumn->new;
		$tv_clmn_descr_text->set_resizable(TRUE);
		$tv_clmn_descr_text->set_title( $gscrot_common->get_gettext->get("Description") );
		my $renderer_descr_effects = Gtk2::CellRendererText->new;
		$tv_clmn_descr_text->pack_start( $renderer_descr_effects, FALSE );
		$tv_clmn_descr_text->set_attributes( $renderer_descr_effects, text => 6 );
		$effects_tree->append_column($tv_clmn_descr_text);
	}

	#language
	my $tv_clmn_lang_text = Gtk2::TreeViewColumn->new;
	$tv_clmn_lang_text->set_resizable(TRUE);
	$tv_clmn_lang_text->set_title( $gscrot_common->get_gettext->get("Language") );
	my $renderer_lang_effects = Gtk2::CellRendererText->new;
	$tv_clmn_lang_text->pack_start( $renderer_lang_effects, FALSE );
	$tv_clmn_lang_text->set_attributes( $renderer_lang_effects, text => 7 );
	$effects_tree->append_column($tv_clmn_lang_text);

	#path
	my $tv_clmn_path_text = Gtk2::TreeViewColumn->new;
	$tv_clmn_path_text->set_resizable(TRUE);
	$tv_clmn_path_text->set_title( $gscrot_common->get_gettext->get("Path") );
	my $renderer_path_effects = Gtk2::CellRendererText->new;
	$tv_clmn_path_text->pack_start( $renderer_path_effects, FALSE );
	$tv_clmn_path_text->set_attributes( $renderer_path_effects, text => 8 );
	$effects_tree->append_column($tv_clmn_path_text);

	return TRUE;
}

sub fct_init_optional {

	print "INFO: searching for optional components...\n\n";
	if ( system("which gtklp") == 0 ) {
		print "SUCCESS: gtklp is installed on your system!\n\n";
	} else {
		warn "WARNING: gtklp is missing --> printing of screenshots will be disabled!\n\n";
		$gtklp = FALSE;
	}
	if ( system("which gnome-web-photo") == 0 ) {
		print "SUCCESS: gnome-web-photo is installed on your system!\n\n";
	} else {
		warn
			"WARNING: gnome-web-photo is missing --> screenshots of websites will be disabled!\n\n";
		$gnome_web_photo = FALSE;
	}
	eval { require Gtk2::ImageView };
	if ($@) {
		warn "WARNING: Gtk2::ImageView is missing --> advanced seletion tool will be disabled!\n\n";
		$gtkimageview = FALSE;
	}
	eval { require Goo::Canvas };
	if ($@) {
		warn "WARNING: Goo::Canvas is missing --> drawing tool will be disabled!\n\n";
		$goocanvas = FALSE;
	}

	return TRUE;
}

sub fct_init {

	#are there any command line params?
	if ( @ARGV > 0 ) {
		foreach my $arg (@ARGV) {
			$arg =~ s/.{2}//;
			if ( $arg eq "debug" ) {
				$gscrot_common->set_debug(TRUE);
			} elsif ( $arg eq "help" ) {
				$gscrot_hfunct->usage;
				exit;
			} elsif ( $arg eq "clear_cache" ) {
				$gscrot_common->set_clear_cache(TRUE);
			} elsif ( $arg eq "min_at_startup" ) {
				$gscrot_common->set_min(TRUE);
			} elsif ( $arg eq "disable_systray" ) {
				$gscrot_common->set_disable_systray(TRUE);
			} elsif ( $arg eq "section" ) {

				#is there already a process of gscrot running?
				my @gscrot_pids = `pidof -o $$ -x $gscrot_path`;
				foreach (@gscrot_pids) {
					kill RTMAX => $_;
					die;
				}
				$gscrot_common->set_start_with("section");
				$gscrot_common->set_min(TRUE);
			} elsif ( $arg eq "selection" ) {

				#is there already a process of gscrot running?
				my @gscrot_pids = `pidof -o $$ -x $gscrot_path`;
				foreach (@gscrot_pids) {
					kill RTMIN => $_;
					die;
				}
				$gscrot_common->set_start_with("select");
				$gscrot_common->set_min(TRUE);
			} elsif ( $arg eq "window" ) {

				#is there already a process of gscrot running?
				my @gscrot_pids = `pidof -o $$ -x $gscrot_path`;
				foreach (@gscrot_pids) {
					kill USR2 => $_;
					die;
				}
				$gscrot_common->set_start_with("window");
				$gscrot_common->set_min(TRUE);
			} elsif ( $arg eq "full" ) {

				#is there already a process of gscrot running?
				my @gscrot_pids = `pidof -o $$ -x $gscrot_path`;
				foreach (@gscrot_pids) {
					kill USR1 => $_;
					die;
				}
				$gscrot_common->set_start_with("raw");
				$gscrot_common->set_min(TRUE);
			} else {
				warn "ERROR: illegal command " . $arg . " \n\n";
				$gscrot_hfunct->usage;
				exit;
			}
			print "INFO: command " . $arg . " recognized!\n\n";
		}
	} else {
		print "INFO: no command line parameters set...\n\n";
	}

	#an old .gscrot file existing?
	unlink("$ENV{ 'HOME' }/.gscrot")
		if ( $gscrot_hfunct->file_exists("$ENV{ 'HOME' }/.gscrot") );

	#an old .gscrot/settings.conf file existing?
	unlink("$ENV{ 'HOME' }/.gscrot/settings.conf")
		if ( $gscrot_hfunct->file_exists("$ENV{ 'HOME' }/.gscrot/settings.conf") );

	#is there already a .gscrot folder?
	mkdir("$ENV{ 'HOME' }/.gscrot")
		unless ( -d "$ENV{ 'HOME' }/.gscrot" );

	#...and a profiles folder?
	mkdir "$ENV{'HOME'}/.gscrot/profiles"
		unless ( -d "$ENV{'HOME'}/.gscrot/profiles" );

	return TRUE;
}

sub fct_init_framework_versions {
	if ( $gscrot_common->get_debug ) {
		print "\nINFO: gathering system information...";
		print "\n";
		printf "Glib %s \n", $Glib::VERSION;
		printf "Gtk2 %s \n", $Gtk2::VERSION;
		print "\n";

		# The version info stuff appeared in 1.040.
		print "Glib built for "
			. join( ".", Glib->GET_VERSION_INFO )
			. ", running with "
			. join( ".", &Glib::major_version, &Glib::minor_version, &Glib::micro_version ) . "\n"
			if $Glib::VERSION >= 1.040;
		print "Gtk2 built for "
			. join( ".", Gtk2->GET_VERSION_INFO )
			. ", running with "
			. join( ".", &Gtk2::major_version, &Gtk2::minor_version, &Gtk2::micro_version ) . "\n"
			if $Gtk2::VERSION >= 1.040;
		print "\n";
	}
	return TRUE;
}

#--------------------------------------

#dialogs
#--------------------------------------

sub dlg_status_message {
	my ( $index, $status_text ) = @_;
	$statusbar->push( $index, $status_text );
	return TRUE;
}

sub dlg_error_message {
	my ( $dlg_error_message, $button_text_extra1, $button_text_extra2, $button_text_extra3 ) = @_;
	my $dlg_header = $gscrot_common->get_gettext->get("Error");
	my $error_dialog = Gtk2::Dialog->new( $dlg_header, $window, [qw/modal destroy-with-parent/] );

	$error_dialog->add_button( 'gtk-cancel', 0 );
	$error_dialog->add_button( $button_text_extra1, 10 ) if $button_text_extra1;
	$error_dialog->add_button( $button_text_extra2, 20 ) if $button_text_extra2;
	$error_dialog->add_button( $button_text_extra3, 30 ) if $button_text_extra3;

	#image and text to dialog
	my $error_hbox = Gtk2::HBox->new( FALSE, 5 );
	$error_hbox->pack_start_defaults( Gtk2::Image->new_from_stock( 'gtk-dialog-error', 'dialog' ) );
	$error_hbox->pack_start_defaults( Gtk2::Label->new($dlg_error_message) );

	$error_dialog->vbox->add($error_hbox);
	$error_dialog->show_all;

	my $error_response = $error_dialog->run;

	$error_dialog->destroy();
	return $error_response;
}

sub dlg_rename {
	my ( $dlg_rename_text, $data ) = @_;
	my $dlg_header   = $gscrot_common->get_gettext->get("Rename file");
	my $input_dialog = Gtk2::Dialog->new(
		$dlg_header,
		$window,
		[qw/modal destroy-with-parent/],
		'gtk-cancel' => 'reject',
		'gtk-apply'  => 'accept'
	);
	$input_dialog->set_default_response('accept');
	my $new_filename_hbox = Gtk2::HBox->new();
	my $new_filename_label
		= Gtk2::Label->new( $gscrot_common->get_gettext->get("New filename") . ": " );
	my $new_filename = Gtk2::Entry->new();
	$new_filename->set_activates_default(TRUE);

	my ( $old_file_name, $directory, $ext ) = fileparse( $dlg_rename_text, '\..*' );

	my $old_file_name_full = $dlg_rename_text;

	$new_filename->set_text($old_file_name);
	$new_filename_hbox->pack_start_defaults($new_filename_label);
	$new_filename_hbox->pack_start_defaults($new_filename);
	$input_dialog->vbox->add($new_filename_hbox);
	$input_dialog->show_all;
	my $input_response = $input_dialog->run;

	if ( $input_response eq "accept" ) {
		my $new_name = $new_filename->get_text;
		$dlg_rename_text = $directory . $new_name . $ext;
		unless ( $old_file_name_full eq $dlg_rename_text ) {    #filenames eq? -> nothing to do here
			unless ( $gscrot_hfunct->file_exists($dlg_rename_text) ) {
				rename(
					$gscrot_hfunct->switch_home_in_file($old_file_name_full),
					$gscrot_hfunct->switch_home_in_file($dlg_rename_text)
				);
			} else {

				if ($gscrot_dialog->dlg_question_message(
						$dlg_rename_text . "\n\n"
							. $gscrot_common->get_gettext->get(
							"File already exists.\nDo you want to overwrite it?")
					)
					)
				{
					rename(
						$gscrot_hfunct->switch_home_in_file($old_file_name_full),
						$gscrot_hfunct->switch_home_in_file($dlg_rename_text)
					);
					$session_screens{$data}->{'filename'} = $dlg_rename_text;
					$input_dialog->destroy();
					return TRUE;
				}
				$input_dialog->destroy();
				return FALSE;
			}
			$session_screens{$data}->{'filename'} = $dlg_rename_text;
		}
		$input_dialog->destroy();
		return TRUE;
	} else {
		$input_dialog->destroy();
		return FALSE;
	}
}

sub dlg_plugin {
	my ( $dlg_plugin_text, $key ) = @_;
	my $dlg_header    = $gscrot_common->get_gettext->get("Choose a plugin");
	my $plugin_dialog = Gtk2::Dialog->new(
		$dlg_header,
		$window,
		[qw/modal destroy-with-parent/],
		'gtk-cancel'  => 'reject',
		'gtk-execute' => 'accept'
	);
	$plugin_dialog->set_default_response('accept');
	my $model = Gtk2::ListStore->new(
		'Gtk2::Gdk::Pixbuf', 'Glib::String', 'Glib::String', 'Glib::String',
		'Glib::String',      'Glib::String'
	);

	foreach ( sort keys %plugins ) {
		next
			unless $plugins{$_}->{'ext'} =~ /$session_screens{$key}->{'filetype'}/;
		if ( $plugins{$_}->{'binary'} ne "" ) {

			$model->set(
				$model->append,         0, $plugins{$_}->{'pixbuf_object'}, 1,
				$plugins{$_}->{'name'}, 2, $plugins{$_}->{'binary'},        3,
				$plugins{$_}->{'lang'}, 4, $plugins{$_}->{'tooltip'},       5,
				$_
			);
		} else {
			print "WARNING: Program $_ is not configured properly, ignoring\n";
		}
	}
	my $plugin_label       = Gtk2::Label->new( $gscrot_common->get_gettext->get("Plugin") . ":" );
	my $plugin_label_blank = Gtk2::Label->new();
	my $plugin             = Gtk2::ComboBox->new($model);
	my $plugin_descr       = Gtk2::Label->new;
	$plugin_descr->set_line_wrap(TRUE);
	$plugin_descr->set_width_chars(30);
	$plugin_descr->set_padding( 10, 10 );
	my $plugin_image       = Gtk2::Image->new;
	my $plugin_descr_frame = Gtk2::Frame->new( $gscrot_common->get_gettext->get("Description") );
	$plugin_descr_frame->add($plugin_descr);
	my $plugin_hbox1 = Gtk2::HBox->new( FALSE, 5 );
	my $plugin_hbox2 = Gtk2::HBox->new( FALSE, 5 );
	$plugin_hbox2->set_border_width(10);

	$plugin->signal_connect(
		'changed' => sub {

			my $model       = $plugin->get_model();
			my $plugin_iter = $plugin->get_active_iter();

			if ($plugin_iter) {
				my $plugin_pixbuf = $model->get_value( $plugin_iter, 0 );
				my $plugin_name   = $model->get_value( $plugin_iter, 1 );
				my $plugin_value  = $model->get_value( $plugin_iter, 2 );
				my $plugin_lang   = $model->get_value( $plugin_iter, 3 );
				my $plugin_tip    = $model->get_value( $plugin_iter, 4 );
				my $plugin_key    = $model->get_value( $plugin_iter, 5 );

				$plugin_descr->set_text($plugin_tip);
				if ( $gscrot_hfunct->file_exists( $plugins{$plugin_key}->{'pixbuf'} ) ) {
					$plugin_image->set_from_pixbuf(
						Gtk2::Gdk::Pixbuf->new_from_file_at_size(
							$plugins{$plugin_key}->{'pixbuf'},
							100, 100
						)
					);
				}
			}
		},
		'changed'
	);
	my $renderer_pix = Gtk2::CellRendererPixbuf->new;
	$plugin->pack_start( $renderer_pix, FALSE );
	$plugin->add_attribute( $renderer_pix, pixbuf => 0 );
	my $renderer_text = Gtk2::CellRendererText->new;
	$plugin->pack_start( $renderer_text, FALSE );
	$plugin->add_attribute( $renderer_text, text => 1 );
	$plugin->set_active(0);

	$plugin_hbox1->pack_start_defaults($plugin);

	$plugin_hbox2->pack_start_defaults($plugin_image);
	$plugin_hbox2->pack_start_defaults($plugin_descr_frame);

	$plugin_dialog->vbox->add($plugin_hbox1);
	$plugin_dialog->vbox->add($plugin_hbox2);

	$plugin_dialog->show_all;

	my $plugin_response = $plugin_dialog->run;

	if ( $plugin_response eq "accept" ) {
		$dlg_plugin_text = $gscrot_hfunct->switch_home_in_file($dlg_plugin_text);
		my $model        = $plugin->get_model();
		my $plugin_iter  = $plugin->get_active_iter();
		my $plugin_value = $model->get_value( $plugin_iter, 2 );
		my $plugin_name  = $model->get_value( $plugin_iter, 1 );
		my $plugin_lang  = $model->get_value( $plugin_iter, 3 );
		unless ( $plugin_value =~ /[a-zA-Z0-9]+/ ) {
			&dlg_error_message( $gscrot_common->get_gettext->get("No plugin specified") );
			return FALSE;
		}

		my $data = [ $plugin_value, $plugin_name, $plugin_lang, $key, $plugin_dialog ];
		&fct_execute_plugin( undef, $data );

		$plugin_dialog->destroy();
		return TRUE;
	} else {
		$plugin_dialog->destroy();
		return FALSE;
	}
}

sub dlg_upload {
	my (@files_to_upload) = @_;

	return FALSE if @files_to_upload < 1;

	my $dlg_header = $gscrot_common->get_gettext->get("Upload");
	my $hosting_dialog = Gtk2::Dialog->new( $dlg_header, $window, [qw/modal destroy-with-parent/] );

	my $cancel_button = $hosting_dialog->add_button( 'gtk-cancel', 'reject' );
	my $upload_button
		= $hosting_dialog->add_button( $gscrot_common->get_gettext->get("_Upload"), 'accept' );
	$upload_button->set_image( Gtk2::Image->new_from_stock( 'gtk-go-up', 'button' ) );
	$hosting_dialog->set_default_response('accept');
	my $model
		= Gtk2::ListStore->new( 'Glib::String', 'Glib::String', 'Glib::String', 'Glib::String' );

	foreach ( keys %accounts ) {

		#cut username so the dialog will not explode ;-)
		my $short_username = $accounts{$_}->{'username'};
		if ( length $accounts{$_}->{'username'} > 10 ) {
			$short_username = substr( $accounts{$_}->{'username'}, 0, 10 ) . "...";
		}

		$model->set(
			$model->append,              0, $accounts{$_}->{'host'},     1,
			$accounts{$_}->{'username'}, 2, $accounts{$_}->{'password'}, 3,
			$short_username
			)
			if (
			( $_ =~ /imageshack/i && $accounts{$_}->{'username'} ne "" )
			|| (   $accounts{$_}->{'username'} ne ""
				&& $accounts{$_}->{'password'} ne "" )
			);
		$model->set(
			$model->append,                            0,
			$accounts{$_}->{'host'},                   1,
			$gscrot_common->get_gettext->get("Guest"), 2,
			"",                                        3,
			$gscrot_common->get_gettext->get("Guest")
		);
	}

	my $hosting_image = Gtk2::Image->new;

	#set up account combobox
	my $hosting       = Gtk2::ComboBox->new($model);
	my $renderer_host = Gtk2::CellRendererText->new;
	$hosting->pack_start( $renderer_host, FALSE );
	$hosting->add_attribute( $renderer_host, text => 0 );
	my $renderer_username = Gtk2::CellRendererText->new;
	$hosting->pack_start( $renderer_username, FALSE );
	$hosting->add_attribute( $renderer_username, text => 3 );
	$hosting->signal_connect(
		'changed' => sub {

			my $model        = $hosting->get_model();
			my $hosting_iter = $hosting->get_active_iter();

			if ($hosting_iter) {
				my $hosting_host     = $model->get_value( $hosting_iter, 0 );
				my $hosting_username = $model->get_value( $hosting_iter, 1 );
				if ( $hosting_host =~ /imageshack/i ) {
					$hosting_image->set_from_pixbuf(
						Gtk2::Gdk::Pixbuf->new_from_file_at_scale(
							"$gscrot_root/share/gscrot/resources/icons/logo-imageshack.png",
							200, 200, TRUE
						)
					);
				} elsif ( $hosting_host =~ /imagebanana/i ) {
					$hosting_image->set_from_pixbuf(
						Gtk2::Gdk::Pixbuf->new_from_file_at_scale(
							"$gscrot_root/share/gscrot/resources/icons/logo-imagebanana.png",
							200, 200, TRUE
						)
					);
				} elsif ( $hosting_host =~ /ubuntu-pics/i ) {
					$hosting_image->set_from_pixbuf(
						Gtk2::Gdk::Pixbuf->new_from_file_at_scale(
							"$gscrot_root/share/gscrot/resources/icons/logo-ubuntu-pics.png",
							200, 200, TRUE
						)
					);
				}

			}
		},
		'changed'
	);

	$hosting->set_active(0);

	#image hoster settings
	my $hosting_hbox1 = Gtk2::HBox->new( TRUE,  5 );
	my $hosting_hbox2 = Gtk2::HBox->new( FALSE, 5 );
	$hosting_hbox2->set_border_width(10);
	$hosting_hbox1->pack_start_defaults(
		Gtk2::Label->new( $gscrot_common->get_gettext->get("Choose account") ) );
	$hosting_hbox1->pack_start_defaults($hosting);
	$hosting_hbox2->pack_start_defaults($hosting_image);

	#ftp settings
	#we are using the same widgets as in the settings and populate
	#them with saved values when possible

	my $ftp_hbox1_dlg = Gtk2::HBox->new( TRUE, 0 );
	my $ftp_hbox2_dlg = Gtk2::HBox->new( TRUE, 0 );
	my $ftp_hbox3_dlg = Gtk2::HBox->new( TRUE, 0 );
	my $ftp_hbox4_dlg = Gtk2::HBox->new( TRUE, 0 );

	#uri
	my $ftp_entry_label_dlg = Gtk2::Label->new( $gscrot_common->get_gettext->get("URI") );
	$ftp_hbox1_dlg->pack_start( $ftp_entry_label_dlg, TRUE, TRUE, 10 );
	my $ftp_remote_entry_dlg = Gtk2::Entry->new;
	$ftp_remote_entry_dlg->set_text( $ftp_remote_entry->get_text );

	$tooltips->set_tip( $ftp_entry_label_dlg,
		$gscrot_common->get_gettext->get("URI\nExample: ftp://host:port/path") );

	$tooltips->set_tip( $ftp_remote_entry_dlg,
		$gscrot_common->get_gettext->get("URI\nExample: ftp://host:port/path") );

	$ftp_hbox1_dlg->pack_start( $ftp_remote_entry_dlg, TRUE, TRUE, 10 );

	#connection mode
	my $ftp_mode_label_dlg
		= Gtk2::Label->new( $gscrot_common->get_gettext->get("Connection mode") );
	$ftp_hbox2_dlg->pack_start( $ftp_mode_label_dlg, TRUE, TRUE, 10 );
	my $ftp_mode_combo_dlg = Gtk2::ComboBox->new_text;
	$ftp_mode_combo_dlg->insert_text( 0, $gscrot_common->get_gettext->get("Active mode") );
	$ftp_mode_combo_dlg->insert_text( 1, $gscrot_common->get_gettext->get("Passive mode") );
	$ftp_mode_combo_dlg->set_active( $ftp_mode_combo->get_active );

	$tooltips->set_tip( $ftp_mode_label_dlg, $gscrot_common->get_gettext->get("Connection mode") );

	$tooltips->set_tip( $ftp_mode_combo_dlg, $gscrot_common->get_gettext->get("Connection mode") );

	$ftp_hbox2_dlg->pack_start( $ftp_mode_combo_dlg, TRUE, TRUE, 10 );

	#username
	my $ftp_username_label_dlg = Gtk2::Label->new( $gscrot_common->get_gettext->get("Username") );
	$ftp_hbox3_dlg->pack_start( $ftp_username_label_dlg, TRUE, TRUE, 10 );
	my $ftp_username_entry_dlg = Gtk2::Entry->new;
	$ftp_username_entry_dlg->set_text( $ftp_username_entry->get_text );

	$tooltips->set_tip( $ftp_username_label_dlg, $gscrot_common->get_gettext->get("Username") );

	$tooltips->set_tip( $ftp_username_entry_dlg, $gscrot_common->get_gettext->get("Username") );

	$ftp_hbox3_dlg->pack_start( $ftp_username_entry_dlg, TRUE, TRUE, 10 );

	#password
	my $ftp_password_label_dlg = Gtk2::Label->new( $gscrot_common->get_gettext->get("Password") );
	$ftp_hbox4_dlg->pack_start( $ftp_password_label_dlg, TRUE, TRUE, 10 );
	my $ftp_password_entry_dlg = Gtk2::Entry->new;
	$ftp_password_entry_dlg->set_invisible_char("*");
	$ftp_password_entry_dlg->set_visibility(FALSE);
	$ftp_password_entry_dlg->set_text( $ftp_password_entry->get_text );

	$tooltips->set_tip( $ftp_password_label_dlg, $gscrot_common->get_gettext->get("Password") );

	$tooltips->set_tip( $ftp_password_entry_dlg, $gscrot_common->get_gettext->get("Password") );

	$ftp_hbox4_dlg->pack_start( $ftp_password_entry_dlg, TRUE, TRUE, 10 );

	my $ftp_vbox_dlg = Gtk2::VBox->new( TRUE, 0 );
	$ftp_vbox_dlg->pack_start( $ftp_hbox1_dlg, FALSE, TRUE, 1 );
	$ftp_vbox_dlg->pack_start( $ftp_hbox2_dlg, FALSE, TRUE, 1 );
	$ftp_vbox_dlg->pack_start( $ftp_hbox3_dlg, FALSE, TRUE, 1 );
	$ftp_vbox_dlg->pack_start( $ftp_hbox4_dlg, FALSE, TRUE, 1 );

	#default setting
	$hosting->set_sensitive(TRUE);
	$ftp_remote_entry_dlg->set_sensitive(FALSE);
	$ftp_mode_combo_dlg->set_sensitive(FALSE);
	$ftp_username_entry_dlg->set_sensitive(FALSE);
	$ftp_password_entry_dlg->set_sensitive(FALSE);

	#handle radiobuttons
	my $radio_imagehoster = Gtk2::RadioButton->new( undef,
		$gscrot_common->get_gettext->get("Upload file to hosting-site") );
	$radio_imagehoster->signal_connect(
		'clicked' => sub {
			$hosting->set_sensitive(TRUE);
			$ftp_remote_entry_dlg->set_sensitive(FALSE);
			$ftp_mode_combo_dlg->set_sensitive(FALSE);
			$ftp_username_entry_dlg->set_sensitive(FALSE);
			$ftp_password_entry_dlg->set_sensitive(FALSE);
		}
	);

	my $radio_ftp = Gtk2::RadioButton->new( $radio_imagehoster,
		$gscrot_common->get_gettext->get("Upload file via FTP") );
	$radio_ftp->signal_connect(
		'clicked' => sub {
			$hosting->set_sensitive(FALSE);
			$ftp_remote_entry_dlg->set_sensitive(TRUE);
			$ftp_mode_combo_dlg->set_sensitive(TRUE);
			$ftp_username_entry_dlg->set_sensitive(TRUE);
			$ftp_password_entry_dlg->set_sensitive(TRUE);
		}
	);

	#final packing
	$hosting_dialog->vbox->add($radio_imagehoster);
	$hosting_dialog->vbox->add($hosting_hbox1);
	$hosting_dialog->vbox->add($hosting_hbox2);

	$hosting_dialog->vbox->add($radio_ftp);
	$hosting_dialog->vbox->add($ftp_vbox_dlg);

	my $hosting_progress = Gtk2::ProgressBar->new;
	$hosting_progress->set_no_show_all(TRUE);
	$hosting_progress->set_ellipsize('middle');
	$hosting_progress->set_orientation('left-to-right');
	$hosting_dialog->vbox->add($hosting_progress);

	$hosting_dialog->show_all;
UPDIALOG: while ($hosting_dialog) {

		#initial state of dialog
		$upload_button->set_sensitive(TRUE);
		$cancel_button->set_sensitive(TRUE);
		$hosting_progress->hide;

		#DIALOG RUN
		my $hosting_response = $hosting_dialog->run;

		#running state of dialog
		$upload_button->set_sensitive(FALSE);
		$cancel_button->set_sensitive(FALSE);
		$hosting_progress->show;

		#start upload
		if ( $hosting_response eq "accept" ) {

			#imagehosting
			if ( $radio_imagehoster->get_active ) {
				my $model            = $hosting->get_model();
				my $hosting_iter     = $hosting->get_active_iter();
				my $hosting_host     = $model->get_value( $hosting_iter, 0 );
				my $hosting_username = $model->get_value( $hosting_iter, 1 );
				my $hosting_password = $model->get_value( $hosting_iter, 2 );
				if ( $hosting_host eq "ubuntu-pics.de" ) {
					my $uploader
						= GScrot::Upload::UbuntuPics->new( $hosting_host, $gscrot_common->get_debug,
						$gscrot_root, $gscrot_common->get_gettext, $window, GSCROT_VERSION );
					my $counter = 1;
					$hosting_progress->set_fraction(0);
					foreach my $file ( sort @files_to_upload ) {
						$hosting_progress->set_text($file);

						#update gui
						&fct_update_gui;
						my %upload_response
							= $uploader->upload( $gscrot_hfunct->switch_home_in_file($file),
							$hosting_username, $hosting_password );

						if ( is_success( $upload_response{'status'} ) ) {
							$uploader->show;
							&dlg_status_message( 1,
								$file . " " . $gscrot_common->get_gettext->get("uploaded") );
						} else {
							my $response = &dlg_upload_error_message( $upload_response{'status'},
								$upload_response{'max_filesize'} );

							#10 == skip all, 20 == skip, else == cancel
							last if $response == 10;
							next if $response == 20;
							redo if $response == 30;
							next UPDIALOG;
						}
						$hosting_progress->set_fraction( $counter / @files_to_upload );

						#update gui
						&fct_update_gui;
						$counter++;
					}
					$uploader->show_all;
				} elsif ( $hosting_host eq "imagebanana.com" ) {
					my $uploader
						= GScrot::Upload::ImageBanana->new( $hosting_host,
						$gscrot_common->get_debug, $gscrot_root, $gscrot_common->get_gettext,
						$window, GSCROT_VERSION );
					my $counter = 1;
					$hosting_progress->set_fraction(0);
					foreach my $file (@files_to_upload) {
						$hosting_progress->set_text($file);

						#update gui
						&fct_update_gui;
						my %upload_response
							= $uploader->upload( $gscrot_hfunct->switch_home_in_file($file),
							$hosting_username, $hosting_password );

						if ( is_success( $upload_response{'status'} ) ) {
							$uploader->show;
							&dlg_status_message( 1,
								$file . " " . $gscrot_common->get_gettext->get("uploaded") );
						} else {
							my $response = &dlg_upload_error_message( $upload_response{'status'},
								$upload_response{'max_filesize'} );

							#10 == skip all, 20 == skip, else == cancel
							last if $response == 10;
							next if $response == 20;
							redo if $response == 30;
							next UPDIALOG;
						}
						$hosting_progress->set_fraction( $counter / @files_to_upload );

						#update gui
						&fct_update_gui;
						$counter++;
					}
					$uploader->show_all;
				} elsif ( $hosting_host eq "imageshack.us" ) {
					my $ishack = GScrot::Upload::ImageShack->new();

					#upload
					my $counter = 1;
					$hosting_progress->set_fraction(0);
					foreach my $file (@files_to_upload) {

						#login
						eval { $ishack->login($hosting_username); };
						if ($@) {
							my $response = &dlg_error_message(
								$gscrot_common->get_gettext->get("Login failed!") . "\n"
									. $gscrot_common->get_gettext->get(
									"Please check your credentials and try again.")
							);

							next UPDIALOG;
						}

						$hosting_progress->set_text($file);

						#update gui
						&fct_update_gui;
						my $url = undef;
						eval { $url = $ishack->host( $file, undef ); };
						if ($@) {
							my $response = &dlg_error_message(
								$gscrot_common->get_gettext->get("Connection error!") . "\n"
									. $gscrot_common->get_gettext->get(
									"Please check your connectivity and try again."),
								$gscrot_common->get_gettext->get("Skip all"),
								$gscrot_common->get_gettext->get("Skip"),
								'gtk-redo'
							);

							#10 == skip all, 20 == skip, else == cancel
							last if $response == 10;
							next if $response == 20;
							redo if $response == 30;
							next UPDIALOG;
						}

						#get thumbnail url
						my $thumb_url = undef;
						eval { $thumb_url = $ishack->hosted_thumb; };

						if ($url) {
							$ishack->show( $hosting_host, $hosting_username, $file, $url,
								$thumb_url, RC_OK, $gscrot_common->get_gettext, $window,
								$gscrot_root );
							&dlg_status_message( 1,
								$file . " " . $gscrot_common->get_gettext->get("uploaded") );
						} else {
							my $response = &dlg_error_message(
								$gscrot_common->get_gettext->get("Connection error!") . "\n"
									. $gscrot_common->get_gettext->get(
									"Please check your connectivity and try again."),
								$gscrot_common->get_gettext->get("Skip all"),
								$gscrot_common->get_gettext->get("Skip"),
								'gtk-redo'
							);

							#10 == skip all, 20 == skip, else == cancel
							last if $response == 10;
							next if $response == 20;
							redo if $response == 30;
							next UPDIALOG;
						}
						$hosting_progress->set_fraction( $counter / @files_to_upload );

						#update gui
						&fct_update_gui;
						$counter++;
					}
					$ishack->show_all;
				}

				#ftp
			} elsif ( $radio_ftp->get_active ) {

				#create upload object
				my $uploader = GScrot::Upload::FTP->new(
					$gscrot_common->get_debug,   $gscrot_root,
					$gscrot_common->get_gettext, $window,
					$ftp_mode_combo_dlg->get_active
				);

				my $counter = 1;
				my $login   = FALSE;
				$hosting_progress->set_fraction(0);

				#start upload
				foreach my $file (@files_to_upload) {

					#need to login?
					my $upload_response;
					unless ($login) {

						eval { $uploader->quit; };

						$upload_response = $uploader->login(
							$ftp_remote_entry_dlg->get_text,
							$ftp_username_entry_dlg->get_text,
							$ftp_password_entry_dlg->get_text
						);

						if ($upload_response) {

							#we already get translated error messaged back
							my $response = &dlg_error_message($upload_response);
							next UPDIALOG;
						} else {
							$login = TRUE;
						}

						$hosting_progress->set_text($upload_response);

					}

					$hosting_progress->set_text($file);

					#update gui
					&fct_update_gui;
					$upload_response
						= $uploader->upload( $gscrot_hfunct->switch_home_in_file($file) );

					#upload returns FALSE if there is no error
					unless ($upload_response) {

						#everything is fine here
						&dlg_status_message( 1,
							$file . " " . $gscrot_common->get_gettext->get("uploaded") );
					} else {

						#we already get translated error messaged back
						my $response = &dlg_error_message(
							$upload_response,
							$gscrot_common->get_gettext->get("Skip all"),
							$gscrot_common->get_gettext->get("Skip"), 'gtk-redo'
						);

						#10 == skip all, 20 == skip, 30 == redo, else == cancel
						if ( $response == 10 ) {
							last;
						} elsif ( $response == 20 ) {
							$login = FALSE;
							next;
						} elsif ( $response == 30 ) {
							$login = FALSE;
							redo;
						} else {
							next UPDIALOG;
						}

					}
					$hosting_progress->set_fraction( $counter / @files_to_upload );

					#update gui
					&fct_update_gui;
					$counter++;
				}    #end foreach
				$uploader->quit;
			}

			$hosting_dialog->destroy();
			return TRUE;
		} else {
			$hosting_dialog->destroy();
			return FALSE;
		}    #if response == accept

	}    #dialog loop
}

sub dlg_upload_error_message {
	my ( $status, $max_filesize ) = @_;

	my $response;
	if ( $status == 999 ) {
		$response
			= &dlg_error_message( $gscrot_common->get_gettext->get("Login failed!") . "\n"
				. $gscrot_common->get_gettext->get("Please check your credentials and try again.")
			);
	} elsif ( $status == 998 ) {
		$response = &dlg_error_message(
			$gscrot_common->get_gettext->get("Maximum filesize reached!") . " ( $max_filesize )",
			$gscrot_common->get_gettext->get("Skip all"),
			$gscrot_common->get_gettext->get("Skip")
		);
	} else {
		$response = &dlg_error_message(
			$gscrot_common->get_gettext->get("Connection error!") . " (" 
				. $status . ")\n"
				. $gscrot_common->get_gettext->get("Please check your connectivity and try again."),
			$gscrot_common->get_gettext->get("Skip all"),
			$gscrot_common->get_gettext->get("Skip"),
			'gtk-redo'
		);
	}
	return $response;
}

sub dlg_website {
	my ( $folder, $filename_value, $filetype_value, $quality_value ) = @_;

	my $website_dialog = Gtk2::Dialog->new(
		$gscrot_common->get_gettext->get("Take a screenshot of a website"),
		$window,
		[qw/modal destroy-with-parent/],
		'gtk-cancel'  => 'reject',
		'gtk-execute' => 'accept'
	);
	$website_dialog->set_default_response('accept');
	my $website_hbox = Gtk2::HBox->new();
	my $website_label
		= Gtk2::Label->new( $gscrot_common->get_gettext->get("URL to capture") . ": " );
	my $website = Gtk2::Entry->new;
	$website->set_text("http://");
	$website->set_activates_default(TRUE);
	my $clipboard_string = $clipboard->wait_for_text;
	print "Content of clipboard is: $clipboard_string\n" if $gscrot_common->get_debug;

	if ( defined $clipboard_string ) {
		if (   $clipboard_string =~ /^http/
			|| $clipboard_string =~ /^file/
			|| $clipboard_string =~ /^www\./ )
		{
			$website->set_text($clipboard_string);
		}
	}
	$website_hbox->pack_start_defaults($website_label);
	$website_hbox->pack_start_defaults($website);
	$website_dialog->vbox->add($website_hbox);

	my $website_progress = Gtk2::ProgressBar->new;
	$website_progress->set_no_show_all(TRUE);
	$website_progress->set_ellipsize('middle');
	$website_progress->set_orientation('left-to-right');
	$website_progress->set_fraction(0);
	$website_dialog->vbox->add($website_progress);

	$website_dialog->show_all;
	my $website_response = $website_dialog->run;

	if ( $website_response eq "accept" ) {

		#imagemagick object
		my $screenshot;

		my $url      = $website->get_text;
		my $hostname = $url;
		$hostname =~ s/http:\/\///;

		if ( $hostname eq "" ) {
			&dlg_error_message( $gscrot_common->get_gettext->get("No valid url entered") );
			$website_dialog->destroy();
			return $screenshot;
		}

		#determining timeout
		my $web_menu = $button_web_menu->get_menu;
		my @timeouts = $web_menu->get_children;
		my $timeout  = undef;
		foreach (@timeouts) {
			if ( $_->get_active ) {
				$timeout = $_->get_children->get_text;
				$timeout =~ /([0-9]+)/;
				$timeout = $1;
				print $timeout. "\n" if $gscrot_common->get_debug;
			}
		}

		my $screenshooter
			= GScrot::Screenshot::Web->new( $timeout, $filetype_value, $quality_value, $url,
			"$folder/$filename_value.$filetype_value" );
		$screenshot = $screenshooter->web();

		$website_dialog->destroy();
		return $screenshot;
	} else {
		$website_dialog->destroy();
		return FALSE;
	}
}

sub dlg_profile_name {
	my ( $curr_profile_name, $combobox_settings_profiles ) = @_;
	my $dlg_header     = $gscrot_common->get_gettext->get("Save as profile");
	my $profile_dialog = Gtk2::Dialog->new(
		$dlg_header,
		$window, [qw/modal destroy-with-parent/],
		'gtk-cancel' => 'reject',
		'gtk-save'   => 'accept'
	);
	$profile_dialog->set_default_response('accept');

	my $new_profile_name_hbox = Gtk2::HBox->new();
	my $new_profile_name_label
		= Gtk2::Label->new( $gscrot_common->get_gettext->get("Profile") . ": " );
	my $new_profile_name = Gtk2::Entry->new();
	$new_profile_name->set_activates_default(TRUE);
	$new_profile_name->set_text($curr_profile_name)
		if defined $curr_profile_name;
	$new_profile_name_hbox->pack_start_defaults($new_profile_name_label);
	$new_profile_name_hbox->pack_start_defaults($new_profile_name);
	$profile_dialog->vbox->add($new_profile_name_hbox);
	$profile_dialog->show_all;
	my $profile_response = $profile_dialog->run;

	if ( $profile_response eq "accept" ) {
		my $entered_name = $new_profile_name->get_text;

		if ( $gscrot_hfunct->file_exists("$ENV{'HOME'}/.gscrot/profiles/$entered_name.xml") ) {

			if ($gscrot_dialog->dlg_question_message(
					$gscrot_common->get_gettext->get(
						"Profile already exists.\nDo you want to overwrite the existing profile?"
					)
				)
				)
			{
				$profile_dialog->destroy();
				return $new_profile_name->get_text;
			} else {
				$profile_dialog->destroy();
				return FALSE;
			}
		}

		$profile_dialog->destroy();
		return $new_profile_name->get_text;
	} else {
		$profile_dialog->destroy();
		return FALSE;
	}
}

#--------------------------------------
