Download lib/Shutter/Draw/DrawingTool.pm from abr00kx/shutter: direct link, hf CLI and curl.
- Browser
- Download file 225 kB
-
https://huggingface.co/abr00kx/shutter/resolve/main/lib/Shutter/Draw/DrawingTool.pm
- Command line
-
hf download hf://abr00kx/shutter/lib/Shutter/Draw/DrawingTool.pm
-
curl -L -o DrawingTool.pm https://huggingface.co/abr00kx/shutter/resolve/main/lib/Shutter/Draw/DrawingTool.pm
225 kB
###################################################
#
# Copyright (C) 2008-2013 Mario Kemper <mario.kemper@gmail.com>
#
# This file is part of Shutter.
#
# Shutter 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.
#
# Shutter 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 Shutter; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
#
###################################################
#perl -x -S perltidy -l=0 -b "%f"
# Native Gtk3::IconSize doesn't work for some reason
# FIXME This package should be cleaned up when fixing DrawingTool
package Gtk3::IconSize;
sub lookup {
my $self = shift;
my $size = shift;
Shutter::App::HelperFunctions->icon_size($size);
}
1;
package Shutter::Draw::DrawingTool;
#modules
#--------------------------------------
use utf8;
use strict;
use warnings;
use constant {
DEFAULT_FONT => "Sans Regular 16"
};
use Gtk3;
use Exporter;
use GooCanvas2;
use GooCanvas2::CairoTypes;
use File::Basename qw/ fileparse dirname basename /;
use File::Glob qw/ bsd_glob /;
use File::Temp qw/ tempfile tempdir /;
use Data::Dumper;
#Sort::Naturally - sort lexically, but sort numeral parts numerically
use Sort::Naturally;
#load and save settings
use XML::Simple;
#Glib
use Glib qw/TRUE FALSE/;
require Shutter::Draw::Utils;
require Shutter::App::Directories;
require Shutter::Draw::UIManager;
#--------------------------------------
sub new {
my $class = shift;
my $self = {_sc => shift};
$self->{_shf} = Shutter::App::HelperFunctions->new($self->{_sc});
#view, selector, dragger
$self->{_view} = Gtk3::ImageView->new;
$self->{_selector} = Gtk3::ImageView::Tool::Selector->new($self->{_view});
$self->{_dragger} = Gtk3::ImageView::Tool::Dragger->new($self->{_view});
$self->{_view}->set_tool($self->{_selector});
$self->{_view_css_provider_alpha} = Gtk3::CssProvider->new;
$self->{_view}->get_style_context->add_provider($self->{_view_css_provider_alpha}, 0);
$self->{_view}->set('zoom-step', 1.2);
#WORKAROUND
#upstream bug
#http://trac.bjourne.webfactional.com/ticket/21
#left => zoom in
#right => zoom out
$self->{_view}->signal_connect(
'scroll-event',
sub {
my ($view, $ev) = @_;
if ($ev->direction eq 'left') {
$ev->direction('up');
} elsif ($ev->direction eq 'right') {
$ev->direction('down');
}
return FALSE;
});
#handle zoom events
#ignore zoom values greater 10 (see: #654185)
$self->{_view}->signal_connect(
'zoom-changed' => sub {
my ($view, $zoom) = @_;
if ($zoom >= 1) {
$view->set_interpolation('nearest');
$view->set_zoom(10) if $zoom > 10;
} else {
$view->set_interpolation('bilinear');
}
});
#clipboard
$self->{_clipboard} = Gtk3::Clipboard::get($Gtk3::Gdk::SELECTION_CLIPBOARD);
#file
$self->{_filename} = undef;
$self->{_filetype} = undef;
$self->{_mimetype} = undef;
$self->{_import_hash} = undef;
#custom cursors
$self->{_cursors} = undef;
#ui
$self->{_uimanager} = undef;
$self->{_factory} = undef;
#canvas
$self->{_canvas} = undef;
#all items are stored here
$self->{_uid} = time;
$self->{_items} = undef;
$self->{_items_history} = undef;
#undo and redo stacks
$self->{_undo} = undef;
$self->{_redo} = undef;
#autoscroll option, disabled by default
$self->{_autoscroll} = FALSE;
#drawing colors and line width
#general - shown in the bottom hbox
$self->{_fill_color} = Gtk3::Gdk::RGBA::parse('#0000ff');
$self->{_fill_color}->alpha(0.25);
$self->{_stroke_color} = Gtk3::Gdk::RGBA::parse('#ff0000');
$self->{_stroke_color}->alpha(1);
$self->{_line_width} = 3;
$self->{_font} = DEFAULT_FONT;
#obtain current colors and font_desc from the main window
$self->{_style} = $self->{_sc}->get_mainwindow->get_style_context;
$self->{_style_bg} = $self->{_style}->get_background_color('selected');
$self->{_style_bg}->alpha(1);
#$self->{_style_tx} = $self->{_style}->text('selected');
#remember drawing colors, line width and font settings
#maybe we have to restore them
$self->{_last_fill_color} = Gtk3::Gdk::RGBA::parse('#0000ff');
$self->{_last_fill_color}->alpha(0.25);
$self->{_last_stroke_color} = Gtk3::Gdk::RGBA::parse('#ff0000');
$self->{_last_stroke_color}->alpha(1);
$self->{_last_line_width} = 3;
$self->{_last_font} = DEFAULT_FONT;
#some status variables
$self->{_busy} = undef;
$self->{_current_item} = undef;
$self->{_current_new_item} = undef;
$self->{_current_copy_item} = undef;
$self->{_last_mode} = 10;
$self->{_current_mode} = 10;
$self->{_current_mode_descr} = "select";
$self->{_current_pixbuf} = undef;
$self->{_current_pixbuf_filename} = undef;
$self->{_cut} = FALSE;
$self->{_start_time} = undef;
$self->{_stipple_pixbuf} = Gtk3::Gdk::Pixbuf->new_from_file($self->{_sc}->get_root . '/share/shutter/resources/gui/stipple.png');
bless $self, $class;
return $self;
}
#~ sub DESTROY {
#~ my $self = shift;
#~ print "$self dying at\n";
#~ }
# Workaround for broken xpm parsing in glycin:
# https://gitlab.gnome.org/GNOME/glycin/-/work_items/291
sub parse_xpm_hotspot {
my ($xpm_path) = @_;
my ($x_hot, $y_hot);
open my $fh, '<', $xpm_path or do {
print "ERROR: Cannot open $xpm_path: $!\n";
return (undef, undef);
};
while (my $line = <$fh>) {
chomp($line);
# Look for the XPM header line with format:
# "width height ncolors chars_per_pixel [x_hot y_hot]"
# Example: "32 32 3 1 4 4"
if ($line =~ /"(\d+)\s+(\d+)\s+(\d+)\s+(\d+)(?:\s+(\d+)\s+(\d+))?/) {
my ($width, $height, $ncolors, $cpp, $xh, $yh) = ($1, $2, $3, $4, $5, $6);
if (defined($xh) && defined($yh)) {
$x_hot = $xh;
$y_hot = $yh;
} else {
print "DEBUG: No hotspot in header in $xpm_path\n";
}
last; # Header is on the first data line
}
}
close $fh;
return ($x_hot, $y_hot);
}
sub show {
my $self = shift;
$self->{_filename} = shift;
$self->{_filetype} = shift;
$self->{_mimetype} = shift;
$self->{_name} = shift;
$self->{_is_unsaved} = shift;
$self->{_import_hash} = shift;
my $icon_theme = shift;
$self->{_cp_to_cb_on_save} = shift;
#gettext
$self->{_d} = $self->{_sc}->get_gettext;
#MAIN WINDOW
#-------------------------------------------------
$self->{_root} = Gtk3::Gdk::get_default_root_window();
($self->{_root}->{x}, $self->{_root}->{y}, $self->{_root}->{w}, $self->{_root}->{h}) = $self->{_root}->get_geometry;
($self->{_root}->{x}, $self->{_root}->{y}) = $self->{_root}->get_origin;
$self->{_drawing_window} = Gtk3::Window->new('toplevel');
if (defined $self->{_is_unsaved} && $self->{_is_unsaved}) {
$self->{_drawing_window}->set_title("*" . $self->{_name} . " - Shutter DrawingTool");
} else {
$self->{_drawing_window}->set_title($self->{_filename} . " - Shutter DrawingTool");
}
$self->{_drawing_window}->set_position('center');
$self->{_drawing_window}->set_modal(1);
$self->{_drawing_window}->signal_connect('delete_event', sub { return $self->quit(TRUE) });
#adjust toplevel window size
if ($self->{_root}->{w} > 640 && $self->{_root}->{h} > 480) {
$self->{_drawing_window}->set_default_size(640, 480);
} else {
$self->{_drawing_window}->set_default_size($self->{_root}->{w} - 100, $self->{_root}->{h} - 100);
}
#dialogs, thumbnail generator and pixbuf loader
$self->{_dialogs} = Shutter::App::SimpleDialogs->new($self->{_drawing_window});
$self->{_lp} = Shutter::Pixbuf::Load->new($self->{_sc}, $self->{_drawing_window});
$self->{_lp_ne} = Shutter::Pixbuf::Load->new($self->{_sc}, $self->{_drawing_window}, TRUE);
#define own icons
if ($icon_theme eq 'auto') {
# Heuristic to detect whether GTK theme is light or dark
my $context = $self->{_drawing_window}->get_style_context();
my $bg = $context->get_background_color('normal');
my $avg_color = ($bg->red + $bg->green + $bg->blue) / 3.0;
if ($avg_color > 0.5) {
$icon_theme = 'dark';
} else {
$icon_theme = 'light';
}
}
if ($icon_theme eq 'dark') {
$self->{_dicons} = $self->{_sc}->get_root . "/share/shutter/resources/icons/drawing_tool";
} else {
$self->{_dicons} = $self->{_sc}->get_root . "/share/shutter/resources/icons/drawing_tool_dark";
}
$self->{_icons} = $self->{_sc}->get_root . "/share/shutter/resources/icons";
#setup cursor-hash
#
#cursors borrowed from inkscape
#http://www.inkscape.org
my @cursors = bsd_glob($self->{_dicons} . "/cursor/*");
foreach my $cursor_path (@cursors) {
my ($cname, $folder, $type) = fileparse($cursor_path, qr/\.[^.]*/);
my $pixbuf = Gtk3::Gdk::Pixbuf->new_from_file($cursor_path);
if (!$pixbuf) {
print "ERROR: Failed to load pixbuf from $cursor_path\n";
next;
}
my $width = $pixbuf->get_width();
my $height = $pixbuf->get_height();
# Parse hotspot from file
my ($x_hot, $y_hot) = parse_xpm_hotspot($cursor_path);
# Fallback to center if not found
$x_hot //= $width / 2;
$y_hot //= $height / 2;
# Store as a hash with pixbuf and hotspot data
$self->{_cursors}{$cname} = {
'pixbuf' => $pixbuf,
'x_hot' => $x_hot,
'y_hot' => $y_hot,
};
}
#setu ui
$self->{_uimanager} = $self->setup_uimanager();
#load settings
$self->load_settings;
#load file
$self->{_drawing_pixbuf} = $self->{_lp}->load($self->{_filename}, undef, undef, undef, TRUE);
unless ($self->{_drawing_pixbuf}) {
$self->{_drawing_window}->destroy if $self->{_drawing_window};
return FALSE;
}
#CANVAS
#-------------------------------------------------
$self->{_canvas} = GooCanvas2::Canvas->new();
#enable dnd for it
$self->{_canvas}->drag_dest_set('all', [Gtk3::TargetEntry->new('text/uri-list', [], 0)], 'copy');
$self->{_canvas}->signal_connect(drag_data_received => sub { $self->import_from_dnd(@_) });
$self->{_canvas}->signal_connect(drag_motion => sub {
my ($view, $ctx, $x, $y, $time) = @_;
for my $target (@{$ctx->list_targets}) {
if ($target->name eq 'text/uri-list') {
Gtk3::Gdk::drag_status($ctx, 'copy', $time);
return TRUE;
}
}
return FALSE;
});
#'redraw-when-scrolled' to reduce the flicker of static items
#
#this property is not available in older versions
#it was added to goocanvas on Mon Nov 17 10:28:07 2008 UTC
#http://svn.gnome.org/viewvc/goocanvas?view=revision&revision=28
if ($self->{_canvas}->find_property('redraw-when-scrolled')) {
$self->{_canvas}->set('redraw-when-scrolled' => TRUE);
}
#~ my $bg = Gtk3::Gdk::RGBA::parse('gray');
$self->{_canvas}->set(
'automatic-bounds' => FALSE,
'bounds-from-origin' => FALSE,
#~ 'background-color' => sprintf( "#%04x%04x%04x", $bg->red, $bg->green, $bg->blue ),
);
#and attach scroll event
#to imitate scroll behavior of
#Gtk3::ImageView widget Ctrl+Mouse Wheel
$self->{_canvas}->signal_connect(
'scroll-event' => sub {
my ($canvas, $ev) = @_;
my $alloc = $self->{_canvas}->get_allocation;
my $scale = $canvas->get_scale;
if ($ev->state >= 'control-mask' && ($ev->direction eq 'up' || $ev->direction eq 'left')) {
$self->zoom_in_cb;
$canvas->scroll_to(int($ev->x - $alloc->{width} / 2) / $scale, int($ev->y - $alloc->{height} / 2) / $scale);
return TRUE;
} elsif ($ev->state >= 'control-mask' && ($ev->direction eq 'down' || $ev->direction eq 'right')) {
$self->zoom_out_cb;
return TRUE;
}
return FALSE;
});
#create rectangle to resize the background
$self->{_canvas_bg_rect} = GooCanvas2::CanvasRect->new(
parent=>$self->{_canvas}->get_root_item, x=>0, y=>0, width=>$self->{_drawing_pixbuf}->get_width, height=>$self->{_drawing_pixbuf}->get_height,
'fill-color-gdk-rgba' => Gtk3::Gdk::RGBA::parse('gray'),
'line-dash' => GooCanvas2::CanvasLineDash->newv([5, 5]),
'line-width' => 1,
'stroke-color' => 'black',
);
#save color
$self->{_canvas_bg_rect}{fill_color} = Gtk3::Gdk::RGBA::parse('gray');
$self->setup_item_signals($self->{_canvas_bg_rect});
$self->handle_bg_rects('create');
$self->handle_bg_rects('update');
#~ #create canvas background (:= screenshot)
#~ $self->{_canvas_bg} = Goo::Canvas::Image->new(
#~ $self->{_canvas}->get_root_item,
#~ $self->{_drawing_pixbuf},
#~ 0, 0,
#~ );
#~ $self->setup_item_signals( $self->{_canvas_bg} );
#set variables
$self->{_current_pixbuf_filename} = $self->{_filename};
$self->{_current_pixbuf} = $self->{_drawing_pixbuf};
#construct an event and create a new image object
my $initevent = Gtk3::Gdk::Event->new('motion-notify');
$initevent->time(Gtk3::get_current_event_time());
$initevent->window($self->{_drawing_window}->get_window);
$initevent->x(int($self->{_canvas_bg_rect}->get('width') / 2));
$initevent->y(int($self->{_canvas_bg_rect}->get('height') / 2));
#new item
my $nitem = $self->create_image($initevent, undef, TRUE);
$self->{_canvas_bg} = $self->{_items}{$nitem}{image};
#this item is locked at first
$self->{_items}{$nitem}{locked} = FALSE;
$self->handle_bg_rects('raise');
#PACKING
#-------------------------------------------------
$self->{_drawing_vbox} = Gtk3::VBox->new(FALSE, 0);
$self->{_drawing_inner_vbox} = Gtk3::VBox->new(FALSE, 0);
$self->{_drawing_inner_vbox_c} = Gtk3::VBox->new(FALSE, 0);
$self->{_drawing_hbox} = Gtk3::HBox->new(FALSE, 0);
$self->{_drawing_hbox_c} = Gtk3::HBox->new(FALSE, 0);
#mark some actions as important
$self->{_uimanager}->get_widget("/ToolBar/Close")->set_is_important(TRUE);
$self->{_uimanager}->get_widget("/ToolBar/Save")->set_is_important(TRUE);
$self->{_uimanager}->get_widget("/ToolBar/Undo")->set_is_important(TRUE);
#disable undo/redo actions at startup
$self->{_uimanager}->get_widget("/MenuBar/Edit/Undo")->set_sensitive(FALSE);
$self->{_uimanager}->get_widget("/MenuBar/Edit/Redo")->set_sensitive(FALSE);
$self->{_uimanager}->get_widget("/ToolBar/Undo")->set_sensitive(FALSE);
$self->{_uimanager}->get_widget("/ToolBar/Redo")->set_sensitive(FALSE);
$self->{_drawing_window}->add($self->{_drawing_vbox});
my $menubar = $self->{_uimanager}->get_widget("/MenuBar");
$self->{_drawing_vbox}->pack_start($menubar, FALSE, FALSE, 0);
my $toolbar_drawing = $self->{_uimanager}->get_widget("/ToolBarDrawing");
$toolbar_drawing->set_orientation('vertical');
$toolbar_drawing->set_style('icons');
$toolbar_drawing->set_icon_size('menu');
$toolbar_drawing->set_show_arrow(FALSE);
$self->{_drawing_hbox}->pack_start($toolbar_drawing, FALSE, FALSE, 0);
#DRAWING TOOL CONTAINER
#-------------------------------------------------
#scrolled window for the canvas
$self->{_scrolled_window} = Gtk3::ScrolledWindow->new;
$self->{_scrolled_window}->set_policy('automatic', 'automatic');
$self->{_scrolled_window}->add($self->{_canvas});
$self->{_hscroll_hid} = $self->{_scrolled_window}->get_hscrollbar->signal_connect('value-changed' => sub { $self->adjust_rulers });
$self->{_vscroll_hid} = $self->{_scrolled_window}->get_vscrollbar->signal_connect('value-changed' => sub { $self->adjust_rulers });
#vruler
#$self->{_vruler} = Gtk3::VRuler->new;
#$self->{_vruler}->set_metric('pixels');
#$self->{_vruler}->set_range(0, $self->{_drawing_pixbuf}->get_height, 0, $self->{_drawing_pixbuf}->get_height);
#hruler
#$self->{_hruler} = Gtk3::HRuler->new;
#$self->{_hruler}->set_metric('pixels');
#$self->{_hruler}->set_range(0, $self->{_drawing_pixbuf}->get_width, 0, $self->{_drawing_pixbuf}->get_width);
#create a table for placing the ruler and scrolle window
$self->{_table} = Gtk3::Table->new(3, 2, FALSE);
#attach scrolled window and rulers to the table
$self->{_table}->attach($self->{_scrolled_window}, 1, 2, 1, 2, ['expand', 'fill'], ['expand', 'fill'], 0, 0);
#$self->{_table}->attach($self->{_hruler}, 1, 2, 0, 1, ['expand', 'shrink', 'fill'], [], 0, 0);
#$self->{_table}->attach($self->{_vruler}, 0, 1, 1, 2, [], ['fill', 'expand', 'shrink'], 0, 0);
$self->{_bhbox} = $self->setup_bottom_hbox;
$self->{_drawing_inner_vbox}->pack_start($self->{_table}, TRUE, TRUE, 0);
$self->{_drawing_inner_vbox}->pack_start($self->{_bhbox}, FALSE, TRUE, 0);
#CROPPING TOOL CONTAINER
#-------------------------------------------------
#scrolled window for the cropping tool
#$self->{_scrolled_window_c} = Gtk3::ImageView::ScrollWin->new($self->{_view});
$self->{_scrolled_window_c} = Gtk3::ScrolledWindow->new;
$self->{_scrolled_window_c}->add_with_viewport($self->{_view});
($self->{_rframe_c}, $self->{_btn_ok_c}) = $self->setup_right_vbox_c;
$self->{_drawing_hbox_c}->pack_start($self->{_scrolled_window_c}, TRUE, TRUE, 0);
$self->{_drawing_hbox_c}->pack_start($self->{_rframe_c}, FALSE, FALSE, 3);
$self->{_drawing_inner_vbox_c}->pack_start($self->{_drawing_hbox_c}, TRUE, TRUE, 0);
#MAIN CONTAINER
#-------------------------------------------------
#pack both containers to the main hbox
$self->{_drawing_hbox}->pack_start($self->{_drawing_inner_vbox}, TRUE, TRUE, 0);
$self->{_drawing_hbox}->pack_start($self->{_drawing_inner_vbox_c}, TRUE, TRUE, 0);
$self->{_drawing_vbox}->pack_start($self->{_uimanager}->get_widget("/ToolBar"), FALSE, FALSE, 0);
$self->{_drawing_vbox}->pack_start($self->{_drawing_hbox}, TRUE, TRUE, 0);
#statusbar
$self->{_drawing_statusbar} = Gtk3::Statusbar->new;
$self->{_drawing_statusbar_image} = Gtk3::Image->new;
$self->{_drawing_statusbar}->pack_start($self->{_drawing_statusbar_image}, FALSE, FALSE, 3);
$self->{_drawing_statusbar}->reorder_child($self->{_drawing_statusbar_image}, 0);
$self->{_drawing_vbox}->pack_start($self->{_drawing_statusbar}, FALSE, FALSE, 6);
$self->{_drawing_window}->show_all();
#STARTUP PROCEDURE
#-------------------------------------------------
$self->{_drawing_window}->get_window->focus(Gtk3::get_current_event_time());
$self->adjust_rulers;
#save start time to show in close dialog
$self->{_start_time} = time;
#remember drawing colors, line width and font settings
#maybe we have to restore them
$self->{_last_fill_color} = $self->{_fill_color_w}->get_rgba;
$self->{_last_stroke_color} = $self->{_stroke_color_w}->get_rgba;
$self->{_last_line_width} = $self->{_line_spin_w}->get_value;
$self->{_last_font} = $self->{_font_btn_w}->get_font_name;
#init last mode
$self->{_last_mode} = 0;
#init current tool
$self->set_drawing_action(int($self->{_current_mode} / 10));
#do show these actions because the user would be confused
#to see multiple shortcuts to handle zooming
#controlequal is used for english keyboard layouts for example
$self->{_uimanager}->get_action("/MenuBar/View/ControlEqual")->set_visible(FALSE);
$self->{_uimanager}->get_action("/MenuBar/View/ControlKpAdd")->set_visible(FALSE);
$self->{_uimanager}->get_action("/MenuBar/View/ControlKpSub")->set_visible(FALSE);
#start with everything deactivated
$self->deactivate_all;
Gtk3->main;
return TRUE;
}
sub setup_bottom_hbox {
my $self = shift;
my $drawing_bottom_hbox = Gtk3::HBox->new(FALSE, 5);
#fill color
my $fill_color_label = Gtk3::Label->new($self->{_d}->get("Fill color") . ":");
$self->{_fill_color_w} = Gtk3::ColorButton->new();
$self->{_fill_color_w}->set_rgba($self->{_fill_color});
$self->{_fill_color_w}->set_use_alpha(TRUE);
$self->{_fill_color_w}->set_title($self->{_d}->get("Choose fill color"));
$fill_color_label->set_tooltip_text($self->{_d}->get("Adjust fill color and opacity"));
$self->{_fill_color_w}->set_tooltip_text($self->{_d}->get("Adjust fill color and opacity"));
$drawing_bottom_hbox->pack_start($fill_color_label, FALSE, FALSE, 5);
$drawing_bottom_hbox->pack_start($self->{_fill_color_w}, FALSE, FALSE, 5);
#stroke color
my $stroke_color_label = Gtk3::Label->new($self->{_d}->get("Stroke color") . ":");
$self->{_stroke_color_w} = Gtk3::ColorButton->new();
$self->{_stroke_color_w}->set_rgba($self->{_stroke_color});
$self->{_stroke_color_w}->set_use_alpha(TRUE);
$self->{_stroke_color_w}->set_title($self->{_d}->get("Choose stroke color"));
$stroke_color_label->set_tooltip_text($self->{_d}->get("Adjust stroke color and opacity"));
$self->{_stroke_color_w}->set_tooltip_text($self->{_d}->get("Adjust stroke color and opacity"));
$drawing_bottom_hbox->pack_start($stroke_color_label, FALSE, FALSE, 5);
$drawing_bottom_hbox->pack_start($self->{_stroke_color_w}, FALSE, FALSE, 5);
#line_width
my $linew_label = Gtk3::Label->new($self->{_d}->get("Line width") . ":");
$self->{_line_spin_w} = Gtk3::SpinButton->new_with_range(0.5, 300, 0.1);
$self->{_line_spin_w}->set_value($self->{_line_width});
$linew_label->set_tooltip_text($self->{_d}->get("Adjust line width"));
$self->{_line_spin_w}->set_tooltip_text($self->{_d}->get("Adjust line width"));
$drawing_bottom_hbox->pack_start($linew_label, FALSE, FALSE, 5);
$drawing_bottom_hbox->pack_start($self->{_line_spin_w}, FALSE, FALSE, 5);
#font button
my $font_label = Gtk3::Label->new($self->{_d}->get("Font") . ":");
$self->{_font_btn_w} = Gtk3::FontButton->new();
$self->{_font_btn_w}->set_font_name($self->{_font});
$font_label->set_tooltip_text($self->{_d}->get("Select font family and size"));
$self->{_font_btn_w}->set_tooltip_text($self->{_d}->get("Select font family and size"));
$drawing_bottom_hbox->pack_start($font_label, FALSE, FALSE, 5);
$drawing_bottom_hbox->pack_start($self->{_font_btn_w}, FALSE, FALSE, 5);
#image button
my $image_label = Gtk3::Label->new($self->{_d}->get("Insert image") . ":");
my $image_btn = Gtk3::MenuToolButton->new(undef, undef);
Glib::Idle->add(
sub {
$image_btn->set_menu($self->import_from_filesystem($image_btn));
return FALSE;
});
#handle property changes
#changes are applied directly to the current item
$self->{_line_spin_wh} = $self->{_line_spin_w}->signal_connect(
'value-changed' => sub {
$self->{_line_width} = $self->{_line_spin_w}->get_value;
if ($self->{_current_item}) {
#apply all changes directly
my $item = $self->{_current_item};
if (my $child = $self->get_child_item($item)) {
$item = $child;
}
my $parent = $self->get_parent_item($item);
#determine key for item hash
my $key = $self->get_item_key($item, $parent);
$self->apply_properties($item, $parent, $key, $self->{_fill_color_w}, $self->{_stroke_color_w}, $self->{_line_spin_w}, $self->{_stroke_color_w}, $self->{_font_btn_w});
}
});
$self->{_stroke_color_wh} = $self->{_stroke_color_w}->signal_connect(
'color-set' => sub {
$self->{_stroke_color} = $self->{_stroke_color_w}->get_rgba;
if ($self->{_current_item}) {
#apply all changes directly
my $item = $self->{_current_item};
if (my $child = $self->get_child_item($item)) {
$item = $child;
}
my $parent = $self->get_parent_item($item);
#determine key for item hash
my $key = $self->get_item_key($item, $parent);
$self->apply_properties($item, $parent, $key, $self->{_fill_color_w}, $self->{_stroke_color_w}, $self->{_line_spin_w}, $self->{_stroke_color_w}, $self->{_font_btn_w});
}
});
$self->{_fill_color_wh} = $self->{_fill_color_w}->signal_connect(
'color-set' => sub {
$self->{_fill_color} = $self->{_fill_color_w}->get_rgba;
if ($self->{_current_item}) {
#apply all changes directly
my $item = $self->{_current_item};
if (my $child = $self->get_child_item($item)) {
$item = $child;
}
my $parent = $self->get_parent_item($item);
#determine key for item hash
my $key = $self->get_item_key($item, $parent);
$self->apply_properties($item, $parent, $key, $self->{_fill_color_w}, $self->{_stroke_color_w}, $self->{_line_spin_w}, $self->{_stroke_color_w}, $self->{_font_btn_w});
}
});
$self->{_font_btn_wh} = $self->{_font_btn_w}->signal_connect(
'font-set' => sub {
my $font_descr = Pango::FontDescription::from_string($self->{_font_btn_w}->get_font_name);
$self->{_font} = $self->{_font_btn_w}->get_font_name;
if ($self->{_current_item}) {
#apply all changes directly
my $item = $self->{_current_item};
if (my $child = $self->get_child_item($item)) {
$item = $child;
}
my $parent = $self->get_parent_item($item);
#determine key for item hash
my $key = $self->get_item_key($item, $parent);
$self->apply_properties($item, $parent, $key, $self->{_fill_color_w}, $self->{_stroke_color_w}, $self->{_line_spin_w}, $self->{_stroke_color_w}, $self->{_font_btn_w});
}
});
$image_btn->signal_connect(
'clicked' => sub {
$self->{_canvas}->get_window->set_cursor($self->change_cursor_to_current_pixbuf);
});
$image_label->set_tooltip_text($self->{_d}->get("Insert an arbitrary object or file"));
$image_btn->set_tooltip_text($self->{_d}->get("Insert an arbitrary object or file"));
$drawing_bottom_hbox->pack_start($image_label, FALSE, FALSE, 5);
$drawing_bottom_hbox->pack_start($image_btn, FALSE, FALSE, 5);
return $drawing_bottom_hbox;
}
sub setup_right_vbox_c {
my $self = shift;
my $cropping_bottom_vbox = Gtk3::VBox->new(FALSE, 5);
#get current pixbuf
my $pixbuf = $self->{_view}->get_pixbuf || $self->{_drawing_pixbuf};
my $value_callback = sub {
$self->{_selector}->set_selection({x=>$self->{_x_spin_w}->get_value, y=>$self->{_y_spin_w}->get_value, width=>$self->{_width_spin_w}->get_value, height=>$self->{_height_spin_w}->get_value});
};
#X
my $xw_label = Gtk3::Label->new($self->{_d}->get("X") . ":");
$self->{_x_spin_w} = Gtk3::SpinButton->new_with_range(0, $pixbuf->get_width, 1);
$self->{_x_spin_w}->set_value(0);
$self->{_x_spin_w_handler} = $self->{_x_spin_w}->signal_connect(
'value-changed' => $value_callback);
my $xw_hbox = Gtk3::HBox->new(FALSE, 5);
$xw_hbox->pack_start($xw_label, FALSE, FALSE, 5);
$xw_hbox->pack_start($self->{_x_spin_w}, FALSE, FALSE, 5);
#y
my $yw_label = Gtk3::Label->new($self->{_d}->get("Y") . ":");
$self->{_y_spin_w} = Gtk3::SpinButton->new_with_range(0, $pixbuf->get_height, 1);
$self->{_y_spin_w}->set_value(0);
$self->{_y_spin_w_handler} = $self->{_y_spin_w}->signal_connect(
'value-changed' => $value_callback);
my $yw_hbox = Gtk3::HBox->new(FALSE, 5);
$yw_hbox->pack_start($yw_label, FALSE, FALSE, 5);
$yw_hbox->pack_start($self->{_y_spin_w}, FALSE, FALSE, 5);
#width
my $widthw_label = Gtk3::Label->new($self->{_d}->get("Width") . ":");
$self->{_width_spin_w} = Gtk3::SpinButton->new_with_range(0, $pixbuf->get_width, 1);
$self->{_width_spin_w}->set_value(0);
$self->{_width_spin_w_handler} = $self->{_width_spin_w}->signal_connect(
'value-changed' => $value_callback);
my $ww_hbox = Gtk3::HBox->new(FALSE, 5);
$ww_hbox->pack_start($widthw_label, FALSE, FALSE, 5);
$ww_hbox->pack_start($self->{_width_spin_w}, FALSE, FALSE, 5);
#height
my $heightw_label = Gtk3::Label->new($self->{_d}->get("Height") . ":");
$self->{_height_spin_w} = Gtk3::SpinButton->new_with_range(0, $pixbuf->get_height, 1);
$self->{_height_spin_w}->set_value(0);
$self->{_height_spin_w_handler} = $self->{_height_spin_w}->signal_connect(
'value-changed' => $value_callback);
my $hw_hbox = Gtk3::HBox->new(FALSE, 5);
$hw_hbox->pack_start($heightw_label, FALSE, FALSE, 5);
$hw_hbox->pack_start($self->{_height_spin_w}, FALSE, FALSE, 5);
#the above values are changed when the selection is changed
$self->{_selector_handler} = $self->{_selector}->signal_connect(
'selection-changed' => sub {
$self->adjust_crop_values($pixbuf);
});
#cancel button
my $crop_c = Gtk3::Button->new_from_stock('gtk-cancel');
$crop_c->signal_connect('clicked' => sub { $self->abort_current_mode });
#crop button
my $crop_ok = Gtk3::Button->new_with_mnemonic($self->{_d}->get("_Crop"));
$crop_ok->set_image(Gtk3::Image->new_from_file($self->{_dicons} . '/transform-crop.png'));
$crop_ok->signal_connect(
'clicked' => sub {
my $s = $self->{_selector}->get_selection;
my $p = $self->{_view}->get_pixbuf;
if ($s && $p) {
#add to undo stack
$self->store_to_xdo_stack($self->{_canvas_bg}, 'modify', 'undo', $s);
#create new pixbuf
#create temp pixbuf because selected area might be bigger than
#source pixbuf (screenshot) => canvas area is resizeable
my $temp = Gtk3::Gdk::Pixbuf->new($self->{_drawing_pixbuf}->get_colorspace, TRUE, 8, $p->get_width, $p->get_height);
#whole pixbuf is transparent
$temp->fill(0x00000000);
#copy source image to temp pixbuf (temp pixbuf's size == $self->{_view}->get_pixbuf)
$self->{_drawing_pixbuf}->copy_area(0, 0, $self->{_drawing_pixbuf}->get_width, $self->{_drawing_pixbuf}->get_height, $temp, 0, 0);
#and create a new subpixbuf from the temp pixbuf
my $new_p = $temp->new_subpixbuf($s->{x}, $s->{y}, $s->{width}, $s->{height});
$self->{_drawing_pixbuf} = $new_p->copy;
#update bounds and bg_rects
$self->{_canvas_bg_rect}->set('width' => $s->{width}, 'height' => $s->{height});
$self->handle_bg_rects('update');
#update canvas and show the new pixbuf
$self->{_canvas_bg}->set('pixbuf' => $new_p);
#now move all items,
#so they are in the right position
#~ print $s->x ." - ".$s->y."\n";
$self->move_all($s->{x}, $s->{y});
#adjust stack order
$self->{_canvas_bg}->lower;
$self->{_canvas_bg_rect}->lower;
$self->handle_bg_rects('raise');
} else {
#nothing here right now
}
#finally reset mode to select tool
$self->abort_current_mode;
});
#put buttons in a separated box
#all buttons = one size
my $sg_butt = Gtk3::SizeGroup->new('vertical');
$sg_butt->add_widget($crop_c);
$sg_butt->add_widget($crop_ok);
my $cropping_bottom_vbox_b = Gtk3::VBox->new(FALSE, 5);
$cropping_bottom_vbox_b->pack_start($crop_c, FALSE, FALSE, 0);
$cropping_bottom_vbox_b->pack_start($crop_ok, FALSE, FALSE, 0);
#final_packing
#all labels = one size
$xw_label->set_alignment(0, 0.5);
$yw_label->set_alignment(0, 0.5);
$widthw_label->set_alignment(0, 0.5);
$heightw_label->set_alignment(0, 0.5);
my $sg_main = Gtk3::SizeGroup->new('horizontal');
$sg_main->add_widget($xw_label);
$sg_main->add_widget($yw_label);
$sg_main->add_widget($widthw_label);
$sg_main->add_widget($heightw_label);
$cropping_bottom_vbox->pack_start($xw_hbox, FALSE, FALSE, 3);
$cropping_bottom_vbox->pack_start($yw_hbox, FALSE, FALSE, 3);
$cropping_bottom_vbox->pack_start($ww_hbox, FALSE, FALSE, 3);
$cropping_bottom_vbox->pack_start($hw_hbox, FALSE, FALSE, 3);
$cropping_bottom_vbox->pack_start($cropping_bottom_vbox_b, TRUE, TRUE, 3);
#nice frame as well
my $crop_frame_label = Gtk3::Label->new;
$crop_frame_label->set_markup("<b>" . $self->{_d}->get("Selection") . "</b>");
my $crop_frame = Gtk3::Frame->new();
$crop_frame->set_border_width(5);
$crop_frame->set_label_widget($crop_frame_label);
$crop_frame->set_shadow_type('none');
$crop_frame->add($cropping_bottom_vbox);
return ($crop_frame, $crop_ok);
}
sub adjust_crop_values {
my $self = shift;
my $pixbuf = shift;
#block 'value-change' handlers for widgets
#so we do not apply the changes twice
$self->{_x_spin_w}->signal_handler_block($self->{_x_spin_w_handler});
$self->{_y_spin_w}->signal_handler_block($self->{_y_spin_w_handler});
$self->{_width_spin_w}->signal_handler_block($self->{_width_spin_w_handler});
$self->{_height_spin_w}->signal_handler_block($self->{_height_spin_w_handler});
my $s = $self->{_selector}->get_selection;
if ($s) {
$self->{_x_spin_w}->set_value($s->{x});
$self->{_x_spin_w}->set_range(0, $pixbuf->get_width - $s->{width});
$self->{_y_spin_w}->set_value($s->{y});
$self->{_y_spin_w}->set_range(0, $pixbuf->get_height - $s->{height});
$self->{_width_spin_w}->set_value($s->{width});
$self->{_width_spin_w}->set_range(0, $pixbuf->get_width - $s->{x});
$self->{_height_spin_w}->set_value($s->{height});
$self->{_height_spin_w}->set_range(0, $pixbuf->get_height - $s->{y});
}
#unblock 'value-change' handlers for widgets
$self->{_x_spin_w}->signal_handler_unblock($self->{_x_spin_w_handler});
$self->{_y_spin_w}->signal_handler_unblock($self->{_y_spin_w_handler});
$self->{_width_spin_w}->signal_handler_unblock($self->{_width_spin_w_handler});
$self->{_height_spin_w}->signal_handler_unblock($self->{_height_spin_w_handler});
return TRUE;
}
sub push_tool_help_to_statusbar {
my ($self, $x, $y, $action) = @_;
#init $action if not defined
$action = 'none' unless defined $action;
#current event coordinates
my $status_text = int($x) . " x " . int($y);
if ($self->{_current_mode} == 10) {
if ($action eq 'resize') {
$status_text .= " " . $self->{_d}->get("Click-Drag to scale (try Control to scale uniformly)");
} elsif ($action eq 'canvas_resize') {
$status_text .= " " . $self->{_d}->get("Click-Drag to resize the canvas");
}
} elsif ($self->{_current_mode} == 20 || $self->{_current_mode} == 30) {
$status_text .= " " . $self->{_d}->get("Click to paint (try Control or Shift for a straight line)");
} elsif ($self->{_current_mode} == 40) {
$status_text .= " " . $self->{_d}->get("Click-Drag to create a new straight line");
} elsif ($self->{_current_mode} == 50) {
$status_text .= " " . $self->{_d}->get("Click-Drag to create a new arrow");
} elsif ($self->{_current_mode} == 60) {
$status_text .= " " . $self->{_d}->get("Click-Drag to create a new rectangle");
} elsif ($self->{_current_mode} == 70) {
$status_text .= " " . $self->{_d}->get("Click-Drag to create a new ellipse");
} elsif ($self->{_current_mode} == 80) {
$status_text .= " " . $self->{_d}->get("Click-Drag to add a new text area");
} elsif ($self->{_current_mode} == 90) {
$status_text .= " " . $self->{_d}->get("Click to censor (try Control or Shift for a straight line)");
} elsif ($self->{_current_mode} == 100) {
$status_text .= " " . $self->{_d}->get("Click-Drag to create a pixelized region");
} elsif ($self->{_current_mode} == 110) {
$status_text .= " " . $self->{_d}->get("Click to add an auto-increment shape");
} elsif ($self->{_current_mode} == 120) {
#nothing to do here....
}
#update statusbar
$self->show_status_message(1, $status_text);
return TRUE;
}
sub show_status_message {
my $self = shift;
my $index = shift;
my $status_text = shift;
my $status_image = shift; #this is a stock-id
#~ #remove old message and timer
#~ $self->{_drawing_statusbar}->pop($index);
#~ Glib::Source->remove ($self->{_drawing_statusbar}->{statusbar_timer}) if defined $self->{_drawing_statusbar}->{statusbar_timer};
#new message and image
if (defined $status_image) {
$self->{_drawing_statusbar_image}->set_from_stock($status_image, 'menu');
} else {
$self->{_drawing_statusbar_image}->clear;
}
$self->{_drawing_statusbar}->push($index, $status_text);
#~ #...and remove it
#~ $self->{_drawing_statusbar}->{statusbar_timer} = Glib::Timeout->add(
#~ 3000,
#~ sub {
#~ $self->{_drawing_statusbar}->pop($index) if defined $self->{_drawing_statusbar};
#~ return FALSE;
#~ }
#~ );
return TRUE;
}
sub change_drawing_tool_cb {
my $self = shift;
my $action = shift;
#~ print "change_drawing_tool_cb\n";
eval { $self->{_current_mode} = $action->get_current_value; };
if ($@) {
$self->{_current_mode} = $action;
}
my $cursor = Gtk3::Gdk::Cursor->new('left-ptr');
#tool is switched from "highlighter" OR censor to something else (excluding select tool)
if ( $self->{_current_mode} != $self->{_last_mode}
&& $self->{_current_mode} != 10
&& $self->{_current_mode} != 30
&& $self->{_current_mode} != 90
&& $self->{_current_mode} != 100
&& $self->{_current_mode} != 120)
{
$self->restore_drawing_properties;
}
#show drawing tool widgets
if ($self->{_current_mode} != 120) {
#show drawing tool widgets
$self->{_table}->show_all;
$self->{_bhbox}->show_all;
$self->{_drawing_inner_vbox}->show_all;
#hide cropping tool
$self->{_drawing_inner_vbox_c}->hide;
}
#enable controls again
$self->{_fill_color_w}->set_sensitive(TRUE);
$self->{_stroke_color_w}->set_sensitive(TRUE);
$self->{_line_spin_w}->set_sensitive(TRUE);
$self->{_font_btn_w}->set_sensitive(TRUE);
if ($self->{_current_mode} == 10) {
$self->{_current_mode_descr} = "select";
} elsif ($self->{_current_mode} == 20) {
$self->{_current_mode_descr} = "freehand";
#disable controls, because they are not useful
$self->{_fill_color_w}->set_sensitive(FALSE);
$self->{_font_btn_w}->set_sensitive(FALSE);
} elsif ($self->{_current_mode} == 30) {
$self->{_current_mode_descr} = "highlighter";
$cursor = Gtk3::Gdk::Cursor->new('dotbox');
#disable controls, because they are not useful
$self->{_fill_color_w}->set_sensitive(FALSE);
$self->{_font_btn_w}->set_sensitive(FALSE);
#restore hard-coded highlighter properties
$self->restore_fixed_properties($self->{_current_mode_descr});
} elsif ($self->{_current_mode} == 40) {
$self->{_current_mode_descr} = "line";
#disable controls, because they are not useful
$self->{_fill_color_w}->set_sensitive(FALSE);
$self->{_font_btn_w}->set_sensitive(FALSE);
} elsif ($self->{_current_mode} == 50) {
$self->{_current_mode_descr} = "arrow";
#disable controls, because they are not useful
$self->{_fill_color_w}->set_sensitive(FALSE);
$self->{_font_btn_w}->set_sensitive(FALSE);
} elsif ($self->{_current_mode} == 60) {
$self->{_current_mode_descr} = "rect";
#disable controls, because they are not useful
$self->{_font_btn_w}->set_sensitive(FALSE);
} elsif ($self->{_current_mode} == 70) {
$self->{_current_mode_descr} = "ellipse";
#disable controls, because they are not useful
$self->{_font_btn_w}->set_sensitive(FALSE);
} elsif ($self->{_current_mode} == 80) {
$self->{_current_mode_descr} = "text";
#disable controls, because they are not useful
$self->{_fill_color_w}->set_sensitive(FALSE);
$self->{_line_spin_w}->set_sensitive(FALSE);
} elsif ($self->{_current_mode} == 90) {
$self->{_current_mode_descr} = "censor";
#disable controls, because they are not useful when using the
#censor tool
$self->{_fill_color_w}->set_sensitive(FALSE);
$self->{_stroke_color_w}->set_sensitive(FALSE);
$self->{_line_spin_w}->set_sensitive(FALSE);
$self->{_font_btn_w}->set_sensitive(FALSE);
#restore hard-coded censor properties
$self->restore_fixed_properties($self->{_current_mode_descr});
} elsif ($self->{_current_mode} == 100) {
$self->{_current_mode_descr} = "pixelize";
#disable controls, because they are not useful when using the
#pixelize tool
$self->{_fill_color_w}->set_sensitive(FALSE);
$self->{_stroke_color_w}->set_sensitive(FALSE);
$self->{_line_spin_w}->set_sensitive(FALSE);
$self->{_font_btn_w}->set_sensitive(FALSE);
} elsif ($self->{_current_mode} == 110) {
$self->{_current_mode_descr} = "number";
} elsif ($self->{_current_mode} == 120) {
$self->{_current_mode_descr} = "crop";
#show cropping tool
$self->{_view}->set_pixbuf($self->save(TRUE));
$self->{_view}->set_zoom(1);
#adjust transp color
my $color_string = $self->{_canvas_bg_rect}{fill_color}->to_string;
$self->{_view_css_provider_alpha}->load_from_data("
.imageview.transparent {
background-color: $color_string;
}
");
$self->{_view}->show_all;
$self->{_drawing_inner_vbox_c}->show_all;
#hide drawing tool widgets
$self->{_drawing_inner_vbox}->hide;
#focus crop-ok-button
$self->{_btn_ok_c}->grab_focus;
}
if ($self->{_canvas} && $self->{_canvas}->get_window) {
if (exists $self->{_cursors}{$self->{_current_mode_descr}}) {
my $cursor_data = $self->{_cursors}{$self->{_current_mode_descr}};
$cursor = Gtk3::Gdk::Cursor->new_from_pixbuf(
Gtk3::Gdk::Display::get_default(),
$cursor_data->{'pixbuf'},
$cursor_data->{'x_hot'},
$cursor_data->{'y_hot'},
);
}
$self->{_canvas}->get_window->set_cursor($cursor);
}
return TRUE;
}
sub zoom_in_cb {
my $self = shift;
if ($self->{_current_mode_descr} ne "crop") {
$self->{_canvas}->set_scale($self->{_canvas}->get_scale + 0.2);
#~ $self->adjust_rulers;
} else {
$self->{_view}->zoom_in;
}
return TRUE;
}
sub zoom_out_cb {
my $self = shift;
if ($self->{_current_mode_descr} ne "crop") {
my $new_scale = $self->{_canvas}->get_scale - 0.2;
if ($new_scale < 0.2) {
$self->{_canvas}->set_scale(0.2);
} else {
$self->{_canvas}->set_scale($new_scale);
}
#~ $self->adjust_rulers;
} else {
$self->{_view}->zoom_out;
}
return TRUE;
}
sub zoom_normal_cb {
my $self = shift;
if ($self->{_current_mode_descr} ne "crop") {
$self->{_canvas}->set_scale(1);
#~ $self->adjust_rulers;
} else {
$self->{_view}->set_zoom(1);
}
return TRUE;
}
sub adjust_rulers {
return TRUE;
my ($self, $ev, $item) = @_;
my $s = $self->{_canvas}->get_scale;
my ($hlower, $hupper, $hposition, $hmax_size) = $self->{_hruler}->get_range;
my ($vlower, $vupper, $vposition, $vmax_size) = $self->{_vruler}->get_range;
if ($ev) {
my $copy_event = $ev->copy;
#modify event to respect scrollbars and canvas scale
$copy_event->x(($copy_event->x_root - $hlower) * $s);
$copy_event->y(($copy_event->y_root - $vlower) * $s);
$self->{_hruler}->signal_emit('motion-notify-event', $copy_event);
$self->{_vruler}->signal_emit('motion-notify-event', $copy_event);
} else {
#modify rulers (e.g. done when scrolling or zooming)
if ($self->{_hruler} && $self->{_hruler}) {
my ($x, $y, $width, $height, $depth) = $self->{_canvas}->get_window->get_geometry;
my $ha = $self->{_scrolled_window}->get_hadjustment->get_value / $s;
my $va = $self->{_scrolled_window}->get_vadjustment->get_value / $s;
$self->{_hruler}->set_range($ha, $ha + $width / $s, 0, $hmax_size);
$self->{_vruler}->set_range($va, $va + $height / $s, 0, $vmax_size);
}
}
return TRUE;
}
sub quit {
my ($self, $show_warning) = @_;
my ($name, $folder, $type) = fileparse($self->{_filename}, qr/\.[^.]*/);
#save settings to a file in the shutter folder
#is there already a .shutter folder?
mkdir("$ENV{ 'HOME' }/.shutter")
unless (-d "$ENV{ 'HOME' }/.shutter");
if ($show_warning && (defined $self->{_undo} && scalar(@{$self->{_undo}}) > 0)) {
#warn the user if there are any unsaved changes
my $warn_dialog = Gtk3::MessageDialog->new($self->{_drawing_window}, [qw/modal destroy-with-parent/], 'other', 'none', undef);
#set question text
$warn_dialog->set('text' => sprintf($self->{_d}->get("Save the changes to image %s before closing?"), "'$name$type'"));
#set text...
$self->update_warning_text($warn_dialog);
#...and update it
my $id = Glib::Timeout->add(
1000,
sub {
$self->update_warning_text($warn_dialog);
return TRUE;
});
$warn_dialog->set('image' => Gtk3::Image->new_from_stock('gtk-save', 'dialog'));
$warn_dialog->set('title' => $self->{_d}->get("Close") . " " . $name . $type);
#don't save button
my $dsave_btn = Gtk3::Button->new_with_mnemonic($self->{_d}->get("Do_n't save"));
$dsave_btn->set_image(Gtk3::Image->new_from_stock('gtk-delete', 'button'));
#cancel button
my $cancel_btn = Gtk3::Button->new_from_stock('gtk-cancel');
$cancel_btn->set_can_default(TRUE);
#save button
my $save_btn = Gtk3::Button->new_from_stock('gtk-save');
$warn_dialog->add_action_widget($dsave_btn, 10);
$warn_dialog->add_action_widget($cancel_btn, 20);
$warn_dialog->add_action_widget($save_btn, 30);
$warn_dialog->set_default_response(20);
$warn_dialog->get_child->show_all;
my $response = $warn_dialog->run;
Glib::Source->remove($id);
if ($response == 20) {
$warn_dialog->destroy;
return TRUE;
} elsif ($response == 30) {
$self->save();
}
$self->{_drawing_window}->hide if $self->{_drawing_window};
$warn_dialog->hide;
$warn_dialog->destroy;
}
$self->save_settings;
if ($self->{_selector_handler}) {
$self->{_selector}->signal_handler_disconnect($self->{_selector_handler});
}
$self->{_drawing_window}->hide if $self->{_drawing_window};
$self->{_drawing_window}->destroy if $self->{_drawing_window};
#remove statusbar timer
#Glib::Source->remove($self->{_drawing_statusbar}->{statusbar_timer}) if defined $self->{_drawing_statusbar}->{statusbar_timer};
#delete hash entries to avoid any
#possible circularity
#
#this would lead to a memory leak
foreach (keys %{$self}) {
delete $self->{$_};
}
Gtk3->main_quit();
return FALSE;
}
sub update_warning_text {
my ($self, $warn_dialog) = @_;
my $minutes = int((time - $self->{_start_time}) / 60);
$minutes = 1 if $minutes == 0;
my $txt = $self->{_d}->nget(
"If you don't save the image, changes from the last minute will be lost",
"If you don't save the image, changes from the last %d minutes will be lost",
$minutes
);
$txt = sprintf($txt, $minutes) if $minutes > 1;
$warn_dialog->set(
'secondary-text' => "$txt."
);
return TRUE;
}
sub load_settings {
my $self = shift;
my $shutter_hfunct = Shutter::App::HelperFunctions->new($self->{_sc});
#settings file
my $settingsfile = "$ENV{ HOME }/.shutter/drawingtool.xml";
my $settings_xml;
if ($shutter_hfunct->file_exists($settingsfile)) {
eval {
$settings_xml = XMLin(IO::File->new($settingsfile));
#restore window state when maximized
if (exists $settings_xml->{'drawing'}->{'state'} && defined $settings_xml->{'drawing'}->{'state'} && $settings_xml->{'drawing'}->{'state'} eq 'maximized') {
$self->{_drawing_window}->maximize;
}
#window size and position
if ($settings_xml->{'drawing'}->{'x'} && $settings_xml->{'drawing'}->{'y'}) {
$self->{_drawing_window}->move($settings_xml->{'drawing'}->{'x'}, $settings_xml->{'drawing'}->{'y'});
}
if ($settings_xml->{'drawing'}->{'width'} && $settings_xml->{'drawing'}->{'height'}) {
$self->{_drawing_window}->resize($settings_xml->{'drawing'}->{'width'}, $settings_xml->{'drawing'}->{'height'});
}
#current mode
if ($settings_xml->{'drawing'}->{'mode'}) {
$self->{_current_mode} = $settings_xml->{'drawing'}->{'mode'};
}
#autoscroll
my $autoscroll_toggle = $self->{_uimanager}->get_widget("/MenuBar/Edit/Autoscroll");
$autoscroll_toggle->set_active($settings_xml->{'drawing'}->{'autoscroll'});
#drawing colors
$self->{_fill_color} = Gtk3::Gdk::RGBA::parse($settings_xml->{'drawing'}->{'fill_color'}) // Gtk3::Gdk::RGBA::parse('black');
$self->{_fill_color}->alpha($settings_xml->{'drawing'}->{'fill_color_alpha'});
$self->{_stroke_color} = Gtk3::Gdk::RGBA::parse($settings_xml->{'drawing'}->{'stroke_color'}) // Gtk3::Gdk::RGBA::parse('black');
$self->{_stroke_color}->alpha($settings_xml->{'drawing'}->{'stroke_color_alpha'});
#line_width
$self->{_line_width} = $settings_xml->{'drawing'}->{'line_width'};
#font
$self->{_font} = $settings_xml->{'drawing'}->{'font'};
};
if ($@) {
warn "ERROR: Settings of DrawingTool could not be restored: $@ - ignoring\n";
}
}
return TRUE;
}
sub save_settings {
my $self = shift;
#to avoid saving the properties of the highlighter
#this does not make any sense
$self->restore_drawing_properties;
#settings file
my $settingsfile = "$ENV{ HOME }/.shutter/drawingtool.xml";
#hash to store settings
my %settings;
#window size and position
if (defined $self->{_drawing_window}->get_window) {
if ($self->{_drawing_window}->get_window->get_state eq 'GDK_WINDOW_STATE_MAXIMIZED') {
$settings{'drawing'}->{'state'} = 'maximized';
}
}
my ($w, $h) = $self->{_drawing_window}->get_size;
my ($x, $y) = $self->{_drawing_window}->get_position;
$settings{'drawing'}->{'x'} = $x;
$settings{'drawing'}->{'y'} = $y;
$settings{'drawing'}->{'width'} = $w;
$settings{'drawing'}->{'height'} = $h;
#current action
#but don't save the crop tool as last action
#as it would be confusing to open the drawing tool
#with crop tool enabled
if ($self->{_current_mode_descr} ne "crop") {
$settings{'drawing'}->{'mode'} = $self->{_current_mode};
} else {
$settings{'drawing'}->{'mode'} = 10;
}
#autoscroll
my $autoscroll_toggle = $self->{_uimanager}->get_widget("/MenuBar/Edit/Autoscroll");
$settings{'drawing'}->{'autoscroll'} = $autoscroll_toggle->get_active();
#drawing colors
$settings{'drawing'}->{'fill_color'} = sprintf("#%04x%04x%04x", $self->{_fill_color}->red * 65535, $self->{_fill_color}->green * 65535, $self->{_fill_color}->blue * 65535);
$settings{'drawing'}->{'fill_color_alpha'} = $self->{_fill_color}->alpha;
$settings{'drawing'}->{'stroke_color'} = sprintf("#%04x%04x%04x", $self->{_stroke_color}->red * 65535, $self->{_stroke_color}->green * 65535, $self->{_stroke_color}->blue * 65535);
$settings{'drawing'}->{'stroke_color_alpha'} = $self->{_stroke_color}->alpha;
#line_width
$settings{'drawing'}->{'line_width'} = $self->{_line_width};
#font
$settings{'drawing'}->{'font'} = $self->{_font};
eval {
#save to file
open(SETTFILE, ">$settingsfile") or die $!;
print SETTFILE XMLout(\%settings);
close(SETTFILE) or die $!;
};
if ($@) {
warn "ERROR: Settings of DrawingTool could not be saved: $@ - ignoring\n";
}
return TRUE;
}
sub export_to_file {
my $self = shift;
my $rfiletype = shift;
my $fs = Gtk3::FileChooserDialog->new(
$self->{_d}->get("Choose a location to save to"),
$self->{_drawing_window}, 'save',
'gtk-cancel' => 'reject',
'gtk-save' => 'accept'
);
my $shutter_hfunct = Shutter::App::HelperFunctions->new($self->{_sc});
#parse filename
my ($short, $folder, $ext) = fileparse($self->{_filename}, qr/\.[^.]*/);
#go to recently used folder
if (defined $self->{_sc}->get_rusf && $shutter_hfunct->folder_exists($self->{_sc}->get_rusf)) {
$fs->set_current_folder($self->{_sc}->get_rusf);
$fs->set_current_name($short . $ext);
} elsif (defined $self->{_is_unsaved} && $self->{_is_unsaved}) {
$fs->set_current_folder(Shutter::App::Directories::get_home_dir());
$fs->set_current_name($short . $ext);
} else {
$fs->set_current_folder($folder);
$fs->set_current_name($short . $ext);
}
#preview widget
my $iprev = Gtk3::Image->new;
$fs->set_preview_widget($iprev);
$fs->signal_connect(
'selection-changed' => sub {
if (my $pfilename = $fs->get_preview_filename) {
my $pixbuf = $self->{_lp_ne}->load($pfilename, 200, 200, TRUE, TRUE);
unless ($pixbuf) {
$fs->set_preview_widget_active(FALSE);
} else {
$fs->get_preview_widget->set_from_pixbuf($pixbuf);
$fs->set_preview_widget_active(TRUE);
}
} else {
$fs->set_preview_widget_active(FALSE);
}
});
#change extension related to the requested filetype
if (defined $rfiletype) {
my ($short, $folder, $ext) = fileparse($self->{_filename}, qr/\.[^.]*/);
$fs->set_current_name($short . "." . $rfiletype);
}
my $extra_hbox = Gtk3::HBox->new;
my $label_save_as_type = Gtk3::Label->new($self->{_d}->get("Image format") . ":");
my $combobox_save_as_type = Gtk3::ComboBoxText->new;
#add supported formats to combobox
my $counter = 0;
my $png_counter = undef;
#add pdf support
if (defined $rfiletype && $rfiletype eq 'pdf') {
$combobox_save_as_type->insert_text($counter, "pdf - Portable Document Format");
$combobox_save_as_type->set_active(0);
#add ps support
} elsif (defined $rfiletype && $rfiletype eq 'ps') {
$combobox_save_as_type->insert_text($counter, "ps - PostScript");
$combobox_save_as_type->set_active(0);
#images
} else {
foreach my $format (Gtk3::Gdk::Pixbuf::get_formats()) {
#we don't want svg here - this is a dedicated action in the DrawingTool
next if !defined $rfiletype && $format->get_name =~ /svg/;
#we have a requested filetype - nothing else will be offered
next if defined $rfiletype && $format->get_name ne $rfiletype;
#we want jpg not jpeg
if ($format->get_name eq "jpeg" || $format->get_name eq "jpg") {
$combobox_save_as_type->insert_text($counter, "jpg" . " - " . $format->get_description);
} else {
$combobox_save_as_type->insert_text($counter, $format->get_name . " - " . $format->get_description);
}
#set active when mime_type is matching
#loop because multiple mime types are registered for fome file formats
foreach my $mime (@{$format->get_mime_types}) {
$combobox_save_as_type->set_active($counter)
if $mime eq $self->{'_mimetype'} || defined $rfiletype;
#save png_counter as well as fallback
$png_counter = $counter if $mime eq 'image/png';
}
$counter++;
}
}
#something went wrong here
#filetype was not detected automatically
#set to png as default
unless ($combobox_save_as_type->get_active_text) {
if (defined $png_counter) {
$combobox_save_as_type->set_active($png_counter);
}
}
$combobox_save_as_type->signal_connect(
'changed' => sub {
my $filename = $self->{_shf}->utf8_decode($fs->get_filename);
my $choosen_format = $combobox_save_as_type->get_active_text;
$choosen_format =~ s/ \-.*//; #get png or jpeg (jpg) for example
#~ print $choosen_format . "\n";
#parse filename
my ($short, $folder, $ext) = fileparse($filename, qr/\.[^.]*/);
$fs->set_current_name($short . "." . $choosen_format);
});
#emit the signal once in order to invoke the sub above
#~ $combobox_save_as_type->signal_emit('changed');
$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 = Gtk3::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 = $self->{_shf}->utf8_decode($fs->get_filename);
#parse filename
my ($short, $folder, $ext) = fileparse($filename, qr/\.[^.]*/);
#keep selected folder in mind
$self->{_sc}->set_rusf($folder);
#handle file format
my $choosen_format = $combobox_save_as_type->get_active_text;
$choosen_format =~ s/ \-.*//; #get png or jpeg (jpg) for example
$filename = $folder . $short . "." . $choosen_format;
my $shutter_hfunct = Shutter::App::HelperFunctions->new($self->{_sc});
unless ($shutter_hfunct->file_exists($filename)) {
#save
$self->save(FALSE, $filename, $choosen_format);
} else {
#ask the user to replace the image
#replace button
my $replace_btn = Gtk3::Button->new_with_mnemonic($self->{_d}->get("_Replace"));
$replace_btn->set_image(Gtk3::Image->new_from_stock('gtk-save-as', 'button'));
my $response = $self->{_dialogs}->dlg_warning_message(
sprintf($self->{_d}->get("The image already exists in %s. Replacing it will overwrite its contents."), "'" . $folder . "'"),
sprintf($self->{_d}->get("An image named %s already exists. Do you want to replace it?"), "'" . $short . "." . $choosen_format . "'"),
undef, undef, undef, $replace_btn, undef, undef
);
if ($response == 40) {
#save
$self->save(FALSE, $filename, $choosen_format);
}
}
}
$fs->destroy();
}
sub export_to_svg {
my $self = shift;
#here might be some more features in future releases of Shutter
#just call the dialog
$self->export_to_file('svg');
return TRUE;
}
sub export_to_ps {
my $self = shift;
#here might be some more features in future releases of Shutter
#just call the dialog
$self->export_to_file('ps');
return TRUE;
}
sub export_to_pdf {
my $self = shift;
#here might be some more features in future releases of Shutter
#just call the dialog
$self->export_to_file('pdf');
return TRUE;
}
sub save {
my $self = shift;
my $save_to_mem = shift;
my $filename = shift || $self->{_filename};
my $filetype = shift || $self->{_filetype};
#make sure not to save the bounding rectangles
$self->deactivate_all;
#hide line and change background color, e.g. for saving
$self->handle_bg_rects('hide');
unless ($save_to_mem) {
#image format supports transparency or not
#we need to support more formats here I think
if ($filetype eq 'jpeg' || $filetype eq 'jpg' || $filetype eq 'bmp') {
$self->{_canvas_bg_rect}->set(
'fill-color-gdk-rgba' => $self->{_canvas_bg_rect}{fill_color},
'line-width' => 0,
);
} elsif ($self->{_canvas_bg_rect}{fill_color}->equal(Gtk3::Gdk::RGBA::parse('gray'))) {
$self->{_canvas_bg_rect}->set('visibility' => 'hidden');
} else {
#ask the user if he wants to save the background color
my $bg_dialog = Gtk3::MessageDialog->new($self->{_drawing_window}, [qw/modal destroy-with-parent/], 'other', 'none', undef);
#set attributes
$bg_dialog->set('text' => $self->{_d}->get("Do you want to save the changed background color?"));
$bg_dialog->set('secondary-text' => $self->{_d}->get("The background is likely to be transparent if you decide to ignore the background color."));
$bg_dialog->set('image' => Gtk3::Image->new_from_stock('gtk-save', 'dialog'));
$bg_dialog->set('title' => $self->{_d}->get("Save Background Color"));
#ignore bg button
my $cancel_btn = Gtk3::Button->new_with_mnemonic($self->{_d}->get("_Ignore Background Color"));
#save bg button
my $bg_btn = Gtk3::Button->new_with_mnemonic($self->{_d}->get("_Save Background Color"));
$bg_btn->set_can_default(TRUE);
$bg_dialog->add_action_widget($cancel_btn, 10);
$bg_dialog->add_action_widget($bg_btn, 20);
$bg_dialog->set_default_response(20);
$bg_dialog->get_child->show_all;
my $response = $bg_dialog->run;
if ($response == 10) {
$self->{_canvas_bg_rect}->set('visibility' => 'hidden');
} elsif ($response == 20) {
$self->{_canvas_bg_rect}->set(
'fill-color-gdk-rgba' => $self->{_canvas_bg_rect}{fill_color},
'line-width' => 0,
);
}
$bg_dialog->destroy;
}
} else {
$self->{_canvas_bg_rect}->set('visibility' => 'hidden');
}
if ($filetype eq 'svg') {
#0.8? => 72 / 90 dpi
my $surface = Cairo::SvgSurface->create($filename, $self->{_canvas_bg_rect}->get('width') * 0.8, $self->{_canvas_bg_rect}->get('height') * 0.8);
my $cr = Cairo::Context->create($surface);
$cr->scale(0.8, 0.8);
$self->{_canvas}->render($cr, $self->{_canvas_bg_rect}->get_bounds, 1);
$cr->show_page;
} elsif ($filetype eq 'ps') {
#0.8? => 72 / 90 dpi
my $surface = Cairo::PsSurface->create($filename, $self->{_canvas_bg_rect}->get('width') * 0.8, $self->{_canvas_bg_rect}->get('height') * 0.8);
my $cr = Cairo::Context->create($surface);
$cr->scale(0.8, 0.8);
$self->{_canvas}->render($cr, $self->{_canvas_bg_rect}->get_bounds, 1);
$cr->show_page;
} elsif ($filetype eq 'pdf') {
#0.8? => 72 / 90 dpi
my $surface = Cairo::PdfSurface->create($filename, $self->{_canvas_bg_rect}->get('width') * 0.8, $self->{_canvas_bg_rect}->get('height') * 0.8);
my $cr = Cairo::Context->create($surface);
$cr->scale(0.8, 0.8);
$self->{_canvas}->render($cr, $self->{_canvas_bg_rect}->get_bounds, 1);
$cr->show_page;
} else {
my $surface = Cairo::ImageSurface->create('argb32', $self->{_canvas_bg_rect}->get('width'), $self->{_canvas_bg_rect}->get('height'));
my $cr = Cairo::Context->create($surface);
$self->{_canvas}->render($cr, $self->{_canvas_bg_rect}->get_bounds, 1);
my $loader = Gtk3::Gdk::PixbufLoader->new;
$surface->write_to_png_stream(
sub {
my ($closure, $data) = @_;
$loader->write([map ord, split //, $data]);
return TRUE;
});
$loader->close;
my $pixbuf = $loader->get_pixbuf;
#just return pixbuf
if ($save_to_mem) {
#update the canvas_rect again
$self->{_canvas_bg_rect}->set(
'fill-color-gdk-rgba' => $self->{_canvas_bg_rect}{fill_color},
'line-width' => 1,
'visibility' => 'visible',
);
$self->handle_bg_rects('show');
return $pixbuf;
}
#save pixbuf to file
my $pixbuf_save = Shutter::Pixbuf::Save->new($self->{_sc}, $self->{_drawing_window});
#save pixbuf to clipboard
if ($self->{_cp_to_cb_on_save}) {
$self->{_clipboard}->set_image($pixbuf);
}
return $pixbuf_save->save_pixbuf_to_file($pixbuf, $filename, $filetype);
}
}
#ITEM SIGNALS
sub setup_item_signals {
my ($self, $item) = @_;
$item->signal_connect(
'motion_notify_event',
sub {
my ($item, $target, $ev) = @_;
$self->event_item_on_motion_notify($item, $target, $ev);
});
$item->signal_connect(
'key_press_event',
sub {
my ($item, $target, $ev) = @_;
$self->event_item_on_key_press($item, $target, $ev);
});
$item->signal_connect(
'button_press_event',
sub {
my ($item, $target, $ev) = @_;
$self->event_item_on_button_press($item, $target, $ev);
});
$item->signal_connect(
'button_release_event',
sub {
my ($item, $target, $ev) = @_;
$self->event_item_on_button_release($item, $target, $ev);
});
return TRUE;
}
sub setup_item_signals_extra {
my ($self, $item) = @_;
$item->signal_connect(
'enter_notify_event',
sub {
my ($item, $target, $ev) = @_;
$self->event_item_on_enter_notify($item, $target, $ev);
});
$item->signal_connect(
'leave_notify_event',
sub {
my ($item, $target, $ev) = @_;
$self->event_item_on_leave_notify($item, $target, $ev);
});
return TRUE;
}
sub event_item_on_motion_notify {
my ($self, $item, $target, $ev) = @_;
$self->adjust_rulers($ev, $item);
#autoscroll if enabled
#as does not work when using the censor tool -> deactivate it
if ($self->{_current_mode_descr} ne "censor" && $self->{_autoscroll} && ($ev->state >= 'button1-mask' || $ev->state >= 'button2-mask')) {
my ($x, $y, $width, $height, $depth) = $self->{_canvas}->get_window->get_geometry;
my $s = $self->{_canvas}->get_scale;
my $ha = $self->{_scrolled_window}->get_hadjustment->get_value;
my $va = $self->{_scrolled_window}->get_vadjustment->get_value;
#autoscroll
if ( $ev->x > ($ha / $s + $width / $s - 100 / $s)
&& $ev->y > ($va / $s + $height / $s - 100 / $s))
{
$self->{_canvas}->scroll_to($ha / $s + 10 / $s, $va / $s + 10 / $s);
} elsif ($ev->x > ($ha / $s + $width / $s - 100 / $s)) {
$self->{_canvas}->scroll_to($ha / $s + 10 / $s, $va / $s);
} elsif ($ev->y > ($va / $s + $height / $s - 100 / $s)) {
$self->{_canvas}->scroll_to($ha / $s, $va / $s + 10 / $s);
} elsif ($ev->x < ($ha / $s + 100 / $s) && $ev->y < ($va / $s + 100 / $s)) {
$self->{_canvas}->scroll_to($ha / $s - 10 / $s, $va / $s - 10 / $s);
} elsif ($ev->x < ($ha / $s + 100 / $s)) {
$self->{_canvas}->scroll_to($ha / $s - 10 / $s, $va / $s);
} elsif ($ev->y < ($va / $s + 100 / $s)) {
$self->{_canvas}->scroll_to($ha / $s, $va / $s - 10 / $s);
}
}
#move
if ($item->{dragging} && ($ev->state >= 'button1-mask' || $ev->state >= 'button2-mask')) {
if ($item->isa('GooCanvas2::CanvasRect')) {
my $new_x = $self->{_items}{$item}->get('x') + $ev->x - $item->{drag_x};
my $new_y = $self->{_items}{$item}->get('y') + $ev->y - $item->{drag_y};
$self->{_items}{$item}->set(
'x' => $new_x,
'y' => $new_y,
);
$item->{drag_x} = $ev->x;
$item->{drag_y} = $ev->y;
$self->handle_rects('update', $item);
$self->handle_embedded('update', $item);
} else {
$item->translate($ev->x - $item->{drag_x}, $ev->y - $item->{drag_y});
}
#add to undo stack
if ($item->{dragging_start}) {
$self->store_to_xdo_stack($item, 'modify', 'undo');
$item->{dragging_start} = FALSE;
}
#freehand line
} elsif (($self->{_current_mode_descr} eq "freehand" || $self->{_current_mode_descr} eq "highlighter" || $self->{_current_mode_descr} eq "censor") && $ev->state >= 'button1-mask') {
#mark as active item
my $item = undef;
if ($self->{_current_new_item}) {
$item = $self->{_current_new_item};
$self->{_current_new_item} = undef;
$self->{_current_item} = $item;
#add to undo stack
$self->store_to_xdo_stack($self->{_current_item}, 'create', 'undo');
} else {
$item = $self->{_current_item};
}
if ($ev->state >= 'control-mask') {
my $last_point = pop @{$self->{_items}{$item}{'points'}};
$last_point = $ev->y unless $last_point;
push @{$self->{_items}{$item}{'points'}}, $last_point, $ev->x, $last_point;
} elsif ($ev->state >= 'shift-mask') {
my $last_point_y = pop @{$self->{_items}{$item}{'points'}};
my $last_point_x = pop @{$self->{_items}{$item}{'points'}};
$last_point_x = $ev->x unless $last_point_x;
$last_point_y = $ev->y unless $last_point_y;
push @{$self->{_items}{$item}{'points'}}, $last_point_x, $last_point_y, $last_point_x, $ev->y;
} else {
push @{$self->{_items}{$item}{'points'}}, $ev->x, $ev->y;
}
$self->{_items}{$item}->set('points' => Shutter::Draw::Utils::points_to_canvas_points(@{$self->{_items}{$item}{'points'}}));
#new item is already on the canvas with small initial size
#drawing is like resizing, so set up for resizing
} elsif ((
$self->{_current_mode_descr} eq "rect"
|| $self->{_current_mode_descr} eq "line"
|| $self->{_current_mode_descr} eq "arrow"
|| $self->{_current_mode_descr} eq "ellipse"
|| $self->{_current_mode_descr} eq "text"
|| $self->{_current_mode_descr} eq "image"
|| $self->{_current_mode_descr} eq "pixelize"
|| $self->{_current_mode_descr} eq "number"
)
&& $ev->state >= 'button1-mask'
&& !$item->{resizing} #if item is not in resize mode already
)
{
#~ print "start resizing\n";
my $item = $self->{_current_new_item};
return FALSE unless $item;
$self->deactivate_all($item);
#mark as active item
$self->{_current_item} = $item;
$self->{_items}{$item}{'bottom-right-corner'}->{res_x} = $ev->x;
$self->{_items}{$item}{'bottom-right-corner'}->{res_y} = $ev->y;
$self->{_items}{$item}{'bottom-right-corner'}->{resizing} = TRUE;
eval {
$self->{_canvas}->pointer_grab($self->{_items}{$item}{'bottom-right-corner'}, ['pointer-motion-mask', 'button-release-mask'], undef, $ev->time);
};
if ($@) {
# workaround for https://gitlab.gnome.org/GNOME/goocanvas/-/merge_requests/8
$self->{_canvas}->pointer_grab($self->{_items}{$item}{'bottom-right-corner'}, ['pointer-motion-mask', 'button-release-mask'], Gtk3::Gdk::Cursor->new('left-ptr'), $ev->time);
}
#add to undo stack
$self->store_to_xdo_stack($item, 'create', 'undo');
#item is resizing mode already
} elsif ($item->{resizing} && $ev->state >= 'button1-mask') {
#~ print "resizing\n";
$self->{_current_mode_descr} = "resize";
#canvas resizing shape
if ($self->{_canvas_bg_rect}{'right-side'} == $item) {
my $new_width = $self->{_canvas_bg_rect}->get('width') + ($ev->x - $item->{res_x});
unless ($new_width < 0) {
$self->{_canvas_bg_rect}->set('width' => $new_width,);
$self->handle_bg_rects('update');
}
} elsif ($self->{_canvas_bg_rect}{'bottom-side'} == $item) {
my $new_height = $self->{_canvas_bg_rect}->get('height') + ($ev->y - $item->{res_y});
unless ($new_height < 0) {
$self->{_canvas_bg_rect}->set('height' => $new_height,);
$self->handle_bg_rects('update');
}
} elsif ($self->{_canvas_bg_rect}{'bottom-right-corner'} == $item) {
my $new_width = $self->{_canvas_bg_rect}->get('width') + ($ev->x - $item->{res_x});
my $new_height = $self->{_canvas_bg_rect}->get('height') + ($ev->y - $item->{res_y});
unless ($new_width < 0 || $new_height < 0) {
$self->{_canvas_bg_rect}->set(
'width' => $new_width,
'height' => $new_height,
);
$self->handle_bg_rects('update');
}
#item resizing shape
} else {
my $curr_item = $self->{_current_item};
#~ my $cursor = undef;
return FALSE unless $curr_item;
#calculate aspect ratio (resizing when control is pressed)
my $ratio = 1;
$ratio = $self->{_items}{$curr_item}->get('width') / $self->{_items}{$curr_item}->get('height') if $self->{_items}{$curr_item}->get('height') != 0;
my $new_x = 0;
my $new_y = 0;
my $new_width = 0;
my $new_height = 0;
foreach (keys %{$self->{_items}{$curr_item}}) {
next unless $_ =~ m/(corner|side)/;
#fancy resizing using our little resize boxes
if ($item == $self->{_items}{$curr_item}{$_}) {
#~ $cursor = $_;
if ($_ eq 'bottom-side') {
$new_x = $self->{_items}{$curr_item}->get('x');
$new_y = $self->{_items}{$curr_item}->get('y');
$new_width = $self->{_items}{$curr_item}->get('width');
$new_height = $self->{_items}{$curr_item}->get('height') + ($ev->y - $item->{res_y});
last;
} elsif ($_ eq 'bottom-right-corner') {
$new_x = $self->{_items}{$curr_item}->get('x');
$new_y = $self->{_items}{$curr_item}->get('y');
if ($ev->state >= 'control-mask') {
$new_width = $self->{_items}{$curr_item}->get('width') + ($ev->y - $item->{res_y}) * $ratio;
$new_height = $self->{_items}{$curr_item}->get('height') + ($ev->y - $item->{res_y});
} else {
$new_width = $self->{_items}{$curr_item}->get('width') + ($ev->x - $item->{res_x});
$new_height = $self->{_items}{$curr_item}->get('height') + ($ev->y - $item->{res_y});
}
last;
} elsif ($_ eq 'top-left-corner') {
if ($ev->state >= 'control-mask') {
$new_x = $self->{_items}{$curr_item}->get('x') + ($ev->y - $item->{res_y}) * $ratio;
$new_y = $self->{_items}{$curr_item}->get('y') + ($ev->y - $item->{res_y});
$new_width = $self->{_items}{$curr_item}->get('width') + ($self->{_items}{$curr_item}->get('x') - $new_x);
$new_height = $self->{_items}{$curr_item}->get('height') + ($self->{_items}{$curr_item}->get('y') - $new_y);
} else {
$new_x = $self->{_items}{$curr_item}->get('x') + $ev->x - $item->{res_x};
$new_y = $self->{_items}{$curr_item}->get('y') + $ev->y - $item->{res_y};
$new_width = $self->{_items}{$curr_item}->get('width') + ($self->{_items}{$curr_item}->get('x') - $new_x);
$new_height = $self->{_items}{$curr_item}->get('height') + ($self->{_items}{$curr_item}->get('y') - $new_y);
}
last;
} elsif ($_ eq 'top-side') {
$new_x = $self->{_items}{$curr_item}->get('x');
$new_y = $self->{_items}{$curr_item}->get('y') + $ev->y - $item->{res_y};
$new_width = $self->{_items}{$curr_item}->get('width');
$new_height = $self->{_items}{$curr_item}->get('height') + ($self->{_items}{$curr_item}->get('y') - $new_y);
last;
} elsif ($_ eq 'top-right-corner') {
$new_x = $self->{_items}{$curr_item}->get('x');
$new_y = $self->{_items}{$curr_item}->get('y') + $ev->y - $item->{res_y};
if ($ev->state >= 'control-mask') {
$new_width = $self->{_items}{$curr_item}->get('width') - ($ev->y - $item->{res_y}) * $ratio;
$new_height = $self->{_items}{$curr_item}->get('height') + ($self->{_items}{$curr_item}->get('y') - $new_y);
} else {
$new_width = $self->{_items}{$curr_item}->get('width') + ($ev->x - $item->{res_x});
$new_height = $self->{_items}{$curr_item}->get('height') + ($self->{_items}{$curr_item}->get('y') - $new_y);
}
last;
} elsif ($_ eq 'left-side') {
$new_x = $self->{_items}{$curr_item}->get('x') + $ev->x - $item->{res_x};
$new_y = $self->{_items}{$curr_item}->get('y');
$new_width = $self->{_items}{$curr_item}->get('width') + ($self->{_items}{$curr_item}->get('x') - $new_x);
$new_height = $self->{_items}{$curr_item}->get('height');
last;
} elsif ($_ eq 'right-side') {
$new_x = $self->{_items}{$curr_item}->get('x');
$new_y = $self->{_items}{$curr_item}->get('y');
$new_width = $self->{_items}{$curr_item}->get('width') + ($ev->x - $item->{res_x});
$new_height = $self->{_items}{$curr_item}->get('height');
last;
} elsif ($_ eq 'bottom-left-corner') {
if ($ev->state >= 'control-mask') {
$new_x = $self->{_items}{$curr_item}->get('x') - $ev->y + $item->{res_y};
$new_y = $self->{_items}{$curr_item}->get('y');
$new_width = $self->{_items}{$curr_item}->get('width') + ($self->{_items}{$curr_item}->get('x') - $new_x);
$new_height = $self->{_items}{$curr_item}->get('height') + ($ev->y - $item->{res_y}) / $ratio;
} else {
$new_x = $self->{_items}{$curr_item}->get('x') + $ev->x - $item->{res_x};
$new_y = $self->{_items}{$curr_item}->get('y');
$new_width = $self->{_items}{$curr_item}->get('width') + ($self->{_items}{$curr_item}->get('x') - $new_x);
$new_height = $self->{_items}{$curr_item}->get('height') + ($ev->y - $item->{res_y});
}
last;
}
}
}
#set cursor
#~ $self->{_canvas}->window->set_cursor( Gtk3::Gdk::Cursor->new($cursor) );
#when width or height are too small we switch to opposite rectangle and do the resizing in this way
if ($ev->state >= 'control-mask' && $new_width < 1 && $new_height < 1) {
$new_x = $self->{_items}{$curr_item}->get('x');
$new_y = $self->{_items}{$curr_item}->get('y');
$new_width = $self->{_items}{$curr_item}->get('width');
$new_height = $self->{_items}{$curr_item}->get('height');
} elsif ($new_width < 0 || $new_height < 0) {
$self->{_canvas}->pointer_ungrab($item, $ev->time);
$self->{_canvas}->keyboard_ungrab($item, $ev->time);
my $oppo = $self->get_opposite_rect($item, $curr_item, $new_width, $new_height);
$self->{_items}{$curr_item}{$oppo}->{res_x} = $ev->x;
$self->{_items}{$curr_item}{$oppo}->{res_y} = $ev->y;
$self->{_items}{$curr_item}{$oppo}->{resizing} = TRUE;
#~ #don'change cursor if this item was just started
#~ if($self->{_last_item} && $self->{_current_item} && $self->{_last_item} == $self->{_current_item}){
#~ $self->{_canvas}->pointer_grab( $self->{_items}{$curr_item}{$oppo}, [ 'pointer-motion-mask', 'button-release-mask' ], undef, $ev->time );
#~ }else{
#~ $self->{_canvas}->pointer_grab( $self->{_items}{$curr_item}{$oppo}, [ 'pointer-motion-mask', 'button-release-mask' ], Gtk3::Gdk::Cursor->new($oppo), $ev->time );
#~ }
eval {
$self->{_canvas}->pointer_grab($self->{_items}{$curr_item}{$oppo}, ['pointer-motion-mask', 'button-release-mask'], undef, $ev->time);
};
if ($@) {
# workaround for https://gitlab.gnome.org/GNOME/goocanvas/-/merge_requests/8
$self->{_canvas}->pointer_grab($self->{_items}{$curr_item}{$oppo}, ['pointer-motion-mask', 'button-release-mask'], Gtk3::Gdk::Cursor->new('left-ptr'), $ev->time);
}
$self->handle_embedded('mirror', $curr_item, $new_width, $new_height);
#adjust new values
if ($new_width < 0) {
$new_x += $new_width;
$new_width = abs($new_width);
}
if ($new_height < 0) {
$new_y += $new_height;
$new_height = abs($new_height);
}
}
#apply new values...
$self->{_items}{$curr_item}->set(
'x' => $new_x,
'y' => $new_y,
'width' => $new_width,
'height' => $new_height,
);
#and update rectangles and embedded items
$self->handle_rects('update', $curr_item);
$self->handle_embedded('update', $curr_item);
}
$item->{res_x} = $ev->x;
$item->{res_y} = $ev->y;
} else {
if ($item->isa('GooCanvas2::CanvasRect')) {
#embedded item?
my $parent = $self->get_parent_item($item);
$item = $parent if $parent;
#shape or canvas background (resizeable rectangle)
if (exists $self->{_items}{$item} or $item == $self->{_canvas_bg_rect}) {
$self->push_tool_help_to_statusbar(int($ev->x), int($ev->y));
#canvas resizing shape
} elsif ($self->{_canvas_bg_rect}{'right-side'} == $item
|| $self->{_canvas_bg_rect}{'bottom-side'} == $item
|| $self->{_canvas_bg_rect}{'bottom-right-corner'} == $item)
{
$self->push_tool_help_to_statusbar(int($ev->x), int($ev->y), 'canvas_resize');
#resizing shape
} else {
$self->push_tool_help_to_statusbar(int($ev->x), int($ev->y), 'resize');
}
} else {
$self->push_tool_help_to_statusbar(int($ev->x), int($ev->y));
}
}
return TRUE;
}
sub get_opposite_rect {
my $self = shift;
my $rect = shift;
my $item = shift;
my $width = shift;
my $height = shift;
foreach (keys %{$self->{_items}{$item}}) {
#fancy resizing using our little resize boxes
if ($rect eq $self->{_items}{$item}{$_}) {
if ($_ eq 'top-left-corner') {
return 'bottom-right-corner' if $width < 0 && $height < 0;
return 'top-right-corner' if $width < 0;
return 'bottom-left-corner' if $height < 0;
} elsif ($_ eq 'top-side') {
return 'bottom-side';
} elsif ($_ eq 'top-right-corner') {
return 'bottom-left-corner' if $width < 0 && $height < 0;
return 'top-left-corner' if $width < 0;
return 'bottom-right-corner' if $height < 0;
} elsif ($_ eq 'left-side') {
return 'right-side';
} elsif ($_ eq 'right-side') {
return 'left-side';
} elsif ($_ eq 'bottom-left-corner') {
return 'top-right-corner' if $width < 0 && $height < 0;
return 'bottom-right-corner' if $width < 0;
return 'top-left-corner' if $height < 0;
} elsif ($_ eq 'bottom-side') {
return 'top-side';
} elsif ($_ eq 'bottom-right-corner') {
return 'top-left-corner' if $width < 0 && $height < 0;
return 'bottom-left-corner' if $width < 0;
return 'top-right-corner' if $height < 0;
}
}
}
return FALSE;
}
sub get_parent_item {
my ($self, $item) = @_;
return FALSE unless $item;
my $parent = undef;
foreach (keys %{$self->{_items}}) {
$parent = $self->{_items}{$_} if exists $self->{_items}{$_}{ellipse} && $self->{_items}{$_}{ellipse} == $item;
$parent = $self->{_items}{$_} if exists $self->{_items}{$_}{text} && $self->{_items}{$_}{text} == $item;
$parent = $self->{_items}{$_} if exists $self->{_items}{$_}{image} && $self->{_items}{$_}{image} == $item;
$parent = $self->{_items}{$_} if exists $self->{_items}{$_}{pixelize} && $self->{_items}{$_}{pixelize} == $item;
$parent = $self->{_items}{$_} if exists $self->{_items}{$_}{line} && $self->{_items}{$_}{line} == $item;
if (defined $parent) {
last;
}
}
#~ #debug
#~ if($parent){
#~ print "parent: $parent queried for item: $item\n";
#~ }else{
#~ print "no parent found for item: $item\n";
#~ }
return $parent;
}
sub get_highest_auto_digit {
my ($self) = @_;
my $number = 0;
foreach (keys %{$self->{_items}}) {
my $item = $self->{_items}{$_};
#numbered shape
if ( exists $self->{_items}{$item}
&& exists $self->{_items}{$item}{type}
&& $self->{_items}{$item}{type} eq 'number'
&& $self->{_items}{$item}{text}->get('visibility') ne 'hidden')
{
$number = $self->{_items}{$item}{text}{digit} if $self->{_items}{$item}{text}{digit} > $number;
}
}
return $number;
}
sub get_pixelated_pixbuf_from_canvas {
my ($self, $item) = @_;
my $bounds = $item->get_bounds;
my $sw = $item->get('width');
my $sh = $item->get('height');
#create surface and cairo context
my $surface = Cairo::ImageSurface->create('rgb24', $bounds->x1 + $sw, $bounds->y1 + $sh);
my $cr = Cairo::Context->create($surface);
#hide rects and image
$self->handle_rects('hide', $item);
$self->handle_embedded('hide', $item);
#render the content and load it via Gtk3::Gdk::PixbufLoader
$self->{_canvas}->render($cr, $bounds, 1);
#show rects again
$self->handle_rects('update', $item);
#~ print "start loader\n";
my $loader = Gtk3::Gdk::PixbufLoader->new;
$surface->write_to_png_stream(
sub {
my ($closure, $data) = @_;
$loader->write([map ord, split //, $data]);
return TRUE;
});
$loader->close;
#create vars
my ($pixbuf, $target) = (undef, undef);
#error icon
my $error = Gtk3::Widget::render_icon(Gtk3::Invisible->new, "gtk-dialog-error", 'menu');
eval {
$pixbuf = $loader->get_pixbuf;
#create target pixbuf
$target = Gtk3::Gdk::Pixbuf->new($pixbuf->get_colorspace, TRUE, 8, $sw, $sh);
};
unless ($@) {
#maybe rect is only partially on canvas
my ($sx, $sy) = ($bounds->x1, $bounds->y1);
my ($dx, $dy) = (0, 0);
if ($bounds->x1 < 0) {
$sx = 0;
$dx = abs $bounds->x1;
$sw += $bounds->x1;
}
if ($bounds->y1 < 0) {
$sy = 0;
$dy = abs $bounds->y1;
$sh += $bounds->y1;
}
#valid pixbuf?
if ($pixbuf) {
#copy area
$pixbuf->copy_area($sx, $sy, $sw, $sh, $target, $dx, $dy);
if ($target->get_width > 10 && $target->get_height > 10) {
eval {
#pixelate the pixbuf - simply scale it down and scale it up afterwards
$target = $target->scale_simple($target->get_width * 0.1, $target->get_height * 0.1, 'tiles');
$target = $target->scale_simple($item->get('width'), $item->get('height'), 'tiles');
};
unless ($@) {
return $target;
}
} elsif ($target->get_width > 5 && $target->get_height > 5) {
eval {
#pixelate the pixbuf - simply scale it down and scale it up afterwards
$target = $target->scale_simple($target->get_width * 0.2, $target->get_height * 0.2, 'tiles');
$target = $target->scale_simple($item->get('width'), $item->get('height'), 'tiles');
};
unless ($@) {
return $target;
}
}
}
}
return $error;
}
sub get_child_item {
my ($self, $item) = @_;
return FALSE unless $item;
my $child = undef;
#notice (special shapes like numbered ellipse do deliver ellipse here => NOT text!)
#therefore the order matters
if (defined $item && exists $self->{_items}{$item}) {
$child = $self->{_items}{$item}{text} if exists $self->{_items}{$item}{text};
$child = $self->{_items}{$item}{ellipse} if exists $self->{_items}{$item}{ellipse};
$child = $self->{_items}{$item}{image} if exists $self->{_items}{$item}{image};
$child = $self->{_items}{$item}{pixelize} if exists $self->{_items}{$item}{pixelize};
$child = $self->{_items}{$item}{line} if exists $self->{_items}{$item}{line};
}
#~ #debug
#~ if($child){
#~ print "child: $child queried for item: $item\n";
#~ }else{
#~ print "no child found for item: $item\n";
#~ }
return $child;
}
sub abort_current_mode {
my ($self) = @_;
if ($self->{_current_item}) {
$self->{_canvas}->pointer_ungrab($self->{_current_item}, Gtk3::get_current_event_time());
$self->{_canvas}->keyboard_ungrab($self->{_current_item}, Gtk3::get_current_event_time());
}
#~ print "abort_current_mode\n";
$self->set_drawing_action(1);
return TRUE;
}
sub clear_item_from_canvas {
my ($self, $item) = @_;
#~ print "clear_item_from_canvas\n";
$self->{_current_item} = undef;
$self->{_current_new_item} = undef;
if ($item) {
#maybe there is a parent item to delete?
my $parent = $self->get_parent_item($item);
$item = $parent if $parent;
#get child
my $child = $self->get_child_item($item);
#only delete if not already deleted (hidden)
return FALSE if ($child && $child->get('visibility') eq 'hidden');
#~ print "1st passed\n";
return FALSE if (!$child && $item->get('visibility') eq 'hidden');
#~ print "2nd passed\n";
$self->store_to_xdo_stack($item, 'delete', 'undo');
$item->set('visibility' => 'hidden');
$self->handle_rects('hide', $item);
$self->handle_embedded('hide', $item);
}
return TRUE;
}
sub store_to_xdo_stack {
#opt1 is currently only used when cropping the image
#it stores the selection
my ($self, $item, $action, $xdo, $opt1, $source) = @_;
return FALSE unless $item;
#~ print "xdo - $item\n";
my %do_info = ();
#general properties for ellipse, rectangle, image, text
if ($item->isa('GooCanvas2::CanvasRect') && $item != $self->{_canvas_bg_rect}) {
my $stroke_color = $self->{_items}{$item}{stroke_color};
my $fill_color = $self->{_items}{$item}{fill_color};
my $line_width = $self->{_items}{$item}->get('line-width');
#line
my $mirrored_w = undef;
my $mirrored_h = undef;
my $end_arrow = undef;
my $start_arrow = undef;
my $arrow_width = undef;
my $arrow_length = undef;
my $tip_length = undef;
#text
my $text = undef;
#numbered ellipse
my $digit = undef;
if (exists $self->{_items}{$item}{ellipse}) {
$line_width = $self->{_items}{$item}{ellipse}->get('line-width');
#numbered ellipse
if (exists $self->{_items}{$item}{text}) {
$text = $self->{_items}{$item}{text}->get('text');
$digit = $self->{_items}{$item}{text}{digit};
}
} elsif (exists $self->{_items}{$item}{text}) {
$text = $self->{_items}{$item}{text}->get('text');
} elsif (exists $self->{_items}{$item}{image}) {
} elsif (exists $self->{_items}{$item}{line}) {
#line width
$line_width = $self->{_items}{$item}{line}->get('line-width');
#arrow properties
$end_arrow = $self->{_items}{$item}{line}->get('end-arrow');
$start_arrow = $self->{_items}{$item}{line}->get('start-arrow');
$arrow_width = $self->{_items}{$item}{line}->get('arrow-width');
$arrow_length = $self->{_items}{$item}{line}->get('arrow-length');
$tip_length = $self->{_items}{$item}{line}->get('arrow-tip-length');
#mirror flag
$mirrored_w = $self->{_items}{$item}{mirrored_w};
$mirrored_h = $self->{_items}{$item}{mirrored_h};
}
#item props
%do_info = (
'item' => $self->{_items}{$item},
'action' => $action,
'x' => $self->{_items}{$item}->get('x'),
'y' => $self->{_items}{$item}->get('y'),
'width' => $self->{_items}{$item}->get('width'),
'height' => $self->{_items}{$item}->get('height'),
'stroke_color' => $self->{_items}{$item}{stroke_color},
'fill_color' => $self->{_items}{$item}{fill_color},
'line-width' => $line_width,
'mirrored_w' => $mirrored_w,
'mirrored_h' => $mirrored_h,
'end-arrow' => $end_arrow,
'start-arrow' => $start_arrow,
'arrow-length' => $arrow_length,
'arrow-width' => $arrow_width,
'arrow-tip-length' => $tip_length,
'text' => $text,
'digit' => $digit,
'opt1' => $opt1,
);
} elsif ($item->isa('GooCanvas2::CanvasImage') && $item == $self->{_canvas_bg}) {
#canvas_bg_image and bg_rect properties
%do_info = (
'item' => $self->{_canvas_bg},
'action' => $action,
'drawing_pixbuf' => $self->{_drawing_pixbuf},
'x' => $self->{_canvas_bg_rect}->get('x'),
'y' => $self->{_canvas_bg_rect}->get('y'),
'width' => $self->{_canvas_bg_rect}->get('width'),
'height' => $self->{_canvas_bg_rect}->get('height'),
'opt1' => $opt1,
);
} elsif ($item->isa('GooCanvas2::CanvasRect') && $item == $self->{_canvas_bg_rect}) {
#canvas_bg_rect properties
%do_info = (
'item' => $self->{_canvas_bg_rect},
'action' => $action,
'x' => $self->{_canvas_bg_rect}->get('x'),
'y' => $self->{_canvas_bg_rect}->get('y'),
'width' => $self->{_canvas_bg_rect}->get('width'),
'height' => $self->{_canvas_bg_rect}->get('height'),
'opt1' => $opt1,
);
#polyline specific properties to hash
} elsif ($item->isa('GooCanvas2::CanvasPolyline')) {
my $transform = $self->{_items}{$item}->get('transform');
my $line_width = $self->{_items}{$item}->get('line-width');
my $points = $self->{_items}{$item}->get('points');
%do_info = (
'item' => $self->{_items}{$item},
'action' => $action,
'points' => $points,
'stroke_color' => $self->{_items}{$item}{stroke_color},
'line-width' => $line_width,
'transform' => $transform,
'opt1' => $opt1,
);
}
#reset redo
if (defined $source && $source eq 'ui') {
#~ print "no clear\n";
} else {
while (defined $self->{_redo} && scalar @{$self->{_redo}} > 0) {
shift @{$self->{_redo}};
}
}
if ($xdo eq 'undo') {
push @{$self->{_undo}}, \%do_info;
} elsif ($xdo eq 'redo') {
push @{$self->{_redo}}, \%do_info;
}
#disable undo/redo actions
$self->{_uimanager}->get_widget("/MenuBar/Edit/Undo")->set_sensitive(scalar @{$self->{_undo}}) if defined $self->{_undo};
$self->{_uimanager}->get_widget("/MenuBar/Edit/Redo")->set_sensitive(scalar @{$self->{_redo}}) if defined $self->{_redo};
$self->{_uimanager}->get_widget("/ToolBar/Undo")->set_sensitive(scalar @{$self->{_undo}}) if defined $self->{_undo};
$self->{_uimanager}->get_widget("/ToolBar/Redo")->set_sensitive(scalar @{$self->{_redo}}) if defined $self->{_redo};
return TRUE;
}
sub xdo_remove {
my $self = shift;
my $xdo = shift;
my $item = shift;
my @indices;
my $counter = 0;
if ($xdo eq 'undo') {
foreach my $do (@{$self->{_undo}}) {
push @indices, $counter if $item == $do->{'item'};
$counter++;
}
#delete from array
foreach my $index (@indices) {
splice(@{$self->{_undo}}, $index, 1);
}
} elsif ($xdo eq 'redo') {
foreach my $do (@{$self->{_redo}}) {
push @indices, $counter if $item == $do->{'item'};
$counter++;
}
#delete from array
foreach my $index (@indices) {
splice(@{$self->{_redo}}, $index, 1);
}
}
#disable undo/redo actions
$self->{_uimanager}->get_widget("/MenuBar/Edit/Undo")->set_sensitive(scalar @{$self->{_undo}}) if defined $self->{_undo};
$self->{_uimanager}->get_widget("/MenuBar/Edit/Redo")->set_sensitive(scalar @{$self->{_redo}}) if defined $self->{_redo};
$self->{_uimanager}->get_widget("/ToolBar/Undo")->set_sensitive(scalar @{$self->{_undo}}) if defined $self->{_undo};
$self->{_uimanager}->get_widget("/ToolBar/Redo")->set_sensitive(scalar @{$self->{_redo}}) if defined $self->{_redo};
return TRUE;
}
sub xdo {
my $self = shift;
my $xdo = shift;
my $source = shift;
my $block_reverse = shift;
my $do = undef;
if ($xdo eq 'undo') {
$do = pop @{$self->{_undo}};
} elsif ($xdo eq 'redo') {
$do = pop @{$self->{_redo}};
}
my $item = $do->{'item'};
my $action = $do->{'action'};
my $opt1 = $do->{'opt1'};
return FALSE unless $item;
return FALSE unless $action;
if ($item->isa('GooCanvas2::CanvasImage') && $item == $self->{_canvas_bg}) {
$opt1->{x} = $do->{'opt1'}->{x} * -1;
$opt1->{y} = $do->{'opt1'}->{y} * -1;
}
#create reverse action
my $reverse_action = 'modify';
if ($action eq 'raise') {
$reverse_action = 'lower_xdo';
} elsif ($action eq 'raise_xdo') {
$reverse_action = 'lower_xdo';
} elsif ($action eq 'lower') {
$reverse_action = 'raise_xdo';
} elsif ($action eq 'lower_xdo') {
$reverse_action = 'raise_xdo';
} elsif ($action eq 'create') {
$reverse_action = 'delete_xdo';
} elsif ($action eq 'delete') {
$reverse_action = 'create_xdo';
} elsif ($action eq 'create_xdo') {
$reverse_action = 'delete_xdo';
} elsif ($action eq 'delete_xdo') {
$reverse_action = 'create_xdo';
}
#undo or redo?
unless ($block_reverse) {
if ($xdo eq 'undo') {
#store to redo stack
$self->store_to_xdo_stack($item, $reverse_action, 'redo', $opt1, $source);
} elsif ($xdo eq 'redo') {
#store to undo stack
$self->store_to_xdo_stack($item, $reverse_action, 'undo', $opt1, $source);
}
}
#finally undo the last event
if ($action eq 'modify') {
if ($item->isa('GooCanvas2::CanvasRect') && $item != $self->{_canvas_bg_rect}) {
$self->{_items}{$item}->set(
'x' => $do->{'x'},
'y' => $do->{'y'},
'width' => $do->{'width'},
'height' => $do->{'height'},
);
if (exists $self->{_items}{$item}{ellipse}) {
$self->{_items}{$item}{ellipse}->set(
'fill-color-gdk-rgba' => $do->{'fill_color'},
'stroke-color-gdk-rgba' => $do->{'stroke_color'},
'line-width' => $do->{'line-width'},
);
#numbered ellipse
if (exists $self->{_items}{$item}{text}) {
$self->{_items}{$item}{text}->set(
'text' => $do->{'text'},
'fill-color-gdk-rgba' => $do->{'stroke_color'},
);
$self->{_items}{$item}{text}{digit} = $do->{'digit'};
}
#restore color and opacity as well
$self->{_items}{$item}{fill_color} = $do->{'fill_color'};
$self->{_items}{$item}{stroke_color} = $do->{'stroke_color'};
} elsif (exists $self->{_items}{$item}{text}) {
$self->{_items}{$item}{text}->set(
'text' => $do->{'text'},
'fill-color-gdk-rgba' => $do->{'stroke_color'},
);
#restore color and opacity as well
$self->{_items}{$item}{stroke_color} = $do->{'stroke_color'};
} elsif (exists $self->{_items}{$item}{pixelize}) {
$self->{_items}{$item}{pixelize}->set(
'x' => int $self->{_items}{$item}->get('x'),
'y' => int $self->{_items}{$item}->get('y'),
'width' => $self->{_items}{$item}->get('width'),
'height' => $self->{_items}{$item}->get('height'),
'pixbuf' => $self->get_pixelated_pixbuf_from_canvas($self->{_items}{$item}),
);
} elsif (exists $self->{_items}{$item}{image}) {
#~ print "xdo image\n";
my $copy = $self->{_lp}->load($self->{_items}{$item}{orig_pixbuf_filename}, $self->{_items}{$item}->get('width'), $self->{_items}{$item}->get('height'), FALSE, TRUE);
if ($copy) {
$self->{_items}{$item}{image}->set(
'x' => int $self->{_items}{$item}->get('x'),
'y' => int $self->{_items}{$item}->get('y'),
'width' => $self->{_items}{$item}->get('width'),
'height' => $self->{_items}{$item}->get('height'),
'pixbuf' => $copy
);
}
} elsif (exists $self->{_items}{$item}{line}) {
#save arrow specific properties
$self->{_items}{$item}{end_arrow} = $do->{'end-arrow'};
$self->{_items}{$item}{start_arrow} = $do->{'start-arrow'};
$self->{_items}{$item}{arrow_width} = $do->{'arrow-width'};
$self->{_items}{$item}{arrow_length} = $do->{'arrow-length'};
$self->{_items}{$item}{arrow_tip_length} = $do->{'arrow-tip-length'};
$self->{_items}{$item}{line}->set(
'fill-color-gdk-rgba' => $do->{'fill_color'},
'stroke-color-gdk-rgba' => $do->{'stroke_color'},
'line-width' => $do->{'line-width'},
'end-arrow' => $self->{_items}{$item}{end_arrow},
'start-arrow' => $self->{_items}{$item}{start_arrow},
'arrow-length' => $self->{_items}{$item}{arrow_length},
'arrow-width' => $self->{_items}{$item}{arrow_width},
'arrow-tip-length' => $self->{_items}{$item}{arrow_tip_length},
);
$self->{_items}{$item}{mirrored_w} = $do->{'mirrored_w'} if exists $do->{'mirrored_w'};
$self->{_items}{$item}{mirrored_h} = $do->{'mirrored_h'} if exists $do->{'mirrored_h'};
#restore color and opacity as well
$self->{_items}{$item}{stroke_color} = $do->{'stroke_color'};
} else {
$self->{_items}{$item}->set(
'fill-color-gdk-rgba' => $do->{'fill_color'},
'stroke-color-gdk-rgba' => $do->{'stroke_color'},
'line-width' => $do->{'line-width'},
);
#restore color and opacity as well
$self->{_items}{$item}{fill_color} = $do->{'fill_color'};
$self->{_items}{$item}{stroke_color} = $do->{'stroke_color'};
}
} elsif ($item->isa('GooCanvas2::CanvasImage') && $item == $self->{_canvas_bg}) {
#~ print "xdo canvas_bg\n";
my $new_w = $do->{'drawing_pixbuf'}->get_width;
my $new_h = $do->{'drawing_pixbuf'}->get_height;
#update canvas and show the new pixbuf
$self->{_canvas_bg}->set('pixbuf' => $do->{'drawing_pixbuf'});
#save new pixbuf in var
$self->{_drawing_pixbuf} = $do->{'drawing_pixbuf'}->copy;
#update bounds and bg_rects
$self->{_canvas_bg_rect}->set(
'x' => $do->{'x'},
'y' => $do->{'y'},
'width' => $do->{'width'},
'height' => $do->{'height'},
);
#we need to move the shapes
$self->move_all($opt1->{x}, $opt1->{y});
} elsif ($item->isa('GooCanvas2::CanvasRect') && $item == $self->{_canvas_bg_rect}) {
#~ print "xdo canvas_bg_rect\n";
$self->{_canvas_bg_rect}->set(
'x' => $do->{'x'},
'y' => $do->{'y'},
'width' => $do->{'width'},
'height' => $do->{'height'},
);
#polyline specific properties
} elsif ($item->isa('GooCanvas2::CanvasPolyline')) {
#if pattern exists
#e.g. censor tool does not have a pattern
if ($do->{'stroke-pattern'}) {
$self->{_items}{$item}->set(
'stroke-color-gdk-rgba' => $do->{'stroke_color'},
'line-width' => $do->{'line-width'},
'points' => $do->{'points'},
'transform' => $do->{'transform'},
);
$self->{_items}{$item}{stroke_color} = $do->{'stroke_color'};
} else {
$self->{_items}{$item}->set(
'line-width' => $do->{'line-width'},
'points' => $do->{'points'},
'transform' => $do->{'transform'},
);
}
}
#handle resize rectangles and embedded objects
if ($item == $self->{_canvas_bg}) {
$self->handle_bg_rects('update', $self->{_canvas_bg_rect});
} elsif ($item == $self->{_canvas_bg_rect}) {
$self->handle_bg_rects('update', $self->{_canvas_bg_rect});
} else {
$self->handle_rects('update', $self->{_items}{$item});
$self->handle_embedded('update', $self->{_items}{$item}, undef, undef, TRUE);
#apply item properties to widgets
#line width, fill color, stroke color etc.
$self->set_and_save_drawing_properties($self->{_current_item}, FALSE);
}
#adjust stack order
$self->{_canvas_bg}->lower;
$self->{_canvas_bg_rect}->lower;
$self->handle_bg_rects('raise');
} elsif ($action eq 'raise' || $action eq 'raise_xdo') {
my $child = $self->get_child_item($item);
if ($child) {
$self->handle_rects('lower', $item);
$child->lower;
$item->lower;
} else {
$self->handle_rects('lower', $item);
$item->lower;
}
$self->{_canvas_bg}->lower;
$self->{_canvas_bg_rect}->lower;
} elsif ($action eq 'lower' || $action eq 'lower_xdo') {
my $child = $self->get_child_item($item);
if ($child) {
$child->raise;
$item->raise;
$self->handle_rects('raise', $item);
} else {
$item->raise;
$self->handle_rects('raise', $item);
}
} elsif ($action eq 'delete' || $action eq 'delete_xdo') {
#mark as current
$self->{_current_item} = $item;
$self->{_current_new_item} = undef;
$self->{_items}{$item}->set('visibility' => 'visible');
$self->handle_rects('update', $self->{_items}{$item});
$self->handle_embedded('update', $self->{_items}{$item}, undef, undef, TRUE);
} elsif ($action eq 'create' || $action eq 'create_xdo') {
$self->{_items}{$item}->set('visibility' => 'hidden');
$self->handle_rects('hide', $self->{_items}{$item});
$self->handle_embedded('hide', $self->{_items}{$item});
}
#disable undo/redo actions
$self->{_uimanager}->get_widget("/MenuBar/Edit/Undo")->set_sensitive(scalar @{$self->{_undo}}) if defined $self->{_undo};
$self->{_uimanager}->get_widget("/MenuBar/Edit/Redo")->set_sensitive(scalar @{$self->{_redo}}) if defined $self->{_redo};
$self->{_uimanager}->get_widget("/ToolBar/Undo")->set_sensitive(scalar @{$self->{_undo}}) if defined $self->{_undo};
$self->{_uimanager}->get_widget("/ToolBar/Redo")->set_sensitive(scalar @{$self->{_redo}}) if defined $self->{_redo};
$self->deactivate_all;
return TRUE;
}
sub set_and_save_drawing_properties {
my $self = shift;
my $item = shift;
my $save_only = shift;
return FALSE unless $item;
#~ print "set_and_save_drawing_properties1\n";
#determine key for item hash
if (my $child = $self->get_child_item($item)) {
$item = $child;
}
my $parent = $self->get_parent_item($item);
my $key = $self->get_item_key($item, $parent);
return FALSE unless $key;
#~ print "set_and_save_drawing_properties2\n";
#we do not remember the properties for some tools
#and don't remember them when just selecting items with the cursor
if ( $self->{_items}{$key}{type} ne "highlighter"
&& $self->{_items}{$key}{type} ne "censor"
&& $self->{_items}{$key}{type} ne "image"
&& $self->{_items}{$key}{type} ne "pixelize"
&& $self->{_current_mode} != 10)
{
#remember drawing colors, line width and font settings
#maybe we have to restore them
$self->{_last_fill_color} = $self->{_fill_color_w}->get_rgba;
$self->{_last_stroke_color} = $self->{_stroke_color_w}->get_rgba;
$self->{_last_line_width} = $self->{_line_spin_w}->get_value;
$self->{_last_font} = $self->{_font_btn_w}->get_font_name;
#remember the last mode as well
$self->{_last_mode} = $self->{_current_mode};
}
return TRUE if $save_only;
#block 'value-change' handlers for widgets
#so we do not apply the changes twice
$self->{_line_spin_w}->signal_handler_block($self->{_line_spin_wh});
$self->{_stroke_color_w}->signal_handler_block($self->{_stroke_color_wh});
$self->{_fill_color_w}->signal_handler_block($self->{_fill_color_wh});
$self->{_font_btn_w}->signal_handler_block($self->{_font_btn_wh});
#~ print "set_and_save_drawing_properties3\n";
if ( $item->isa('GooCanvas2::CanvasRect')
|| $item->isa('GooCanvas2::CanvasEllipse')
|| $item->isa('GooCanvas2::CanvasPolyline'))
{
#line width
$self->{_line_spin_w}->set_value($item->get('line-width'));
#stroke color
#some items, e.g. censor tool, do not have a color - skip them
if ($self->{_items}{$key}{stroke_color}) {
#~ print $self->{_items}{$key}{stroke_color}->to_string, "\n";
$self->{_stroke_color_w}->set_rgba($self->{_items}{$key}{stroke_color});
}
if ($item->isa('GooCanvas2::CanvasRect') || $item->isa('GooCanvas2::CanvasEllipse')) {
#fill color
$self->{_fill_color_w}->set_rgba($self->{_items}{$key}{fill_color});
#numbered shapes
if (exists($self->{_items}{$key}{text})) {
#determine font description from string
my ($ret, $attr_list, $text_raw, $accel_char) = Pango::parse_markup($self->{_items}{$key}{text}->get('text'), -1, 0);
my $font_desc = Pango::FontDescription->new();
$attr_list->get_iterator->get_font($font_desc);
#apply current font settings to button
$self->{_font_btn_w}->set_font_name($font_desc ? $font_desc->to_string : $self->{_font});
}
}
} elsif ($item->isa('GooCanvas2::CanvasText')) {
#determine font description from string
my ($ret, $attr_list, $text_raw, $accel_char) = Pango::parse_markup($item->get('text'), -1, 0);
my $font_desc = Pango::FontDescription->new();
$attr_list->get_iterator->get_font($font_desc);
#font color
$self->{_stroke_color_w}->set_rgba($self->{_items}{$key}{stroke_color});
#apply current font settings to button
$self->{_font_btn_w}->set_font_name($font_desc ? $font_desc->to_string : $self->{_font});
}
#update global values
$self->{_line_width} = $self->{_line_spin_w}->get_value;
$self->{_stroke_color} = $self->{_stroke_color_w}->get_rgba;
$self->{_fill_color} = $self->{_fill_color_w}->get_rgba;
my $font_descr = Pango::FontDescription::from_string($self->{_font_btn_w}->get_font_name);
$self->{_font} = $self->{_font_btn_w}->get_font_name;
#unblock 'value-change' handlers for widgets
$self->{_line_spin_w}->signal_handler_unblock($self->{_line_spin_wh});
$self->{_stroke_color_w}->signal_handler_unblock($self->{_stroke_color_wh});
$self->{_fill_color_w}->signal_handler_unblock($self->{_fill_color_wh});
$self->{_font_btn_w}->signal_handler_unblock($self->{_font_btn_wh});
}
sub restore_fixed_properties {
my $self = shift;
my $mode = shift;
#~ print "restore_highlighter_properties\n";
#block 'value-change' handlers for widgets
#so we do not apply the changes twice
$self->{_line_spin_w}->signal_handler_block($self->{_line_spin_wh});
$self->{_stroke_color_w}->signal_handler_block($self->{_stroke_color_wh});
$self->{_fill_color_w}->signal_handler_block($self->{_fill_color_wh});
$self->{_font_btn_w}->signal_handler_block($self->{_font_btn_wh});
if ($mode eq "highlighter") {
#highlighter
my $fill_color = Gtk3::Gdk::RGBA::parse('#00000000ffff');
$fill_color->alpha(0.234683756771191);
$self->{_fill_color_w}->set_rgba($fill_color);
my $stroke_color = Gtk3::Gdk::RGBA::parse('#ffffffff0000');
$stroke_color->alpha(0.499992370489052);
$self->{_stroke_color_w}->set_rgba($stroke_color);
$self->{_line_spin_w}->set_value(18);
} elsif ($mode eq "censor") {
#censor
$self->{_line_spin_w}->set_value(14);
}
#update global values
$self->{_line_width} = $self->{_line_spin_w}->get_value;
$self->{_stroke_color} = $self->{_stroke_color_w}->get_rgba;
$self->{_fill_color} = $self->{_fill_color_w}->get_rgba;
#unblock 'value-change' handlers for widgets
$self->{_line_spin_w}->signal_handler_unblock($self->{_line_spin_wh});
$self->{_stroke_color_w}->signal_handler_unblock($self->{_stroke_color_wh});
$self->{_fill_color_w}->signal_handler_unblock($self->{_fill_color_wh});
$self->{_font_btn_w}->signal_handler_unblock($self->{_font_btn_wh});
}
sub restore_drawing_properties {
my $self = shift;
#saved properties available?
return FALSE unless defined $self->{_last_fill_color};
#anything done until now?
return FALSE unless defined $self->{_last_mode};
#~ print "restore_drawing_properties\n";
#block 'value-change' handlers for widgets
#so we do not apply the changes twice
$self->{_line_spin_w}->signal_handler_block($self->{_line_spin_wh});
$self->{_stroke_color_w}->signal_handler_block($self->{_stroke_color_wh});
$self->{_fill_color_w}->signal_handler_block($self->{_fill_color_wh});
$self->{_font_btn_w}->signal_handler_block($self->{_font_btn_wh});
#restore them
$self->{_fill_color_w}->set_rgba($self->{_last_fill_color});
$self->{_stroke_color_w}->set_rgba($self->{_last_stroke_color});
$self->{_line_spin_w}->set_value($self->{_last_line_width});
$self->{_font_btn_w}->set_font_name($self->{_last_font});
#update global values
$self->{_line_width} = $self->{_line_spin_w}->get_value;
$self->{_stroke_color} = $self->{_stroke_color_w}->get_rgba;
$self->{_fill_color} = $self->{_fill_color_w}->get_rgba;
my $font_descr = Pango::FontDescription::from_string($self->{_font_btn_w}->get_font_name);
$self->{_font} = $self->{_font_btn_w}->get_font_name;
#unblock 'value-change' handlers for widgets
$self->{_line_spin_w}->signal_handler_unblock($self->{_line_spin_wh});
$self->{_stroke_color_w}->signal_handler_unblock($self->{_stroke_color_wh});
$self->{_fill_color_w}->signal_handler_unblock($self->{_fill_color_wh});
$self->{_font_btn_w}->signal_handler_unblock($self->{_font_btn_wh});
}
sub event_item_on_key_press {
my ($self, $item, $target, $ev) = @_;
if ($self->{_current_item}) {
#current item
my $curr_item = $self->{_current_item};
if (exists $self->{_items}{$curr_item}) {
#construct an motion-notify event
my $mevent = Gtk3::Gdk::Event->new('motion-notify');
$mevent->state('button2-mask');
$mevent->time(Gtk3::get_current_event_time());
$mevent->window($self->{_drawing_window}->get_window);
#get current x, y values
my $old_x = $self->{_items}{$curr_item}->get('x');
my $old_y = $self->{_items}{$curr_item}->get('y');
#set item flags
$curr_item->{drag_x} = $old_x;
$curr_item->{drag_y} = $old_y;
$curr_item->{dragging} = TRUE;
$curr_item->{dragging_start} = TRUE;
#move with arrow keys
if ($ev->keyval == Gtk3::Gdk::keyval_from_name('Up')) {
#~ print $ev->keyval," $old_x,$old_y-up\n";
$mevent->x($old_x);
$mevent->y($old_y - 1);
} elsif ($ev->keyval == Gtk3::Gdk::keyval_from_name('Down')) {
#~ print $ev->keyval," $old_x,$old_y-down\n";
$mevent->x($old_x);
$mevent->y($old_y + 1);
} elsif ($ev->keyval == Gtk3::Gdk::keyval_from_name('Left')) {
#~ print $ev->keyval," $old_x,$old_y-left\n";
$mevent->x($old_x - 1);
$mevent->y($old_y);
} elsif ($ev->keyval == Gtk3::Gdk::keyval_from_name('Right')) {
#~ print $ev->keyval," $old_x,$old_y-right\n";
$mevent->x($old_x + 1);
$mevent->y($old_y);
} else {
return FALSE;
}
#finally call motion-notify handler
$self->event_item_on_motion_notify($curr_item, $target, $mevent);
}
}
return TRUE;
}
sub event_item_on_button_press {
my ($self, $item, $target, $ev, $select) = @_;
#~ print "button-press\n";
#canvas is busy now...
$self->{_busy} = TRUE;
my $cursor = Gtk3::Gdk::Cursor->new('left-ptr');
#activate item
#if it is not activated yet
# => single click
if ($ev->type eq 'button-press' && ($self->{_current_mode_descr} eq "select" || $select || $ev->button == 2 || $ev->button == 3)) {
#embedded item?
my $parent = $self->get_parent_item($item);
$item = $parent if $parent;
#real shape
if (exists $self->{_items}{$item}) {
unless (defined $self->{_current_item} && $item == $self->{_current_item}) {
unless ($self->{_current_mode_descr} eq "number" || $self->{_current_mode_descr} eq "text") {
unless ($self->{_items}{$item}{locked}) {
#deactivate last item
my $last_item = $self->{_current_item};
if (defined $last_item) {
#~ print "deactivated item: $last_item\n";
$self->{_canvas}->pointer_ungrab($last_item, $ev->time);
$self->{_canvas}->keyboard_ungrab($last_item, $ev->time);
$self->handle_rects('hide', $last_item);
}
#mark as active item
$self->{_current_item} = $item;
$self->{_current_new_item} = undef;
$self->handle_rects('update', $self->{_current_item});
#apply item properties to widgets
#line width, fill color, stroke color etc.
$self->set_and_save_drawing_properties($self->{_current_item}, FALSE);
#~ print "activated item: $item\n";
} else {
$self->deactivate_all;
#~ print "deactivate because $item is locked\n";
}
} else {
$self->deactivate_all($self->{_current_item});
#~ print "deactivate because $item is text or number\n";
}
} else {
#~ print "no activate because $item is already current item\n";
}
#no item selected, deactivate all items
} elsif ($item == $self->{_canvas_bg_rect}) {
$self->deactivate_all;
#~ print "deactivate because $item is background rectangle\n";
} else {
#~ print "no activate because $item does not exist\n";
}
} else {
#~ print "no activate action\n";
}
#left mouse click to drag, resize, create or delelte items
if ($ev->type eq 'button-press' && ($ev->button == 1 || $ev->button == 2)) {
#MOVE
if ($self->{_current_mode_descr} eq "select" || $ev->button == 2) {
#don't_move the bounding rectangle or the bg_image
return TRUE if $item == $self->{_canvas_bg_rect};
#don't move locked item
return TRUE if (exists $self->{_items}{$item} && $self->{_items}{$item}{locked});
if ($item->isa('GooCanvas2::CanvasRect')) {
#real shape => move
if (exists $self->{_items}{$item}) {
$item->{drag_x} = $ev->x;
$item->{drag_y} = $ev->y;
$item->{dragging} = TRUE;
$item->{dragging_start} = TRUE;
$cursor = Gtk3::Gdk::Cursor->new('fleur');
#resizing shape => resize
} else {
$item->{res_x} = $ev->x;
$item->{res_y} = $ev->y;
$item->{resizing} = TRUE;
$cursor = undef;
#resizing the canvas_bg_rect
if ( $self->{_canvas_bg_rect}{'right-side'} == $item
|| $self->{_canvas_bg_rect}{'bottom-side'} == $item
|| $self->{_canvas_bg_rect}{'bottom-right-corner'} == $item)
{
#add to undo stack
$self->store_to_xdo_stack($self->{_canvas_bg_rect}, 'modify', 'undo');
#other resizing rectangles
} else {
#add to undo stack
$self->store_to_xdo_stack($self->{_current_item}, 'modify', 'undo');
}
#restore style pattern
$item->set('fill-color-gdk-rgba' => $self->{_style_bg});
}
#no rectangle, e.g. polyline
} else {
#no rect, just move it ...
$item->{drag_x} = $ev->x;
$item->{drag_y} = $ev->y;
$item->{dragging} = TRUE;
$item->{dragging_start} = TRUE;
#add to undo stack
#~ $self->store_to_xdo_stack($self->{_current_item} , 'modify', 'undo');
$cursor = undef;
}
#~ print "grab keyboard and pointer focus for $item\n";
#grab keyboard and pointer focus
eval {
$self->{_canvas}->pointer_grab($item, ['pointer-motion-mask', 'button-release-mask'], $cursor, $ev->time);
};
if ($@) {
# workaround for https://gitlab.gnome.org/GNOME/goocanvas/-/merge_requests/8
$self->{_canvas}->pointer_grab($item, ['pointer-motion-mask', 'button-release-mask'], Gtk3::Gdk::Cursor->new('left-ptr'), $ev->time);
}
$self->{_canvas}->grab_focus($item);
#current mode not equal 'select' and no polyline
} elsif ($ev->button == 1) {
#resizing shape => resize (no real shape)
#no polyline modes
if ( $item->isa('GooCanvas2::CanvasRect')
&& !exists $self->{_items}{$item}
&& $item != $self->{_canvas_bg_rect}
&& $self->{_current_mode_descr} ne "freehand"
&& $self->{_current_mode_descr} ne "highlighter"
&& $self->{_current_mode_descr} ne "censor")
{
$item->{res_x} = $ev->x;
$item->{res_y} = $ev->y;
$item->{resizing} = TRUE;
$cursor = undef;
#resizing the canvas_bg_rect
if ( $self->{_canvas_bg_rect}{'right-side'} == $item
|| $self->{_canvas_bg_rect}{'bottom-side'} == $item
|| $self->{_canvas_bg_rect}{'bottom-right-corner'} == $item)
{
#add to undo stack
$self->store_to_xdo_stack($self->{_canvas_bg_rect}, 'modify', 'undo');
#other resizing rectangles
} else {
#add to undo stack
$self->store_to_xdo_stack($self->{_current_item}, 'modify', 'undo');
}
#restore style pattern
$item->set('fill-color-gdk-rgba' => $self->{_style_bg});
#~ print "grab keyboard and pointer focus for $item\n";
#grab keyboard and pointer focus
eval {
$self->{_canvas}->pointer_grab($item, ['pointer-motion-mask', 'button-release-mask'], $cursor, $ev->time);
};
if ($@) {
# workaround for https://gitlab.gnome.org/GNOME/goocanvas/-/merge_requests/8
$self->{_canvas}->pointer_grab($item, ['pointer-motion-mask', 'button-release-mask'], Gtk3::Gdk::Cursor->new('left-ptr'), $ev->time);
}
$self->{_canvas}->grab_focus($item);
#create new item
} else {
#freehand
if ($self->{_current_mode_descr} eq "freehand") {
$self->deactivate_all;
$self->create_polyline($ev, undef, FALSE);
#highlighter
} elsif ($self->{_current_mode_descr} eq "highlighter") {
$self->deactivate_all;
$self->create_polyline($ev, undef, TRUE);
#Line
} elsif ($self->{_current_mode_descr} eq "line") {
$self->create_line($ev, undef);
#Arrow
} elsif ($self->{_current_mode_descr} eq "arrow") {
$self->create_line($ev, undef, TRUE, FALSE);
#Censor
} elsif ($self->{_current_mode_descr} eq "censor") {
$self->deactivate_all;
$self->create_censor($ev, undef);
#Number
} elsif ($self->{_current_mode_descr} eq "number") {
$self->create_ellipse($ev, undef, TRUE);
#RECTANGLES
} elsif ($self->{_current_mode_descr} eq "rect") {
$self->create_rectangle($ev, undef);
#ELLIPSE
} elsif ($self->{_current_mode_descr} eq "ellipse") {
$self->create_ellipse($ev, undef);
#TEXT
} elsif ($self->{_current_mode_descr} eq "text") {
$self->create_text($ev, undef);
#IMAGE
} elsif ($self->{_current_mode_descr} eq "image") {
$self->create_image($ev, undef);
#PIXELIZE
} elsif ($self->{_current_mode_descr} eq "pixelize") {
$self->create_pixel_image($ev, undef);
}
#grab keyboard focus
if (my $nitem = $self->{_current_new_item}) {
#~ print "grab keyboard focus for new item $nitem\n";
$self->{_canvas}->grab_focus($nitem);
}
}
}
#right click => show context menu, double-click => show properties directly
} elsif ($ev->type eq '2button-press' || $ev->button == 3) {
$self->{_canvas}->pointer_ungrab($item, $ev->time);
$self->{_canvas}->keyboard_ungrab($item, $ev->time);
#determine key for item hash
if (my $child = $self->get_child_item($item)) {
$item = $child;
}
my $parent = $self->get_parent_item($item);
my $key = $self->get_item_key($item, $parent);
#real shape
if (defined $key && exists $self->{_items}{$key}) {
if ( $ev->type eq '2button-press'
&& $ev->button == 1
&& $self->{_current_mode_descr} ne "text"
&& $self->{_current_mode_descr} ne "number"
&& $self->{_current_mode_descr} ne "freehand"
&& $self->{_current_mode_descr} ne "highlighter"
&& $self->{_current_mode_descr} ne "censor")
{
#some items do not have properties, e.g. images or censor
return FALSE if $item->isa('GooCanvas2::CanvasImage') || !exists($self->{_items}{$key}{stroke_color});
#~ print $item, $parent, $key, "\n";
$self->show_item_properties($item, $parent, $key);
} elsif ($ev->type eq 'button-press' && $ev->button == 3) {
my $item_menu = $self->ret_item_menu($item, $parent, $key);
$item_menu->popup(
undef, # parent menu shell
undef, # parent menu item
undef, # menu pos func
undef, # data
$ev->button,
$ev->time
);
}
} else {
#background rectangle
if ($item == $self->{_canvas_bg_rect}) {
my $bg_menu = $self->ret_background_menu($item);
$bg_menu->popup(
undef, # parent menu shell
undef, # parent menu item
undef, # menu pos func
undef, # data
$ev->button,
$ev->time
);
}
}
#canvas idle now
$self->{_busy} = FALSE;
}
return TRUE;
}
sub ret_background_menu {
my $self = shift;
my $item = shift;
my $menu_bg = Gtk3::Menu->new;
#properties
my $prop_item = Gtk3::ImageMenuItem->new($self->{_d}->get("Change Background Color..."));
$prop_item->set_image(Gtk3::Image->new_from_stock('gtk-select-color', 'menu'));
$prop_item->signal_connect(
'activate' => sub {
my $color_dialog = Gtk3::ColorChooserDialog->new($self->{_d}->get("Choose fill color"));
#add reset button
my $reset_btn = Gtk3::Button->new_with_mnemonic($self->{_d}->get("_Reset to Default"));
$color_dialog->add_action_widget($reset_btn, 'reject');
$color_dialog->set_rgba($self->{_canvas_bg_rect}{fill_color});
$color_dialog->show_all;
#run dialog
my $response = 'reject';
while ($response eq 'reject') {
$response = $color_dialog->run;
if ($response eq 'ok') {
#apply new color
$self->{_canvas_bg_rect}{fill_color} = $color_dialog->get_rgba;
$self->{_canvas_bg_rect}{fill_color}->alpha(1);
$self->{_canvas_bg_rect}->set('fill-color-gdk-rgba', $self->{_canvas_bg_rect}{fill_color});
last;
} elsif ($response eq 'reject') {
$color_dialog->set_rgba(Gtk3::Gdk::RGBA::parse('gray'));
} else {
last;
}
}
$color_dialog->destroy;
});
$menu_bg->append($prop_item);
$menu_bg->show_all;
return $menu_bg;
}
sub ret_item_menu {
my $self = shift;
my $item = shift;
my $parent = shift;
my $key = shift;
#~ print "ret_item_menu\n";
my $menu_item = Gtk3::Menu->new;
#raise
my $raise_item = Gtk3::ImageMenuItem->new($self->{_d}->get("Raise"));
$raise_item->set_image(Gtk3::Image->new_from_pixbuf(Gtk3::Gdk::Pixbuf->new_from_file_at_size($self->{_dicons} . '/draw-raise.png', Gtk3::IconSize->lookup('menu'))));
$raise_item->signal_connect(
'activate' => sub {
if ($parent) {
#add to undo stack
$self->store_to_xdo_stack($parent, 'raise', 'undo');
$parent->raise;
$item->raise;
$self->handle_rects('raise', $parent);
} else {
#add to undo stack
$self->store_to_xdo_stack($item, 'raise', 'undo');
$item->raise;
$self->handle_rects('raise', $item);
}
});
$menu_item->append($raise_item);
#lower
my $lower_item = Gtk3::ImageMenuItem->new($self->{_d}->get("Lower"));
$lower_item->set_image(Gtk3::Image->new_from_pixbuf(Gtk3::Gdk::Pixbuf->new_from_file_at_size($self->{_dicons} . '/draw-lower.png', Gtk3::IconSize->lookup('menu'))));
$lower_item->signal_connect(
'activate' => sub {
if ($parent) {
#add to undo stack
$self->store_to_xdo_stack($parent, 'lower', 'undo');
$self->handle_rects('lower', $parent);
$item->lower;
$parent->lower;
} else {
#add to undo stack
$self->store_to_xdo_stack($item, 'lower', 'undo');
$self->handle_rects('lower', $item);
$item->lower;
}
$self->{_canvas_bg}->lower;
$self->{_canvas_bg_rect}->lower;
});
$menu_item->append($lower_item);
$menu_item->append(Gtk3::SeparatorMenuItem->new);
#copy item
my $copy_item = Gtk3::ImageMenuItem->new_from_stock('gtk-copy');
$copy_item->signal_connect(
'activate' => sub {
#clear clipboard
$self->{_clipboard}->set_text("");
$self->{_cut} = FALSE;
$self->{_current_copy_item} = $self->{_current_item};
});
$menu_item->append($copy_item);
#cut item
my $cut_item = Gtk3::ImageMenuItem->new_from_stock('gtk-cut');
$cut_item->signal_connect(
'activate' => sub {
#clear clipboard
$self->{_clipboard}->set_text("");
$self->{_cut} = TRUE;
$self->{_current_copy_item} = $self->{_current_item};
$self->clear_item_from_canvas($self->{_current_copy_item});
});
$menu_item->append($cut_item);
#paste item
my $paste_item = Gtk3::ImageMenuItem->new_from_stock('gtk-paste');
$paste_item->signal_connect(
'activate' => sub {
$self->paste_item($self->{_current_copy_item}, $self->{_cut});
$self->{_cut} = FALSE;
});
$menu_item->append($paste_item);
#delete item
my $remove_item = Gtk3::ImageMenuItem->new_from_stock('gtk-delete');
$remove_item->signal_connect(
'activate' => sub {
$self->clear_item_from_canvas($item);
});
$menu_item->append($remove_item);
$menu_item->append(Gtk3::SeparatorMenuItem->new);
#add lock/unlock entry if item == background image
if ($item == $self->{_canvas_bg}) {
my $lock_item = undef;
if (exists $self->{_items}{$key} && $self->{_items}{$key}{locked} == TRUE) {
$lock_item = Gtk3::ImageMenuItem->new_with_label($self->{_d}->get("Unlock"));
$lock_item->set_image(Gtk3::Image->new_from_pixbuf(Gtk3::Gdk::Pixbuf->new_from_file_at_size($self->{_dicons} . '/draw-unlocked.png', Gtk3::IconSize->lookup('menu'))));
} elsif (exists $self->{_items}{$key} && $self->{_items}{$key}{locked} == FALSE) {
$lock_item = Gtk3::ImageMenuItem->new_with_label($self->{_d}->get("Lock"));
$lock_item->set_image(Gtk3::Image->new_from_pixbuf(Gtk3::Gdk::Pixbuf->new_from_file_at_size($self->{_dicons} . '/draw-locked.png', Gtk3::IconSize->lookup('menu'))));
}
#handler
$lock_item->signal_connect(
'activate' => sub {
if (exists $self->{_items}{$key} && $self->{_items}{$key}{locked} == FALSE) {
$self->{_items}{$key}{locked} = TRUE;
$self->deactivate_all;
} elsif (exists $self->{_items}{$key} && $self->{_items}{$key}{locked} == TRUE) {
$self->{_items}{$key}{locked} = FALSE;
}
});
$menu_item->append($lock_item);
$menu_item->append(Gtk3::SeparatorMenuItem->new);
}
#properties
my $prop_item = Gtk3::ImageMenuItem->new($self->{_d}->get("Edit Preferences..."));
$prop_item->set_image(Gtk3::Image->new_from_stock('gtk-properties', 'menu'));
#some items do not have properties, e.g. images or censor
$prop_item->set_sensitive(FALSE) if $item->isa('GooCanvas2::CanvasImage') || !exists($self->{_items}{$key}{stroke_color});
$prop_item->signal_connect(
'activate' => sub {
$self->show_item_properties($item, $parent, $key);
});
$menu_item->append($prop_item);
$menu_item->show_all;
return $menu_item;
}
sub get_item_key {
my ($self, $item, $parent) = @_;
if (exists $self->{_items}{$item}) {
return $item;
} else {
return $parent;
}
}
sub show_item_properties {
my ($self, $item, $parent, $key) = @_;
#~ print "show_item_properties\n";
#create dialog
my $prop_dialog = Gtk3::Dialog->new(
$self->{_d}->get("Preferences"),
$self->{_drawing_window},
[qw/modal destroy-with-parent/],
'gtk-cancel' => 'cancel',
'gtk-ok' => 'ok'
);
$prop_dialog->set_default_response('ok');
#RECT OR ELLIPSE OR POLYLINE
my $line_spin = undef;
my $fill_color = undef;
my $stroke_color = undef;
#NUMBERED ELLIPSE
my $number_spin = undef;
#ARROW
my $end_arrow = undef;
my $start_arrow = undef;
my $arrow_spin = undef;
my $arrowl_spin = undef;
my $arrowt_spin = undef;
#TEXT
my $font_btn;
my $text;
my $textview;
my $font_color;
#RECT OR ELLIPSE OR NUMBER OR POLYLINE
#GENERAL SETTINGS
if ( $item->isa('GooCanvas2::CanvasRect')
|| $item->isa('GooCanvas2::CanvasEllipse')
|| $item->isa('GooCanvas2::CanvasPolyline')
|| ($item->isa('GooCanvas2::CanvasText') && defined $self->{_items}{$key}{ellipse}))
{
my $general_vbox = Gtk3::VBox->new(FALSE, 5);
my $label_general = Gtk3::Label->new;
$label_general->set_markup("<b>" . $self->{_d}->get("Main") . "</b>");
my $frame_general = Gtk3::Frame->new();
$frame_general->set_label_widget($label_general);
$frame_general->set_shadow_type('none');
$frame_general->set_border_width(5);
$prop_dialog->get_child->add($frame_general);
#line_width
my $line_hbox = Gtk3::HBox->new(FALSE, 5);
$line_hbox->set_border_width(5);
my $linew_label = Gtk3::Label->new($self->{_d}->get("Line width") . ":");
$line_spin = Gtk3::SpinButton->new_with_range(0.5, 20, 0.1);
$line_spin->set_value($item->get('line-width'));
$line_hbox->pack_start($linew_label, FALSE, TRUE, 12);
$line_hbox->pack_start($line_spin, TRUE, TRUE, 0);
$general_vbox->pack_start($line_hbox, FALSE, FALSE, 0);
if ($item->isa('GooCanvas2::CanvasRect') || $item->isa('GooCanvas2::CanvasEllipse')) {
#fill color
my $fill_color_hbox = Gtk3::HBox->new(FALSE, 5);
$fill_color_hbox->set_border_width(5);
my $fill_color_label = Gtk3::Label->new($self->{_d}->get("Fill color") . ":");
$fill_color = Gtk3::ColorButton->new();
$fill_color->set_rgba($self->{_items}{$key}{fill_color});
$fill_color->set_use_alpha(TRUE);
$fill_color->set_title($self->{_d}->get("Choose fill color"));
$fill_color_hbox->pack_start($fill_color_label, FALSE, TRUE, 12);
$fill_color_hbox->pack_start($fill_color, TRUE, TRUE, 0);
$general_vbox->pack_start($fill_color_hbox, FALSE, FALSE, 0);
}
#some items, e.g. censor tool, do not have a color - skip them
if ($self->{_items}{$key}{stroke_color}) {
#stroke color
my $stroke_color_hbox = Gtk3::HBox->new(FALSE, 5);
$stroke_color_hbox->set_border_width(5);
my $stroke_color_label = Gtk3::Label->new($self->{_d}->get("Stroke color") . ":");
$stroke_color = Gtk3::ColorButton->new();
$stroke_color->set_rgba($self->{_items}{$key}{stroke_color});
$stroke_color->set_use_alpha(TRUE);
$stroke_color->set_title($self->{_d}->get("Choose stroke color"));
$stroke_color_hbox->pack_start($stroke_color_label, FALSE, TRUE, 12);
$stroke_color_hbox->pack_start($stroke_color, TRUE, TRUE, 0);
$general_vbox->pack_start($stroke_color_hbox, FALSE, FALSE, 0);
}
$frame_general->add($general_vbox);
#special shapes like numbered ellipse
if (defined $self->{_items}{$key}{text}) {
my $numbered_vbox = Gtk3::VBox->new(FALSE, 5);
my $label_numbered = Gtk3::Label->new;
$label_numbered->set_markup("<b>" . $self->{_d}->get("Numbering") . "</b>");
my $frame_numbered = Gtk3::Frame->new();
$frame_numbered->set_label_widget($label_numbered);
$frame_numbered->set_shadow_type('none');
$frame_numbered->set_border_width(5);
$prop_dialog->get_child->add($frame_numbered);
#current digit
my $number_hbox = Gtk3::HBox->new(FALSE, 5);
$number_hbox->set_border_width(5);
my $numberw_label = Gtk3::Label->new($self->{_d}->get("Current value") . ":");
$number_spin = Gtk3::SpinButton->new_with_range(0, 999, 1);
$number_spin->set_value($self->{_items}{$key}{text}{digit});
$number_hbox->pack_start($numberw_label, FALSE, TRUE, 12);
$number_hbox->pack_start($number_spin, TRUE, TRUE, 0);
$numbered_vbox->pack_start($number_hbox, FALSE, FALSE, 0);
#font button
my $font_hbox = Gtk3::HBox->new(FALSE, 5);
$font_hbox->set_border_width(5);
my $font_label = Gtk3::Label->new($self->{_d}->get("Font") . ":");
$font_btn = Gtk3::FontButton->new();
#determine font description from string
my ($ret, $attr_list, $text_raw, $accel_char) = Pango::parse_markup($self->{_items}{$key}{text}->get('text'), -1, 0);
my $font_desc = Pango::FontDescription->new();
$attr_list->get_iterator->get_font($font_desc);
#apply current font settings to button
$font_btn->set_font_name($font_desc ? $font_desc->to_string : $self->{_font});
$font_hbox->pack_start($font_label, FALSE, TRUE, 12);
$font_hbox->pack_start($font_btn, TRUE, TRUE, 0);
$numbered_vbox->pack_start($font_hbox, FALSE, FALSE, 0);
$frame_numbered->add($numbered_vbox);
}
}
#ARROW item
if ( $item->isa('GooCanvas2::CanvasPolyline')
&& defined $self->{_items}{$key}{end_arrow}
&& defined $self->{_items}{$key}{start_arrow})
{
my $arrow_vbox = Gtk3::VBox->new(FALSE, 5);
my $label_arrow = Gtk3::Label->new;
$label_arrow->set_markup("<b>" . $self->{_d}->get("Arrow") . "</b>");
my $frame_arrow = Gtk3::Frame->new();
$frame_arrow->set_label_widget($label_arrow);
$frame_arrow->set_shadow_type('none');
$frame_arrow->set_border_width(5);
$prop_dialog->get_child->add($frame_arrow);
#arrow_width
my $arrow_hbox = Gtk3::HBox->new(FALSE, 5);
$arrow_hbox->set_border_width(5);
my $arroww_label = Gtk3::Label->new($self->{_d}->get("Width") . ":");
$arrow_spin = Gtk3::SpinButton->new_with_range(0.5, 10, 0.1);
$arrow_spin->set_value($item->get('arrow-width'));
$arrow_hbox->pack_start($arroww_label, FALSE, TRUE, 12);
$arrow_hbox->pack_start($arrow_spin, TRUE, TRUE, 0);
$arrow_vbox->pack_start($arrow_hbox, FALSE, FALSE, 0);
#arrow_length
my $arrowl_hbox = Gtk3::HBox->new(FALSE, 5);
$arrowl_hbox->set_border_width(5);
my $arrowl_label = Gtk3::Label->new($self->{_d}->get("Length") . ":");
$arrowl_spin = Gtk3::SpinButton->new_with_range(0.5, 10, 0.1);
$arrowl_spin->set_value($item->get('arrow-length'));
$arrowl_hbox->pack_start($arrowl_label, FALSE, TRUE, 12);
$arrowl_hbox->pack_start($arrowl_spin, TRUE, TRUE, 0);
$arrow_vbox->pack_start($arrowl_hbox, FALSE, FALSE, 0);
#arrow_tip_length
my $arrowt_hbox = Gtk3::HBox->new(FALSE, 5);
$arrowt_hbox->set_border_width(5);
my $arrowt_label = Gtk3::Label->new($self->{_d}->get("Tip length") . ":");
$arrowt_spin = Gtk3::SpinButton->new_with_range(0.5, 10, 0.1);
$arrowt_spin->set_value($item->get('arrow-tip-length'));
$arrowt_hbox->pack_start($arrowt_label, FALSE, TRUE, 12);
$arrowt_hbox->pack_start($arrowt_spin, TRUE, TRUE, 0);
$arrow_vbox->pack_start($arrowt_hbox, FALSE, FALSE, 0);
#checkboxes for start and end arrows
$end_arrow = Gtk3::CheckButton->new($self->{_d}->get("Display an arrow at the end of the line"));
$end_arrow->set_active($self->{_items}{$key}{end_arrow});
$start_arrow = Gtk3::CheckButton->new($self->{_d}->get("Display an arrow at the start of the line"));
$start_arrow->set_active($self->{_items}{$key}{start_arrow});
my $end_arrow_hbox = Gtk3::HBox->new(FALSE, 5);
$end_arrow_hbox->set_border_width(5);
my $start_arrow_hbox = Gtk3::HBox->new(FALSE, 5);
$start_arrow_hbox->set_border_width(5);
$end_arrow_hbox->pack_start($end_arrow, FALSE, TRUE, 12);
$start_arrow_hbox->pack_start($start_arrow, FALSE, TRUE, 12);
$arrow_vbox->pack_start($start_arrow_hbox, FALSE, FALSE, 0);
$arrow_vbox->pack_start($end_arrow_hbox, FALSE, FALSE, 0);
#final packing
$frame_arrow->add($arrow_vbox);
#simple TEXT item (no numbered ellipse)
} elsif ($item->isa('GooCanvas2::CanvasText')
&& !defined $self->{_items}{$key}{ellipse})
{
my $text_vbox = Gtk3::VBox->new(FALSE, 5);
my $label_text = Gtk3::Label->new;
$label_text->set_markup("<b>" . $self->{_d}->get("Text") . "</b>");
my $frame_text = Gtk3::Frame->new();
$frame_text->set_label_widget($label_text);
$frame_text->set_shadow_type('none');
$frame_text->set_border_width(5);
$prop_dialog->get_child->add($frame_text);
#font button
my $font_hbox = Gtk3::HBox->new(FALSE, 5);
$font_hbox->set_border_width(5);
my $font_label = Gtk3::Label->new($self->{_d}->get("Font") . ":");
$font_btn = Gtk3::FontButton->new();
#determine font description from string
my ($ret, $attr_list, $text_raw, $accel_char) = Pango::parse_markup($item->get('text'), -1, 0);
my ($font_desc) = Pango::FontDescription::from_string($self->{_font});
$font_hbox->pack_start($font_label, FALSE, TRUE, 12);
$font_hbox->pack_start($font_btn, TRUE, TRUE, 0);
$text_vbox->pack_start($font_hbox, FALSE, FALSE, 0);
#font color
my $font_color_hbox = Gtk3::HBox->new(FALSE, 5);
$font_color_hbox->set_border_width(5);
my $font_color_label = Gtk3::Label->new($self->{_d}->get("Font color") . ":");
$font_color = Gtk3::ColorButton->new();
$font_color->set_use_alpha(TRUE);
$font_color->set_rgba($self->{_items}{$key}{stroke_color});
$font_color->set_title($self->{_d}->get("Choose font color"));
$font_color_hbox->pack_start($font_color_label, FALSE, TRUE, 12);
$font_color_hbox->pack_start($font_color, TRUE, TRUE, 0);
$text_vbox->pack_start($font_color_hbox, FALSE, FALSE, 0);
#initial buffer
my $text = Gtk3::TextBuffer->new;
$text->set_text($text_raw);
#textview
my $textview_hbox = Gtk3::HBox->new(FALSE, 5);
$textview_hbox->set_border_width(5);
$textview = Gtk3::TextView->new_with_buffer($text);
$textview->set_can_focus(TRUE);
$textview->set_size_request(150, 200);
$textview_hbox->pack_start($textview, TRUE, TRUE, 0);
$text_vbox->pack_start($textview_hbox, TRUE, TRUE, 0);
#use font checkbox
my $use_font = Gtk3::CheckButton->new_with_label($self->{_d}->get("Use selected font"));
$use_font->set_active(FALSE);
$text_vbox->pack_start($use_font, TRUE, TRUE, 0);
#use font color checkbox
my $use_font_color = Gtk3::CheckButton->new_with_label($self->{_d}->get("Use selected font color"));
$use_font_color->set_active(FALSE);
$text_vbox->pack_start($use_font_color, TRUE, TRUE, 0);
#apply changes directly
$use_font->signal_connect(
'toggled' => sub {
$self->modify_text_in_properties($font_btn, $textview, $font_color, $item, $use_font, $use_font_color);
});
$use_font_color->signal_connect(
'toggled' => sub {
$self->modify_text_in_properties($font_btn, $textview, $font_color, $item, $use_font, $use_font_color);
});
$font_btn->signal_connect(
'font-set' => sub {
$self->modify_text_in_properties($font_btn, $textview, $font_color, $item, $use_font, $use_font_color);
});
$font_color->signal_connect(
'color-set' => sub {
$self->modify_text_in_properties($font_btn, $textview, $font_color, $item, $use_font, $use_font_color);
});
#apply current font settings to button
$font_btn->set_font_name($font_desc ? $font_desc->to_string : $self->{_font});
#FIXME >> why do we have to invoke this manually??
$font_btn->signal_emit('font-set');
$frame_text->add($text_vbox);
}
#instant changes
my $store_count = 0;
if (defined $line_spin) {
$line_spin->signal_connect(
'value-changed' => sub {
$self->apply_properties(
$item, $parent, $key, $fill_color, $stroke_color, $line_spin, $font_color, $font_btn,
$textview, $end_arrow, $start_arrow, $arrow_spin, $arrowl_spin, $arrowt_spin, $number_spin, $store_count
);
$store_count++;
});
}
if (defined $fill_color) {
$fill_color->signal_connect(
'color-set' => sub {
$self->apply_properties(
$item, $parent, $key, $fill_color, $stroke_color, $line_spin, $font_color, $font_btn,
$textview, $end_arrow, $start_arrow, $arrow_spin, $arrowl_spin, $arrowt_spin, $number_spin, $store_count
);
$store_count++;
});
}
if (defined $stroke_color) {
$stroke_color->signal_connect(
'color-set' => sub {
$self->apply_properties(
$item, $parent, $key, $fill_color, $stroke_color, $line_spin, $font_color, $font_btn,
$textview, $end_arrow, $start_arrow, $arrow_spin, $arrowl_spin, $arrowt_spin, $number_spin, $store_count
);
$store_count++;
});
}
if (defined $number_spin) {
$number_spin->signal_connect(
'value-changed' => sub {
$self->apply_properties(
$item, $parent, $key, $fill_color, $stroke_color, $line_spin, $font_color, $font_btn,
$textview, $end_arrow, $start_arrow, $arrow_spin, $arrowl_spin, $arrowt_spin, $number_spin, $store_count
);
$store_count++;
});
}
if (defined $end_arrow) {
$end_arrow->signal_connect(
'toggled' => sub {
$self->apply_properties(
$item, $parent, $key, $fill_color, $stroke_color, $line_spin, $font_color, $font_btn,
$textview, $end_arrow, $start_arrow, $arrow_spin, $arrowl_spin, $arrowt_spin, $number_spin, $store_count
);
$store_count++;
});
}
if (defined $start_arrow) {
$start_arrow->signal_connect(
'toggled' => sub {
$self->apply_properties(
$item, $parent, $key, $fill_color, $stroke_color, $line_spin, $font_color, $font_btn,
$textview, $end_arrow, $start_arrow, $arrow_spin, $arrowl_spin, $arrowt_spin, $number_spin, $store_count
);
$store_count++;
});
}
if (defined $arrow_spin) {
$arrow_spin->signal_connect(
'value-changed' => sub {
$self->apply_properties(
$item, $parent, $key, $fill_color, $stroke_color, $line_spin, $font_color, $font_btn,
$textview, $end_arrow, $start_arrow, $arrow_spin, $arrowl_spin, $arrowt_spin, $number_spin, $store_count
);
$store_count++;
});
}
if (defined $arrowl_spin) {
$arrowl_spin->signal_connect(
'value-changed' => sub {
$self->apply_properties(
$item, $parent, $key, $fill_color, $stroke_color, $line_spin, $font_color, $font_btn,
$textview, $end_arrow, $start_arrow, $arrow_spin, $arrowl_spin, $arrowt_spin, $number_spin, $store_count
);
$store_count++;
});
}
if (defined $arrowt_spin) {
$arrowt_spin->signal_connect(
'value-changed' => sub {
$self->apply_properties(
$item, $parent, $key, $fill_color, $stroke_color, $line_spin, $font_color, $font_btn,
$textview, $end_arrow, $start_arrow, $arrow_spin, $arrowl_spin, $arrowt_spin, $number_spin, $store_count
);
$store_count++;
});
}
if (defined $font_btn) {
$font_btn->signal_connect(
'font-set' => sub {
$self->apply_properties(
$item, $parent, $key, $fill_color, $stroke_color, $line_spin, $font_color, $font_btn,
$textview, $end_arrow, $start_arrow, $arrow_spin, $arrowl_spin, $arrowt_spin, $number_spin, $store_count
);
$store_count++;
});
}
if (defined $font_color) {
$font_color->signal_connect(
'color-set' => sub {
$self->apply_properties(
$item, $parent, $key, $fill_color, $stroke_color, $line_spin, $font_color, $font_btn,
$textview, $end_arrow, $start_arrow, $arrow_spin, $arrowl_spin, $arrowt_spin, $number_spin, $store_count
);
$store_count++;
});
}
if (defined $textview) {
$textview->signal_connect(
'key-release-event' => sub {
$self->apply_properties(
$item, $parent, $key, $fill_color, $stroke_color, $line_spin, $font_color, $font_btn,
$textview, $end_arrow, $start_arrow, $arrow_spin, $arrowl_spin, $arrowt_spin, $number_spin, $store_count
);
$store_count++;
});
}
#layout adjustments
my $sg_prop = Gtk3::SizeGroup->new('horizontal');
foreach ($prop_dialog->get_children->get_children) {
if ($_->can('get_children')) {
foreach ($_->get_children) {
if ($_->can('get_children')) {
foreach ($_->get_children) {
if ($_->can('get_children')) {
foreach ($_->get_children) {
if ($_ =~ /Gtk3::Label/) {
#~ print $_->get_text, "\n";
$_->set_alignment(0, 0.5);
$sg_prop->add_widget($_);
}
}
}
}
}
}
}
}
#run dialog
$prop_dialog->show_all;
#textview grab focus to be able to edit
#immediately
if (defined $textview) {
$textview->grab_focus;
}
my $prop_dialog_res = $prop_dialog->run;
if ($prop_dialog_res eq 'ok') {
$self->apply_properties(
$item, $parent, $key, $fill_color, $stroke_color, $line_spin, $font_color, $font_btn,
$textview, $end_arrow, $start_arrow, $arrow_spin, $arrowl_spin, $arrowt_spin, $number_spin, $store_count
);
#apply item properties to widgets
#line width, fill color, stroke color etc.
$self->set_and_save_drawing_properties($self->{_current_item}, FALSE);
#FIXME - we need to save the changed values in this case
$self->set_and_save_drawing_properties($self->{_current_item}, TRUE);
$prop_dialog->destroy;
return TRUE;
} else {
if ($store_count) {
$self->xdo('undo', undef, TRUE);
}
$prop_dialog->destroy;
return FALSE;
}
}
sub apply_properties {
my (
$self,
#item related infos
$item,
$parent,
$key,
#general properties
$fill_color,
$stroke_color,
$line_spin,
#only text
$font_color,
$font_btn,
$textview,
#only arrow
$end_arrow,
$start_arrow,
$arrow_spin,
$arrowl_spin,
$arrowt_spin,
#only numbered shapes
$number_spin,
#DO NOT STORE THE CHANGES (UNDO/REDO)
$dont_store
) = @_;
#~ print "apply_properties\n";
#remember drawing colors, line width and font settings
#maybe we have to restore them
if ( $self->{_items}{$key}{type} ne "highlighter"
&& $self->{_items}{$key}{type} ne "censor")
{
$self->{_last_fill_color} = $self->{_fill_color_w}->get_rgba;
$self->{_last_stroke_color} = $self->{_stroke_color_w}->get_rgba;
$self->{_last_line_width} = $self->{_line_spin_w}->get_value;
$self->{_last_font} = $self->{_font_btn_w}->get_font_name;
#remember the last mode as well
$self->{_last_mode} = $self->{_current_mode};
}
#add to undo stack
unless ($dont_store) {
$self->store_to_xdo_stack($self->{_current_item}, 'modify', 'undo');
}
#apply rect or ellipse options
if ($item->isa('GooCanvas2::CanvasRect') || $item->isa('GooCanvas2::CanvasEllipse')) {
$item->set(
'line-width' => $line_spin->get_value,
'fill-color-gdk-rgba' => $fill_color->get_rgba,
'stroke-color-gdk-rgba' => $stroke_color->get_rgba,
);
#special shapes like numbered ellipse (digit changed)
if (defined $self->{_items}{$key}{text}) {
#determine new or current digit
my $digit = undef;
if (defined $number_spin) {
$digit = $number_spin->get_value;
} else {
$digit = $self->{_items}{$key}{text}{digit};
}
my $fill_color = undef;
if (defined $font_color) {
$fill_color = $font_color->get_rgba;
} elsif (defined $stroke_color) {
$fill_color = $stroke_color->get_rgba;
}
my $font_descr = Pango::FontDescription::from_string($font_btn->get_font_name);
$self->{_items}{$key}{text}->set(
'text' => "<span font_desc=' " . $font_btn->get_font_name . " ' >" . $digit . "</span>",
'fill-color-gdk-rgba' => $fill_color,
);
#adjust parent rectangle
my $tb = $self->{_items}{$key}{text}->get_bounds;
#keep ratio = 1
my $qs = abs($tb->x1 - $tb->x2);
$qs = abs($tb->y1 - $tb->y2) if abs($tb->y1 - $tb->y2) > abs($tb->x1 - $tb->x2);
#add line width of parent ellipse
$qs += $self->{_items}{$key}{ellipse}->get('line-width') + 5;
$parent->set(
'width' => $qs,
'height' => $qs,
);
#save digit in hash as well (only item properties dialog)
if (defined $number_spin) {
$self->{_items}{$key}{text}{digit} = $digit;
}
$self->handle_rects('update', $parent);
$self->handle_embedded('update', $parent);
}
#save color and opacity as well
$self->{_items}{$key}{fill_color} = $fill_color->get_rgba;
$self->{_items}{$key}{stroke_color} = $stroke_color->get_rgba;
}
#apply polyline options (arrow)
if ( $item->isa('GooCanvas2::CanvasPolyline')
&& defined $self->{_items}{$key}{end_arrow}
&& defined $self->{_items}{$key}{start_arrow})
{
#these values are only available in the item menu
if ( defined $arrowl_spin
&& defined $arrow_spin
&& defined $arrowt_spin
&& defined $end_arrow
&& defined $start_arrow)
{
$item->set(
'line-width' => $line_spin->get_value,
'stroke-color-gdk-rgba' => $stroke_color->get_rgba,
'end-arrow' => $end_arrow->get_active,
'start-arrow' => $start_arrow->get_active,
'arrow-length' => $arrowl_spin->get_value,
'arrow-width' => $arrow_spin->get_value,
'arrow-tip-length' => $arrowt_spin->get_value,
);
} else {
$item->set(
'line-width' => $line_spin->get_value,
'stroke-color-gdk-rgba' => $stroke_color->get_rgba,
'end-arrow' => $self->{_items}{$key}{line}->get('end-arrow'),
'start-arrow' => $self->{_items}{$key}{line}->get('start-arrow'),
);
}
#save color and opacity as well
$self->{_items}{$key}{stroke_color} = $stroke_color->get_rgba;
#save arrow specific properties
$self->{_items}{$key}{end_arrow} = $self->{_items}{$key}{line}->get('end-arrow');
$self->{_items}{$key}{start_arrow} = $self->{_items}{$key}{line}->get('start-arrow');
$self->{_items}{$key}{arrow_width} = $self->{_items}{$key}{line}->get('arrow-width');
$self->{_items}{$key}{arrow_length} = $self->{_items}{$key}{line}->get('arrow-length');
$self->{_items}{$key}{arrow_tip_length} = $self->{_items}{$key}{line}->get('arrow-tip-length');
#apply polyline options (freehand, highlighter)
} elsif ($item->isa('GooCanvas2::CanvasPolyline')
&& defined $self->{_items}{$key}{stroke_color})
{
$item->set(
'line-width' => $line_spin->get_value,
'stroke-color-gdk-rgba' => $stroke_color->get_rgba,
);
#save color and opacity as well
$self->{_items}{$key}{stroke_color} = $stroke_color->get_rgba;
}
#apply text options
if ($item->isa('GooCanvas2::CanvasText')) {
my $font_descr = Pango::FontDescription::from_string($font_btn->get_font_name);
my $new_text = undef;
if ($textview) {
$new_text = $textview->get_buffer->get_text($textview->get_buffer->get_start_iter, $textview->get_buffer->get_end_iter, FALSE)
|| " ";
} else {
#determine font description and text from string
my ($ret, $attr_list, $text_raw, $accel_char) = Pango::parse_markup($item->get('text'), -1, 0);
$new_text = $text_raw;
}
$item->set(
'text' => "<span font_desc=' " . $font_btn->get_font_name . " ' >" . Glib::Markup::escape_text($new_text) . "</span>",
'width' => -1,
'use-markup' => TRUE,
'fill-color-gdk-rgba' => $font_color->get_rgba,
);
#adjust parent rectangle
my $tb = $item->get_bounds;
$parent->set(
'width' => abs($tb->x1 - $tb->x2),
'height' => abs($tb->y1 - $tb->y2),
);
$self->handle_rects('update', $parent);
$self->handle_embedded('update', $parent);
#save color and opacity as well
$self->{_items}{$key}{stroke_color} = $font_color->get_rgba;
}
}
sub modify_text_in_properties {
my $self = shift;
my $font_btn = shift;
my $textview = shift;
my $font_color = shift;
my $item = shift;
my $use_font = shift;
my $use_font_color = shift;
my $font_descr = Pango::FontDescription::from_string($font_btn->get_font_name);
my $texttag = Gtk3::TextTag->new;
if ($use_font->get_active && $use_font_color->get_active) {
$texttag->set('font-desc' => $font_descr, 'foreground-rgba' => $font_color->get_rgba);
} elsif ($use_font->get_active) {
$texttag->set('font-desc' => $font_descr);
} elsif ($use_font_color->get_active) {
$texttag->set('foreground-rgba' => $font_color->get_rgba);
}
my $texttagtable = Gtk3::TextTagTable->new;
$texttagtable->add($texttag);
my $text = Gtk3::TextBuffer->new($texttagtable);
$text->signal_connect(
'changed' => sub {
$text->apply_tag($texttag, $text->get_start_iter, $text->get_end_iter);
});
$text->set_text($textview->get_buffer->get_text($textview->get_buffer->get_start_iter, $textview->get_buffer->get_end_iter, FALSE));
$text->apply_tag($texttag, $text->get_start_iter, $text->get_end_iter);
$textview->set_buffer($text);
return TRUE;
}
sub move_all {
my ($self, $x, $y) = @_;
foreach (keys %{$self->{_items}}) {
my $item = $self->{_items}{$_};
#embedded item?
my $parent = $self->get_parent_item($item);
$item = $parent if $parent;
#real shape
if (exists $self->{_items}{$item}) {
if ($item->isa('GooCanvas2::CanvasRect')) {
$item->set(
'x' => $item->get('x') - $x,
'y' => $item->get('y') - $y,
);
my $child = $self->get_child_item($item);
$child = $item unless $child;
#it item is hidden, keep the status
if ($child->get('visibility') eq 'hidden') {
$self->handle_rects('hide', $item);
$self->handle_embedded('hide', $item);
} else {
$self->handle_rects('update', $item);
#pixelizer is treated differently
if ($child && $child->isa('GooCanvas2::CanvasImage')) {
my $parent = $self->get_parent_item($child);
if (exists $self->{_items}{$parent}{pixelize}) {
Glib::Idle->add(
sub {
$self->{_items}{$parent}{pixelize}->set(
'x' => int $self->{_items}{$parent}->get('x'),
'y' => int $self->{_items}{$parent}->get('y'),
'width' => $self->{_items}{$parent}->get('width'),
'height' => $self->{_items}{$parent}->get('height'),
'pixbuf' => $self->get_pixelated_pixbuf_from_canvas($self->{_items}{$parent}),
);
$self->handle_embedded('update', $parent, undef, undef, TRUE);
#deactivate all after move
$self->deactivate_all;
return FALSE;
});
} else {
$self->handle_embedded('update', $item);
}
} else {
$self->handle_embedded('update', $item);
}
}
#freehand line for example
} else {
$item->translate(-$x, -$y);
}
}
}
#deactivate all after move
$self->deactivate_all;
return TRUE;
}
sub deactivate_all {
my $self = shift;
my $exclude = shift || 0;
#~ print "deactivate_all\n";
foreach (keys %{$self->{_items}}) {
my $item = $self->{_items}{$_};
next if $item == $exclude;
#embedded item?
my $parent = $self->get_parent_item($item);
$item = $parent if $parent;
#real shape
if (exists $self->{_items}{$item}) {
$self->handle_rects('hide', $item);
}
}
$self->{_current_item} = undef;
$self->{_current_new_item} = undef;
return TRUE;
}
sub handle_embedded {
my ($self, $action, $item, $new_width, $new_height, $force_show) = @_;
return FALSE unless ($item && exists $self->{_items}{$item});
if ($action eq 'update') {
my $visibility = 'visible';
#embedded ellipse
if (exists $self->{_items}{$item}{ellipse}) {
$self->{_items}{$item}{ellipse}->set(
'center-x' => $self->{_items}{$item}->get('x') + $self->{_items}{$item}->get('width') / 2,
'center-y' => $self->{_items}{$item}->get('y') + $self->{_items}{$item}->get('height') / 2,
);
$self->{_items}{$item}{ellipse}->set(
'radius-x' => $self->{_items}{$item}->get('x') + $self->{_items}{$item}->get('width') - $self->{_items}{$item}{ellipse}->get('center-x'),
'radius-y' => $item->get('y') + $self->{_items}{$item}->get('height') - $self->{_items}{$item}{ellipse}->get('center-y'),
'visibility' => $visibility,
);
#numbered ellipse
if (exists $self->{_items}{$item}{text}) {
$self->{_items}{$item}{text}->set(
'x' => $self->{_items}{$item}{ellipse}->get('center-x'),
'y' => $self->{_items}{$item}{ellipse}->get('center-y'),
'visibility' => $visibility,
);
}
} elsif (exists $self->{_items}{$item}{text}) {
$self->{_items}{$item}{text}->set(
'x' => $self->{_items}{$item}->get('x'),
'y' => $self->{_items}{$item}->get('y'),
'width' => $self->{_items}{$item}->get('width'),
'visibility' => $visibility,
);
} elsif (exists $self->{_items}{$item}{line}) {
#handle possible arrows properly
#arrow is always and end-arrow
if ($self->{_items}{$item}{mirrored_w} < 0 && $self->{_items}{$item}{mirrored_h} < 0) {
$self->{_items}{$item}{line}->set(
'points' => Shutter::Draw::Utils::points_to_canvas_points(
$self->{_items}{$item}->get('x') + $self->{_items}{$item}->get('width'), $self->{_items}{$item}->get('y') + $self->{_items}{$item}->get('height'),
$self->{_items}{$item}->get('x'), $self->{_items}{$item}->get('y')
),
'visibility' => $visibility
);
} elsif ($self->{_items}{$item}{mirrored_w} < 0) {
$self->{_items}{$item}{line}->set(
'points' => Shutter::Draw::Utils::points_to_canvas_points(
$self->{_items}{$item}->get('x') + $self->{_items}{$item}->get('width'), $self->{_items}{$item}->get('y'),
$self->{_items}{$item}->get('x'), $self->{_items}{$item}->get('y') + $self->{_items}{$item}->get('height')
),
'visibility' => $visibility
);
} elsif ($self->{_items}{$item}{mirrored_h} < 0) {
$self->{_items}{$item}{line}->set(
'points' => Shutter::Draw::Utils::points_to_canvas_points(
$self->{_items}{$item}->get('x'), $self->{_items}{$item}->get('y') + $self->{_items}{$item}->get('height'),
$self->{_items}{$item}->get('x') + $self->{_items}{$item}->get('width'), $self->{_items}{$item}->get('y')
),
'visibility' => $visibility
);
} else {
$self->{_items}{$item}{line}->set(
'points' => Shutter::Draw::Utils::points_to_canvas_points(
$self->{_items}{$item}->get('x'), $self->{_items}{$item}->get('y'),
$self->{_items}{$item}->get('x') + $self->{_items}{$item}->get('width'), $self->{_items}{$item}->get('y') + $self->{_items}{$item}->get('height')
),
'visibility' => $visibility
);
}
} elsif (exists $self->{_items}{$item}{pixelize}) {
if ($force_show) {
$self->{_items}{$item}{pixelize}->set('visibility' => $visibility,);
} else {
$self->{_items}{$item}{pixelize}->set('visibility' => 'hidden',);
}
} elsif (exists $self->{_items}{$item}{image}) {
if ($self->{_items}{$item}->get('width') == $self->{_items}{$item}{image}->get('width') && $self->{_items}{$item}->get('height') == $self->{_items}{$item}{image}->get('height')) {
$self->{_items}{$item}{image}->set(
'x' => int $self->{_items}{$item}->get('x'),
'y' => int $self->{_items}{$item}->get('y'),
'visibility' => $visibility,
);
} else {
#be careful when resizing images
#don't do anything when width or height are too small
if ($self->{_items}{$item}->get('width') > 5 && $self->{_items}{$item}->get('height') > 5) {
$self->{_items}{$item}{image}->set(
'x' => int $self->{_items}{$item}->get('x'),
'y' => int $self->{_items}{$item}->get('y'),
'width' => $self->{_items}{$item}->get('width'),
'height' => $self->{_items}{$item}->get('height'),
'pixbuf' => $self->{_items}{$item}{orig_pixbuf}->scale_simple($self->{_items}{$item}->get('width'), $self->{_items}{$item}->get('height'), 'nearest'),
'visibility' => $visibility,
);
} else {
$self->{_items}{$item}{image}->set(
'x' => int $self->{_items}{$item}->get('x'),
'y' => int $self->{_items}{$item}->get('y'),
'width' => $self->{_items}{$item}->get('width'),
'height' => $self->{_items}{$item}->get('height'),
'visibility' => $visibility,
);
}
}
}
} elsif ($action eq 'delete') {
#ellipse
if (exists $self->{_items}{$item}{ellipse}) {
if (my $nint = $self->{_canvas}->get_root_item->find_child($self->{_items}{$item}{ellipse})) {
$self->{_canvas}->get_root_item->remove_child($nint);
}
}
#text
if (exists $self->{_items}{$item}{text}) {
if (my $nint = $self->{_canvas}->get_root_item->find_child($self->{_items}{$item}{text})) {
$self->{_canvas}->get_root_item->remove_child($nint);
}
}
#pixelize
if (exists $self->{_items}{$item}{pixelize}) {
if (my $nint = $self->{_canvas}->get_root_item->find_child($self->{_items}{$item}{pixelize})) {
$self->{_canvas}->get_root_item->remove_child($nint);
}
}
#image
if (exists $self->{_items}{$item}{image}) {
if (my $nint = $self->{_canvas}->get_root_item->find_child($self->{_items}{$item}{image})) {
$self->{_canvas}->get_root_item->remove_child($nint);
}
}
#line
if (exists $self->{_items}{$item}{line}) {
if (my $nint = $self->{_canvas}->get_root_item->find_child($self->{_items}{$item}{line})) {
$self->{_canvas}->get_root_item->remove_child($nint);
}
}
} elsif ($action eq 'hide') {
my $visibility = 'hidden';
#ellipse => hide rectangle as well
if (exists $self->{_items}{$item}{ellipse}) {
$self->{_items}{$item}{ellipse}->set('visibility' => $visibility);
}
#text => hide rectangle as well
if (exists $self->{_items}{$item}{text}) {
$self->{_items}{$item}{text}->set('visibility' => $visibility);
}
#pixelize => hide rectangle as well
if (exists $self->{_items}{$item}{pixelize}) {
$self->{_items}{$item}{pixelize}->set('visibility' => $visibility);
}
#image => hide rectangle as well
if (exists $self->{_items}{$item}{image}) {
$self->{_items}{$item}{image}->set('visibility' => $visibility);
}
#line => hide rectangle as well
if (exists $self->{_items}{$item}{line}) {
$self->{_items}{$item}{line}->set('visibility' => $visibility);
}
} elsif ($action eq 'mirror') {
if (exists $self->{_items}{$item}{line}) {
#width
if ($new_width < 0 && $self->{_items}{$item}{mirrored_w} >= 0) {
$self->{_items}{$item}{mirrored_w} = $new_width;
} elsif ($new_width < 0 && $self->{_items}{$item}{mirrored_w} < 0) {
$self->{_items}{$item}{mirrored_w} = 0;
}
#height
if ($new_height < 0 && $self->{_items}{$item}{mirrored_h} >= 0) {
$self->{_items}{$item}{mirrored_h} = $new_height;
} elsif ($new_height < 0 && $self->{_items}{$item}{mirrored_h} < 0) {
$self->{_items}{$item}{mirrored_h} = 0;
}
}
}
return TRUE;
}
sub handle_bg_rects {
my ($self, $action) = @_;
my $x = $self->{_canvas_bg_rect}->get('x');
my $y = $self->{_canvas_bg_rect}->get('y');
my $width = $self->{_canvas_bg_rect}->get('width');
my $height = $self->{_canvas_bg_rect}->get('height');
my $middle_h = $x + $width / 2;
my $middle_v = $y + $height / 2;
my $bottom = $y + $height;
my $top = $y;
my $left = $x;
my $right = $x + $width;
if ($action eq 'create') {
$self->{_canvas_bg_rect}{'bottom-side'} = GooCanvas2::CanvasRect->new(
parent=>$self->{_canvas}->get_root_item, x=>$middle_h, y=>$bottom, width=>8, height=>8,
'fill-color-gdk-rgba' => $self->{_style_bg},
'line-width' => 1,
);
$self->{_canvas_bg_rect}{'bottom-right-corner'} = GooCanvas2::CanvasRect->new(
parent=>$self->{_canvas}->get_root_item, x=>$right, y=>$bottom, width=>8, height=>8,
'fill-color-gdk-rgba' => $self->{_style_bg},
'line-width' => 1,
);
$self->{_canvas_bg_rect}{'right-side'} = GooCanvas2::CanvasRect->new(
parent=>$self->{_canvas}->get_root_item, x=>$right, y=>$middle_v, width=>8, height=>8,
'fill-color-gdk-rgba' => $self->{_style_bg},
'line-width' => 1,
);
$self->setup_item_signals($self->{_canvas_bg_rect}{'bottom-side'});
$self->setup_item_signals($self->{_canvas_bg_rect}{'bottom-right-corner'});
$self->setup_item_signals($self->{_canvas_bg_rect}{'right-side'});
$self->setup_item_signals_extra($self->{_canvas_bg_rect}{'bottom-side'});
$self->setup_item_signals_extra($self->{_canvas_bg_rect}{'bottom-right-corner'});
$self->setup_item_signals_extra($self->{_canvas_bg_rect}{'right-side'});
} elsif ($action eq 'hide' || $action eq 'show') {
my $visibility = undef;
if ($action eq 'hide') {
$visibility = 'hidden';
} elsif ($action eq 'show') {
$visibility = 'visible';
}
foreach (keys %{$self->{_canvas_bg_rect}}) {
if ($self->{_canvas_bg_rect}{$_}->can('set')) {
$self->{_canvas_bg_rect}{$_}->set('visibility' => $visibility,);
}
} #end determine rect
} elsif ($action eq 'update') {
#update the canvas bounds as well
$self->{_canvas}->set_bounds(0, 0, $self->{_canvas_bg_rect}->get('width'), $self->{_canvas_bg_rect}->get('height'));
$self->{_canvas_bg_rect}{'bottom-side'}->set(
'x' => $middle_h - 8,
'y' => $bottom - 8,
);
$self->{_canvas_bg_rect}{'bottom-right-corner'}->set(
'x' => $right - 8,
'y' => $bottom - 8,
);
$self->{_canvas_bg_rect}{'right-side'}->set(
'x' => $right - 8,
'y' => $middle_v - 8,
);
$self->handle_bg_rects('raise');
} elsif ($action eq 'raise') {
$self->{_canvas_bg_rect}{'bottom-side'}->raise;
$self->{_canvas_bg_rect}{'bottom-right-corner'}->raise;
$self->{_canvas_bg_rect}{'right-side'}->raise;
}
}
sub handle_rects {
my ($self, $action, $item) = @_;
#~ print "entering handle_rects1\n";
return FALSE unless $item;
return FALSE unless exists $self->{_items}{$item};
#~ print "entering handle_rects2\n";
#get root item
my $root = $self->{_canvas}->get_root_item;
if ($self->{_items}{$item}->isa('GooCanvas2::CanvasRect')) {
my $x = $self->{_items}{$item}->get('x');
my $y = $self->{_items}{$item}->get('y');
my $width = $self->{_items}{$item}->get('width');
my $height = $self->{_items}{$item}->get('height');
my $middle_h = $x + $width / 2;
my $middle_v = $y + $height / 2;
my $bottom = $y + $height;
my $top = $y;
my $left = $x;
my $right = $x + $width;
if ($action eq 'create') {
$self->{_items}{$item}{'top-side'} = GooCanvas2::CanvasRect->new(
parent=>$root, x=>$middle_h, y=>$top, width=>8, height=>8,
'fill-color-gdk-rgba' => $self->{_style_bg},
'visibility' => 'hidden',
'line-width' => 0.5,
);
$self->{_items}{$item}{'top-left-corner'} = GooCanvas2::CanvasRect->new(
parent=>$root, x=>$left, y=>$top, width=>8, height=>8,
'fill-color-gdk-rgba' => $self->{_style_bg},
'visibility' => 'hidden',
'line-width' => 0.5,
'radius-x' => 8,
'radius-y' => 8,
);
$self->{_items}{$item}{'top-right-corner'} = GooCanvas2::CanvasRect->new(
parent=>$root, x=>$right, y=>$top, width=>8, height=>8,
'fill-color-gdk-rgba' => $self->{_style_bg},
'visibility' => 'hidden',
'line-width' => 0.5,
'radius-x' => 8,
'radius-y' => 8,
);
$self->{_items}{$item}{'bottom-side'} = GooCanvas2::CanvasRect->new(
parent=>$root, x=>$middle_h, y=>$bottom, width=>8, height=>8,
'fill-color-gdk-rgba' => $self->{_style_bg},
'visibility' => 'hidden',
'line-width' => 0.5,
);
$self->{_items}{$item}{'bottom-left-corner'} = GooCanvas2::CanvasRect->new(
parent=>$root, x=>$left, y=>$bottom, width=>8, height=>8,
'fill-color-gdk-rgba' => $self->{_style_bg},
'visibility' => 'hidden',
'line-width' => 0.5,
'radius-x' => 8,
'radius-y' => 8,
);
$self->{_items}{$item}{'bottom-right-corner'} = GooCanvas2::CanvasRect->new(
parent=>$root, x=>$right, y=>$bottom, width=>8, height=>8,
'fill-color-gdk-rgba' => $self->{_style_bg},
'visibility' => 'hidden',
'line-width' => 0.5,
'radius-x' => 8,
'radius-y' => 8,
);
$self->{_items}{$item}{'left-side'} = GooCanvas2::CanvasRect->new(
parent=>$root, x=>$left - 8, y=>$middle_v, width=>8, height=>8,
'fill-color-gdk-rgba' => $self->{_style_bg},
'visibility' => 'hidden',
'line-width' => 0.5,
);
$self->{_items}{$item}{'right-side'} = GooCanvas2::CanvasRect->new(
parent=>$root, x=>$right, y=>$middle_v, width=>8, height=>8,
'fill-color-gdk-rgba' => $self->{_style_bg},
'visibility' => 'hidden',
'line-width' => 0.5,
);
$self->setup_item_signals($self->{_items}{$item}{'top-side'});
$self->setup_item_signals($self->{_items}{$item}{'top-left-corner'});
$self->setup_item_signals($self->{_items}{$item}{'top-right-corner'});
$self->setup_item_signals($self->{_items}{$item}{'bottom-side'});
$self->setup_item_signals($self->{_items}{$item}{'bottom-left-corner'});
$self->setup_item_signals($self->{_items}{$item}{'bottom-right-corner'});
$self->setup_item_signals($self->{_items}{$item}{'left-side'});
$self->setup_item_signals($self->{_items}{$item}{'right-side'});
$self->setup_item_signals_extra($self->{_items}{$item}{'top-side'});
$self->setup_item_signals_extra($self->{_items}{$item}{'top-left-corner'});
$self->setup_item_signals_extra($self->{_items}{$item}{'top-right-corner'});
$self->setup_item_signals_extra($self->{_items}{$item}{'bottom-side'});
$self->setup_item_signals_extra($self->{_items}{$item}{'bottom-left-corner'});
$self->setup_item_signals_extra($self->{_items}{$item}{'bottom-right-corner'});
$self->setup_item_signals_extra($self->{_items}{$item}{'left-side'});
$self->setup_item_signals_extra($self->{_items}{$item}{'right-side'});
} elsif ($action eq 'delete') {
if (my $nint = $self->{_canvas}->get_root_item->find_child($self->{_items}{$item}{'top-side'})) {
$self->{_canvas}->get_root_item->remove_child($nint);
}
if (my $nint = $self->{_canvas}->get_root_item->find_child($self->{_items}{$item}{'top-left-corner'})) {
$self->{_canvas}->get_root_item->remove_child($nint);
}
if (my $nint = $self->{_canvas}->get_root_item->find_child($self->{_items}{$item}{'top-right-corner'})) {
$self->{_canvas}->get_root_item->remove_child($nint);
}
if (my $nint = $self->{_canvas}->get_root_item->find_child($self->{_items}{$item}{'bottom-side'})) {
$self->{_canvas}->get_root_item->remove_child($nint);
}
if (my $nint = $self->{_canvas}->get_root_item->find_child($self->{_items}{$item}{'bottom-left-corner'})) {
$self->{_canvas}->get_root_item->remove_child($nint);
}
if (my $nint = $self->{_canvas}->get_root_item->find_child($self->{_items}{$item}{'bottom-right-corner'})) {
$self->{_canvas}->get_root_item->remove_child($nint);
}
if (my $nint = $self->{_canvas}->get_root_item->find_child($self->{_items}{$item}{'left-side'})) {
$self->{_canvas}->get_root_item->remove_child($nint);
}
if (my $nint = $self->{_canvas}->get_root_item->find_child($self->{_items}{$item}{'right-side'})) {
$self->{_canvas}->get_root_item->remove_child($nint);
}
} elsif ($action eq 'update' || $action eq 'hide') {
my $visibility = 'visible';
$visibility = 'hidden' if $action eq 'hide';
my $lw = $item->get('line-width');
#ellipse => hide rectangle as well
if (exists $self->{_items}{$item}{ellipse}) {
$self->{_items}{$item}->set('visibility' => $visibility);
}
#text => hide rectangle as well
if (exists $self->{_items}{$item}{text}) {
$self->{_items}{$item}->set('visibility' => $visibility);
}
#pixelize => hide rectangle as well
if (exists $self->{_items}{$item}{pixelize}) {
$self->{_items}{$item}->set('visibility' => $visibility);
}
#image => hide rectangle as well
if (exists $self->{_items}{$item}{image}) {
$self->{_items}{$item}->set('visibility' => $visibility);
}
#line => hide rectangle as well
if (exists $self->{_items}{$item}{line}) {
$self->{_items}{$item}->set('visibility' => $visibility);
}
#just to make sure the update routines are not
#called in wrong order
#we test the first value, if this is ok
#we believe all other resize rects are ok as well
return FALSE unless defined $self->{_items}{$item}{'top-side'};
$self->{_items}{$item}{'top-side'}->set(
'x' => $middle_h - 4,
'y' => $top - 8,
'visibility' => $visibility,
);
$self->{_items}{$item}{'top-left-corner'}->set(
'x' => $left - 8,
'y' => $top - 8,
'visibility' => $visibility,
);
$self->{_items}{$item}{'top-right-corner'}->set(
'x' => $right,
'y' => $top - 8,
'visibility' => $visibility,
);
$self->{_items}{$item}{'bottom-side'}->set(
'x' => $middle_h - 4,
'y' => $bottom,
'visibility' => $visibility,
);
$self->{_items}{$item}{'bottom-left-corner'}->set(
'x' => $left - 8,
'y' => $bottom,
'visibility' => $visibility,
);
$self->{_items}{$item}{'bottom-right-corner'}->set(
'x' => $right,
'y' => $bottom,
'visibility' => $visibility,
);
$self->{_items}{$item}{'left-side'}->set(
'x' => $left - 8,
'y' => $middle_v - 4,
'visibility' => $visibility,
);
$self->{_items}{$item}{'right-side'}->set(
'x' => $right,
'y' => $middle_v - 4,
'visibility' => $visibility,
);
#~ $self->handle_bg_rects('raise');
} elsif ($action eq 'raise') {
$self->{_items}{$item}{'top-side'}->raise;
$self->{_items}{$item}{'top-left-corner'}->raise;
$self->{_items}{$item}{'top-right-corner'}->raise;
$self->{_items}{$item}{'bottom-side'}->raise;
$self->{_items}{$item}{'bottom-left-corner'}->raise;
$self->{_items}{$item}{'bottom-right-corner'}->raise;
$self->{_items}{$item}{'left-side'}->raise;
$self->{_items}{$item}{'right-side'}->raise;
} elsif ($action eq 'lower') {
$self->{_items}{$item}{'top-side'}->lower;
$self->{_items}{$item}{'top-left-corner'}->lower;
$self->{_items}{$item}{'top-right-corner'}->lower;
$self->{_items}{$item}{'bottom-side'}->lower;
$self->{_items}{$item}{'bottom-left-corner'}->lower;
$self->{_items}{$item}{'bottom-right-corner'}->lower;
$self->{_items}{$item}{'left-side'}->lower;
$self->{_items}{$item}{'right-side'}->lower;
}
}
return TRUE;
}
sub event_item_on_button_release {
my ($self, $item, $target, $ev) = @_;
$self->{_canvas}->pointer_ungrab($item, $ev->time);
$self->{_canvas}->keyboard_ungrab($item, $ev->time);
#canvas is idle now...
$self->{_busy} = FALSE;
#we handle some minimum sizes here if the new items are too small
#maybe the user just wanted to place an rect or an object on the canvas
#and clicked on it without describing an rectangular area
my $nitem = $self->{_current_new_item};
if ($nitem) {
#apply item properties to widgets
#line width, fill color, stroke color etc.
$self->set_and_save_drawing_properties($nitem, FALSE);
#flag if item has to be deleted directly
my $deleted = FALSE;
#set minimum sizes
if ($nitem->isa('GooCanvas2::CanvasRect')) {
#real shape
if (exists $self->{_items}{$nitem}) {
#images
if (exists $self->{_items}{$nitem}{image}) {
$self->{_items}{$nitem}->set(
'x' => $ev->x - int($self->{_items}{$nitem}{orig_pixbuf}->get_width / 2),
'y' => $ev->y - int($self->{_items}{$nitem}{orig_pixbuf}->get_height / 2),
'width' => $self->{_items}{$nitem}{orig_pixbuf}->get_width,
'height' => $self->{_items}{$nitem}{orig_pixbuf}->get_height,
);
#texts
} elsif (exists $self->{_items}{$nitem}{text}) {
if ($self->{_items}{$nitem}{type} eq 'text') {
#clear text
$self->{_items}{$nitem}{text}->set('text' => "<span font_desc='" . $self->{_font} . "' ></span>");
#adjust parent rectangle
my $tb = $self->{_items}{$nitem}{text}->get_bounds;
$nitem->set(
'x' => $ev->x,
'y' => $ev->y - int(abs($tb->y1 - $tb->y2) / 2),
'width' => abs($tb->x1 - $tb->x2),
'height' => abs($tb->y1 - $tb->y2),
);
#show property dialog directly
Glib::Idle->add(
sub {
unless ($self->show_item_properties($self->{_items}{$nitem}{text}, $nitem, $nitem)) {
if (my $nint = $self->{_canvas}->get_root_item->find_child($nitem)) {
#delete canvas objects
$self->{_canvas}->get_root_item->remove_child($nint);
$self->handle_rects('delete', $nitem);
$self->handle_embedded('delete', $nitem);
#delete from hash
delete $self->{_items}{$nitem};
#delete all xdo emtries for this object
$self->xdo_remove('undo', $nitem);
$self->xdo_remove('redo', $nitem);
$self->deactivate_all;
}
}
return FALSE;
});
} elsif ($self->{_items}{$nitem}{type} eq 'number') {
$self->{_items}{$nitem}->set(
'x' => $ev->x - int($self->{_items}{$nitem}->get('width') / 2),
'y' => $ev->y - int($self->{_items}{$nitem}->get('height') / 2),
'width' => $self->{_items}{$nitem}->get('width'),
'height' => $self->{_items}{$nitem}->get('height'),
);
}
#all other objects
} else {
#delete
if (my $nint = $self->{_canvas}->get_root_item->find_child($nitem)) {
#delete from canvas
$self->{_canvas}->get_root_item->remove_child($nint);
#mark as deleted
$deleted = TRUE;
#~ print "item $nitem marked as deleted at ",$ev->x,", ",$ev->y,"\n";
}
}
#~ print "new item created: $item\n";
}
}
if ($deleted) {
#delete child objects and resizing rectangles
$self->handle_rects('delete', $nitem);
$self->handle_embedded('delete', $nitem);
#delete from hash
delete $self->{_items}{$nitem};
#~ print "item $nitem deleted at ",$ev->x,", ",$ev->y,"\n";
#deactivate all
$self->deactivate_all;
if (my $oitem = $self->{_canvas}->get_item_at($ev->x_root, $ev->y_root, TRUE)) {
#~ print "item $oitem found at ",$ev->x,", ",$ev->y,"\n";
#turn into a button-press-event
my $initevent = Gtk3::Gdk::Event->new('button-press');
$initevent->time(Gtk3::get_current_event_time());
$initevent->window($self->{_drawing_window}->get_window);
$initevent->x($ev->x);
$initevent->y($ev->y);
$self->event_item_on_button_press($oitem, undef, $initevent, TRUE);
$self->event_item_on_button_release($oitem, undef, $initevent);
return FALSE;
}
} else {
$self->deactivate_all($nitem);
#mark as active item
$self->{_current_item} = $nitem;
$self->handle_rects('update', $nitem);
$self->handle_embedded('update', $nitem);
#add to undo stack
$self->store_to_xdo_stack($nitem, 'create', 'undo');
}
#no new item
#existing item selected
} else {
#cleanup
#it may happen that items are created
#but resize mode is not activated immediately
#those items would not be visible on the canvas
#we delete them here
my $citem = $self->{_current_item};
if ($citem && $citem->isa('GooCanvas2::CanvasRect')) {
if (exists $self->{_items}{$citem}) {
if ($self->{_items}{$citem}->get('visibility') eq 'hidden') {
if (my $nint = $self->{_canvas}->get_root_item->find_child($citem)) {
$self->xdo('undo', undef, TRUE);
#delete from canvas
$self->{_canvas}->get_root_item->remove_child($nint);
#delete child objects and resizing rectangles
$self->handle_rects('delete', $citem);
$self->handle_embedded('delete', $citem);
#delete from hash
delete $self->{_items}{$citem};
}
}
}
}
#apply item properties to widgets
#line width, fill color, stroke color etc.
$self->set_and_save_drawing_properties($citem, FALSE);
}
#uncheck previous active item
$self->{_current_new_item} = undef;
#unset action flags
$item->{dragging} = FALSE if exists $item->{dragging};
$item->{dragging_start} = FALSE if exists $item->{dragging_start};
$item->{resizing} = FALSE if exists $item->{resizing};
#because of performance reason we load the current image new from file when
#the current action is over => button-release
#when resizing or moving the image we just scale the current image with low quality settings
#see handle_embedded
my $child = $self->get_child_item($self->{_current_item});
if ($child && $child->isa('GooCanvas2::CanvasImage')) {
my $parent = $self->get_parent_item($child);
if (exists $self->{_items}{$parent}{pixelize}) {
$self->{_items}{$parent}{pixelize}->set(
'x' => int $self->{_items}{$parent}->get('x'),
'y' => int $self->{_items}{$parent}->get('y'),
'width' => $self->{_items}{$parent}->get('width'),
'height' => $self->{_items}{$parent}->get('height'),
'pixbuf' => $self->get_pixelated_pixbuf_from_canvas($self->{_items}{$parent}),
);
$self->handle_embedded('update', $parent, undef, undef, TRUE);
} else {
my $copy = $self->{_lp}->load($self->{_items}{$parent}{orig_pixbuf_filename}, $self->{_items}{$parent}->get('width'), $self->{_items}{$parent}->get('height'), FALSE, TRUE);
if ($copy) {
$self->{_items}{$parent}{image}->set(
'x' => int $self->{_items}{$parent}->get('x'),
'y' => int $self->{_items}{$parent}->get('y'),
'width' => $self->{_items}{$parent}->get('width'),
'height' => $self->{_items}{$parent}->get('height'),
'pixbuf' => $copy,
);
$self->handle_embedded('update', $parent, undef, undef, TRUE);
} else {
#Try to load it with default width and height (Bug #975247)
$self->{_items}{$parent}->set(
'x' => $ev->x - int($self->{_items}{$parent}{orig_pixbuf}->get_width / 2),
'y' => $ev->y - int($self->{_items}{$parent}{orig_pixbuf}->get_height / 2),
'width' => $self->{_items}{$parent}{orig_pixbuf}->get_width,
'height' => $self->{_items}{$parent}{orig_pixbuf}->get_height,
);
#mark as active item
$self->{_current_item} = $parent;
$self->handle_rects('update', $parent);
$self->handle_embedded('update', $parent, undef, undef, TRUE);
#~ $self->abort_current_mode;
}
}
}
$self->set_drawing_action(int($self->{_current_mode} / 10));
return TRUE;
}
sub event_item_on_enter_notify {
my ($self, $item, $target, $ev) = @_;
return TRUE if $self->{_busy};
if (
($item->isa('GooCanvas2::CanvasRect') || $item->isa('GooCanvas2::CanvasEllipse') || $item->isa('GooCanvas2::CanvasText') || $item->isa('GooCanvas2::CanvasImage') || $item->isa('GooCanvas2::CanvasPolyline'))
&& ( $self->{_current_mode_descr} ne "freehand"
&& $self->{_current_mode_descr} ne "highlighter"
&& $self->{_current_mode_descr} ne "censor")
)
{
#embedded item?
my $parent = $self->get_parent_item($item);
$item = $parent if $parent;
#real shape
if (exists $self->{_items}{$item}) {
#nothing here yet
#canvas resizing shape
} elsif ($self->{_canvas_bg_rect}{'right-side'} == $item
|| $self->{_canvas_bg_rect}{'bottom-side'} == $item
|| $self->{_canvas_bg_rect}{'bottom-right-corner'} == $item)
{
$item->set('fill-color' => 'red');
#resizing shape
} else {
$item->set('fill-color' => 'red');
}
}
return TRUE;
}
sub event_item_on_leave_notify {
my ($self, $item, $target, $ev) = @_;
return TRUE if $self->{_busy};
if (
($item->isa('GooCanvas2::CanvasRect') || $item->isa('GooCanvas2::CanvasEllipse') || $item->isa('GooCanvas2::CanvasText') || $item->isa('GooCanvas2::CanvasImage') || $item->isa('GooCanvas2::CanvasPolyline'))
&& ( $self->{_current_mode_descr} ne "freehand"
&& $self->{_current_mode_descr} ne "highlighter"
&& $self->{_current_mode_descr} ne "censor")
)
{
#embedded item?
my $parent = $self->get_parent_item($item);
$item = $parent if $parent;
#real shape
if (exists $self->{_items}{$item}) {
#nothing here yet
#canvas resizing shape
} elsif ($self->{_canvas_bg_rect}{'right-side'} == $item
|| $self->{_canvas_bg_rect}{'bottom-side'} == $item
|| $self->{_canvas_bg_rect}{'bottom-right-corner'} == $item)
{
$item->set('fill-color-gdk-rgba' => $self->{_style_bg});
#resizing shape
} else {
$item->set('fill-color-gdk-rgba' => $self->{_style_bg});
}
}
return TRUE;
}
#ui related stuff
sub setup_uimanager {
my $self = shift;
return Shutter::Draw::UIManager->new( app => $self )->setup;
}
sub import_from_dnd {
my ($self, $widget, $context, $x, $y, $selection, $info, $time) = @_;
my $type = $selection->get_target->name;
return unless $type eq 'text/uri-list';
my $data = $selection->get_data;
$data = join('', map { chr } @$data);
my @files = grep defined($_), split /[\r\n]+/, $data;
my @valid_files;
foreach my $file (@files) {
my $giofile = Glib::IO::File::new_for_uri($file);
my ($mime_type) = Glib::Object::Introspection->invoke('Gio', undef, 'content_type_guess', $giofile->get_path);
$mime_type =~ s/image\/x\-apple\-ios\-png/image\/png/; #FIXME
if ($mime_type && $self->check_valid_mime_type($mime_type)) {
push @valid_files, $file;
}
}
#open all valid files
if (@valid_files) {
#backup current pixbuf and filename
my $old_current = $self->{_current_pixbuf};
my $old_filename = $self->{_current_pixbuf_filename};
foreach (@valid_files) {
#transform uri to path
my $new_uri = Glib::IO::File::new_for_uri($_);
my $new_file = $new_uri->get_path;
$self->{_current_pixbuf} = $self->{_lp}->load($new_file, undef, undef, undef, TRUE);
if ($self->{_current_pixbuf}) {
$self->{_current_pixbuf_filename} = $new_file;
#construct an event and create a new image object
my $initevent = Gtk3::Gdk::Event->new('motion-notify');
$initevent->time(Gtk3::get_current_event_time());
$initevent->window($self->{_drawing_window}->get_window);
$initevent->x($x);
$initevent->y($y);
#new item
my $nitem = $self->create_image($initevent, undef, TRUE);
#add to undo stack
$self->store_to_xdo_stack($nitem, 'create', 'undo');
} else {
$self->abort_current_mode;
}
}
#restore saved values
$self->{_current_pixbuf} = $old_current;
$self->{_current_pixbuf_filename} = $old_filename;
#uncheck previous active item
$self->{_current_new_item} = undef;
} else {
Gtk3::drag_finish($context, 0, 0, $time);
return FALSE;
}
Gtk3::drag_finish($context, 1, 0, $time);
return TRUE;
}
sub utf8_decode {
my $self = shift;
my $string = shift;
#see https://bugs.launchpad.net/shutter/+bug/347821
utf8::decode $string;
return $string;
}
sub check_valid_mime_type {
my $self = shift;
my $mime_type = shift;
foreach my $format (Gtk3::Gdk::Pixbuf::get_formats()) {
foreach my $mime (@{$format->get_mime_types}) {
return TRUE if $mime_type eq $mime_type;
last;
}
}
return FALSE;
}
sub import_from_filesystem {
my $self = shift;
my $button = shift;
#used when called recursively
my $parent = shift;
my $directory = shift;
my $menu_objects = Gtk3::Menu->new;
my $dobjects = $directory || $self->{_sc}->get_root . "/share/shutter/resources/icons/drawing_tool/objects";
#first directory flag (see description above)
my $fd = TRUE;
my $ff = FALSE;
my @objects = bsd_glob("$dobjects/*");
foreach my $name (sort { -d $a <=> -d $b } @objects) {
#parse filename
my ($short, $folder, $type) = fileparse($name, qr/\.[^.]*/);
#if current object is a directory we call the current sub
#recursively
if (-d $name) {
#objects from each directory are sorted (files first)
#we display a separator when the first directory is listed
if ($fd && $ff) {
$menu_objects->append(Gtk3::SeparatorMenuItem->new);
$fd = FALSE;
}
#objects from directory $name
my $subdir_item = Gtk3::ImageMenuItem->new_with_label($short);
$subdir_item->set('always_show_image' => TRUE);
$subdir_item->set_image(Gtk3::Image->new_from_stock('gtk-directory', 'menu'));
#add empty menu first
my $menu_empty = Gtk3::Menu->new;
my $empty_item = Gtk3::MenuItem->new_with_label($self->{_d}->get("No icon was found"));
$empty_item->set_sensitive(FALSE);
$menu_empty->append($empty_item);
$subdir_item->set_submenu($menu_empty);
#and populate later (performance)
$subdir_item->{'nid'} = $subdir_item->signal_connect(
'activate' => sub {
$subdir_item->set_image(Gtk3::Image->new_from_file($self->{_icons} . "/throbber_16x16.gif"));
my $submenu = $self->import_from_filesystem($button, $subdir_item, $dobjects . "/$short");
if ($submenu->get_children) {
$subdir_item->set_submenu($submenu);
} else {
$subdir_item->set_image(Gtk3::Image->new_from_stock('gtk-directory', 'menu'));
}
return TRUE;
});
#diconnect handler when this event occurs
$subdir_item->signal_connect(
'leave-notify-event' => sub {
if ($subdir_item->signal_handler_is_connected($subdir_item->{'nid'})) {
$subdir_item->signal_handler_disconnect($subdir_item->{'nid'});
}
});
$menu_objects->append($subdir_item);
next;
}
#there is at least one single file
#set the flag
$ff = TRUE;
#init item with filename first
my $new_item = Gtk3::ImageMenuItem->new_with_label($short);
$new_item->set('always_show_image' => TRUE);
$menu_objects->append($new_item);
#sfsdc
$new_item->{'name'} = $name;
}
#do not do that when called recursively
#top level call
unless ($directory) {
$menu_objects->append(Gtk3::SeparatorMenuItem->new);
#~ #objects from icontheme
#~ if ( Gtk3->CHECK_VERSION( 2, 12, 0 ) ) {
#~ my $icontheme = Gtk3::IconTheme::get_default();
#~
#~ my $utheme_item = Gtk3::ImageMenuItem->new_with_label( $self->{_d}->get("Import from current theme...") );
#~ $utheme_item->set( 'always_show_image' => TRUE ) if Gtk3->CHECK_VERSION( 2, 16, 0 );
#~ if ( $icontheme->has_icon('preferences-desktop-theme') ) {
#~ $utheme_item->set_image( Gtk3::Image->new_from_icon_name( 'preferences-desktop-theme', 'menu' ) );
#~ }
#~
#~ $utheme_item->set_submenu( $self->import_from_utheme( $icontheme, $button ) );
#~
#~ $menu_objects->append($utheme_item);
#~
#~ $menu_objects->append( Gtk3::SeparatorMenuItem->new );
#~ }
#objects from session
my $session_menu_item = Gtk3::ImageMenuItem->new_with_label($self->{_d}->get("Import from session..."));
$session_menu_item->set('always_show_image' => TRUE);
$session_menu_item->set_image(Gtk3::Image->new_from_stock('gtk-index', 'menu'));
$session_menu_item->set_submenu($self->import_from_session($button));
#gen thumbnails in an idle callback
$self->gen_thumbnail_on_idle('gtk-index', $session_menu_item, $button, TRUE, $session_menu_item->get_submenu->get_children);
$menu_objects->append($session_menu_item);
#objects from filesystem
my $filesystem_menu_item = Gtk3::ImageMenuItem->new_with_label($self->{_d}->get("Import from filesystem..."));
$filesystem_menu_item->set('always_show_image' => TRUE);
$filesystem_menu_item->set_image(Gtk3::Image->new_from_stock('gtk-open', 'menu'));
$filesystem_menu_item->signal_connect(
'activate' => sub {
my $fs = Gtk3::FileChooserDialog->new(
$self->{_d}->get("Choose file to open"), $self->{_drawing_window}, 'open',
'gtk-cancel' => 'reject',
'gtk-open' => 'accept'
);
$fs->set_select_multiple(FALSE);
#preview widget
my $iprev = Gtk3::Image->new;
$fs->set_preview_widget($iprev);
$fs->signal_connect(
'selection-changed' => sub {
if (my $pfilename = $fs->get_preview_filename) {
my $pixbuf = $self->{_lp_ne}->load($pfilename, 200, 200, TRUE, TRUE);
unless ($pixbuf) {
$fs->set_preview_widget_active(FALSE);
} else {
$fs->get_preview_widget->set_from_pixbuf($pixbuf);
$fs->set_preview_widget_active(TRUE);
}
} else {
$fs->set_preview_widget_active(FALSE);
}
});
my $filter_all = Gtk3::FileFilter->new;
$filter_all->set_name($self->{_d}->get("All compatible image formats"));
$fs->add_filter($filter_all);
foreach my $format (Gtk3::Gdk::Pixbuf::get_formats()) {
my $filter = Gtk3::FileFilter->new;
$filter->set_name($format->get_name . " - " . $format->get_description);
foreach my $ext (@{$format->get_extensions}) {
$filter->add_pattern("*." . uc $ext);
$filter_all->add_pattern("*." . uc $ext);
$filter->add_pattern("*." . $ext);
$filter_all->add_pattern("*." . $ext);
}
$fs->add_filter($filter);
}
if ($ENV{'HOME'}) {
$fs->set_current_folder($ENV{'HOME'});
}
my $fs_resp = $fs->run;
my $new_file;
if ($fs_resp eq "accept") {
$new_file = $fs->get_filenames;
$self->{_current_pixbuf} = $self->{_lp}->load($new_file, undef, undef, undef, TRUE);
if ($self->{_current_pixbuf}) {
$self->{_current_pixbuf_filename} = $new_file;
$button->set_icon_widget(Gtk3::Image->new_from_pixbuf(Gtk3::Gdk::Pixbuf->new_from_file_at_size($self->{_dicons} . '/draw-image.svg', Gtk3::IconSize->lookup('menu'))));
$button->show_all;
$self->{_canvas}->get_window->set_cursor($self->change_cursor_to_current_pixbuf);
} else {
$self->abort_current_mode;
}
$fs->destroy();
} else {
$fs->destroy();
}
});
$menu_objects->append($filesystem_menu_item);
}
$button->show_all;
$menu_objects->show_all;
#generate thumbnails in an idle callback
$self->gen_thumbnail_on_idle('gtk-directory', $parent, $button, FALSE, $menu_objects->get_children);
return $menu_objects;
}
sub import_from_utheme {
my $self = shift;
my $icontheme = shift;
my $button = shift;
my $menu_ctxt = Gtk3::Menu->new;
foreach my $context (sort $icontheme->list_contexts) {
#objects from current theme (contexts)
my $utheme_ctxt = Gtk3::ImageMenuItem->new_with_label($context);
$utheme_ctxt->set('always_show_image' => TRUE);
$utheme_ctxt->set_image(Gtk3::Image->new_from_stock('gtk-directory', 'menu'));
#add empty menu first
my $menu_empty = Gtk3::Menu->new;
my $empty_item = Gtk3::MenuItem->new_with_label($self->{_d}->get("No icon was found"));
$empty_item->set_sensitive(FALSE);
$menu_empty->append($empty_item);
$utheme_ctxt->set_submenu($menu_empty);
#and populate later (performance)
my @menu_items;
$utheme_ctxt->{'nid'} = $utheme_ctxt->signal_connect(
'activate' => sub {
$utheme_ctxt->set_image(Gtk3::Image->new_from_file($self->{_icons} . "/throbber_16x16.gif"));
my $context_submenu = $self->import_from_utheme_ctxt($icontheme, $context, $button);
if ($context_submenu->get_children) {
$utheme_ctxt->set_submenu($context_submenu);
#gen thumbnails in an idle callback
$self->gen_thumbnail_on_idle('gtk-directory', $utheme_ctxt, $button, TRUE, $utheme_ctxt->get_submenu->get_children);
} else {
$utheme_ctxt->set_image(Gtk3::Image->new_from_stock('gtk-directory', 'menu'));
}
return TRUE;
});
#disconnect handler when this event occurs
$utheme_ctxt->signal_connect(
'leave-notify-event' => sub {
if ($utheme_ctxt->signal_handler_is_connected($utheme_ctxt->{'nid'})) {
$utheme_ctxt->signal_handler_disconnect($utheme_ctxt->{'nid'});
}
});
$menu_ctxt->append($utheme_ctxt);
}
$menu_ctxt->show_all;
return $menu_ctxt;
}
sub import_from_utheme_ctxt {
my $self = shift;
my $icontheme = shift;
my $context = shift;
my $button = shift;
my $menu_ctxt_items = Gtk3::Menu->new;
my $size = Gtk3::IconSize->lookup('dialog');
foreach my $icon (sort $icontheme->list_icons($context)) {
#objects from current theme (icons for specific contexts)
my $utheme_ctxt_item = Gtk3::ImageMenuItem->new_with_label($icon);
$utheme_ctxt_item->set('always_show_image' => TRUE);
my $iconinfo = $icontheme->lookup_icon($icon, $size, 'generic-fallback');
#save filename and generate thumbnail later
#idle callback
$utheme_ctxt_item->{'name'} = $iconinfo->get_filename;
$menu_ctxt_items->append($utheme_ctxt_item);
}
$menu_ctxt_items->show_all;
return $menu_ctxt_items;
}
sub import_from_session {
my $self = shift;
my $button = shift;
my $menu_session_objects = Gtk3::Menu->new;
my %import_hash = %{$self->{_import_hash}};
foreach my $key (Sort::Naturally::nsort(keys %import_hash)) {
next unless exists $import_hash{$key}->{'short'};
next unless defined $import_hash{$key}->{'short'};
#init item with filename
my $screen_menu_item = Gtk3::ImageMenuItem->new_with_label($import_hash{$key}->{'short'});
$screen_menu_item->set('always_show_image' => TRUE);
#set sensitive == FALSE if image eq current file
$screen_menu_item->set_sensitive(FALSE)
if $import_hash{$key}->{'long'} eq $self->{_filename};
#save filename and attributes
$screen_menu_item->{'name'} = $import_hash{$key}->{'long'};
$screen_menu_item->{'mime_type'} = $import_hash{$key}->{'mime_type'};
$screen_menu_item->{'mtime'} = $import_hash{$key}->{'mtime'};
$screen_menu_item->{'giofile'} = $import_hash{$key}->{'giofile'};
$screen_menu_item->{'no_thumbnail'} = $import_hash{$key}->{'no_thumbnail'};
$menu_session_objects->append($screen_menu_item);
}
$menu_session_objects->show_all;
return $menu_session_objects;
}
sub gen_thumbnail_on_idle {
my $self = shift;
my $stock = shift;
my $parent = shift;
my $button = shift;
my $no_init = shift;
my @menu_items = @_;
my $shutter_hfunct = Shutter::App::HelperFunctions->new($self->{_sc});
#generate thumbnails in an idle callback
my $next_item = 0;
Glib::Idle->add(
sub {
#get next item
my $child = $menu_items[$next_item];
#no valid item - stop the idle handler
unless ($child) {
$parent->set_image(Gtk3::Image->new_from_stock($stock, 'menu')) if $parent;
return FALSE;
}
my $name = $child->{'name'};
#no valid item - stop the idle handler
unless ($name) {
$parent->set_image(Gtk3::Image->new_from_stock($stock, 'menu')) if $parent;
return FALSE;
}
#increment counter
$next_item++;
#create thumbnail
my $small_image;
eval {
#if uri exists we generate a thumbnail
#with Shutter::Pixbuf::Thumbnail
if (exists $child->{'giofile'}) {
my $thumb;
unless ($child->{'no_thumbnail'}) {
$thumb = $self->{_lp_ne}->load($shutter_hfunct->utf8_decode($child->{'giofile'}->get_path), Gtk3::IconSize->lookup('small-toolbar'));
} else {
$thumb = Gtk3::Gdk::Pixbuf->new('rgb', TRUE, 8, 5, 5);
$thumb->fill(0x00000000);
}
$small_image = Gtk3::Image->new_from_pixbuf($thumb);
} else {
my $pixbuf = $self->{_lp_ne}->load($name, undef, undef, undef, TRUE);
#16x16 is minimum size
if ($pixbuf->get_width >= 16 && $pixbuf->get_height >= 16) {
$small_image = Gtk3::Image->new_from_pixbuf($pixbuf->scale_simple(Gtk3::IconSize->lookup('menu'), 'bilinear'));
}
}
};
unless ($@) {
if ($small_image) {
$child->set_image($small_image);
#init when toplevel
unless ($no_init) {
unless ($button->get_icon_widget) {
$button->set_icon_widget(Gtk3::Image->new_from_pixbuf($small_image->get_pixbuf));
$self->{_current_pixbuf_filename} = $name;
$button->show_all;
}
}
$child->signal_connect(
'activate' => sub {
$self->{_current_pixbuf_filename} = $name;
$button->set_icon_widget(Gtk3::Image->new_from_pixbuf($small_image->get_pixbuf));
$button->show_all;
$self->{_canvas}->get_window->set_cursor($self->change_cursor_to_current_pixbuf);
});
} else {
$child->destroy;
}
} else {
$child->destroy;
}
return TRUE;
}); #end idle callback
}
sub set_drawing_action {
my $self = shift;
my $index = shift;
#~ print "set_drawing_action\n";
my $item_index = 0;
my $toolbar = $self->{_uimanager}->get_widget("/ToolBarDrawing");
for (my $i = 0 ; $i < $toolbar->get_n_items ; $i++) {
my $item = $toolbar->get_nth_item($i);
#skip separators
#we only want to activate tools
next if $item->isa('Gtk3::SeparatorToolItem');
#add 1 to item index
$item_index++;
if ($item_index == $index) {
if ($item->get_active) {
$self->change_drawing_tool_cb($item_index * 10);
} else {
$item->set_active(TRUE);
}
last;
}
}
}
sub change_cursor_to_current_pixbuf {
my $self = shift;
#~ print "change_cursor_to_current_pixbuf\n";
$self->{_current_mode_descr} = "image";
my $cursor = undef;
#load file
$self->{_current_pixbuf} = $self->{_lp}->load($self->{_current_pixbuf_filename}, undef, undef, undef, TRUE);
unless ($self->{_current_pixbuf}) {
$cursor = Gtk3::Gdk::Cursor->new_from_pixbuf(Gtk3::Gdk::Display::get_default(), Gtk3::Gdk::Pixbuf->new_from_file($self->{_dicons} . '/draw-image.svg'), Gtk3::IconSize->lookup('menu'));
}
#very big images usually don't work as a cursor (no error though??)
my $pb_w = $self->{_current_pixbuf}->get_width;
my $pb_h = $self->{_current_pixbuf}->get_height;
if ($pb_w < 800 && $pb_h < 800) {
eval {
#maximum cursor size
my ($cw, $ch) = Gtk3::Gdk::Display::get_default->get_maximal_cursor_size;
#images smaller than max cursor size?
# => don't scale to a bigger size
if ($cw > $pb_w || $ch > $pb_w) {
$cursor = Gtk3::Gdk::Cursor->new_from_pixbuf(Gtk3::Gdk::Display::get_default(), $self->{_current_pixbuf}, int($pb_w / 2), int($pb_h / 2));
} else {
my $cpixbuf = $self->{_lp}->load($self->{_current_pixbuf_filename}, $cw, $ch, TRUE, TRUE);
$cursor = Gtk3::Gdk::Cursor->new_from_pixbuf(Gtk3::Gdk::Display::get_default(), $cpixbuf, int($cpixbuf->get_width / 2), int($cpixbuf->get_height / 2));
}
};
if ($@) {
my $response = $self->{_dialogs}->dlg_error_message(
sprintf($self->{_d}->get("Error while opening image %s."), "'" . $self->{_current_pixbuf_filename} . "'"),
$self->{_d}->get("There was an error opening the image."),
undef, undef, undef, undef, undef, undef, $@
);
$self->abort_current_mode;
}
} else {
$cursor = Gtk3::Gdk::Cursor->new_from_pixbuf(Gtk3::Gdk::Display::get_default(), Gtk3::Gdk::Pixbuf->new_from_file($self->{_dicons} . '/draw-image.svg'), Gtk3::IconSize->lookup('menu'));
}
return $cursor;
}
sub paste_item {
my $self = shift;
my $item = shift;
#cut instead of copy
my $delete_after = shift;
#import from system's clipboard
if (my $image = $self->{_clipboard}->wait_for_image) {
#backup current pixbuf and filename
my $old_current = $self->{_current_pixbuf};
my $old_filename = $self->{_current_pixbuf_filename};
#create tempfile
my ($tmpfh, $tmpfilename) = tempfile(UNLINK => 1);
#save pixbuf to tempfile and integrate it
my $pixbuf_save = Shutter::Pixbuf::Save->new($self->{_sc}, $self->{_drawing_window});
if ($pixbuf_save->save_pixbuf_to_file($image, $tmpfilename, 'png')) {
#set pixbuf vars
$self->{_current_pixbuf} = $image;
$self->{_current_pixbuf_filename} = $tmpfilename;
#construct an event and create a new image object
my $initevent = Gtk3::Gdk::Event->new('motion-notify');
$initevent->time(Gtk3::get_current_event_time());
$initevent->window($self->{_drawing_window}->get_window);
#calculate coordinates
$initevent->x(int($self->{_canvas_bg_rect}->get('width') / 2));
$initevent->y(int($self->{_canvas_bg_rect}->get('height') / 2));
#new item
my $nitem = $self->create_image($initevent, undef, TRUE);
#add to undo stack
$self->store_to_xdo_stack($nitem, 'create', 'undo');
#restore saved values
$self->{_current_pixbuf} = $old_current;
$self->{_current_pixbuf_filename} = $old_filename;
#uncheck
$self->{_current_new_item} = undef;
$self->{_current_item} = undef;
$self->{_current_copy_item} = undef;
}
#import from DrawingTool's clipboard
} elsif (defined $item) {
my $child = $self->get_child_item($item);
my $new_item = undef;
if ($item->isa('GooCanvas2::CanvasRect') && !$child) {
#~ print "Creating Rectangle...\n";
$new_item = $self->create_rectangle(undef, $item);
} elsif ($item->isa('GooCanvas2::CanvasPolyline') && !$child) {
#~ print "Creating Polyline...\n";
$new_item = $self->create_polyline(undef, $item);
} elsif ($child->isa('GooCanvas2::CanvasPolyline') && exists $self->{_items}{$item}{stroke_color}) {
#~ print "Creating Line...\n";
$new_item = $self->create_line(undef, $item);
} elsif ($child->isa('GooCanvas2::CanvasPolyline')) {
#~ print "Creating Censor...\n";
$new_item = $self->create_censor(undef, $item);
} elsif ($child->isa('GooCanvas2::CanvasEllipse')) {
#~ print "Creating Ellipse...\n";
$new_item = $self->create_ellipse(undef, $item);
} elsif ($child->isa('GooCanvas2::CanvasText')) {
#~ print "Creating Text...\n";
$new_item = $self->create_text(undef, $item);
} elsif ($child->isa('GooCanvas2::CanvasImage') && exists $self->{_items}{$item}{pixelize}) {
#~ print "Creating Pixelize...\n";
$new_item = $self->create_pixel_image(undef, $item);
} elsif ($child->isa('GooCanvas2::CanvasImage')) {
#~ print "Creating Image...\n";
$new_item = $self->create_image(undef, $item);
}
#cut instead of copy
if ($delete_after) {
$self->clear_item_from_canvas($item);
$self->{_current_item} = undef;
$self->{_current_copy_item} = undef;
}
#add to undo stack
$self->store_to_xdo_stack($new_item, 'create', 'undo');
}
return TRUE;
}
sub create_polyline {
my $self = shift;
my $ev = shift;
my $copy_item = shift;
#this is a highlighter?
#we need different default values in this case
my $highlighter = shift;
my @points = ();
my $stroke_color = $self->{_stroke_color};
my $transform;
my $line_width = $self->{_line_width};
#use event coordinates
if ($ev) {
@points = ($ev->x, $ev->y, $ev->x, $ev->y);
#use source item coordinates
} elsif ($copy_item) {
foreach (@{$self->{_items}{$copy_item}{points}}) {
push @points, $_ + 20;
}
$stroke_color = $self->{_items}{$copy_item}{stroke_color};
$transform = $self->{_items}{$copy_item}->get('transform');
$line_width = $self->{_items}{$copy_item}->get('line_width');
}
my $item = undef;
if ($highlighter) {
$stroke_color = Gtk3::Gdk::RGBA::parse('#FFFF00');
$stroke_color->alpha(0.5);
$item = GooCanvas2::CanvasPolyline->new(
parent=>$self->{_canvas}->get_root_item, close_path=>FALSE,
'stroke-color-gdk-rgba' => $stroke_color,
'line-width' => 18,
'fill-rule' => 'CAIRO_FILL_RULE_EVEN_ODD',
'line-cap' => 'CAIRO_LINE_CAP_SQUARE',
'line-join' => 'CAIRO_LINE_JOIN_BEVEL',
);
} else {
$item = GooCanvas2::CanvasPolyline->new(
parent=>$self->{_canvas}->get_root_item, close_path=>FALSE,
'stroke-color-gdk-rgba' => $stroke_color,
'line-width' => $line_width,
'line-cap' => 'CAIRO_LINE_CAP_ROUND',
'line-join' => 'CAIRO_LINE_JOIN_ROUND',
);
}
$self->{_current_new_item} = $item unless ($copy_item);
$self->{_items}{$item} = $item;
#need at least 2 points
push @{$self->{_items}{$item}{'points'}}, @points;
$self->{_items}{$item}->set(points => Shutter::Draw::Utils::points_to_canvas_points(@{$self->{_items}{$item}{'points'}}));
$self->{_items}{$item}->set(transform => $transform) if $transform;
if ($highlighter) {
#set type flag
$self->{_items}{$item}{type} = 'highlighter';
$self->{_items}{$item}{uid} = $self->{_uid}++;
$self->{_items}{$item}{stroke_color} = Gtk3::Gdk::RGBA::parse('#FFFF00');
$self->{_items}{$item}{stroke_color}->alpha(0.5);
} else {
#set type flag
$self->{_items}{$item}{type} = 'freehand';
$self->{_items}{$item}{uid} = $self->{_uid}++;
$self->{_items}{$item}{stroke_color} = $self->{_stroke_color};
}
$self->setup_item_signals($self->{_items}{$item});
$self->setup_item_signals_extra($self->{_items}{$item});
return $item;
}
sub create_censor {
my $self = shift;
my $ev = shift;
my $copy_item = shift;
my @points = ();
my $transform;
#use event coordinates
if ($ev) {
@points = ($ev->x, $ev->y, $ev->x, $ev->y);
#use source item coordinates
} elsif ($copy_item) {
foreach (@{$self->{_items}{$copy_item}{points}}) {
push @points, $_ + 20;
}
$transform = $self->{_items}{$copy_item}->get('transform');
}
my $item = GooCanvas2::CanvasPolyline->new(
parent=>$self->{_canvas}->get_root_item, close_path=>FALSE,
'stroke-pixbuf' => $self->{_stipple_pixbuf},
'line-width' => 14,
'line-cap' => 'CAIRO_LINE_CAP_ROUND',
'line-join' => 'CAIRO_LINE_JOIN_ROUND',
);
$self->{_current_new_item} = $item unless ($copy_item);
$self->{_items}{$item} = $item;
#set type flag
$self->{_items}{$item}{type} = 'censor';
$self->{_items}{$item}{uid} = $self->{_uid}++;
#need at least 2 points
push @{$self->{_items}{$item}{'points'}}, @points;
$self->{_items}{$item}->set(points => Shutter::Draw::Utils::points_to_canvas_points(@{$self->{_items}{$item}{'points'}}));
$self->{_items}{$item}->set(transform => $transform) if $transform;
$self->setup_item_signals($self->{_items}{$item});
$self->setup_item_signals_extra($self->{_items}{$item});
return $item;
}
sub create_pixel_image {
my $self = shift;
my $ev = shift;
my $copy_item = shift;
my ($x, $y, $width, $height) = (0, 0, 0, 0);
#use event coordinates and selected color
if ($ev) {
$x = $ev->x;
$y = $ev->y;
#use source item coordinates and item color
} elsif ($copy_item) {
$x = $copy_item->get('x') + 20;
$y = $copy_item->get('y') + 20;
$width = $copy_item->get('width');
$height = $copy_item->get('height');
}
my $item = GooCanvas2::CanvasRect->new(
parent=>$self->{_canvas}->get_root_item, x=>$x, y=>$y, width=>$width, height=>$height,
'fill-color-rgba' => 0,
'line-dash' => GooCanvas2::CanvasLineDash->newv([5, 5]),
'line-width' => 1,
'stroke-color' => 'gray',
);
$self->{_current_new_item} = $item unless ($copy_item);
$self->{_items}{$item} = $item;
#blank pixbuf
my $blank = Gtk3::Gdk::Pixbuf->new('rgb', TRUE, 8, 2, 2);
#whole pixbuf is transparent
$blank->fill(0x00000000);
$self->{_items}{$item}{pixelize} = GooCanvas2::CanvasImage->new(
parent=>$self->{_canvas}->get_root_item,
pixbuf=>$blank,
x=>$item->get('x'),
y=>$item->get('y'),
'width' => 2,
'height' => 2,
);
#set type flag
$self->{_items}{$item}{type} = 'pixelize';
$self->{_items}{$item}{uid} = $self->{_uid}++;
#create rectangles
$self->handle_rects('create', $item);
if ($copy_item) {
$self->{_items}{$item}{pixelize}->set(
'x' => int $self->{_items}{$item}->get('x'),
'y' => int $self->{_items}{$item}->get('y'),
'width' => $self->{_items}{$item}->get('width'),
'height' => $self->{_items}{$item}->get('height'),
'pixbuf' => $self->get_pixelated_pixbuf_from_canvas($self->{_items}{$item}),
);
$self->handle_embedded('update', $item, undef, undef, TRUE);
}
$self->setup_item_signals($self->{_items}{$item}{pixelize});
$self->setup_item_signals_extra($self->{_items}{$item}{pixelize});
$self->setup_item_signals($self->{_items}{$item});
$self->setup_item_signals_extra($self->{_items}{$item});
return $item;
}
sub create_image {
my $self = shift;
my $ev = shift;
my $copy_item = shift;
my $force_orig_size_init = shift;
my ($x, $y, $width, $height) = (0, 0, 0, 0);
#use event coordinates
if ($ev) {
#we create the new image item
#and use the original image size
#dnd for example
if ($force_orig_size_init) {
$x = $ev->x - int($self->{_current_pixbuf}->get_width / 2);
$y = $ev->y - int($self->{_current_pixbuf}->get_height / 2);
$width = $self->{_current_pixbuf}->get_width;
$height = $self->{_current_pixbuf}->get_height;
} else {
$x = $ev->x;
$y = $ev->y;
}
#use source item coordinates
} elsif ($copy_item) {
$x = $copy_item->get('x') + 20;
$y = $copy_item->get('y') + 20;
$width = $self->{_items}{$copy_item}->get('width');
$height = $self->{_items}{$copy_item}->get('height');
}
my $item = GooCanvas2::CanvasRect->new(
parent=>$self->{_canvas}->get_root_item, x=>$x, y=>$y, width=>$width, height=>$height,
'fill-color-rgba' => 0,
'line-dash' => GooCanvas2::CanvasLineDash->newv([5, 5]),
'line-width' => 1,
'stroke-color' => 'gray',
);
$self->{_current_new_item} = $item unless ($copy_item);
$self->{_items}{$item} = $item;
if ($ev) {
$self->{_items}{$item}{orig_pixbuf} = $self->{_current_pixbuf}->copy;
$self->{_items}{$item}{orig_pixbuf_filename} = $self->{_current_pixbuf_filename};
} elsif ($copy_item) {
$self->{_items}{$item}{orig_pixbuf} = $self->{_items}{$copy_item}{orig_pixbuf}->copy;
$self->{_items}{$item}{orig_pixbuf_filename} = $self->{_items}{$copy_item}{orig_pixbuf_filename};
}
$self->{_items}{$item}{image} = GooCanvas2::CanvasImage->new(
parent=>$self->{_canvas}->get_root_item,
pixbuf=>$self->{_items}{$item}{orig_pixbuf},
x=>$item->get('x'),
y=>$item->get('y'),
'width' => 2,
'height' => 2,
);
#set type flag
$self->{_items}{$item}{type} = 'image';
$self->{_items}{$item}{uid} = $self->{_uid}++;
#create rectangles
$self->handle_rects('create', $item);
#show image directly when copy or dnd
if ($copy_item || $force_orig_size_init) {
$self->handle_embedded('update', $item);
}
$self->setup_item_signals($self->{_items}{$item}{image});
$self->setup_item_signals_extra($self->{_items}{$item}{image});
$self->setup_item_signals($self->{_items}{$item});
$self->setup_item_signals_extra($self->{_items}{$item});
if ($copy_item) {
my $copy = $self->{_lp}->load($self->{_items}{$item}{orig_pixbuf_filename}, $self->{_items}{$item}->get('width'), $self->{_items}{$item}->get('height'), FALSE, TRUE);
$self->{_items}{$item}{image}->set(
'x' => int $self->{_items}{$item}->get('x'),
'y' => int $self->{_items}{$item}->get('y'),
'pixbuf' => $copy
);
$self->handle_rects('hide', $item);
}
return $item;
}
sub create_text {
my $self = shift;
my $ev = shift;
my $copy_item = shift;
my ($x, $y, $width, $height) = (0, 0, 0, 0);
my $stroke_color = $self->{_stroke_color};
my $text = $self->{_d}->get('New text...');
my $line_width = $self->{_line_width};
#use event coordinates and selected color
if ($ev) {
$x = $ev->x;
$y = $ev->y;
#use source item coordinates and item color
} elsif ($copy_item) {
$x = $copy_item->get('x') + 20;
$y = $copy_item->get('y') + 20;
$width = $copy_item->get('width');
$height = $copy_item->get('height');
$stroke_color = $self->{_items}{$copy_item}{stroke_color};
$text = $self->{_items}{$copy_item}{text}->get('text');
$line_width = $self->{_items}{$copy_item}{text}->get('line-width');
}
my $item = GooCanvas2::CanvasRect->new(
parent=>$self->{_canvas}->get_root_item, x=>$x, y=>$y, width=>$width, height=>$height,
'fill-color-rgba' => 0,
'line-dash' => GooCanvas2::CanvasLineDash->newv([5, 5]),
'line-width' => 1,
'stroke-color' => 'gray',
);
$self->{_current_new_item} = $item unless ($copy_item);
$self->{_items}{$item} = $item;
$self->{_items}{$item}{text} = GooCanvas2::CanvasText->new(
parent=>$self->{_canvas}->get_root_item, text=>"<span font_desc='" . $self->{_font} . "' >" . $text . "</span>",
x=>$item->get('x'),
y=>$item->get('y'),
width=>-1,
anchor=>'nw',
'use-markup' => TRUE,
'fill-color-gdk-rgba' => $stroke_color,
'line-width' => $line_width,
);
#adjust parent rectangle
my $tb = $self->{_items}{$item}{text}->get_bounds;
my $w = abs($tb->x1 - $tb->x2);
my $h = abs($tb->y1 - $tb->y2);
if ($copy_item) {
$self->{_items}{$item}->set(
'x' => $self->{_items}{$item}->get('x') + 20,
'y' => $self->{_items}{$item}->get('y') + 20,
'width' => $w,
'height' => $h,
'visibility' => 'hidden',
);
} else {
$self->{_items}{$item}->set(
'x' => $ev->x - $w,
'y' => $ev->y - $h,
'width' => $w,
'height' => $h,
'visibility' => 'hidden',
);
}
#update text
$self->handle_embedded('hide', $item);
#set type flag
$self->{_items}{$item}{type} = 'text';
$self->{_items}{$item}{uid} = $self->{_uid}++;
$self->{_items}{$item}{stroke_color} = $self->{_stroke_color};
#create rectangles
$self->handle_rects('create', $item);
if ($copy_item) {
$self->handle_embedded('update', $item);
$self->handle_rects('hide', $item);
}
$self->setup_item_signals($self->{_items}{$item}{text});
$self->setup_item_signals_extra($self->{_items}{$item}{text});
$self->setup_item_signals($self->{_items}{$item});
$self->setup_item_signals_extra($self->{_items}{$item});
return $item;
}
sub create_line {
my $self = shift;
my $ev = shift;
my $copy_item = shift;
my $end_arrow = shift;
my $start_arrow = shift;
my ($x, $y, $width, $height) = (0, 0, 0, 0);
my $stroke_color = $self->{_stroke_color};
my $line_width = $self->{_line_width};
my $mirrored_w = 0;
my $mirrored_h = 0;
#default values
my $arrow_width = 4;
my $arrow_length = 5;
my $arrow_tip_length = 4;
#use event coordinates and selected color
if ($ev) {
$x = $ev->x;
$y = $ev->y;
#use source item coordinates and item color
} elsif ($copy_item) {
$x = $copy_item->get('x') + 20;
$y = $copy_item->get('y') + 20;
$width = $copy_item->get('width');
$height = $copy_item->get('height');
$stroke_color = $self->{_items}{$copy_item}{stroke_color};
$line_width = $self->{_items}{$copy_item}{line}->get('line-width');
$mirrored_w = $self->{_items}{$copy_item}{mirrored_w};
$mirrored_h = $self->{_items}{$copy_item}{mirrored_h};
#arrow specific properties
$end_arrow = $self->{_items}{$copy_item}{end_arrow};
$start_arrow = $self->{_items}{$copy_item}{start_arrow};
$arrow_width = $self->{_items}{$copy_item}{arrow_width};
$arrow_length = $self->{_items}{$copy_item}{arrow_length};
$arrow_tip_length = $self->{_items}{$copy_item}{arrow_tip_length};
}
my $item = GooCanvas2::CanvasRect->new(
parent=>$self->{_canvas}->get_root_item, x=>$x, y=>$y, width=>$width, height=>$height,
'fill-color-rgba' => 0,
'line-dash' => GooCanvas2::CanvasLineDash->newv([5, 5]),
'line-width' => 1,
'stroke-color' => 'gray',
);
$self->{_current_new_item} = $item unless ($copy_item);
$self->{_items}{$item} = $item;
$self->{_items}{$item}{line} = GooCanvas2::CanvasPolyline->new(
parent=>$self->{_canvas}->get_root_item,
close_path=>FALSE,
points => Shutter::Draw::Utils::points_to_canvas_points(
$item->get('x'),
$item->get('y'),
$item->get('x') + $item->get('width'),
$item->get('y') + $item->get('height'),
),
'stroke-color-gdk-rgba' => $stroke_color,
'line-width' => $line_width,
'line-cap' => 'CAIRO_LINE_CAP_ROUND',
'line-join' => 'CAIRO_LINE_JOIN_ROUND',
'end-arrow' => $end_arrow,
'start-arrow' => $start_arrow,
'arrow-length' => $arrow_length,
'arrow-width' => $arrow_width,
'arrow-tip-length' => $arrow_tip_length,
'visibility' => 'hidden',
);
if (defined $end_arrow || defined $start_arrow) {
#save arrow specific properties
$self->{_items}{$item}{end_arrow} = $self->{_items}{$item}{line}->get('end-arrow');
$self->{_items}{$item}{start_arrow} = $self->{_items}{$item}{line}->get('start-arrow');
$self->{_items}{$item}{arrow_width} = $self->{_items}{$item}{line}->get('arrow-width');
$self->{_items}{$item}{arrow_length} = $self->{_items}{$item}{line}->get('arrow-length');
$self->{_items}{$item}{arrow_tip_length} = $self->{_items}{$item}{line}->get('arrow-tip-length');
}
#set type flag
$self->{_items}{$item}{type} = 'line';
$self->{_items}{$item}{uid} = $self->{_uid}++;
$self->{_items}{$item}{mirrored_w} = $mirrored_w;
$self->{_items}{$item}{mirrored_h} = $mirrored_h;
$self->{_items}{$item}{stroke_color} = $self->{_stroke_color};
#create rectangles
$self->handle_rects('create', $item);
if ($copy_item) {
$self->handle_embedded('update', $item);
$self->handle_rects('hide', $item);
}
$self->setup_item_signals($self->{_items}{$item}{line});
$self->setup_item_signals_extra($self->{_items}{$item}{line});
$self->setup_item_signals($self->{_items}{$item});
$self->setup_item_signals_extra($self->{_items}{$item});
return $item;
}
sub create_ellipse {
my $self = shift;
my $ev = shift;
my $copy_item = shift;
my $numbered = shift;
my ($x, $y, $width, $height) = (0, 0, 0, 0);
my $stroke_color = $self->{_stroke_color};
my $fill_color = $self->{_fill_color};
my $line_width = $self->{_line_width};
#use event coordinates and selected color
if ($ev) {
$x = $ev->x;
$y = $ev->y;
#use source item coordinates and item color
} elsif ($copy_item) {
$x = $copy_item->get('x') + 20;
$y = $copy_item->get('y') + 20;
$width = $copy_item->get('width');
$height = $copy_item->get('height');
$stroke_color = $self->{_items}{$copy_item}{stroke_color};
$fill_color = $self->{_items}{$copy_item}{fill_color};
$line_width = $self->{_items}{$copy_item}{ellipse}->get('line-width');
$numbered = TRUE if exists $self->{_items}{$copy_item}{text};
}
my $item = GooCanvas2::CanvasRect->new(
parent=>$self->{_canvas}->get_root_item, x=>$x, y=>$y, width=>$width, height=>$height,
'fill-color-rgba' => 0,
'line-dash' => GooCanvas2::CanvasLineDash->newv([5, 5]),
'line-width' => 1,
'stroke-color' => 'gray',
);
$self->{_current_new_item} = $item unless ($copy_item);
$self->{_items}{$item} = $item;
$self->{_items}{$item}{ellipse} = GooCanvas2::CanvasEllipse->new(
parent=>$self->{_canvas}->get_root_item, x=>$item->get('x'), y=>$item->get('y'), width=>$item->get('width'),
height=>$item->get('height'),
'fill-color-gdk-rgba' => $fill_color,
'stroke-color-gdk-rgba' => $stroke_color,
'line-width' => $line_width,
);
#numbered ellipse
if ($numbered) {
my $number = $self->get_highest_auto_digit();
$number++;
$self->{_items}{$item}{text} = GooCanvas2::CanvasText->new(
parent=>$self->{_canvas}->get_root_item, text=>"<span font_desc='" . $self->{_font} . "' >" . $number . "</span>",
x=>$self->{_items}{$item}{ellipse}->get('center-x'),
y=>$self->{_items}{$item}{ellipse}->get('center-y'),
width=>-1,
anchor=> 'center',
'use-markup' => TRUE,
'fill-color-gdk-rgba' => $stroke_color,
'line-width' => $line_width,
);
#save used number
$self->{_items}{$item}{text}{digit} = $number;
#set type flag
$self->{_items}{$item}{type} = 'number';
$self->{_items}{$item}{uid} = $self->{_uid}++;
#adjust parent rectangle if numbered ellipse
my $tb = $self->{_items}{$item}{text}->get_bounds;
#keep ratio = 1
my $qs = abs($tb->x1 - $tb->x2);
$qs = abs($tb->y1 - $tb->y2) if abs($tb->y1 - $tb->y2) > abs($tb->x1 - $tb->x2);
#add line width of parent ellipse
$qs += $self->{_items}{$item}{ellipse}->get('line-width') + 5;
if ($copy_item) {
$self->{_items}{$item}->set(
'x' => $self->{_items}{$item}->get('x') + 20,
'y' => $self->{_items}{$item}->get('y') + 20,
'width' => $qs,
'height' => $qs,
'visibility' => 'hidden',
);
} else {
$self->{_items}{$item}->set(
'x' => $self->{_items}{$item}->get('x') - $qs,
'y' => $self->{_items}{$item}->get('y') - $qs,
'width' => $qs,
'height' => $qs,
'visibility' => 'hidden',
);
}
$self->handle_embedded('hide', $item);
} else {
#set type flag
$self->{_items}{$item}{type} = 'ellipse';
$self->{_items}{$item}{uid} = $self->{_uid}++;
}
#save color and opacity as well
$self->{_items}{$item}{fill_color} = $self->{_fill_color};
$self->{_items}{$item}{stroke_color} = $self->{_stroke_color};
#create rectangles
$self->handle_rects('create', $item);
if ($copy_item) {
$self->handle_embedded('update', $item);
$self->handle_rects('hide', $item);
}
if ($numbered) {
$self->setup_item_signals($self->{_items}{$item}{text});
$self->setup_item_signals_extra($self->{_items}{$item}{text});
}
$self->setup_item_signals($self->{_items}{$item}{ellipse});
$self->setup_item_signals_extra($self->{_items}{$item}{ellipse});
$self->setup_item_signals($self->{_items}{$item});
$self->setup_item_signals_extra($self->{_items}{$item});
return $item;
}
sub create_rectangle {
my $self = shift;
my $ev = shift;
my $copy_item = shift;
my ($x, $y, $width, $height) = (0, 0, 0, 0);
my $stroke_color = $self->{_stroke_color};
my $fill_color = $self->{_fill_color};
my $line_width = $self->{_line_width};
#use event coordinates and selected color
if ($ev) {
$x = $ev->x;
$y = $ev->y;
#use source item coordinates and item color
} elsif ($copy_item) {
$x = $copy_item->get('x') + 20;
$y = $copy_item->get('y') + 20;
$width = $copy_item->get('width');
$height = $copy_item->get('height');
$stroke_color = $self->{_items}{$copy_item}{stroke_color};
$fill_color = $self->{_items}{$copy_item}{fill_color};
$line_width = $self->{_items}{$copy_item}->get('line-width');
}
my $item = GooCanvas2::CanvasRect->new(
parent=>$self->{_canvas}->get_root_item, x=>$x, y=>$y, width=>$width, height=>$height,
'fill-color-gdk-rgba' => $fill_color,
'stroke-color-gdk-rgba' => $stroke_color,
'line-width' => $line_width,
);
$self->{_current_new_item} = $item unless ($copy_item);
$self->{_items}{$item} = $item;
#set type flag
$self->{_items}{$item}{type} = 'rectangle';
$self->{_items}{$item}{uid} = $self->{_uid}++;
$self->{_items}{$item}{fill_color} = $self->{_fill_color};
$self->{_items}{$item}{stroke_color} = $self->{_stroke_color};
#create rectangles
$self->handle_rects('create', $item);
$self->setup_item_signals($self->{_items}{$item});
$self->setup_item_signals_extra($self->{_items}{$item});
return $item;
}
# getters and setters
sub gettext { shift->{_d} }
sub dicons { shift->{_dicons} }
sub icons { shift->{_icons} }
sub clipboard { shift->{_clipboard} }
sub items { shift->{_items} }
sub drawing_window { shift->{_drawing_window} }
sub canvas { shift->{_canvas} }
sub cut {
my $self = shift;
$self->{_cut} = shift if scalar @_;
return $self->{_cut};
}
sub current_copy_item {
my $self = shift;
$self->{_current_copy_item} = shift if scalar @_;
return $self->{_current_copy_item};
}
sub current_item {
my $self = shift;
$self->{_current_item} = shift if scalar @_;
return $self->{_current_item};
}
sub current_new_item {
my $self = shift;
$self->{_current_new_item} = shift if scalar @_;
return $self->{_current_new_item};
}
sub canvas_bg {
my $self = shift;
$self->{_canvas_bg} = shift if scalar @_;
return $self->{_canvas_bg};
}
sub factory {
my $self = shift;
$self->{_factory} = shift if scalar @_;
return $self->{_factory};
}
sub autoscroll {
my $self = shift;
$self->{_autoscroll} = shift if scalar @_;
return $self->{_autoscroll};
}
sub stroke_color {
my $self = shift;
$self->{_stroke_color} = shift if scalar @_;
return $self->{_stroke_color};
}
sub fill_color {
my $self = shift;
$self->{_fill_color} = shift if scalar @_;
return $self->{_fill_color};
}
sub line_width {
my $self = shift;
$self->{_line_width} = shift if scalar @_;
return $self->{_line_width};
}
sub font {
my $self = shift;
$self->{_font} = shift if scalar @_;
return $self->{_font};
}
sub uid { shift->{_uid} }
sub increase_uid { shift->{_uid}++ }
sub uimanager { shift->{_uimanager} }
1;
###################################################
#
# Copyright (C) 2008-2013 Mario Kemper <mario.kemper@gmail.com>
#
# This file is part of Shutter.
#
# Shutter 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.
#
# Shutter 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 Shutter; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
#
###################################################
#perl -x -S perltidy -l=0 -b "%f"
# Native Gtk3::IconSize doesn't work for some reason
# FIXME This package should be cleaned up when fixing DrawingTool
package Gtk3::IconSize;
sub lookup {
my $self = shift;
my $size = shift;
Shutter::App::HelperFunctions->icon_size($size);
}
1;
package Shutter::Draw::DrawingTool;
#modules
#--------------------------------------
use utf8;
use strict;
use warnings;
use constant {
DEFAULT_FONT => "Sans Regular 16"
};
use Gtk3;
use Exporter;
use GooCanvas2;
use GooCanvas2::CairoTypes;
use File::Basename qw/ fileparse dirname basename /;
use File::Glob qw/ bsd_glob /;
use File::Temp qw/ tempfile tempdir /;
use Data::Dumper;
#Sort::Naturally - sort lexically, but sort numeral parts numerically
use Sort::Naturally;
#load and save settings
use XML::Simple;
#Glib
use Glib qw/TRUE FALSE/;
require Shutter::Draw::Utils;
require Shutter::App::Directories;
require Shutter::Draw::UIManager;
#--------------------------------------
sub new {
my $class = shift;
my $self = {_sc => shift};
$self->{_shf} = Shutter::App::HelperFunctions->new($self->{_sc});
#view, selector, dragger
$self->{_view} = Gtk3::ImageView->new;
$self->{_selector} = Gtk3::ImageView::Tool::Selector->new($self->{_view});
$self->{_dragger} = Gtk3::ImageView::Tool::Dragger->new($self->{_view});
$self->{_view}->set_tool($self->{_selector});
$self->{_view_css_provider_alpha} = Gtk3::CssProvider->new;
$self->{_view}->get_style_context->add_provider($self->{_view_css_provider_alpha}, 0);
$self->{_view}->set('zoom-step', 1.2);
#WORKAROUND
#upstream bug
#http://trac.bjourne.webfactional.com/ticket/21
#left => zoom in
#right => zoom out
$self->{_view}->signal_connect(
'scroll-event',
sub {
my ($view, $ev) = @_;
if ($ev->direction eq 'left') {
$ev->direction('up');
} elsif ($ev->direction eq 'right') {
$ev->direction('down');