diff options
| author | Jörg Frings-Fürst <jff@merkur> | 2014-07-06 15:20:38 +0200 |
|---|---|---|
| committer | Jörg Frings-Fürst <jff@merkur> | 2014-07-06 15:20:38 +0200 |
| commit | 126bb8cb6b93240bb4d3a2b816b74c286c3d422b (patch) | |
| tree | e66e1dfe77d53a52539489765c88d23e4423ae27 /lib/gcstar/GCGraphicComponents/GCBaseWidgets.pm | |
Imported Upstream version 1.7.0upstream/1.7.0
Diffstat (limited to 'lib/gcstar/GCGraphicComponents/GCBaseWidgets.pm')
| -rw-r--r-- | lib/gcstar/GCGraphicComponents/GCBaseWidgets.pm | 4023 |
1 files changed, 4023 insertions, 0 deletions
diff --git a/lib/gcstar/GCGraphicComponents/GCBaseWidgets.pm b/lib/gcstar/GCGraphicComponents/GCBaseWidgets.pm new file mode 100644 index 0000000..f2f9af4 --- /dev/null +++ b/lib/gcstar/GCGraphicComponents/GCBaseWidgets.pm @@ -0,0 +1,4023 @@ +package GCBaseWidgets; + +################################################### +# +# Copyright 2005-2010 Christian Jodar +# +# This file is part of GCstar. +# +# GCstar 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 2 of the License, or +# (at your option) any later version. +# +# GCstar 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 GCstar; if not, write to the Free Software +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA +# +################################################### +use utf8; +use Gtk2; +#use GCBorrowings; +use Encode; + + +use strict; + +our @videoExtensions = ('.aaf','.3gp','.asf','.avi','.flv','.m1v','.m2v','.m4v','.mkv','.mov', + '.mp4','.mpeg','.mpg','.mpe','.mxf','.nsv','.ogg','.ogv','.rm','.swf','.wmv', + '.iso'); + +our @ebookExtensions = ('.txt','.htm','.html','.azw','.opf','.tr2','.tr3','.aeh','.fb2','.chm', + '.pdf','.ps','.djvu','.lit','.pdb','.dnl','.xeb','.ceb','.lbr','.prc', + '.mobi','.epub','.lrf','.lrx','.pdg','.doc','.odt','.cbr','.cbz','.djvu'); + +our @audioExtensions = ('.m3u','.pls','.asx','.wax','.wvx','.b4s','.kpl','.ram','.smil','.iso', + '.cue','.bin','.mp3','.ogg','.oga','.flac'); + +sub createWidget +{ + my ($parent, $info, $comparison) = @_; + my $widget; + my $withComparisonLabel = 1; + + if ($info->{type} eq 'short text') + { + if ($comparison eq 'range') + { + $widget = new GCRange('text', $parent->{lang}); + $widget->setWidth(16); + $withComparisonLabel = 0; + } + else + { + $widget = new GCShortText; + } + } + elsif ($info->{type} eq 'number') + { + #If we want to have values that are less to the specified one, + #we use max as default to be sure everything will be returned + #in that case. + my $default = $info->{min}; + $default = $info->{max} + if $comparison =~ /^l/; + if (exists $info->{min}) + { + if ($comparison eq 'range') + { + $widget = new GCRange('number', + $parent->{lang}, + $info->{min}, + $info->{max}, + $info->{step}); + $widget->setWidth(16); + $withComparisonLabel = 0; + } + else + { + $widget = new GCNumeric($default, + $info->{min}, + $info->{max}, + $info->{step}); + } + } + else + { + if ($comparison eq 'range') + { + $widget = new GCRange('numeric text', $parent->{lang}); + $widget->setWidth(16); + $withComparisonLabel = 0; + } + else + { + $widget = new GCCheckedText('0-9.'); + } + } + } + elsif ($info->{type} eq 'checked text') + { + $widget = new GCCheckedText($info->{format}); + } + elsif (($info->{type} eq 'history text') + || (($info->{type} =~ /list/) + && ($info->{history} ne 'false'))) + { + $widget = new GCHistoryText; + } + elsif ($info->{type} eq 'options') + { + $widget = new GCMenuList; + $widget->setValues($parent->{model}->getValues($info->{values}), $info->{separator}); + } + elsif ($info->{type} eq 'yesno') + { + $widget = new GCCheckBoxWithIgnore($parent); + $withComparisonLabel = 0; + } + elsif ($info->{type} eq 'date') + { + if ($comparison eq 'range') + { + $widget = new GCRange('date', $parent->{lang}, undef, undef, undef, $parent); + $widget->setWidth(16); + $withComparisonLabel = 0; + } + else + { + $widget = new GCDate($parent->{window}, $parent->{lang}, 1, + $parent->{options}->dateFormat); + } + } + else + { + $widget = new GCShortText; + } + + return ($widget, $withComparisonLabel); +} + +{ + package GCGraphicComponent; + + use base 'Exporter'; + our @EXPORT = qw($somethingChanged); + our $somethingChanged = 0; + + sub expand + { + } + + sub lock + { + } + + sub getMainParent + { + my $self = shift; + return if ! $self->{parent}; + my $tmpWidget = $self; + $tmpWidget = $tmpWidget->{parent} while $tmpWidget && (! $tmpWidget->isa('GCFrame')); + $self->{mainParent} = $tmpWidget; + } + + sub acceptMarkup + { + my $self = shift; + return 0; + } + + sub cleanMarkup + { + my ($self, $text, $encodeSubset) = @_; + $text =~ s|<br ?/?>|\n|g; + if ($encodeSubset) + { + # Encode only the characters set_markup has issues with + $text =~ s|&|&|g; + $text =~ s|<|<|g; + $text =~ s|>|>|g; + } + else + { + $text = GCUtils::encodeEntities($text) + } + return $text; + } + + sub selectAll + { + } + + sub getTagFromSpan + { + my ($self, $desc) = @_; + my @result = (); #('background' => $self->{background}); + my @keyvalues = split / /, $desc; + foreach (@keyvalues) + { + /([^=]*)=(.*)/; + my $key = $1; + my $value = $2; + $value =~ s/('|")//g; + #"' + next if $key =~ /=/; + push @result, ($key, $value); + } + return @result; + } + + sub valueToDisplayed + { + # 1st parameter is self + shift; + # Here we don't change the value; + return shift; + } + + sub hasChanged + { + my $self = shift; + + return $self->{hasChanged}; + } + + sub setChanged + { + my $self = shift; + $self->{hasChanged} = 1; + $somethingChanged = 1; + } + + sub setWidth + { + my ($self, $value) = @_; + } + + sub setHeight + { + my ($self, $height) = @_; + } + + sub resetChanged + { + my $self = shift; + $self->{hasChanged} = 0; + } + + sub activateStateTracking + { + # We do nothing by default + # Other widget should connect a signal handler or something similar + # when the content has been changed + } + + sub getLinkedValue + { + } + sub setLinkedValue + { + } + + sub setLinkedComponent + { + my ($self, $linked) = @_; + $self->{linkedComponent} = $linked; + } +} + +{ + package GCPseudoHistoryComponent; + # + # This is an abstract package handling a little history + # + sub initHistory + { + my ($self, $listType) = @_; + $self->{history} = {}; + + # listType contains the type of the original field: + # 0: No list + # >0: Multiple list (number of columns) + $self->{listType} = $listType; + + $self->{history}->{0} = {'' => 1}; + for(my $i = 1; $i < $listType; $i++) + { + $self->{history}->{$i} = {'' => 1}; + } + $self->{listType} = $listType; + } + + sub addHistory + { + my $self = shift; + + my $value = shift; + my $i; + if (ref($value) eq 'ARRAY') + { + foreach (@$value) + { + $i = 0; + foreach my $item(@$_) + { + $self->{history}->{$i}->{$item} = 1; + $i++; + } + } + } + else + { + # The separator used was ; instead of , + $value =~ s/;/,/g if $value !~ /,/; + my @values = split m/,/, $value; + foreach (@values) + { + my @items = split m/;/; + $i = 0; + foreach my $item(@items) + { + $self->{history}->{$i}->{$item} = 1; + $i++; + } + } + } + } + + sub setDropDown + { + } + + sub getValues + { + my $self = shift; + my @array; + + + if ($self->{listType} < 1) + { + @array = sort keys %{$self->{history}->{0}}; + } + else + { + foreach (sort keys %{$self->{history}}) + { + my @tmpArray = sort keys %{$self->{history}->{$_}}; + push @array, \@tmpArray; + } + } + return \@array; + } + + sub setValues + { + my ($self, $values) = @_; + if ($self->{listType} == 0) + { + $self->{history} = {}; + $self->{history}->{0}->{$_} = 1 foreach (@$values); + } + else + { + $self->{history} = {}; + for (my $i = 0; $i < $self->{listType}; $i++) + { + $self->{history}->{$i}->{$_} = 1 foreach (@{$values->[$i]}); + } + } + } +} + +{ + package GCLinkedComponent; + @GCLinkedComponent::ISA = ('GCGraphicComponent'); + + sub new + { + my ($proto, $linked) = @_; + my $class = ref($proto) || $proto; + + my $self = {linked => $linked}; + bless ($self, $class); + $linked->setLinkedComponent($self); + return $self; + } + + sub setValue + { + my $self = shift; + $self->setChanged; + return $self->{linked}->setLinkedValue(@_); + } + + sub getValue + { + my $self = shift; + return $self->{linked}->getLinkedValue(@_); + } + + sub resetChanged + { + my $self = shift; + $self->{hasChanged} = 0; + return $self->{linked}->resetChanged(@_); + } + + sub hide + { + my $self = shift; + $self->{linked}->setLinkedActivated(0); + } + + sub show + { + my $self = shift; + $self->{linked}->setLinkedActivated(1); + } +} + +{ + package GCShortText; + + use Glib::Object::Subclass + Gtk2::Entry:: + ; + + @GCShortText::ISA = ('Gtk2::Entry', 'GCGraphicComponent'); + + sub new + { + my ($proto) = @_; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new; + + bless ($self, $class); + return $self; + } + + sub activateStateTracking + { + my $self = shift; + return if $self->{readOnly}; + $self->signal_connect('changed' => sub {; + $self->setChanged; + }); + } + + sub isEmpty + { + my $self = shift; + + return $self->getValue eq ''; + } + + sub selectAll + { + my $self = shift; + $self->select_region(0, length($self->getValue)); + $self->grab_focus; + } + + sub getValue + { + my $self = shift; + return $self->get_text; + } + + sub setValue + { + my ($self, $value) = @_; + $self->set_text($value); + } + + sub clear + { + my $self = shift; + $self->setValue(''); + } + + sub setWidth + { + my ($self, $value) = @_; + $self->set_width_chars($value); + } + + sub setReadOnly + { + my $self = shift; + $self->set_editable(0); + $self->{readOnly} = 1; + } + + sub lock + { + my ($self, $locked) = @_; + return if $self->{readOnly}; + #$self->can_focus(!$locked); + $self->set_editable(!$locked); + } +} + +our $hasSpellChecker; +BEGIN { + eval 'use Gtk2::Spell'; + if ($@) + { + $hasSpellChecker = 0; + } + else + { + $hasSpellChecker = 1; + } +} +{ + package GCLongText; + + + use Glib::Object::Subclass + Gtk2::ScrolledWindow:: + ; + + @GCLongText::ISA = ('Gtk2::ScrolledWindow', 'GCGraphicComponent'); + + sub new + { + my ($proto) = @_; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new; + + $self->{text} = new Gtk2::TextView; + $self->{text}->set_editable(1); + $self->{text}->set_wrap_mode('word'); + $self->set_border_width(0); + $self->set_shadow_type('in'); + $self->set_policy('automatic', 'automatic'); + #$self->set_size_request(-1,80); + + $self->add($self->{text}); + $self->{spellChecker} = 0; + + bless ($self, $class); + return $self; + } + + sub activateStateTracking + { + my $self = shift; + $self->{text}->get_buffer->signal_connect('changed' => sub {; + $self->setChanged; + }); + } + + sub setSpellChecking + { + my ($self, $activate, $lang) = @_; + return if ! $GCGraphicComponents::hasSpellChecker; + if ($activate) + { + $lang ||= $ENV{LANG}; + if ($self->{spellChecker}) + { + return if $lang eq $self->{lang}; + $self->setSpellChecking(0) + } + eval { + $self->{spellChecker} = Gtk2::Spell->new_attach($self->{text}); + $self->{spellChecker}->set_language($lang); + $self->{lang} = $lang; + }; + if ($@) + { + $self->setSpellChecking(0); + } + } + else + { + $self->{spellChecker}->detach if $self->{spellChecker}; + $self->{spellChecker} = 0; + } + } + + sub isEmpty + { + my $self = shift; + + return $self->getValue eq ''; + } + + sub getValue + { + my $self = shift; + my $buffer = $self->{text}->get_buffer; + my $text = $buffer->get_text($buffer->get_start_iter, + $buffer->get_end_iter, 1); + #$text =~s/\n/<br\/>/g; + return $text; + } + + sub setValue + { + my ($self, $text) = @_; + #$text =~s/<br\/>/\n/g; + $text = '' if !defined $text; + $self->{text}->get_buffer->set_text($text); + } + + sub clear + { + my $self = shift; + $self->setValue(''); + } + + sub lock + { + my ($self, $locked) = @_; + + $self->{text}->can_focus(!$locked); + } + + sub setHeight + { + my ($self, $height) = @_; + + # TODO Change height + } +} + +{ + package GCHistoryText; + + + use Glib::Object::Subclass + Gtk2::Combo:: + ; + + @GCHistoryText::ISA = ('Gtk2::Combo', 'GCGraphicComponent'); + + sub new + { + my ($proto) = @_; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new; + $self->{history} = {'' => 1}; + + # Settings for auto-completion + $self->{completionModel} = Gtk2::ListStore->new('Glib::String'); + $self->{completion} = Gtk2::EntryCompletion->new; + $self->{completion}->set_model($self->{completionModel}); + $self->{completion}->set_text_column(0); + $self->entry->set_completion($self->{completion}); + + bless ($self, $class); + return $self; + } + + sub activateStateTracking + { + my $self = shift; + $self->entry->signal_connect('changed' => sub {; + $self->setChanged; + }); + } + + sub isEmpty + { + my $self = shift; + + return $self->getValue eq ''; + } + + sub selectAll + { + my $self = shift; + $self->entry->select_region(0, -1); + $self->entry->grab_focus; + } + + sub getValue + { + my $self = shift; + my @children = $self->get_children; + return $children[0]->get_text if $children[0]; + } + + sub setValue + { + my ($self, $text) = @_; + my @children = $self->get_children; + $children[0]->set_text($text); + } + + sub clear + { + my $self = shift; + $self->setValue(''); + } + + sub setWidth + { + my ($self, $value) = @_; + ($self->get_children)[0]->set_width_chars($value); + } + + sub lock + { + my ($self, $locked) = @_; + + ($self->get_children)[0]->can_focus(!$locked); + ($self->get_children)[1]->set_sensitive(!$locked); + } + + sub addHistory + { + my $self = shift; + my $value = (scalar @_) ? shift : $self->getValue; + my $noUpdate = shift; + $value =~ s/^\s*//; + if (!exists $self->{history}->{$value}) + { + $self->{history}->{$value} = 1; + if (!$noUpdate) + { + $self->setDropDown(sort keys %{$self->{history}}); + } + } + } + + sub setDropDown + { + my $self = shift; + my @values = (scalar @_) ? @_ : sort keys %{$self->{history}}; + my $previousValue = $self->getValue; + + # Update history list + $self->set_popdown_strings(@values); + + # Restore value as it is lost when updating list + $self->setValue($previousValue); + + # Update auto-completion list + $self->{completionModel}->clear; + foreach (@values) + { + my $iter = $self->{completionModel}->append; + $self->{completionModel}->set($iter, + 0 => $_); + } + } + + sub getValues + { + my $self = shift; + my @array = sort keys %{$self->{history}}; + return \@array; + } + + sub setValues + { + my ($self, $values) = @_; + $self->{history} = {}; + $self->setDropDown(@$values); + $self->{history}->{$_} = 1 foreach (@$values); + } + + sub setActivate + { + my $value + } + + sub popup + { + my $self = shift; + ($self->get_children)[1]->grab_focus; + ($self->get_children)[1]->signal_emit('activate'); + } +} + +{ + package GCNumeric; + + + use Glib::Object::Subclass + Gtk2::SpinButton:: + ; + + @GCNumeric::ISA = ('Gtk2::SpinButton', 'GCRatingWidget', 'GCGraphicComponent'); + + use GCWidgets; + use GCLang; + + sub new + { + my ($proto, $default, $min, $max, $step, $format) = @_; + my $class = ref($proto) || $proto; + + my $self; + + if (($format eq 'text') || (!$format)) + { + # Standard numeric field + $step = 1 if !$step; + my $pageStep = 10 * $step; + + my $decimals = 0; + $decimals = length($1) if $step =~ /\.(.*)$/; + + my $accel = 0; + my $values = ($max - $min) / $step; + $accel = 0.2 if $values > 100; + $accel = 0.5 if $values > 500; + $accel = 1.0 if $values > 2000; + $default = 0 if $default eq ''; + my $adj = Gtk2::Adjustment->new($default, $min, $max, $step, $pageStep, 0) ; + $self = $class->SUPER::new($adj, $accel, $decimals); + $self->{default} = $default; + $self->{step} = $step; + $self->{pageStep} = $pageStep; + $self->{accel} = $accel; + $self->{format} = 'text'; + $self->set_numeric(1); + } + elsif ($format eq 'graphical') + { + # Graphical rating widget + $default = 0 if $default eq ''; + $max = 10 if $max eq ''; + + $self = GCRatingWidget->new (maxStars=>$max, rating=>$default, direction=>GCLang::languageDirection($ENV{LANG})); + $self->{format} = 'graphical'; + } + bless ($self, $class); + return $self; + } + + sub activateStateTracking + { + my $self = shift; + $self->signal_connect('changed' => sub {; + $self->setChanged; + }); + } + + sub isEmpty + { + my $self = shift; + + if ($self->{format} eq 'text') + { + return $self->get_text eq ''; + } + elsif ($self->{format} eq 'graphical') + { + return $self->get('rating') eq 0; + } + } + + sub selectAll + { + my $self = shift; + if ($self->{format} eq 'text') + { + $self->select_region(0, length($self->getValue)); + } + } + + sub getValue + { + my $self = shift; + my $value; + + if ($self->{format} eq 'text') + { + $value = $self->get_text; + $value =~ s/,/./; + } + elsif ($self->{format} eq 'graphical') + { + $value = $self->get('rating'); + } + + return $value; + } + + sub setValue + { + my ($self, $text) = @_; + + if ($self->{format} eq 'text') + { + $text = $self->{default} if $text eq ''; + $self->set_value($text); + } + elsif ($self->{format} eq 'graphical') + { + $text = $self->{default} if $text eq ''; + $self->set_rating($text); + } + } + + sub clear + { + my $self = shift; + + if ($self->{format} eq 'text') + { + $self->set_value($self->{default}); + } + elsif ($self->{format} eq 'graphical') + { + $self->set_rating($self->{default}); + } + } + + sub setWidth + { + my ($self, $value) = @_; + $self->set_width_chars($value); + } + + sub lock + { + my ($self, $locked) = @_; + + if ($self->{format} eq 'text') + { + $self->can_focus(!$locked); + my $step = ($locked ? 0 : $self->{step}); + $self->set_increments($step, $self->{pageStep}); + } + elsif ($self->{format} eq 'graphical') + { + $self->set(sensitive=>!$locked); + } + } +} + +{ + package GCCheckedText; + + use Glib::Object::Subclass + Gtk2::Entry:: + ; + + @GCCheckedText::ISA = ('GCShortText'); + + sub new + { + my ($proto, $format) = @_; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new; + bless ($self, $class); + my $forbidden = qr/[^$format]/; + $self->signal_connect('insert-text' => sub { + # Remove forbidden characters + $_[1] =~ s/$forbidden//g; + () # this callback must return either 2 or 0 items. + }); + + return $self; + } +} + +{ + package GCRange; + + use Glib::Object::Subclass + Gtk2::HBox:: + ; + + @GCRange::ISA = ('Gtk2::HBox', 'GCGraphicComponent'); + + sub new + { + my ($proto, $type, $lang, $min, $max, $step, $parent) = @_; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new; + bless ($self, $class); + + if ($type eq 'text') + { + $self->{from} = new GCShortText; + $self->{to} = new GCShortText; + } + elsif ($type eq 'numeric text') + { + new GCCheckedText('0-9.'); + $self->{to} = new GCCheckedText('0-9.'); + } + elsif ($type eq 'date') + { + $self->{from} = new GCDate($parent->{window}, $lang, 1, + $parent->{options}->dateFormat); + $self->{to} = new GCDate($parent->{window}, $lang, 1, + $parent->{options}->dateFormat); + } + else + { + $self->{from} = new GCNumeric($min, $min, $max, $step); + $self->{to} = new GCNumeric($max, $min, $max, $step); + } + $self->pack_start(Gtk2::Label->new($lang->{PanelFrom}), 0, 0, 12); + $self->pack_start($self->{from}, 1, 1, 0); + $self->pack_start(Gtk2::Label->new($lang->{PanelTo}), 0, 0, 12); + $self->pack_start($self->{to}, 1, 1, 0); + + return $self; + } + + sub activateStateTracking + { + my $self = shift; + $self->{from}->activateStateTracking; + $self->{to}->activateStateTracking; + } + + sub isEmpty + { + my $self = shift; + + return $self->getValue eq ''; + } + + sub getValue + { + my $self = shift; + return $self->{from}->getValue.';'.$self->{to}->getValue; + } + + sub setValue + { + my ($self, $value) = @_; + my @values = split m/;/, $value; + $self->{from}->setValue($values[0]); + $self->{to}->setValue($values[0]); + } + + sub setWidth + { + my ($self, $value) = @_; + $self->{from}->setWidth($value / 2); + $self->{to}->setWidth($value / 2); + } + + sub lock + { + my ($self, $locked) = @_; + + $self->{from}->lock(!$locked); + $self->{to}->lock(!$locked); + } + + sub signal_connect + { + my $self = shift; + $self->{from}->signal_connect(@_); + $self->{to}->signal_connect(@_); + } + + sub AUTOLOAD + { + my $self = shift; + my $name = our $AUTOLOAD; + return if $name =~ /::DESTROY$/; + $name =~ s/.*?::(.*)/$1/; + $self->{from}->$name(@_); + $self->{to}->$name(@_); + } +} + +{ + package GCDate; + + use Glib::Object::Subclass + Gtk2::HBox:: + ; + + @GCDate::ISA = ('Gtk2::HBox', 'GCGraphicComponent'); + + sub selectValue + { + my $self = shift; + $self->{dialog} = new GCDateSelectionDialog($self->{mainParent}) + if ! $self->{dialog}; + $self->{dialog}->date($self->getRawValue); + if ($self->{dialog}->show) + { + $self->setValue($self->{dialog}->date); + } + $self->{parent}->showMe; + } + + sub new + { + my ($proto, $parent, $lang, $reverseDate, $format) = @_; + $format ||= '%d/%m/%Y'; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new; + bless ($self, $class); + + $self->{parent} = $parent; + $self->getMainParent; + $self->{reverseDate} = $reverseDate; + $self->{entry} = Gtk2::Entry->new; #_with_max_length(10); + $self->{entry}->set_width_chars(12); + $self->{button} = new Gtk2::Button($lang->{PanelDateSelect}); + $self->{button}->signal_connect('clicked' => sub { + $self->selectValue; + }); + $self->pack_start($self->{entry}, 1, 1, 0); + $self->pack_start($self->{button}, 0, 0, 0); + + $self->{format} = $format; + #$self->{format} = '%d %B %Y'; + return $self; + } + + sub setFormat + { + my ($self, $format) = @_; + my $current = $self->getValue; + $self->{format} = $format; + $self->setValue($current); + } + + sub activateStateTracking + { + my $self = shift; + $self->{entry}->signal_connect('changed' => sub {; + $self->setChanged; + }); + } + + sub isEmpty + { + my $self = shift; + + return $self->getValue eq ''; + } + + sub getCurrentDate + { + my $self = shift; + + my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time); + return sprintf('%02d/%02d/%4d', $mday, $mon+1, 1900+$year); + } + + + sub getRawValue + { + my $self = shift; + my $value = $self->{entry}->get_text; + $value = GCUtils::strToTime($value, $self->{format}) + if $self->{format} && $value; + return $value; + + } + + sub getValue + { + my $self = shift; + my $value = $self->getRawValue; + return GCPreProcess::reverseDate($value) if $self->{reverseDate}; + return $value; + } + + sub setValue + { + my ($self, $text) = @_; + $text = GCPreProcess::restoreDate($text) if $self->{reverseDate}; + if ($text eq 'current') + { + $text = $self->getCurrentDate; + $self->setChanged; + } + $text = GCUtils::timeToStr($text, $self->{format}) if $self->{format}; + $self->{entry}->set_text($text); + } + + sub clear + { + my $self = shift; + $self->setValue(''); + } + + sub setWidth + { + my ($self, $value) = @_; + $self->{entry}->set_width_chars($value); + } + + sub lock + { + my ($self, $locked) = @_; + + $self->{entry}->can_focus(!$locked); + $self->{button}->set_sensitive(!$locked); + } +} + +{ + package GCFile; + + use Glib::Object::Subclass + Gtk2::HBox:: + ; + + @GCFile::ISA = ('Gtk2::HBox', 'GCGraphicComponent', 'GCPseudoHistoryComponent'); + + use File::Basename; + + sub selectValue + { + my $self = shift; + + my $dialog = GCFileChooserDialog->new($self->{title}, + $self->{mainParent}, + $self->{type}, + $self->{withFilter}); + $dialog->set_filename($self->getValue); + $dialog->set_pattern_filter($self->{patterns}) + if $self->{patterns}; + my $response = $dialog->run; + if ($response eq 'ok') + { + $self->setValue($dialog->get_filename); + } + $dialog->hide; + $self->{parent}->showMe; + } + + sub setPatternFilter + { + my ($self, $patterns) = @_; + $self->{patterns} = $patterns; + } + + sub setType + { + my ($self, $type, $withFilter) = @_; + + if (($type ne $self->{type}) || ($withFilter != $self->{withFilter})) + { + $self->{dialog}->destroy + if $self->{dialog}; + $self->{dialog} = undef; + $self->{type} = $type; + $self->{withFilter} = $withFilter; + } + } + + sub setTitle + { + my ($self, $title) = @_; + $self->{title} = $title; + if ($self->{dialog}) + { + $self->{dialog}->setTitle($title); + } + } + + sub new + { + my ($proto, $parent, $title, $type, $withFilter, $defaultValue, $allowContextMenu, $fieldType) = @_; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new; + bless ($self, $class); + $self->{parent} = $parent; + $self->getMainParent; + + $title ||= $self->{parent}->{lang}->{PanelSelectFileTitle}; + $self->{title} = $title; + $type ||= 'open'; + $self->{type} = $type; + $withFilter = 0 if !$withFilter; + $self->{withFilter} = $withFilter; + + $self->{entry} = Gtk2::Entry->new; + + $self->{button} = new GCButton($self->{parent}->{lang}->{PanelSelectFileTitle}); + + # For video/ebook/audio files, set file pattern filters + if (($fieldType eq 'video') || ($fieldType eq 'ebook') || ($fieldType eq 'audio')) + { + $self->setPatternFilter([$self->{parent}->{lang}->{FileVideoFiles}, \@videoExtensions]) + if ($fieldType eq 'video'); + $self->setPatternFilter([$self->{parent}->{lang}->{FileEbookFiles}, \@ebookExtensions]) + if ($fieldType eq 'ebook'); + $self->setPatternFilter([$self->{parent}->{lang}->{FileAudioFiles}, \@audioExtensions]) + if ($fieldType eq 'audio'); + $self->{withFilter} = 1; + } + + $self->{button}->signal_connect('clicked' => sub { + $self->selectValue; + }); + + if ($allowContextMenu) + { + my @subMenuFileChoose; + $subMenuFileChoose[0] = Gtk2::ImageMenuItem->new_with_mnemonic($parent->{lang}->{ContextChooseFile}); + $subMenuFileChoose[0]->signal_connect("activate" , sub {$self->selectValue}); + $subMenuFileChoose[1] = Gtk2::ImageMenuItem->new_with_mnemonic($parent->{lang}->{ContextChooseFolder}); + $subMenuFileChoose[1]->signal_connect("activate" , sub { + $self->{type} = 'select-folder'; + $self->{title} = $parent->{lang}->{ContextChooseFolder}; + $self->selectValue; + }); + $self->{button}->setContextMenu(\@subMenuFileChoose); + $self->{button}->enableContextMenu; + } + + $self->pack_start($self->{entry}, 1, 1, 0); + + if ($defaultValue) + { + $self->{defaultButton} = GCButton->newFromStock('gtk-undo', 0, $parent->{lang}->{PanelRestoreDefault}); + $parent->{tooltips}->set_tip($self->{defaultButton}, + $parent->{lang}->{PanelRestoreDefault}.$parent->{lang}->{Separator}.$defaultValue) + if $parent->{tooltips}; + $self->pack_start($self->{defaultButton}, 0, 0, 0); + $self->{defaultButton}->signal_connect('clicked' => sub { + $self->setValue($defaultValue); + }); + } + + # Add the 'select file' button only if the field is not a url field + $self->pack_start($self->{button}, 0, 0, 0) + if ($fieldType ne 'url'); + + return $self; + } + + sub activateStateTracking + { + my $self = shift; + $self->{entry}->signal_connect('changed' => sub {; + $self->setChanged; + }); + } + + sub isEmpty + { + my $self = shift; + + return $self->getValue eq ''; + } + + sub getValue + { + my $self = shift; + return $self->{entry}->get_text; + } + + sub setValue + { + my ($self, $text) = @_; + $self->{entry}->set_text($text); + } + + sub clear + { + my $self = shift; + $self->setValue(''); + } + + sub setWidth + { + my ($self, $value) = @_; + $self->{entry}->set_width_chars($value); + } + + sub lock + { + my ($self, $locked) = @_; + + $self->{entry}->can_focus(!$locked); + $self->{button}->set_sensitive(!$locked); + } +} + +{ + package GCUrl; + + use Glib::Object::Subclass + Gtk2::HBox:: + ; + + @GCUrl::ISA = ('GCFile'); + + sub selectValue + { + my $self = shift; + my $url = $self->getValue; + return if !$url; + $self->{opener}->launch($url, 'url'); + } + + sub new + { + my ($proto, $opener) = @_; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new(undef, '', 'url'); + $self->{opener} = $opener; + bless ($self, $class); + return $self; + } +} + +{ + package GCButton; + + use Glib::Object::Subclass + Gtk2::Button:: + ; + + @GCButton::ISA = ('Gtk2::Button', 'GCGraphicComponent'); + + sub new + { + my ($proto, $label) = @_; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new($label); + + bless ($self, $class); + return $self; + } + + sub newFromStock + { + my ($proto, $stock, $nolabel, $label) = @_; + my $class = ref($proto) || $proto; + + $nolabel = 0 if ($^O =~ /win32/i); + + my $self = $class->SUPER::new_from_stock($stock); + + if ($nolabel) + { + my $tmpWidget = $self; + $tmpWidget = $tmpWidget->child while ! $tmpWidget->isa('Gtk2::HBox'); + ($tmpWidget->get_children)[1]->destroy; + } + elsif ($label) + { + my $tmpWidget = $self; + $tmpWidget = $tmpWidget->child while ! $tmpWidget->isa('Gtk2::HBox'); + ($tmpWidget->get_children)[1]->set_label($label); + } + + bless ($self, $class); + return $self; + } + + sub isEmpty + { + my $self = shift; + + return 0; + } + + sub getValue + { + my $self = shift; + } + + sub setValue + { + my ($self, $value) = @_; + $self->setChanged; + return $value; + } + + sub clear + { + my $self = shift; + $self->setValue(''); + } + + sub lock + { + my ($self, $locked) = @_; + + $self->set_sensitive(!$locked); + } + + sub setWidth + { + my ($self, $value) = @_; + $self->set_size_request($value, -1); + } + sub setContextMenu + { + my ($self, $menu) = @_; + $self->{popupContextMenu}=new Gtk2::Menu if !$self->{popupContextMenu}; + for my $i(0..$#{$self->{popupContextMenu}->{items}}) + { + $self->{popupContextMenu}->remove($self->{popupContextMenu}->{items}->[$i]); + $self->{popupContextMenu}->{items}->[$i]->destroy; + } + delete $self->{popupContextMenu}->{items}; + for my $i(0..$#$menu) + { + $self->{popupContextMenu}->{items}->[$i]=$menu->[$i]; + $self->{popupContextMenu}->append($self->{popupContextMenu}->{items}->[$i]); + } + $self->{popupContextMenu}->show_all; + } + sub enableContextMenu + { + my ($self,$button) = @_; + #TODO enabled context for one button mouses + $button=3 if !$button; + $self->{contextMenuSignalHandler}=$self->signal_connect('button_press_event' => sub { + my ($widget, $event) = @_; + return 0 if $event->button ne $button; + $self->{popupContextMenu}->popup(undef, undef, undef, undef, $event->button, $event->time); + return 0; + }) if !$self->{contextMenuSignalHandler}; + } + sub disableContextMenu + { + my $self = shift; + if($self->{contextMenuSignalHandler}) + { + $self->signal_handler_disconnect($self->{contextMenuSignalHandler}); + delete $self->{contextMenuSignalHandler}; + } + } +} + +{ + package GCUrlButton; + + use Glib::Object::Subclass + Gtk2::Button:: + ; + + @GCUrlButton::ISA = ('GCButton', 'GCGraphicComponent'); + + sub new + { + my ($proto, $label, $opener) = @_; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new($label); + $self->{opener}=$opener; + $self->{defaultLabel} = $label; + $self->{clicSignalHandler}=$self->signal_connect('clicked' => sub { + $self->{opener}->launch($self->{url}, 'url'); + }); + + + bless ($self, $class); + return $self; + } + + sub getValue + { + my $self = shift; + + return $self->{value}; + } + + sub setValue + { + my ($self, $value) = @_; + + $self->setChanged; + my @urls=split ';',$value; + if(scalar(@urls)>1) + { + my (@menu,$i,$url); + foreach my $urlName(@urls) + { + $urlName =~ /^(.*?)##(.*)$/; + my $name=$2; + my $menuItem=Gtk2::MenuItem->new_with_label($name); + $menuItem->signal_connect("activate" ,sub { + $self->{opener}->launch($_[1], 'url') + },$1); + push @menu,$menuItem; + } + $self->{url} =''; + $self->setContextMenu(\@menu); + $self->enableContextMenu(1); + $self->lock(0); + #$self->signal_handler_block($self->{clicSignalHandler}); + $self->setLabel($self->{defaultLabel}); + } + else + { + if ($value =~ /^(.*?)##(.*)$/) + { + $self->{url} = $1; + $self->setLabel($2); + } + else + { + $self->{url} = $value; + $self->setLabel($self->{defaultLabel}); + } + $self->lock(!$self->{url}); + $self->disableContextMenu; + #$self->signal_handler_unblock($self->{clicHandler}); + } + $self->{value} = $value; + } + + sub setLabel + { + my ($self, $label) = @_; + $self->set_label($label); + } +} + +{ + package GCCheckBox; + + use Glib::Object::Subclass + Gtk2::CheckButton:: + ; + + @GCCheckBox::ISA = ('Gtk2::CheckButton', 'GCGraphicComponent'); + + sub new + { + my ($proto, $label) = @_; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new($label); + + bless ($self, $class); + return $self; + } + + sub activateStateTracking + { + my $self = shift; + + $self->signal_connect('toggled' => sub { + $self->setChanged; + }); + } + + sub isEmpty + { + my $self = shift; + + return 0; + } + + sub getValue + { + my $self = shift; + return 1 if ($self->get_active); + return 0; + } + + sub getValueAsText + { + my $self = shift; + return 'true' if ($self->get_active); + return 'false'; + } + + sub setValue + { + my ($self, $value) = @_; + $self->set_active($value); + } + + sub clear + { + my $self = shift; + $self->setValue(0); + } + + sub lock + { + my ($self, $locked) = @_; + + $self->set_sensitive(!$locked); + } +} + +{ + package GCCheckBoxWithIgnore; + + use Glib::Object::Subclass + Gtk2::HBox:: + ; + + @GCCheckBoxWithIgnore::ISA = ('Gtk2::HBox', 'GCGraphicComponent'); + + sub new + { + my ($proto, $parent) = @_; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new(0,0); + bless ($self, $class); + + $self->{check}->[0] = new Gtk2::RadioButton(undef,$parent->{lang}->{CheckUndef}); + $self->{group} = $self->{check}->[0]->get_group; + $self->{check}->[1] = new Gtk2::RadioButton($self->{group},$parent->{lang}->{CheckNo}); + $self->{check}->[2] = new Gtk2::RadioButton($self->{group},$parent->{lang}->{CheckYes}); + + $self->pack_start($self->{check}->[0], 0, 0, 10); + $self->pack_start($self->{check}->[1], 0, 0, 10); + $self->pack_start($self->{check}->[2], 0, 0, 10); + + return $self; + } + + sub activateStateTracking + { + my $self = shift; + + foreach (@{$self->{check}}) + { + $_->signal_connect('toggled' => sub { + $self->setChanged; + }); + } + } + + sub isEmpty + { + my $self = shift; + + return $self->{check}->[0]->get_active; + } + + sub getValue + { + my $self = shift; + my $i = 0; + foreach (@{$self->{check}}) + { + last if $self->{check}->[$i]->get_active; + $i++; + } + $i--; + return $i; + } + + sub setValue + { + my ($self, $value) = @_; + $self->{check}->[$value + 1]->set_active(1); + } + + sub clear + { + my $self = shift; + $self->setValue(-1); + } + + sub lock + { + my ($self, $locked) = @_; + + $self->set_sensitive(!$locked); + } +} + +{ + package GCMultipleList; + + use Glib::Object::Subclass + Gtk2::HBox:: + ; + + @GCMultipleList::ISA = ('Gtk2::HBox', 'GCGraphicComponent'); + + sub new + { + my ($proto, $parent, $number, $labels, $withHistory, $readonly, $useFiles,$types) = @_; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new(0,0); + + $self->{number} = $number; + $self->{readonly} = $readonly; + $self->{withHistory} = $withHistory; + + my $hboxActions = new Gtk2::HBox(0,0); + + my @histories; + my @listColumns; + my $i; + for $i (0..($number - 1)) + { + push @histories, {'' => 1}; + push @listColumns, ($labels->[$i] => 'text'); + next if $readonly; + if ($useFiles) + { + $self->{entries}->[$i] = GCFile->new($parent); + $self->{entries}->[$i]->{entry}->signal_connect('activate' => sub { + $self->addValues; + }); + } + else + { + if($types && $types->[$i] eq 'date') + { + $self->{entries}->[$i] = GCDate->new($parent, $parent->{lang}, 1,$parent->{options}->dateFormat); + $self->{entries}->[$i]->{entry}->signal_connect('activate' => sub { + $self->addValues; + $self->{entries}->[0]->grab_focus; + }); + $self->{withHistoryField}->[$i]=0; + } + elsif ($withHistory && (!$types || $types->[$i] eq 'history')) + { + $self->{entries}->[$i] = GCHistoryText->new; + $self->{entries}->[$i]->entry->signal_connect('activate' => sub { + my $widget = $self->{entries}->[$i]; + if ($widget->getValue) + { + $self->addValues; + # FIXME. It seems this does nothing: + $self->{entries}->[0]->grab_focus; + } + $widget->entry->signal_stop_emission_by_name('activate'); + }); + $self->{withHistoryField}->[$i]=1; + } + else + { + $self->{entries}->[$i] = GCShortText->new; + $self->{entries}->[$i]->signal_connect('activate' => sub { + $self->addValues; + $self->{entries}->[0]->grab_focus; + }); + $self->{withHistoryField}->[$i]=0 if $withHistory; + } + } + $self->{entries}->[$i]->setWidth(12); + $hboxActions->pack_start($self->{entries}->[$i], 1, 1, 6); + } + + $self->{histories} = [\@histories]; + + $self->{box} = new Gtk2::VBox(0,0); + + # If list belongs to an expander, set box size to a reasonable size + $self->{box}->{signalHandler} = $self->{box}->signal_connect('size-allocate' => sub { + if (($self->{realParent}) && ($self->{realParent}->isa('GCExpander'))) + { + my $width = $self->allocation->width - ( 2 * $GCUtils::margin) ; + $self->{box}->set_size_request(($width >= -1) ? $width : -1 , -1); + return 0; + } + }); + + $self->{list} = new Gtk2::SimpleList(@listColumns); + for $i (0..($number - 1)) + { + $self->{list}->set_column_editable($i, 1); + } + $self->{list}->unset_rows_drag_source; + $self->{list}->unset_rows_drag_dest; + $self->{list}->set_reorderable(1); + #($self->{list}->get_column(0)->get_cell_renderers)[0]->set('wrap-mode' => 'word'); + + for $i (0..($number - 1)) + { + $self->{list}->get_column($i)->set_resizable(1); + } + my $scroll = new Gtk2::ScrolledWindow; + $scroll->set_policy ('automatic', 'automatic'); + $scroll->set_shadow_type('etched-in'); + $scroll->set_size_request(-1, 120); + $scroll->add($self->{list}); + $self->{box}->pack_start($scroll, 1, 1, 2); + if (!$readonly) + { + $self->{addButton} = GCButton->newFromStock('gtk-add', 0); + $self->{addButton}->signal_connect('clicked' => sub { + $self->addValues; + }); + $self->{removeButton} = GCButton->newFromStock('gtk-remove', 0); + $hboxActions->pack_start($self->{addButton}, 0, 0, 6); + $hboxActions->pack_start($self->{removeButton}, 0, 0, 6); + } + else + { + $self->{removeButton} = GCButton->newFromStock('gtk-remove', 0); + $self->{clearButton} = GCButton->newFromStock('gtk-clear', 0); + $self->{clearButton}->signal_connect('clicked' => sub { + $self->clear; + }); + $hboxActions->pack_start($self->{removeButton}, 1, 0, 6); + $hboxActions->pack_start($self->{clearButton}, 1, 0, 6); + } + $self->{box}->pack_start($hboxActions, 0, 0, 6) + if $readonly < 2; + + $self->{removeButton}->signal_connect('clicked' => sub { + my @idx = $self->{list}->get_selected_indices; + my $selected = $idx[0]; + splice @{$self->{list}->{data}}, $selected, 1; + $selected-- if ($selected >= scalar(@{$self->{list}->{data}})); + $selected = 0 if $selected < 0 ; + $self->{list}->select($selected); + }); + + $self->{list}->signal_connect('key-press-event' => sub { + my ($widget, $event) = @_; + my $key = Gtk2::Gdk->keyval_name($event->keyval); + if ((!$self->{readonly}) && ($key eq 'Delete')) + { + $self->{removeButton}->activate; + return 1; + } + # Let key be managed by Gtk2 + return 0; + }); + + + $self->pack_start($self->{box},1,$self->{readonly},0); + + bless ($self, $class); + return $self; + } + + sub activateStateTracking + { + my $self = shift; + $self->{list}->get_model->signal_connect('row-inserted' => sub { + $self->setChanged; + }); + $self->{list}->get_model->signal_connect('row-deleted' => sub { + $self->setChanged; + }); + $self->{list}->get_model->signal_connect('row-changed' => sub { + $self->setChanged; + }); + } + + sub expand + { + my $self = shift; + $self->set_child_packing($self->{box},1,1,0,'start'); + } + + sub addValues + { + my ($self, @values) = @_; + if (!$self->{readonly}) + { + for my $i (0..($self->{number} - 1)) + { + $values[$i] = $self->{entries}->[$i]->getValue if !$values[$i]; + $self->{entries}->[$i]->addHistory($values[$i]) + if $self->{withHistory} && $self->{withHistoryField}->[$i]; + $self->{entries}->[$i]->clear; + } + } + # Check that at least one value is not empty + my $isEmpty = 1; + for my $val (@values) + { + if ($val) + { + $isEmpty = 0; + last; + } + } + if (!$isEmpty) + { + push @{$self->{list}->{data}}, \@values; + $self->{list}->select($#{$self->{list}->{data}}); + my $path = $self->{list}->get_selection->get_selected_rows; + $self->{list}->scroll_to_cell($path) if $path; + } + } + + sub isEmpty + { + my $self = shift; + + return $self->getValue eq ''; + } + + sub getValue + { + my $self = shift; + my $formated = shift; + + if ($formated) + { + return GCPreProcess::multipleList($self->{list}->{data}, $self->{number}); + } + else + { + # As data in list is a tied array, we need to copy all the values + my @value; + foreach (@{$self->{list}->{data}}) + { + push @value, []; + foreach my $col(@$_) + { + push @{$value[-1]}, $col; + } + } + return \@value; + } + } + + sub setValue + { + my ($self, $value) = @_; + + if (ref($value) eq 'ARRAY') + { + @{$self->{list}->{data}} = @{$value}; + } + else + { + # The separator used was ; instead of , + $value =~ s/;/,/g if $value !~ /,/; + @{$self->{list}->{data}} = (); + my @values = split m/,/, $value; + foreach my $entry (@values) + { + my @items = split m/;/, $entry; + s/^\s*// foreach(@items); + push @{$self->{list}->{data}}, \@items; + } + } + } + + sub clear + { + my $self = shift; + $self->setValue(''); + } + + sub lock + { + my ($self, $locked) = @_; + return if $self->{readonly}; + $self->{addButton}->set_sensitive(!$locked); + $self->{removeButton}->set_sensitive(!$locked); + foreach (@{$self->{entries}}) + { + $_->lock($locked); + } + } + + sub addHistory + { + my $self = shift; + my $value = (scalar @_) ? shift : $self->getValue; + my $noUpdate = shift; + + return if $self->{readonly}; + my $i; + my $item; + if (ref($value) eq 'ARRAY') + { + foreach (@$value) + { + $i = 0; + foreach $item(@$_) + { + $self->{entries}->[$i]->addHistory($item, $noUpdate) if $self->{withHistoryField}->[$i]; + $i++; + } + } + } + else + { + # The separator used was ; instead of , + $value =~ s/;/,/g if $value !~ /,/; + my @values = split m/,/, $value; + foreach (@values) + { + my @items = split m/;/; + $i = 0; + foreach my $item(@items) + { + $self->{entries}->[$i]->addHistory($item, $noUpdate) if $self->{withHistoryField}->[$i]; + $i++; + } + #push @{$self->{list}->{data}}, \@items; + } + } + } + + sub setDropDown + { + my $self = shift; + + my $i = 0; + foreach (@{$self->{entries}}) + { + $_->setDropDown if $self->{withHistoryField}->[$i]; + $i++; + } + } + + sub getValues + { + my $self = shift; + return [] if $self->{readonly}; + my @array; + my $i=0; + foreach (@{$self->{entries}}) + { + my $val=[]; + $val=$_->getValues if ($self->{withHistoryField}->[$i++]); + push @array, $val; + } + # = sort keys %{$self->{history}}; + return \@array; + } + + sub setValues + { + my ($self, $values) = @_; + return if $self->{readonly}; + my $i = 0; + foreach (@$values) + { + $self->{entries}->[$i]->setValues($_) if ($self->{withHistoryField}->[$i]); + $i++; + } + } +} + + +{ + package GCItemImage; + + use Glib::Object::Subclass + Gtk2::Image:: + ; + + @GCItemImage::ISA = ('Gtk2::Image', 'GCGraphicComponent'); + + use File::Spec; + use File::Basename; + + sub new + { + my ($proto, $options, $parent, $fixedSize, $width, $height) = @_; + my $class = ref($proto) || $proto; +# my $self = Gtk2::Image->new_from_file($parent->{defaultImage}); + my $self = Gtk2::Image->new; + $self->{options} = $options; + #$self->{defaultImage} = $defaultImage; + $self->{parent} = $parent; + $self->{displayedImage} = ''; + $self->{fixedSize} = $fixedSize; + bless ($self, $class); + if ($width && $height) + { + $self->{width} = $width; + $self->{height} = $height; + } + else + { + $self->{width} = 120; + $self->{height} = 160; + } + $self->{immediate} = 0; + return $self; + } + + sub setImmediate + { + my ($self) = @_; + $self->{immediate} = 1; + } + sub activateStateTracking + { + my $self = shift; + $self->{trackState} = 1; + } + + sub isEmpty + { + my $self = shift; + + return $self->getValue eq ''; + } + + sub setValue + { + my ($self, $displayedImage, $placer) = @_; + $self->{displayedImage} = $displayedImage; + $self->setChanged if $self->{trackState}; + if ($self->{immediate}) + { + $self->setPicture; + } + else + { + Glib::Source->remove($self->{timer}) + if $self->{timer}; + $self->{timer} = Glib::Timeout->add(100, sub { + $self->setPicture; + $placer->placeImg if $placer; + return 0; + }); + } + } + + sub setPicture + { + my $self = shift; + $self->{timer} = 0; + my $displayedImage = GCUtils::getDisplayedImage($self->{displayedImage}, + $self->{parent}->{defaultImage}, + $self->{options}->file); + my $pixbuf; + eval + { + $pixbuf = Gtk2::Gdk::Pixbuf->new_from_file($displayedImage); + }; + if ($@) + { + $displayedImage = $self->{parent}->{defaultImage}; + $pixbuf = Gtk2::Gdk::Pixbuf->new_from_file($displayedImage); + } + $self->{realImage} = $displayedImage; + $pixbuf = GCUtils::scaleMaxPixbuf($pixbuf, $self->{width}, $self->{height}); + $self->set_from_pixbuf($pixbuf); + $self->set_size_request($self->{width}, $self->{height}) if $self->{fixedSize}; + } + + sub getValue + { + my $self = shift; + return $self->{displayedImage}; + } + + sub getFile + { + my $self = shift; + return $self->{realImage}; + } + + sub clear + { + my $self = shift; + $self->setValue(''); + } + + sub lock + { + my ($self, $locked) = @_; + } + + sub setWidth + { + my ($self, $value) = @_; + $self->{width} = $value; + } + + sub setHeight + { + my ($self, $value) = @_; + $self->{height} = $value; + } + + sub getSize + { + my $self = shift; + my $pixbuf = $self->get_pixbuf; + return ($pixbuf->get_width, $pixbuf->get_height); + } +} + + +our $hasGnome2VFS; +BEGIN { + eval 'use Gnome2::VFS'; + if ($@) + { + $hasGnome2VFS = 0; + } + else + { + $hasGnome2VFS = 1; + Gnome2::VFS->init(); + } +} + +{ + package GCImageButton; + + use Glib::Object::Subclass + Gtk2::Button:: + ; + + @GCImageButton::ISA = ('Gtk2::Button', 'GCGraphicComponent'); + + use File::Basename; + use Encode; + + sub animateImg + { + my ($self, $from, $to) = @_; + my $pixbuf1 = Gtk2::Gdk::Pixbuf->new_from_file($from); + $pixbuf1 = GCUtils::scaleMaxPixbuf($pixbuf1, $self->{img}->{width}, $self->{img}->{height}); + my $pixbuf2 = Gtk2::Gdk::Pixbuf->new_from_file($to); + $pixbuf2 = GCUtils::scaleMaxPixbuf($pixbuf2, $self->{img}->{width}, $self->{img}->{height}); + my $height = $pixbuf2->get_height; + my $width = $pixbuf2->get_width; + foreach my $i(0..20) + { + Glib::Timeout->add(30*$i, sub { + my $pixbufA = $pixbuf1->copy; + my $pixbufB = $pixbuf2->copy; + $pixbufA->composite($pixbufB, 0, 0, int($width - (($i/20)*$width)), $height, 0, 0, 1, 1, 'nearest', 255); + $self->{img}->set_from_pixbuf($pixbufB); + }); + } + } + + sub setImg + { + my ($self, $value) = @_; + $self->{img}->setValue($value, $self); + } + + sub placeImg + { + my ($self) = @_; + my ($picWidth, $picHeight) = $self->{img}->getSize; + my ($buttonWidth, $buttonHeight) = ($self->allocation->width, $self->allocation->height); + my $x = ($buttonWidth - $picWidth - $GCUtils::margin)/ 2; + my $y = ($buttonHeight -$picHeight - $GCUtils::margin)/ 2; + + # Don't allow negative positions, can happen when button has not been allocated a width/height yet + $x = 0 if ($x < 0); + $y = 0 if ($y < 0); + + $self->{layout}->move($self->{img}, $x, $y); + } + + sub changeState + { + my $self = shift; + if ($self->{trackState}) + { + if ($self->{flipped}) + { + $self->{linkedComponent}->setChanged; + } + else + { + $self->setChanged; + } + } + } + + sub clearImage + { + my $self = shift; + + $self->changeState; + $self->{mainParent}->checkPictureToBeRemoved($self->{imageFile}); + $self->setValueWithParent(''); + } + + sub changeImage + { + my ($self, $fileName) = @_; + return 0 if $self->{locked}; + if (!$fileName) + { + my $imageDialog = GCFileChooserDialog->new($self->{parent}->{lang}->{PanelImageTitle}, $self->{mainParent}, 'open'); + $imageDialog->setWithImagePreview(1); + + my $currentFile = $self->{img}->getValue; + if ($currentFile) + { + $imageDialog->set_filename($currentFile); + } + else + { + $imageDialog->set_filename($self->{previousDirectory}); + } + my $response = $imageDialog->run; + $fileName = $imageDialog->get_filename; + $imageDialog->destroy; + + $self->{parent}->showMe; + if ($response eq 'ok') + { + $self->{previousDirectory} = dirname($fileName); + $self->setChanged if $self->{trackState}; + } + else + { + return; + } + } + + my $ref = ($self->{flipped} ? $self->{backPic} : $self->{imageFile}); + if ($fileName ne $ref) + { + $self->{mainParent}->checkPictureToBeRemoved($ref); + $self->changeState; + } + my $image = $self->{mainParent}->transformPicturePath($fileName); + $self->setValueWithParent($image); + return; + } + + sub isEmpty + { + my $self = shift; + + return $self->getValue eq ''; + } + + sub setValue + { + my ($self, $value) = @_; + $self->setChanged if $self->{trackState}; + $self->setActualValue($value); + } + + sub setValueWithParent + { + my ($self, $value, $keepWatcher) = @_; + + $self->setActualValue($value, $keepWatcher, $self->{flipped}); + if ($self->{isCover} && !$self->{flipped}) + { + $self->{mainParent}->{items}->updateSelectedItemInfoFromPanel(0, [$self->{name}]); + $self->{hasChanged} = 0 if $self->{parent} eq $self->{mainParent}->{panel} && !$keepWatcher; + } + } + + sub setActualValue + { + my ($self, $value, $keepWatcher, $flipped) = @_; + Glib::Source->remove($self->{fileWatcher}) + if $self->{fileWatcher} && !$keepWatcher; + if ($flipped) + { + $self->{backPic} = $value; + } + else + { + $self->{imageFile} = $value; + } + $self->setImg($value); + } + + sub getValue + { + my $self = shift; + if ($self->{flipped}) + { + return $self->{imageFile}; + } + return $self->{img}->getValue; + } + + sub setLinkedActivated + { + my ($self, $value) = @_; + $self->flipImage(1) if $self->{flipped}; + $self->{flipActivated} = $value; + } + + sub flipImage + { + my ($self, $noButton) = @_; + my $newLabel; + if ($self->{flipped}) + { + $self->setImg($self->{imageFile}); + $self->{frontFlipImage}->show if !$noButton; + $self->{backFlipImage}->hide; + #$self->animateImg($self->{backPic}, $self->{imageFile}); + } + else + { + $self->setImg($self->{backPic}); + $self->{backFlipImage}->show if !$noButton; + $self->{frontFlipImage}->hide; + #$self->animateImg($self->{imageFile}, $self->{backPic}); + } + $self->{flipped} = !$self->{flipped}; + } + + sub setLinkedValue + { + my ($self, $linkedValue) = @_; + $self->setChanged if $self->{trackState}; + $self->{backPic} = $linkedValue; + $self->setImg($linkedValue) if $self->{flipped}; + } + + sub getLinkedValue + { + my ($self, $linkedValue) = @_; + return $self->{backPic}; + } + + sub setLinkedComponent + { + my ($self, $linked) = @_; + $self->{linkedComponent} = $linked; + + $self->{flipActivated} = 1; + $self->{frontFlipImage} = Gtk2::Image->new_from_file($ENV{GCS_SHARE_DIR}.'/overlays/flip.png'); + $self->{frontFlipImage}->set_no_show_all(1); + $self->{backFlipImage} = Gtk2::Image->new_from_file($ENV{GCS_SHARE_DIR}.'/overlays/flip2.png'); + $self->{backFlipImage}->set_no_show_all(1); + my $pixbuf = $self->{frontFlipImage}->get_pixbuf; + my ($picWidth, $picHeight) = ($pixbuf->get_width, $pixbuf->get_height); + + $self->{addedFlipButton} = 0; + $self->signal_connect('enter' => sub { + return if ! $self->{flipActivated}; + if (!$self->{addedFlipButton}) + { + $self->{flipX} = $self->{width} - $picWidth - $GCUtils::margin; + $self->{flipY} = $self->{height} - $picHeight - $GCUtils::margin; + $self->{layout}->put($self->{frontFlipImage}, + $self->{flipX}, + $self->{flipY}); + $self->{layout}->put($self->{backFlipImage}, + $self->{flipX}, + $self->{flipY}); + $self->{addedFlipButton} = 1; + } + if ($self->{flipped}) + { + $self->{backFlipImage}->show; + } + else + { + $self->{frontFlipImage}->show; + } + }); + $self->signal_connect('leave' => sub { + $self->{frontFlipImage}->hide; + $self->{backFlipImage}->hide; + }); + $self->signal_connect('button-release-event' => sub { + return 0 if ! $self->{flipActivated}; + my ($button, $event) = @_; + my ($x, $y) = $event->get_coords; + if (($x > $self->{flipX}) && ($y > $self->{flipY})) + { + $self->flipImage; + $self->set_sensitive(0); + $self->released; + $self->set_sensitive(1); + return 1; + } + else + { + return 0; + } + }); + + $self->signal_connect('key-press-event' => sub { + return 0 if ! $self->{flipActivated}; + my ($widget, $event) = @_; + my $key = Gtk2::Gdk->keyval_name($event->keyval); + + if (($key eq 'f') || ($key eq 'BackSpace')) + { + $self->flipImage; + return 1; + } + return 0; + }); + + $self->signal_connect('query_tooltip' => sub { + my ($window, $x, $y, $keyboard_mode, $tip) = @_; + return if $self->{settingTip}; + $self->{settingTip} = 1; + if ($self->{flipActivated} && ($x > $self->{flipX}) && ($y > $self->{flipY})) + { + $self->{tooltips}->set_tip($self, $self->{flipped} ? + $self->{parent}->{lang}->{ContextImgFront} : + $self->{parent}->{lang}->{ContextImgBack}); + } + else + { + $self->{tooltips}->set_tip($self, $self->{tip}); + } + $self->{settingTip} = 0; + return 0; + }); + + } + + sub clear + { + my $self = shift; + $self->setValue(''); + } + + sub new + { + my ($proto, $parent, $img, $isCover, $default) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new; + bless ($self, $class); + + $default = 'view' if !$default; + + $self->{layout} = new Gtk2::Fixed; + $self->{layout}->put($img, 0, 0); + $self->add($self->{layout}); + + $self->{img} = $img; + $self->{default} = $default; + #$self->set_size_request(130,170); + $self->{width} = -1; + $self->{height} = -1; + $self->{imageFile} = $img->getValue; + + # True if this is the cover used in image mode + $self->{isCover} = $isCover; + + $self->{parent} = $parent; + $self->getMainParent; + $self->{tooltips} = $self->{mainParent}->{tooltips}; + + $self->{tip} = ($default eq 'open') ? $parent->{lang}->{PanelImageTipOpen} : $parent->{lang}->{PanelImageTipView}; + $self->{tip} .= $parent->{lang}->{PanelImageTipMenu}; + $self->{tooltips}->set_tip($self, $self->{tip}); + + $self->signal_connect('button_press_event' => sub { + my ($widget, $event) = @_; + return 0 if $event->button ne 3; + $self->createContextMenu(); + $self->{imgContext}->popup(undef, undef, undef, undef, $event->button, $event->time); + return 0; + }); + + $self->signal_connect('clicked' => sub { + $self->changeImage if $self->{default} eq 'open'; + $self->showImage if $self->{default} eq 'view'; + return 1; + }); + + #Drag and drop a picture on a button + $self->drag_dest_set('all', ['copy','private','default','move','link','ask']); + my $target_list = Gtk2::TargetList->new(); + my $atom1 = Gtk2::Gdk::Atom->new('text/uri-list'); + my $atom2 = Gtk2::Gdk::Atom->new('text/plain'); + $target_list->add($atom1, 0, 0); + $target_list->add($atom2, 0, 0); + if ($^O =~ /win32/i) + { + my $atom2 = Gtk2::Gdk::Atom->new('DROPFILES_DND'); + $target_list->add($atom2, 0, 0); + } + $self->drag_dest_set_target_list($target_list); + $self->signal_connect(drag_data_received => sub { + my ($widget, $context, $widget_x, $widget_y, $data, $info,$time) = @_; + my @files = split /\n/, $data->data; + my $fileName = $files[0]; + if ($fileName =~ /^http/) + { + $fileName = $self->{mainParent}->downloadPicture($fileName); + } + else + { + $fileName = Glib::filename_from_uri $fileName; + $fileName = decode('utf8', $fileName); + $fileName =~ s|^file://?(.*)\W*$|$1|; + $fileName =~ s|^/*|| if ($^O =~ /win32/i); + $fileName =~ s/.$//ms; + $fileName =~ s/%20/ /g; + } + $self->changeImage($fileName); + }); + + $self->{previousDirectory} = ''; + $self->{flipped} = 0; + $self->{flipActivated} = 0; + + return $self; + } + + sub createContextMenu + { + my $self = shift; + + my $parent; + $parent = $self->{parent}; + + $self->{imgContext} = new Gtk2::Menu; + + if ($parent->{options}->tearoffMenus) + { + $self->{imgContext}->append(Gtk2::TearoffMenuItem->new()); + } + + $self->{itemOpen} = Gtk2::ImageMenuItem->new_with_mnemonic($parent->{lang}->{ContextChooseImage}); + my $itemOpenImage = Gtk2::Image->new_from_stock('gtk-open', 'menu'); + $self->{itemOpen}->set_image($itemOpenImage); + # This item will be deactivated if the component is locked + $self->{itemOpen}->set_sensitive(!$self->{locked}); + $self->{itemOpen}->signal_connect("activate" , sub { + $self->changeImage; + }); + $self->{imgContext}->append($self->{itemOpen}); + $self->{itemShow} = Gtk2::ImageMenuItem->new_from_stock('gtk-zoom-100',undef); + $self->{itemShow}->signal_connect("activate" , sub { + $self->showImage; + }); + # Disable for default image + $self->{itemShow}->set_sensitive(0) if $self->isDefaultImage(); + $self->{imgContext}->append($self->{itemShow}); + + if ($self->{linkedComponent}) + { + $self->{itemFlip} = Gtk2::MenuItem->new($self->{flipped} ? + $parent->{lang}->{ContextImgFront} : + $parent->{lang}->{ContextImgBack}); + $self->{itemFlip}->signal_connect("activate" , sub { + $self->flipImage; + }); + $self->{imgContext}->append($self->{itemFlip}); + } + + $self->{itemClear} = Gtk2::ImageMenuItem->new_from_stock('gtk-clear',undef); + # This item will be deactivated if the component is locked + $self->{itemClear}->set_sensitive(!$self->{locked}); + $self->{itemClear}->signal_connect("activate" , sub { + $self->clearImage; + }); + $self->{imgContext}->append($self->{itemClear}); + # Disable for default image + $self->{itemClear}->set_sensitive(0) if $self->isDefaultImage(); + $self->{imgContext}->show_all; + + my $itemOpenWith = Gtk2::MenuItem->new_with_mnemonic($parent->{lang}->{ContextOpenWith}); + $self->{menuOpenWith} = Gtk2::Menu->new; + + if ($hasGnome2VFS && ($parent->{options}->programs eq 'system' || $parent->{options}->imageEditor eq '')) + { + # Get applications for mime types corresponding with image + + # Get all editors/viewers for jpeg file format + my $mimeTest = Gnome2::VFS::Mime::Type->new ("image/jpeg"); + my @mimeList = $mimeTest->get_short_list_applications; + + # Add applications to open with list + foreach (@mimeList) + { + my $launchApp = $_; + my $item = Gtk2::MenuItem->new_with_mnemonic($launchApp->get_name); + $item->signal_connect ('activate' => sub { + $self->openWith($launchApp); + }); + $self->{menuOpenWith}->append($item); + } + + #Gnome2::VFS -> shutdown(); + } + elsif ($parent->{options}->programs eq 'system' || $parent->{options}->imageEditor eq '') + { + # Can't parse applications, so use system default app + my $item = Gtk2::MenuItem->new_with_mnemonic($parent->{lang}->{ContextImageEditor}); + + my $command; + $command = ($^O =~ /win32/i) ? '' + : ($^O =~ /macos/i) ? '/usr/bin/open' + : $ENV{GCS_SHARE_DIR}.'/helpers/xdg-open'; + + # Not sure if this is correct, haven't tested with Windows: + if ($^O =~ /win32/i) + { + $command = '"'.$command.'"' if $command; + } + + $item->signal_connect ('activate' => sub { + $self->openWithImageEditor($command); + }); + + $self->{menuOpenWith}->append($item); + } + else + { + # Use user defined app + my $item = Gtk2::MenuItem->new_with_mnemonic($parent->{lang}->{ContextImageEditor}); + $item->signal_connect ('activate' => sub { + $self->openWithImageEditor($parent->{options}->imageEditor); + }); + + $self->{menuOpenWith}->append($item); + } + + + $itemOpenWith->set_submenu($self->{menuOpenWith}); + + # Disable for default image + $itemOpenWith->set_sensitive(0) if $self->isDefaultImage(); + + $self->{imgContext}->append($itemOpenWith); + $self->{imgContext}->show_all; + + } + + sub activateStateTracking + { + my $self = shift; + $self->{trackState} = 1; + } + + sub lock + { + my ($self, $locked) = @_; + + $self->{locked} = $locked; + } + + sub showImage + { + my $self = shift; + $self->{mainParent}->launch($self->{img}->getValue, 'image'); + } + + sub isDefaultImage + { + my ($self) = @_; + + if ($self->{img}->getFile eq $self->{parent}->{defaultImage}) + { + return 1; + } + else + { + return 0; + } + } + + sub openWith + { + my ($self, $app) = @_; + my $cmd; + my $escFileName; + + # Ultra hacky workaround, because $app->{launch} segfaults. See http://bugzilla.gnome.org/show_bug.cgi?id=315049 + # Probably should change to gvfs when perl modules are available + + if ($app->{command} =~ m/(\w*)/) + { + $cmd = $1; + } + + $escFileName = $self->{img}->getFile; + $escFileName =~ s/\ /%20/g; + $self->editPicture("$cmd file://$escFileName"); + } + + sub openWithImageEditor + { + my ($self, $editor) = @_; + my $file = $self->{img}->getFile; + $file =~ s|/|\\|g if ($^O =~ /win32/i); + $self->editPicture("$editor \"$file\""); + } + + sub editPicture + { + my ($self, $commandLine) = @_; + my $file = $self->{img}->getFile; + + my $flipped = $self->{flipped}; + $self->{fileWatchDays} = -M $file; + $self->{fileWatcher} = Glib::Timeout->add(1000, sub { + my $currentDays = -M $file; + if ($currentDays < $self->{fileWatchDays}) + { + $self->changeState; + # We remove it from the pixbuf cache in items view. Useful + # for detailed list to be sure it will be re-loaded + delete $self->{mainParent}->{itemsView}->{cache}->{$file} + if $self->{mainParent}->{itemsView}->{cache}; + $self->setValueWithParent($self->{img}->getValue, 1, $flipped); + $self->{fileWatchDays} = $currentDays; + } + return 1; + }); + $self->{mainParent}->launch($commandLine, 'program', 1); + } + + sub setWidth + { + my ($self, $value) = @_; + $self->{width} = $value; + $self->set_size_request($value, $self->{height}); + $self->{img}->setWidth($value - $GCUtils::margin); + } + + sub setHeight + { + my ($self, $value) = @_; + $self->{height} = $value; + $self->set_size_request($self->{width}, $value); + $self->{img}->setHeight($value - $GCUtils::margin); + } + +} + +{ + package GCMenuList; + + use Glib::Object::Subclass + Gtk2::ComboBox:: + ; + + @GCMenuList::ISA = ('Gtk2::ComboBox', 'GCGraphicComponent'); + + our $separatorValue = 'GCSSeparator'; + + sub isEmpty + { + my $self = shift; + + return 1 if ! defined $self->get_active_iter; + return ($self->{listModel}->get($self->get_active_iter))[1] eq ''; + my $idx = $self->get_history; + $idx-- if $idx >= $self->{separatorPosition}; + $idx = 0 if $idx < 0; + return $self->{'values'}->[$idx]->{displayed} eq ''; + } + + sub valueToDisplayed + { + my ($self, $value) = @_; + + foreach (@{$self->{'values'}}) + { + return $_->{displayed} if $_->{value} eq $value + } + return ''; + } + + sub getValue + { + my ($self, $formatted) = @_; + my $iter = $self->get_active_iter; + my $value = ''; + $value = ($self->{listModel}->get($iter))[0] if $iter; + $value = $self->valueToDisplayed($value) if $formatted; + return $value; + } + + sub getDisplayedValue + { + my $self = shift; + my $iter = $self->get_active_iter; + return ($self->{listModel}->get($iter))[1] if $iter; + return ''; + } + + sub setValue + { + my ($self, $value) = @_; + + $value = 0 if !$value; + my $i = 0; + if ($value) + { + foreach (@{$self->{values}}) + { + last if $_->{value} eq $value; + $i++; + } + } + $i++ if $i >= $self->{separatorPosition}; + $i-- if ($self->{default} == -1) && ($i >= $self->{count}); + $self->set_active($i) + if ($i < scalar(@{$self->{values}})); + } + + sub clear + { + my $self = shift; + $self->set_active(0); + } + + sub lock + { + my ($self, $locked) = @_; + + $self->set_sensitive(!$locked); + } + + sub getValues + { + my $self = shift; + + my @values; + return $self->{values}; + } + + sub setValues + { + my ($self, $values, $separatorPosition, $preserveValue) = @_; + if ($self->{title}) + { + $separatorPosition = 1; + unshift @$values, {value => -1, displayed => $self->{title}}; + } + my $model = $self->{listModel}; + my $previous = $self->getValue if $preserveValue; + $self->{values} = $values; + $self->{separatorPosition} = $separatorPosition || 9999; + + $model->clear; + my $i = 0; + foreach (@$values) + { + if ($i == $self->{separatorPosition}) + { + $model->set($model->append, 0 => $GCMenuList::separatorValue, 1 => ''); + $i++; + } + $model->set($model->append, + 0 => $_->{value}, + 1 => $_->{displayed}); + $i++; + } + + $self->{count} = $i; + $self->setValue($previous) if $preserveValue; + $self->set_active(0) if !$preserveValue; + } + + sub setLastForDefault + { + my $self = shift; + $self->{default} = -1; + } + + sub setTitle + { + my ($self, $title) = @_; + $self->{title} = $title; + } + + sub new + { + my ($proto, $values, $separatorPosition) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new; + bless ($self, $class); + + $self->{listModel} = Gtk2::ListStore->new('Glib::String', 'Glib::String'); + $self->set_model($self->{listModel}); + my $renderer = Gtk2::CellRendererText->new; + $self->pack_start($renderer, 1); + $self->add_attribute($renderer, text => 1); + $self->set_row_separator_func(sub { + my ($model, $iter) = @_; + my @values = $model->get($iter, 0); + my $val = ''; + $val = $values[0] if defined $values[0]; + return $val eq $GCMenuList::separatorValue; + }); + + $self->setValues($values, $separatorPosition) if $values; + $self->{default} = 0; + $self->set_focus_on_click(1); + return $self; + } + + sub activateStateTracking + { + my $self = shift; + $self->signal_connect('changed' => sub { + $self->setChanged; + }); + } +} + +{ + package GCHeaderLabel; + + use Glib::Object::Subclass + Gtk2::Label:: + ; + + @GCHeaderLabel::ISA = ('Gtk2::Label', 'GCGraphicComponent'); + + sub new + { + my ($proto, $label) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new; + bless ($self, $class); + + $self->setText($label); + $self->set_alignment(0,1); + + return $self; + } + + sub setText + { + my ($self, $label) = @_; + $self->set_markup('<b>'.$label.'</b>'); + } +} + +{ + package GCLabel; + + use Glib::Object::Subclass + Gtk2::Label:: + ; + + @GCLabel::ISA = ('Gtk2::Label', 'GCGraphicComponent'); + + sub new + { + my ($proto, $label, $disableMarkup) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new; + bless ($self, $class); + $self->set_markup($label) unless $disableMarkup; + $self->set_label($label) if $disableMarkup; + $self->set_alignment(0,0.5); + return $self; + } +} + +{ + package GCColorLabel; + + use Glib::Object::Subclass + Gtk2::EventBox:: + ; + + @GCColorLabel::ISA = ('Gtk2::EventBox', 'GCGraphicComponent', 'GCPseudoHistoryComponent'); + + sub new + { + my ($proto, $color, $listType) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new; + + bless ($self, $class); + + $listType = 0 if !$listType; + $self->modify_bg('normal', $color); + $self->{label} = Gtk2::Label->new; + $self->{label}->show; + $self->{hboxFill} = new Gtk2::HBox(0,0); + $self->{hboxFill}->pack_start($self->{label},1,1,0); + $self->add($self->{hboxFill}); + $self->set_alignment(0,0.5); + $self->initHistory($listType); + + return $self; + } + + sub acceptMarkup + { + my $self = shift; + return 1; + } + + sub setMarkup + { + my ($self, $text) = @_; + + $self->{label}->set_markup($text); + } + + sub getValue + { + my $self = shift; + + (my $label = $self->{label}->get_label) =~ s/<.*?>(.*?)<\/.*?>/$1/g; + return $label; + } + + sub setBgColor + { + my ($self, $color) = @_; + $self->modify_bg('normal', $color); + } + + sub set_justify + { + my ($self, $value) = @_; + $self->{label}->set_justify($value); + $self->{label}->set_alignment(0.5,0) if $value eq 'center'; + $self->{label}->set_alignment(1,0) if $value eq 'right'; + } + + sub AUTOLOAD + { + my $self = shift; + my $name = our $AUTOLOAD; + return if $name =~ /::DESTROY$/; + $name =~ s/.*?::(.*)/$1/; + $self->{label}->$name(@_); + } +} + +{ + package GCColorLink; + + use Glib::Object::Subclass + Gtk2::EventBox:: + ; + + @GCColorLink::ISA = ('GCColorLabel'); + + sub new + { + my ($proto, $color, $opener) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new($color); + bless ($self, $class); + $self->{opener} = $opener; + $self->signal_connect('button-release-event' => sub { + my $value = $self->getValue; + return if !$value; + $self->{opener}->launch($value, 'url'); + }); + $self->signal_connect('enter-notify-event' => sub { + $self->window->set_cursor(Gtk2::Gdk::Cursor->new('hand2')) + if $self->getValue; + }); + #$self->window->set_cursor(Gtk2::Gdk::Cursor->new('watch')); + return $self; + } +} + +{ + package GCColorLongLabel; + + use Glib::Object::Subclass + Gtk2::TextView:: + ; + + @GCColorLongLabel::ISA = ('Gtk2::TextView', 'GCGraphicComponent'); + + sub new + { + my ($proto, $color) = @_; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new; + bless ($self, $class); + + $self->set_editable(0); + $self->set_wrap_mode('word'); + $self->{background} = $color; + $self->modify_base('normal', $color); + $self->modify_bg('normal', $color); + $self->set_border_width($GCUtils::halfMargin); + + my $layout = $self->create_pango_layout('G'); + my (undef, $rect) = $layout->get_pixel_extents; + $self->{em} = 1.5 * $rect->{height}; + + + return $self; + } + + sub acceptMarkup + { + my $self = shift; + return 1; + } + + sub setMarkup + { + my ($self, $text) = @_; + + #$text =~ s/&/&/g; + if ($self->{resize}) + { + $self->resize; + } + else + { + my $buffer = $self->get_buffer; + $self->get_buffer->set_text(''); + $text =~ s|<span ([^>]*?)>([^<]*?)</span>|$2|; + if ($self->{spanTag}) + { + $buffer->get('tag-table')->remove($self->{spanTag}); + } + $self->{spanTag} = $buffer->create_tag('span', $self->getTagFromSpan($1)); + $buffer->insert_with_tags_by_name ($buffer->get_start_iter, $text, 'span'); + } + } + + sub getValue + { + my $self = shift; + + (my $label = $self) =~ s/<.*?>(.*?)<\/.*?>/$1/g; + return $label; + } + +} + +{ + package GCColorTable; + + use Glib::Object::Subclass + Gtk2::Table:: + ; + + @GCColorTable::ISA = ('Gtk2::Table', 'GCGraphicComponent', 'GCPseudoHistoryComponent'); + + sub new + { + my ($proto, $columns, $labels, $headerStyle, $contentStyle, $topHeader) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new(1, $columns); + + bless ($self, $class); + + $self->set_col_spacings(3); + $self->set_row_spacings(3); + $self->{number} = $columns; + $self->{style} = $contentStyle; + $self->{firstRow} = 0; + if ($topHeader) + { + $self->{firstRow}++; + my $top = new GCColorLabel($headerStyle->{bgColor}); + $top->set_padding($GCUtils::halfMargin,$GCUtils::halfMargin); + $top->setMarkup('<span '.$headerStyle->{style}.'>'.$topHeader.'</span>'); + $self->attach($top, 0, $columns, 0, 1, ['expand', 'fill'], 'fill', 0, 0); + } + my $i; + if ($columns > 1) + { + for $i(0..($columns - 1)) + { + my $header = new GCColorLabel($headerStyle->{bgColor}); + $header->set_padding($GCUtils::halfMargin,$GCUtils::halfMargin); + $header->setMarkup('<span '.$headerStyle->{style}.'>'.$labels->[$i].'</span>'); + $self->attach($header, $i, $i + 1, $self->{firstRow}, $self->{firstRow} + 1, ['expand', 'fill'], 'fill', 0, 0); + } + $self->{firstRow}++; + } + $self->initHistory($columns); + return $self; + } + + sub setValue + { + my ($self, $value) = @_; + $self->{value} = $value; + + foreach (@{$self->{labels}}) + { + $self->remove($_); + $_->destroy; + } + + $self->{labels} = []; + my @lines; + if (ref($value) eq 'ARRAY') + { + @lines = @$value; + } + else + { + $value =~ s/^\s*//; + @lines = split m/,/, $value; + } + if ($#lines < 0) + { + $self->hide_all; + return; + } + my $i = $self->{firstRow}; + $self->resize($#lines + 1 + $self->{firstRow}, $self->{number}); + foreach (@lines) + { + my @cols; + if (ref($value) eq 'ARRAY') + { + @cols = @$_; + } + else + { + @cols = split m/;/, $_; + } + my $j = 0; + for my $col(@cols) + { + # TODO Optimize GCColorLongLabel. It offers a better display (no scrollbar) + # but it slows down the display. + my $label = new GCColorLabel($self->{style}->{bgColor}); + $label->set_padding($GCUtils::halfMargin,$GCUtils::halfMargin); + #my $label = new GCColorLongLabel($self->{style}->{bgColor}, '2em'); + $label->setMarkup('<span '.$self->{style}->{style}.'>'.$self->cleanMarkup($col, 1).'</span>'); + $self->attach($label, $j, $j + 1, $i, $i + 1, ['expand', 'fill'], 'fill', 0, 0); + push @{$self->{labels}}, $label; + $j++; + } + $i++; + } + $self->show_all; + } + + sub getValue + { + my $self = shift; + return $self->{value}; + } + + sub setBgColor + { + my ($self, $color) = @_; + return; + } + + sub set_justify + { + my ($self, $value) = @_; + return; + } + +} + +{ + package GCColorText; + + use Glib::Object::Subclass + Gtk2::ScrolledWindow:: + ; + + @GCColorText::ISA = ('Gtk2::ScrolledWindow', 'GCGraphicComponent', 'GCPseudoHistoryComponent'); + + sub new + { + my ($proto, $color, $height, $listType) = @_; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new; + bless ($self, $class); + + $listType = 0 if !$listType; + $self->{text} = new Gtk2::TextView; + $self->{text}->set_editable(0); + $self->{text}->set_wrap_mode('word'); + $self->{background} = $color; + $self->{text}->modify_base('normal', $color); + $self->{text}->modify_bg('normal', $color); + $self->{text}->set_border_width($GCUtils::halfMargin); + $self->set_border_width(0); + $self->set_shadow_type('none'); + $self->set_policy('automatic', 'automatic'); + $self->add($self->{text}); + $self->initHistory($listType); + + my $layout = $self->create_pango_layout('G'); + my (undef, $rect) = $layout->get_pixel_extents; + $self->{em} = 1.5 * $rect->{height}; + + $self->setHeight($height) if $height; + + return $self; + } + + sub acceptMarkup + { + my $self = shift; + return 1; + } + + sub setMarkup + { + my ($self, $text) = @_; + + if ($self->{resize}) + { + $self->resize; + } + else + { + my $buffer = $self->{text}->get_buffer; + $self->{text}->get_buffer->set_text(''); + $text =~ s|<span ([^>]*?)>([^<]*?)</span>|$2|; + if ($self->{spanTag}) + { + $buffer->get('tag-table')->remove($self->{spanTag}); + } + $self->{spanTag} = $buffer->create_tag('span', $self->getTagFromSpan($1)); + $buffer->insert_with_tags_by_name ($buffer->get_start_iter, $text, 'span'); + } + } + + sub getValue + { + my $self = shift; + + (my $label = $self->{text}) =~ s/<.*?>(.*?)<\/.*?>/$1/g; + return $label; + } + + sub setHeight + { + my ($self, $height) = @_; + $height =~ s/^([0-9]+)em$/$1*$self->{em}/e; + $self->set_size_request(-1, $height); + } + + sub AUTOLOAD + { + my $self = shift; + my $name = our $AUTOLOAD; + return if $name =~ /::DESTROY$/; + $name =~ s/.*?::(.*)/$1/; + $self->{text}->$name(@_); + } +} + +{ + package GCColorExpander; + + use Glib::Object::Subclass + Gtk2::Expander:: + ; + + @GCColorExpander::ISA = ('GCExpander'); + + sub new + { + my ($proto, $label, $bgColor, $fgStyle) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new($label); + + bless ($self, $class); + $self->{label} = new GCColorLabel($bgColor); + $self->set_label_widget($self->{label}); + $self->{fgStyle} = $fgStyle; + + return $self; + } + + sub setValue + { + my ($self, $label, $description) = @_; + + $label = '<span '.$self->{fgStyle}.">$label</span>"; + + $self->{label}->set_markup($label); + if ($description) + { + $self->{description}->set_label($description); + $self->{description}->show; + } + else + { + $self->{description}->set_label(''); + $self->{description}->hide; + } + + + } +} + +{ + package GCDialogHeader; + + use Glib::Object::Subclass + Gtk2::HBox:: + ; + + @GCDialogHeader::ISA = ('Gtk2::HBox', 'GCGraphicComponent'); + + sub new + { + my ($proto, $text, $imageStock, $logosDir) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new; + + bless ($self, $class); + + $self->{label} = new Gtk2::Label; + $self->{label}->set_markup("<span size='large' weight='bold'>$text</span>"); + $self->{label}->set_alignment(0,0.5); + + if (-f $logosDir.$imageStock.'.png') + { + $self->{image} = Gtk2::Image->new_from_file($logosDir.$imageStock.'.png'); + $self->pack_start($self->{image},0,1,5); + } + + $self->pack_start($self->{label},0,1,5); + + return $self; + } +} + +{ + package GCImageBox; + + use Glib::Object::Subclass + Gtk2::VBox:: + ; + + @GCImageBox::ISA = ('Gtk2::VBox', 'GCGraphicComponent'); + + sub new_from_file + { + my ($proto, $imageFile, $label) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new(); + + bless ($self, $class); + + my $image = Gtk2::Image->new_from_file($imageFile); + $self->init($image, $label); + + return $self; + } + sub new_from_stock + { + my ($proto, $stockId, $label) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new(); + + bless ($self, $class); + + my $image = Gtk2::Image->new_from_stock($stockId, 'large-toolbar'); + $self->init($image, $label); + + return $self; + } + + sub init + { + my ($self, $image, $label) = @_; + + $self->{label} = new Gtk2::Label($label); + + $self->pack_start($image, 0, 0, 0); + $self->pack_start($self->{label}, 0, 0, 0); + + $self->show_all; + } +} + +{ + package GCGroup; + + use Glib::Object::Subclass + Gtk2::Frame:: + ; + + @GCGroup::ISA = ('Gtk2::Frame', 'GCGraphicComponent'); + + sub new + { + my ($proto, $title) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new; + + bless ($self, $class); + + $self->set_shadow_type('none'); + $self->set_border_width($GCUtils::margin); + $self->{label} = new Gtk2::Label; + $self->{label}->set_padding(0,0); + #$label->set_border_width(0); + $self->setLabel($title); + $self->set_label_widget($self->{label}); + $self->set_label_align(0,0); + + $self->{marginBox} = new Gtk2::HBox(0,0); + $self->{marginBox}->set_border_width($GCUtils::halfMargin); + $self->add($self->{marginBox}); + + return $self; + } + + sub setLabel + { + my ($self, $label) = @_; + + $self->{label}->set_markup('<b>'.$label.'</b>'); + } + + sub addWidget + { + my ($self, $widget, $margin) = @_; + $margin = $GCUtils::halfMargin if !$margin; + $self->{marginBox}->pack_start($widget, 1, 1, $margin); + } + + sub setPadding + { + my ($self, $value) = @_; + + $self->{marginBox}->set_border_width($value); + } +} + +{ + package GCExpander; + + use Glib::Object::Subclass + Gtk2::Expander:: + ; + + @GCExpander::ISA = ('Gtk2::Expander', 'GCGraphicComponent'); + + sub new + { + my ($proto, $label, $bold) = @_; + my $class = ref($proto) || $proto; + + my $self = $class->SUPER::new($label); + + bless ($self, $class); + $self->{hbox} = new Gtk2::HBox(0,0); + $self->{label} = new Gtk2::Label($label); + $self->{label}->set_alignment(0,0.5); + $self->{label}->set_markup("<b>$label</b>") + if $bold; + $self->{description} = new Gtk2::Label; + $self->{description}->set_alignment(0,0); + eval {$self->{description}->set_line_wrap_mode('word');}; + $self->{hbox}->pack_start($self->{label}, 0, 0, 0); + $self->{hbox}->pack_start($self->{description}, 1, 1, 0); + $self->set_label_widget($self->{hbox}); + $self->{signalHandler} = undef; + return $self; + } + + sub setMode + { + my ($self, $mode) = @_; + if ($mode eq 'asis') + { + $self->{description}->set_ellipsize('none'); + $self->{description}->set_line_wrap(0); + if ($self->{signalHandler}) + { + $self->signal_handler_disconnect($self->{signalHandler}); + $self->{signalHandler} = undef; + $self->{description}->set_size_request(-1, -1); + } + } + else + { + $self->{signalHandler} = $self->signal_connect('size-allocate' => sub { + my $width = $self->allocation->width + - $self->{label}->allocation->width + - ( 4 * $GCUtils::margin); + $self->{description}->set_size_request(($width >= -1) ? $width : -1 , -1); + return 0; + }); + if ($mode eq 'wrap') + { + $self->{description}->set_ellipsize('none'); + $self->{description}->set_line_wrap(1); + } + else + { + $self->{description}->set_ellipsize('end'); + $self->{description}->set_line_wrap(0); + } + } + } + + sub setValue + { + my ($self, $label, $description) = @_; + + $self->{label}->set_label($label); + if ($description) + { + $self->{description}->set_label($description); + $self->{description}->show; + } + else + { + $self->{description}->set_label(''); + $self->{description}->hide; + } + } +} + +{ + package GCFieldSelector; + + use Glib::Object::Subclass + Gtk2::ComboBox:: + ; + + @GCFieldSelector::ISA = ('GCMenuList'); + our $anyFieldValue = 'GCAnyField'; + + sub valueToDisplayed + { + my ($self, $value) = @_; + return ''; + } + + sub setValue + { + my ($self, $value) = @_; + + $self->{listModel}->foreach(sub { + my ($model, $path, $iter) = @_; + if ($model->get_value($iter, 0) eq $value) + { + $self->set_active_iter($iter); + return 1; + } + return 0; + }); + } + + sub getValues + { + my $self = shift; + return []; + } + + sub setValues + { + my ($self, $values, $separatorPosition, $preserveValue) = @_; + return; + } + + sub new + { + my ($proto, $withImages, $model, $advancedFilter, $withAnyField, $withoutEmpty, $uniqueType) = @_; + my $class = ref($proto) || $proto; + my $self = Gtk2::ComboBox->new; + bless($self, $class); + $self->{withImages} = $withImages; + $self->{advancedFilter} = $advancedFilter; + $self->{withAnyField} = $withAnyField; + $self->{withoutEmpty} = $withoutEmpty; + $self->{uniqueType} = $uniqueType; + + $self->{listModel} = Gtk2::TreeStore->new('Glib::String', 'Glib::String'); + $self->set_model($self->{listModel}); + my $renderer = Gtk2::CellRendererText->new; + $self->pack_start($renderer, 1); + $self->add_attribute($renderer, text => 1); + + $self->set_cell_data_func($renderer, sub { + my ($layout, $cell, $model, $iter) = @_; + my $sensitive = !$model->iter_has_child($iter); + $cell->set('sensitive', $sensitive); + }); + + $self->{default} = 0; + $self->set_focus_on_click(1); + + $self->setModel($model) if $model; + + return $self; + } + + sub setModel + { + my ($self, $model) = @_; + + $self->{listModel}->clear; + my $field; + my @fieldsInfo = @{$model->getDisplayedInfo}; + + if (! $self->{withoutEmpty}) + { + $self->{listModel}->set($self->{listModel}->append(undef), + 0 => '', + 1 => ''); + } + if ($self->{withAnyField}) + { + $self->{listModel}->set($self->{listModel}->append(undef), + 0 => $anyFieldValue, + 1 => $model->getDisplayedText('AdvancedSearchAnyField')); + } + + foreach my $group(@fieldsInfo) + { + my @fields; + foreach $field (@{$group->{items}}) + { + my $id = $field->{id}; + next if ($model->{fieldsInfo}->{$id}->{type} eq 'image') && (!$self->{withImages}); + next if ($self->{advancedFilter} + && ( + ($id eq $model->{commonFields}->{id}) + || ($id eq $model->{commonFields}->{title}) + || ($id eq $model->{commonFields}->{url}) + ) + ); + next if ! $field->{label}; + next if $self->{uniqueType} && ($self->{uniqueType} ne $model->{fieldsInfo}->{$id}->{type}); + push @fields, $field; + } + if (scalar @fields) + { + my $groupIter = $self->{listModel}->append(undef); + $self->{listModel}->set($groupIter, + 0 => undef, + 1 => $group->{title}); + foreach $field(sort {$a->{label} cmp $b->{label}} @fields) + { + my $fieldIter = $self->{listModel}->append($groupIter); + $self->{listModel}->set($fieldIter, + 0 => $field->{id}, + 1 => $field->{label}); + } + } + } + $self->{model} = $model; + } + sub activateStateTracking + { + my $self = shift; + } + + # Create a widget suitable to enter a value according to current field type + # It will destroy the current widget if it exists + sub createEntryWidget + { + # $parent is the class that contains needed information + # $comparison is the kind of comparison. Mainly useful if it is 'range' to create 2 fields + # $currentWidget is the one we are replacing + my ($self, $parent, $comparison, $currentWidget) = @_; + my $value; + if ($currentWidget) + { + $value = $currentWidget->getValue; + $currentWidget->destroy; + } + my $widget; + my $field = $self->getValue; + my $info = $self->{model}->{fieldsInfo}->{$field}; + + # These ones are required for createWidget + $self->{lang} = $parent->{lang}; + $self->{options} = $parent->{options}; + $self->{window} = $parent; + + ($widget, undef) = GCBaseWidgets::createWidget($self, $info, $comparison); + + if ($info->{type} eq 'history text') + { + $widget->setValues($parent->{parent}->{panel}->getValues($field)); + } + elsif ($info->{type} eq 'single list') + { + $widget->setValues($parent->{parent}->{panel}->getValues($field)->[0]); + } + $widget->setValue($value); + + return $widget; + } +} + +{ + package GCComparisonSelector; + + use Glib::Object::Subclass + Gtk2::ComboBox:: + ; + + @GCComparisonSelector::ISA = ('GCMenuList'); + + sub new + { + my ($proto, $parent) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new; + bless($self, $class); + $self->setValues([ + {value => 'contain', displayed => $parent->{lang}->{ModelFilterContain}}, + {value => 'notcontain', displayed => $parent->{lang}->{ModelFilterDoesNotContain}}, + {value => 'regexp', displayed => $parent->{lang}->{ModelFilterRegexp}}, + {value => 'range', displayed => $parent->{lang}->{ModelFilterRange}}, + {value => 'eq', displayed => '='}, + {value => 'lt', displayed => '<'}, + {value => 'le', displayed => '≤'}, + {value => 'gt', displayed => '>'}, + {value => 'ge', displayed => '≥'}, + ]); + return $self; + } +} + +1; |