From 126bb8cb6b93240bb4d3a2b816b74c286c3d422b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Sun, 6 Jul 2014 15:20:38 +0200 Subject: Imported Upstream version 1.7.0 --- lib/gcstar/GCItemsLists/GCImageListComponents.pm | 848 +++++++++ lib/gcstar/GCItemsLists/GCImageLists.pm | 2028 +++++++++++++++++++++ lib/gcstar/GCItemsLists/GCListOptions.pm | 496 +++++ lib/gcstar/GCItemsLists/GCTextLists.pm | 2101 ++++++++++++++++++++++ 4 files changed, 5473 insertions(+) create mode 100644 lib/gcstar/GCItemsLists/GCImageListComponents.pm create mode 100644 lib/gcstar/GCItemsLists/GCImageLists.pm create mode 100644 lib/gcstar/GCItemsLists/GCListOptions.pm create mode 100644 lib/gcstar/GCItemsLists/GCTextLists.pm (limited to 'lib/gcstar/GCItemsLists') diff --git a/lib/gcstar/GCItemsLists/GCImageListComponents.pm b/lib/gcstar/GCItemsLists/GCImageListComponents.pm new file mode 100644 index 0000000..aa2bf2b --- /dev/null +++ b/lib/gcstar/GCItemsLists/GCImageListComponents.pm @@ -0,0 +1,848 @@ +package GCImageListComponents; + +################################################### +# +# Copyright 2005-2011 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 strict; + +{ + package GCImageListItem; + + use GCUtils; + use GCStyle; + use base "Gtk2::EventBox"; + use File::Temp qw/ tempfile /; + + @GCImageListItem::ISA = ('Gtk2::EventBox'); + + sub new + { + my ($proto, $container, $info) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new; + bless ($self, $class); + + # Some information that we'll need later + $self->{info} = $info; + $self->{container} = $container; + $self->{style} = $container->{style}; + $self->{tooltips} = $container->{tooltips}; + $self->{file} = $container->{parent}->{options}->file; + $self->{collectionDir} = $container->{collectionDir}; + $self->{model} = $container->{parent}->{model}; + $self->{imageCache} = $container->{imageCache}; + $self->{dataManager} = $container->{parent}->{items}; + + $self->can_focus(1); + my $image = new Gtk2::Image; + $self->add($image); + $self->refreshInfo($info); + $self->set_size_request($container->{style}->{vboxWidth}, $container->{style}->{vboxHeight}); + $self->show_all; + + return $self; + } + + sub setInfo + { + my ($self, $info) = @_; + + $self->{info} = $info; + } + + sub refreshInfo + { + my ($self, $info, $cacheRefresh) = @_; + + $self->setInfo($info); + + $self->refreshPopup; + + delete $self->{zoomedPixbufCache}; + + { + my $pixbuf = $self->createPixbuf($info, $cacheRefresh); + if (! $self->{style}->{withImage}) + { + $self->modify_bg('normal', $self->{style}->{inactiveBg}); + } + $self->{previousPixbuf} = $pixbuf->copy; + $self->child->set_from_pixbuf($pixbuf); + } + if ($self->{selected}) + { + $self->{selected} = 0; + $self->highlight; + $self->{selected} = 1; + } + } + + sub refreshPopup + { + my $self = shift; + # Old versions of Gtk2 don't support set_tooltip_markup + eval { + $self->set_tooltip_markup($self->{dataManager}->getSummary($self->{info}->{idx})); + }; + if ($@) + { + print "$@\n"; + # So we do it the old way for them + $self->{tooltips}->set_tip($self, $self->{info}->{title}, ''); + } + } + + sub savePicture + { + my $self = shift; + $self->{previousPixbuf} = $self->child->get_pixbuf->copy + if $self->child; + } + + sub restorePicture + { + my $self = shift; + $self->child->set_from_pixbuf($self->{previousPixbuf}) + if $self->{previousPixbuf} && $self->child; + } + + sub startZoomAnimation + { + my $self = shift; + $self->{currentZoom} = 1.01; + my $pixbuf = $self->createPixbuf($self->{info}, 0, 1.01); + $self->child->set_from_pixbuf($pixbuf); + $self->{zoomTimeout} = Glib::Timeout->add(20 , sub { + my $widget = shift; + $widget->{currentZoom} += 0.02; + if ($widget->{currentZoom} > 1.06) + { + $widget->{zoomTimeout} = undef; + return 0; + } + my $pixbuf = $widget->createPixbuf($self->{info}, 0, $widget->{currentZoom}); + $widget->child->set_from_pixbuf($pixbuf) + if $widget->child; + return 1; + }, $self); + } + + sub stopZoomAnimation + { + my $self = shift; + Glib::Source->remove($self->{zoomTimeout}) + if $self->{zoomTimeout}; + } + + # This method sets all the event callbacks + sub prepareHandlers + { + my ($self, $idx, $info) = @_; + $self->{idx} = $idx; + $self->{info} = $info; + + $self->signal_handler_disconnect($self->{mouseHandler}) + if $self->{mouseHandler}; + $self->{mouseHandler} = $self->signal_connect('button_press_event' => sub { + my ($widget, $event) = @_; + + if (($event->type ne '2button-press') && !(($event->button eq 3) && ($widget->{selected}))) + { + my $state = $event->get_state; + my $keepPrevious = 0; + if ($state =~ /control-mask/) + { + $widget->{container}->select($widget->{idx}, 0, 1); + } + elsif ($state =~ /shift-mask/) + { + $widget->{container}->restorePrevious; + $widget->{container}->selectMany($widget->{idx}); + } + else + { + $widget->{container}->select($widget->{idx}); + } + $widget->{container}->setPreviousSelectedDisplayed($widget->{idx}); + + #$self->{parent}->display($widget->{idx}) unless $event->type eq '2button-press'; + $widget->{container}->displayDetails(0, keys %{$widget->{container}->{selectedIndexes}}); + } + + $widget->{container}->displayDetails(1, $widget->{idx}) if $event->type eq '2button-press'; + $widget->{container}->showPopupMenu($event->button, $event->time) if ($event->button eq 3); + $widget->grab_focus; + }); + + if ($self->{style}->{withAnimation}) + { + $self->signal_handler_disconnect($self->{enterHandler}) + if $self->{enterHandler}; + $self->{enterHandler} = $self->signal_connect('enter_notify_event' => sub { + my ($widget, $event) = @_; + if (!$widget->{selected}) + { + $widget->startZoomAnimation; + } + }); + + $self->signal_handler_disconnect($self->{leaveHandler}) + if $self->{leaveHandler}; + $self->{leaveHandler} = $self->signal_connect('leave_notify_event' => sub { + my ($widget, $event) = @_; + if (!$widget->{selected}) + { + $widget->stopZoomAnimation; + $widget->restorePicture; + } + }); + } + + + $self->signal_handler_disconnect($self->{keyHandler}) + if $self->{keyHandler}; + + $self->{keyHandler} = $self->signal_connect('key-press-event' => sub { + my ($widget, $event) = @_; + my $displayed = $self->{container}->convertIdxToDisplayed($widget->{idx}); + my $key = Gtk2::Gdk->keyval_name($event->keyval); + if ($key eq 'Delete') + { + $widget->{container}->{parent}->deleteCurrentItem; + return 1; + } + if (($key eq 'Return') || ($key eq 'space')) + { + $widget->{container}->displayDetails(1, $widget->{idx}); + return 1; + } + my $unicode = Gtk2::Gdk->keyval_to_unicode($event->keyval); + if ($unicode) + { + $self->{container}->showSearch(pack('U',$unicode)); + } + else + { + my $columns = $widget->{container}->getColumnsNumber; + + ($key eq 'Right') ? $displayed++ : + ($key eq 'Left') ? $displayed-- : + ($key eq 'Down') ? $displayed += $columns : + ($key eq 'Up') ? $displayed -= $columns : + ($key eq 'Page_Down') ? $displayed += ($widget->{style}->{pageCount} * $columns): + ($key eq 'Page_Up') ? $displayed -= ($widget->{style}->{pageCount} * $columns): + ($key eq 'Home') ? $displayed = 0 : + ($key eq 'End') ? $displayed = $widget->{container}->getNbItems - 1 : + return 1; + + return 1 if ($displayed < 0) || ($displayed >= $widget->{container}->getNbItems); + my $column = $displayed % $columns; + my $valueIdx = $widget->{container}->convertDisplayedToIdx($displayed); +# my $keepPrevious = 0; + my $state = $event->get_state; + if ($state =~ /control-mask/) + { + $widget->{container}->select($valueIdx, 0, 1); + $widget->{container}->unsetPreviousSelectedDisplayed; + } + elsif ($state =~ /shift-mask/) + { + $widget->{container}->setPreviousSelectedDisplayed($widget->{idx}); + $widget->{container}->restorePrevious; + $widget->{container}->selectMany($valueIdx); + } + else + { + $widget->{container}->select($valueIdx); + $widget->{container}->unsetPreviousSelectedDisplayed; + } + $widget->{container}->displayDetails(0, $valueIdx); + $widget->{container}->grab_focus; + $widget->{container}->showCurrent unless (($key eq 'Left') && ($column != ($columns - 1))) + || (($key eq 'Right') && ($column != 0)); + } + return 1; + + }); + + } + + sub highlight + { + my ($self, $keepPrevious) = @_; + return if $self->{selected}; + $self->{selected} = 1; + if (! $self->{style}->{withImage}) + { + $self->modify_bg('normal', $self->{style}->{activeBg}); + } +# $self->savePicture +# unless $keepPrevious; + + my $pixbuf = $self->createPixbuf($self->{info}, 0, 1.1); + + $pixbuf->saturate_and_pixelate($pixbuf, 1.5, 0); + $pixbuf = $pixbuf->composite_color_simple ($pixbuf->get_width, $pixbuf->get_height, 'nearest',220, 128, $self->{style}->{activeBgValue}, $self->{style}->{activeBgValue}); + $self->child->set_from_pixbuf($pixbuf); + } + + sub unhighlight + { + my ($self) = @_; + + $self->modify_bg('normal', $self->{style}->{inactiveBg}) + if (! $self->{style}->{withImage}); + $self->restorePicture; + $self->{selected} = 0; + } + + sub createPixbuf + { + my ($self, $info, $cacheRefresh, $zoom) = @_; + + my $displayedImage = $info->{picture}; + my $pixbuf = undef; + + my $borrower = $info->{borrower}; + my $favourite = $info->{favourite}; + + # Item has a picture assigned + if ($cacheRefresh) + { + $self->{imageCache}->forceCacheUpdateForNextUse; + } + + if ($zoom) + { + if (! exists $self->{zoomedPixbufCache}->{$zoom}) + { + $self->{zoomedPixbufCache}->{$zoom} = $self->{imageCache}->getPixbuf($info, $zoom); + } + $pixbuf = $self->{zoomedPixbufCache}->{$zoom}; + } + else + { + $pixbuf = $self->{imageCache}->getPixbuf($info, $zoom); + } + + my $width; + my $height; + my $boxWidth = $self->{style}->{imgWidth}; + my $boxHeight = $self->{style}->{imgHeight}; + + my $overlay; + my $imgWidth; + my $imgHeight; + my $targetOverlayHeight; + my $targetOverlayWidth; + my $pixbufTempHeight; + my $pixbufTempWidth; + my $alpha = 1; + if ($self->{style}->{useOverlays}) + { + # Need to call this to get the overlay padding + ($imgWidth, $imgHeight, $overlay) = $self->{imageCache}->getDestinationImgSize($pixbuf->get_width, + $pixbuf->get_height); + } + $width = $pixbuf->get_width; + $height = $pixbuf->get_height; + + # Do the composition + + if ($self->{style}->{useOverlays}) + { + if ($self->{style}->{withImage}) + { + # Using background, so center accordingly + my $offsetX = (($self->{style}->{offsetX} / 2) * $self->{style}->{factor}) + (($boxWidth - ($width + $overlay->{paddingLeft} + $overlay->{paddingRight})) / 2); + my $offsetY = 15 * $self->{style}->{factor} + ($boxHeight - ($height + $overlay->{paddingTop} + $overlay->{paddingBottom})); + + # Make an empty pixbuf to work within + my $tempPixbuf =Gtk2::Gdk::Pixbuf->new('rgb', 1, 8, + $self->{style}->{backgroundPixbuf}->get_width, + $self->{style}->{backgroundPixbuf}->get_height); + $tempPixbuf->fill(0x00000000); + + # Place cover in pixbuf + $pixbuf->composite($tempPixbuf, + $offsetX + $overlay->{paddingLeft}, $offsetY + $overlay->{paddingTop}, + $width , $height, + $offsetX + $overlay->{paddingLeft}, $offsetY + $overlay->{paddingTop}, + 1, 1, + 'nearest', 255); + $pixbuf = $tempPixbuf; + + # Composite overlay picture + $self->{style}->{overlayPixbuf}->composite($pixbuf, + $offsetX, $offsetY, + $width + $overlay->{paddingLeft} + $overlay->{paddingRight}, + $height + $overlay->{paddingTop} + $overlay->{paddingBottom}, + $offsetX, $offsetY, + ($width + $overlay->{paddingLeft} + $overlay->{paddingRight}) / $self->{style}->{overlayPixbuf}->get_width, + ($height + $overlay->{paddingTop} + $overlay->{paddingBottom}) / $self->{style}->{overlayPixbuf}->get_height, + 'nearest', 255); + + # Overlay borrower image if required + if ($borrower && ($borrower ne 'none')) + { + # De-saturate borrowed items + $pixbuf->saturate_and_pixelate($pixbuf, .1, 0); + $self->{style}->{lendPixbuf}->composite($pixbuf, + $pixbuf->get_width - $self->{style}->{lendPixbuf}->get_width - $offsetX, + $offsetY + $height + $overlay->{paddingTop} + $overlay->{paddingBottom} - $self->{style}->{lendPixbuf}->get_height, + $self->{style}->{lendPixbuf}->get_width, $self->{style}->{lendPixbuf}->get_height, + $pixbuf->get_width - $self->{style}->{lendPixbuf}->get_width - $offsetX, + $offsetY + $height + $overlay->{paddingTop} + $overlay->{paddingBottom} - $self->{style}->{lendPixbuf}->get_height, + 1, 1, + 'nearest', 255); + } + + # Overlay favourite image if required + if ($favourite) + { + $self->{style}->{favPixbuf}->composite($pixbuf, + $pixbuf->get_width - $self->{style}->{favPixbuf}->get_width - $offsetX, + $offsetY, + $self->{style}->{favPixbuf}->get_width, $self->{style}->{favPixbuf}->get_height, + $pixbuf->get_width - $self->{style}->{favPixbuf}->get_width - $offsetX, + $offsetY, + 1, 1, + 'nearest', 255); + } + + # Create and apply reflection if required + if ($self->{style}->{withReflect}) + { + my $reflect; + $reflect = $pixbuf->flip(0); + $reflect->composite( + $pixbuf, + 0, 2 * ($offsetY + $height + $overlay->{paddingTop} + $overlay->{paddingBottom}) - $pixbuf->get_height, + $pixbuf->get_width, + 2 * ($pixbuf->get_height - $height - $offsetY - $overlay->{paddingTop} - $overlay->{paddingBottom}) - (10 * $self->{style}->{factor}), + 0, 2 * ($offsetY + $height + $overlay->{paddingTop} + $overlay->{paddingBottom}) - $pixbuf->get_height, + 1, 1, + 'nearest', 100 + ); + + # Apply foreground fading + $self->{style}->{foregroundPixbuf}->composite( + $pixbuf, + 0, 0, + $pixbuf->get_width, $pixbuf->get_height, + 0, 0, + 1, 1, + 'nearest', 255 + ); + } + + # Heft created pixbuf onto background + my $bgPixbuf = $self->{style}->{backgroundPixbuf}->copy; + $pixbuf->composite($bgPixbuf, + 0,0, + $pixbuf->get_width , $pixbuf->get_height, + 0,0, + 1, 1, + 'nearest', 255); + $pixbuf = $bgPixbuf; + + } + else + { + # Not using background, so we need to make an empty pixbuf which is right size for overlay first + my $tempPixbuf =Gtk2::Gdk::Pixbuf->new('rgb', 1, 8, + $width + $overlay->{paddingLeft} + $overlay->{paddingRight}, + $height + $overlay->{paddingTop} + $overlay->{paddingBottom}); + $tempPixbuf->fill(0x00000000); + + # Now, place list image inside empty pixbuf + $pixbuf->composite($tempPixbuf, + $overlay->{paddingLeft}, $overlay->{paddingTop}, + $width , $height, + $overlay->{paddingLeft}, $overlay->{paddingTop}, + 1, 1, + 'nearest', 255 * $alpha); + $pixbuf = $tempPixbuf; + + # Place overlay on top of pixbuf + $self->{style}->{overlayPixbuf}->composite($pixbuf, + 0, 0, + $width + $overlay->{paddingLeft} + $overlay->{paddingRight}, + $height + $overlay->{paddingTop} + $overlay->{paddingBottom}, + 0, 0, + ($width + $overlay->{paddingLeft} + $overlay->{paddingRight}) / $self->{style}->{overlayPixbuf}->get_width, + ($height + $overlay->{paddingTop} + $overlay->{paddingBottom}) / $self->{style}->{overlayPixbuf}->get_height, + 'nearest', 255 * $alpha); + + # Overlay borrower image if required + if ($borrower && ($borrower ne 'none')) + { + # De-saturate borrowed items + $pixbuf->saturate_and_pixelate($pixbuf, .1, 0); + + $self->{style}->{lendPixbuf}->composite($pixbuf, + $pixbuf->get_width - $self->{style}->{lendPixbuf}->get_width, + $pixbuf->get_height - $self->{style}->{lendPixbuf}->get_height, + $self->{style}->{lendPixbuf}->get_width, $self->{style}->{lendPixbuf}->get_height, + $pixbuf->get_width - $self->{style}->{lendPixbuf}->get_width, + $pixbuf->get_height - $self->{style}->{lendPixbuf}->get_height, + 1, 1, + 'nearest', 255); + } + + # Overlay favourite image if required + if ($favourite) + { + $self->{style}->{favPixbuf}->composite($pixbuf, + $pixbuf->get_width - $self->{style}->{favPixbuf}->get_width, + 0, + $self->{style}->{favPixbuf}->get_width, $self->{style}->{favPixbuf}->get_height, + $pixbuf->get_width - $self->{style}->{favPixbuf}->get_width, + 0, + 1, 1, + 'nearest', 255); + } + + } + } + else + { + # No overlays, nice and simple + + # Overlay borrower image if required + if ($borrower && ($borrower ne 'none')) + { + # De-saturate borrowed items + $pixbuf->saturate_and_pixelate($pixbuf, .1, 0); + $self->{style}->{lendPixbuf}->composite($pixbuf, + $width - $self->{style}->{lendPixbuf}->get_width - $self->{style}->{factor}, + $height - $self->{style}->{lendPixbuf}->get_height - $self->{style}->{factor}, + $self->{style}->{lendPixbuf}->get_width, $self->{style}->{lendPixbuf}->get_height, + $width - $self->{style}->{lendPixbuf}->get_width - $self->{style}->{factor}, + $height - $self->{style}->{lendPixbuf}->get_height - $self->{style}->{factor}, + 1, 1, + 'nearest', 255); + } + + # Overlay favourite image if required + if ($favourite) + { + $self->{style}->{favPixbuf}->composite($pixbuf, + $width - $self->{style}->{favPixbuf}->get_width - $self->{style}->{factor}, + $self->{style}->{factor}, + $self->{style}->{favPixbuf}->get_width, $self->{style}->{favPixbuf}->get_height, + $width - $self->{style}->{favPixbuf}->get_width - $self->{style}->{factor}, + $self->{style}->{factor}, + 1, 1, + 'nearest', 255); + } + + my $reflect; + $reflect = $pixbuf->flip(0) + if $self->{style}->{withReflect}; + + my $offsetX = (($self->{style}->{offsetX} / 2) * $self->{style}->{factor}) + (($boxWidth - $width) / 2); + my $offsetY = 15 * $self->{style}->{factor} + ($boxHeight - $height); + if ($self->{style}->{withImage}) + { + my $bgPixbuf = $self->{style}->{backgroundPixbuf}->copy; + $pixbuf->composite($bgPixbuf, + $offsetX, $offsetY, + $width, $height, + $offsetX, $offsetY, + 1, 1, + 'nearest', 255); + $pixbuf = $bgPixbuf; + } + + if ($self->{style}->{withReflect}) + { + $reflect->composite( + $pixbuf, + $offsetX, $height + $offsetY, + $width, $pixbuf->get_height - $height - $offsetY - (10 * $self->{style}->{factor}), + $offsetX, $height + $offsetY, + 1, 1, + 'nearest', 100 + ); + + # Apply foreground fading + $self->{style}->{foregroundPixbuf}->composite( + $pixbuf, + 0, 0, + $pixbuf->get_width, $pixbuf->get_height, + 0, 0, + 1, 1, + 'nearest', 255 + ); + } + } + return $pixbuf; + } + + + +} + +{ + package GCImageCache; + + use File::Path; + use File::Copy; + use List::Util qw/min/; + + sub new + { + my ($proto, $imagesDir, $imageSize, $style, $defaultImage) = @_; + my $class = ref($proto) || $proto; + my $self = { + imagesDir => $imagesDir, + imageSize => $imageSize, + style => $style, + cacheDir => $imagesDir.'/.cache/', + oldCacheDir => $imagesDir, + defaultImage => $defaultImage, + forceUpdate => 0, + }; + # Make sure destination directory exists + if ( ! -d $self->{cacheDir}) + { + mkpath $self->{cacheDir}; + } + bless ($self, $class); + + $self->clearOldCache; + + return $self; + } + + # This method removes images cached by previous versions + sub clearOldCache + { + my $self = shift; + my $trashDir = $self->{imagesDir}.'.trash'; + mkpath $trashDir; + foreach (glob $self->{oldCacheDir}.'/*') + { + if (/\.cache\.[0-4](\.|$)/) + { + move $_, $trashDir; + } + } + } + + sub forceCacheUpdateForNextUse + { + my ($self) = @_; + $self->{forceUpdate} = 1; + } + + sub getPixbuf + { + my ($self, $info, $zoom) = @_; + my $fileName; + my $pixbuf = undef; + if (!$zoom) + { + $fileName = $self->getCachedFileName($info); + if ($self->{forceUpdate} || (! -e $fileName)) + { + $self->createImageCache($info); + } + $self->{forceUpdate} = 0; + eval { + $pixbuf = Gtk2::Gdk::Pixbuf->new_from_file($fileName); + }; + } + else + { + # When a zoom is requested, we have to generate the picture + $fileName = $self->getCachedFileName($info); + # Get picture size from cached file to avoid re-computing everything + my ($picFormat, $picWidth, $picHeight) = Gtk2::Gdk::Pixbuf->get_file_info($fileName); + # Then open the original file + my $origFileName = $info->{picture}; + if (! -f $origFileName) + { + $origFileName = $self->{defaultImage}; + } + if (!$self->{style}->{useOverlays}) + { + $zoom -= 0.01; + } + + eval { + $pixbuf = Gtk2::Gdk::Pixbuf->new_from_file($origFileName); + my $newWidth = int($picWidth * $zoom); + my $newHeight = int($picHeight * $zoom); + $pixbuf = GCUtils::scaleMaxPixbuf($pixbuf, $newWidth, $newHeight, 1, 0); + }; + } + + return $pixbuf; + } + + sub getCachedFileName + { + my ($self, $info, $size) = @_; + + my $gcsautoid = $info->{autoid}; + my $title = $info->{title}; + + $title =~ s/[^a-zA-Z0-9]*//g; + my $cacheFilename = $self->{cacheDir}; + if ($info->{picture}) + { + $cacheFilename .= $gcsautoid + ."." + .$title; + } + else + { + $cacheFilename .= 'GCSDefaultImage'; + } + $cacheFilename .= (defined $size ? $size : $self->{imageSize}); + $cacheFilename .= ".overlay" + if $self->{style}->{useOverlays}; + + return $cacheFilename; + } + + # Resizes artwork to required sizes and saves copies of the images, for fast loading + sub createImageCache + { + my ($self, $info) = @_; + + my $srcImage = $info->{picture}; + if (! -f $srcImage) + { + $srcImage = $self->{defaultImage}; + $info->{picture} = ""; + } + + # Load in the original source image + my $origPixbuf = Gtk2::Gdk::Pixbuf->new_from_file($srcImage); + + my $gcsautoid = $info->{autoid}; + my $title = $info->{title}; + $title =~ s/[^a-zA-Z0-9]*//g; + # Get original picture format + my ($picFormat, $picWidth, $picHeight) = Gtk2::Gdk::Pixbuf->get_file_info($srcImage); + + # Loop through possible sizes + for (my $size = 0; $size < 5; $size++) { + my $imgWidth; + my $imgHeight; + my $overlay; + + my $cacheFilename = $self->getCachedFileName($info, $size); + + # Get size for cached image + ($imgWidth, $imgHeight, $overlay) = $self->getDestinationImgSize($picWidth, + $picHeight, + $size); + + # Scale pixbuf and save + my $scaledPixbuf = GCUtils::scaleMaxPixbuf($origPixbuf, $imgWidth, $imgHeight, 0, 0); + if ($picFormat->{name} eq 'jpeg') + { + $scaledPixbuf->save ($cacheFilename, 'jpeg', quality => '99'); + } + else + { + $scaledPixbuf->save ($cacheFilename, 'png'); + } + } + } + + # Calculates height and width of list image + sub getDestinationImgSize + { + my ($self, $origWidth, $origHeight, $size) = @_; + + $size = $self->{imageSize} + if (!defined $size); + + my $imgWidth; + my $imgHeight; + my $overlay; + + # No overlays + $imgWidth = $self->{style}->{imgWidth} / $self->{style}->{factor}; + $imgHeight = $self->{style}->{imgHeight} / $self->{style}->{factor}; + + if ($self->{style}->{useOverlays}) + { + # Overlays + + # Calculate size of list image with proportional size of overlay padding added + my $pixbufTempHeight = (($self->{style}->{overlayPaddingTop} + $self->{style}->{overlayPaddingBottom})/$self->{style}->{overlayPixbuf}->get_height + 1) * $origHeight; + my $pixbufTempWidth = (($self->{style}->{overlayPaddingLeft} + $self->{style}->{overlayPaddingRight})/$self->{style}->{overlayPixbuf}->get_width + 1) * $origWidth; + + # Find out target size of overlay, keeping the same ratio as the size calculated above (ie, list image + relative padding) + my $ratio = $pixbufTempHeight / $pixbufTempWidth; + my $targetOverlayHeight; + my $targetOverlayWidth; + if (($pixbufTempWidth > $imgWidth) || ($pixbufTempHeight > $imgHeight)) + { + if (($pixbufTempWidth * $imgHeight/$pixbufTempHeight) < $imgHeight ) + { + $targetOverlayHeight = $imgHeight; + $targetOverlayWidth = int($imgHeight / $ratio); + } + else + { + $targetOverlayHeight = int( $imgWidth * $ratio); + $targetOverlayWidth = $imgWidth; + } + } + else + { + # Special case when image is small enough and doesn't need to be resized + $targetOverlayHeight = $pixbufTempHeight; + $targetOverlayWidth = $pixbufTempWidth; + } + + # Calculate final offset amounts for target size of overlay + $overlay->{paddingLeft} = int($self->{style}->{overlayPaddingLeft} * $targetOverlayWidth / $self->{style}->{overlayPixbuf}->get_width); + $overlay->{paddingRight} = int($self->{style}->{overlayPaddingRight} * $targetOverlayWidth / $self->{style}->{overlayPixbuf}->get_width); + $overlay->{paddingTop} = int($self->{style}->{overlayPaddingTop} * $targetOverlayHeight / $self->{style}->{overlayPixbuf}->get_height); + $overlay->{paddingBottom} = int($self->{style}->{overlayPaddingBottom} * $targetOverlayHeight / $self->{style}->{overlayPixbuf}->get_height); + + $imgWidth = $imgWidth - $overlay->{paddingLeft} - $overlay->{paddingRight}; + $imgHeight = $imgHeight - $overlay->{paddingTop} - $overlay->{paddingBottom}; + } + + my $factor = ($size == 0) ? 0.5 + : ($size == 1) ? 0.8 + : ($size == 3) ? 1.5 + : ($size == 4) ? 2 + : 1; + $imgWidth *= $factor; + $imgHeight *= $factor; + + return ($imgWidth, $imgHeight, $overlay); + } + +} + +1; diff --git a/lib/gcstar/GCItemsLists/GCImageLists.pm b/lib/gcstar/GCItemsLists/GCImageLists.pm new file mode 100644 index 0000000..2250bcb --- /dev/null +++ b/lib/gcstar/GCItemsLists/GCImageLists.pm @@ -0,0 +1,2028 @@ +package GCImageLists; + +################################################### +# +# 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 strict; +use locale; + +# Number of ms to wait before enhancing the next picture +my $timeOutBetweenEnhancements = 50; + +{ + package GCBaseImageList; + + use File::Basename; + use GCItemsLists::GCImageListComponents; + use GCUtils; + use GCStyle; + use base "Gtk2::VBox"; + use File::Temp qw/ tempfile /; + + sub new + { + my ($proto, $container, $columns) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new(0,0); + bless ($self, $class); + + my $parent = $container->{parent}; + + $self->{preferences} = $parent->{model}->{preferences}; + $self->{imagesDir} = $parent->getImagesDir(); + $self->{coverField} = $parent->{model}->{commonFields}->{cover}; + $self->{titleField} = $parent->{model}->{commonFields}->{title}; + $self->{idField} = $parent->{model}->{commonFields}->{id}; + $self->{borrowerField} = $parent->{model}->{commonFields}->{borrower}->{name}; + # Sort field + $self->{sortField} = $self->{preferences}->secondarySort + || $self->{titleField}; + $self->{fileIdx} = ""; + $self->{selectedIndexes} = {}; + $self->{previousSelectedDisplayed} = 0; + $self->{displayedToItemsArray} = {}; + $self->{container} = $container; + $self->{scroll} = $container->{scroll}; + $self->{searchEntry} = $container->{searchEntry}; + + + $self->{preferences}->sortOrder(1) + if ! $self->{preferences}->exists('sortOrder'); + + $self->{parent} = $container->{parent}; + + $self->{tooltips} = Gtk2::Tooltips->new(); + + $self->{columns} = $columns; + $self->{dynamicSize} = ($columns == 0); + $self->clearCache; + + + $self->set_border_width(0); + + $self->signal_connect('button_press_event' => sub { + my ($widget, $event) = @_; + if ($event->button eq 3) + { + $self->{parent}->{context}->popup(undef, undef, undef, undef, $event->button, $event->time) + } + }); + + $self->can_focus(1); + + $self->{imageCache} = new GCImageCache($self->{imagesDir}, + $self->{preferences}->listImgSize, + $container->{style}, + $self->{parent}->{defaultImage}); + + return $self; + } + + sub couldExpandAll + { + my $self = shift; + + return 0; + } + + sub getCurrentIdx + { + my $self = shift; + return $self->{displayedToIdx}->{$self->{current}}; + } + + sub getCurrentItems + { + my $self = shift; + my @indexes = keys %{$self->{selectedIndexes}}; + return \@indexes; + } + + sub isSelected + { + my ($self, $idx) = @_; + foreach (keys %{$self->{selectedIndexes}}) + { + return 1 if $_ == $idx; + } + return 0; + } + + sub DESTROY + { + my $self = shift; + + #unlink $self->{style}->{tmpBgPixmap}; + $self->SUPER::DESTROY; + } + + sub isUsingDate + { + my ($self) = @_; + return 0; + } + + sub setSortOrder + { + my ($self, $order) = @_; + $order = 0 if !defined $order; + $self->{currentOrder} = ($order == -1) ? (1 - $self->{currentOrder}) + : $self->{preferences}->sortOrder; + + if ($self->{itemsArray}) + { + if ($order == -1) + { + @{$self->{itemsArray}} = reverse @{$self->{itemsArray}}; + } + else + { + sub compare + { + return ( + GCUtils::gccmpe($a->{sortValue}, $b->{sortValue}) + ); + } + if ($self->{currentOrder} == 1) + { + @{$self->{itemsArray}} = sort compare @{$self->{itemsArray}}; + } + else + { + @{$self->{itemsArray}} = reverse sort compare @{$self->{itemsArray}}; + } + } + } + $self->refresh if ! $self->{initializing}; + $self->{initializing} = 0; + } + + sub setFilter + { + my ($self, $filter, $items, $refresh, $splash) = @_; + $self->{displayedNumber} = 0; + $self->{filter} = $filter; + $self->{displayedToItemsArray} = {}; + my $current = $self->{current}; + $self->restorePrevious; + my $i = 0; + foreach (@{$self->{itemsArray}}) + { + $_->{displayed} = $filter->test($items->[$_->{idx}]); + if ($_->{displayed}) + { + $self->{displayedToItemsArray}->{$self->{displayedNumber}} = $i; + $self->{displayedNumber}++; + } + $self->{container}->setDisplayed($_->{idx}, $_->{displayed}); + $i++; + } + my $newIdx = $self->getFirstVisibleIdx($current); + my $conversionNeeded = 0; + $conversionNeeded = 1 if ! exists $self->{boxes}->[$current]; + + if ($refresh) + { + $self->refresh(1, $splash); + $self->show_all; + } + + $self->{initializing} = 0; + return $self->displayedToItemsArrayIdx($newIdx) + if $conversionNeeded; + return $newIdx; + } + + sub getFirstVisibleIdx + { + my ($self, $displayed) = @_; + return $displayed if ! exists $self->{boxes}->[$displayed]; + my $currentIdx = $self->{boxes}->[$displayed]->{info}->{idx}; + my $info = $self->{boxes}->[$displayed]->{info}; + + return $currentIdx if (! exists $self->{boxes}->[$displayed]) + || ($self->{boxes}->[$displayed]->{info}->{displayed}); + my $previous = -1; + my $after = 0; + foreach my $item(@{$self->{itemsArray}}) + { + $after = 1 if $item->{idx} == $currentIdx; + if ($after) + { + return $item->{idx} if $item->{displayed}; + } + else + { + $previous = $item->{idx} if $item->{displayed}; + } + } + return $previous; + } + + sub refresh + { + my ($self, $forceClear, $splash) = @_; + return if $self->{columns} == 0; + + # Store current item index + my $currentIdx = $self->{displayedToIdx}->{$self->{current}}; + $self->{boxes} = []; + $self->{displayedToIdx} = {}; + $self->{idxToDisplayed} = {}; + + $self->clearView if (! $self->{initializing}) || $forceClear; + $self->{number} = 0; + my $idx = 0; + $self->{collectionDir} = dirname($self->{parent}->{options}->file); + foreach (@{$self->{itemsArray}}) + { + $splash->setProgressForItemsSort($idx++) if $splash; + next if ! $_->{displayed}; + $self->addDisplayedItem($_); + } + delete $self->{collectionDir}; + # Determine new current displayed + $self->{current} = $self->{idxToDisplayed}->{$currentIdx}; + if ($self->{toBeSelectedLater}) + { + $self->{parent}->display($self->select(-1)); + $self->{toBeSelectedLater} = 0; + } + #$self->show_all; + } + + sub getNbItems + { + my $self = shift; + return $self->{displayedNumber}; + } + + sub clearCache + { + my $self = shift; + + if ($self->{cache}) + { + foreach (@{$self->{cache}}) + { + $_->{imageBox}->destroy + if $_->{imageBox}; + } + } + $self->{cache} = []; + } + + sub reset + { + my $self = shift; + #Restore current picture if modified + $self->restorePrevious; + + $self->{itemsArray} = []; + $self->{boxes} = []; + $self->{number} = 0; + $self->{count} = 0; + $self->{displayedNumber} = 0; + $self->{current} = 0; + $self->{previous} = 0; + $self->clearView; + } + + sub clearView + { + my $self = shift; + + # TODO : This will be different with many lists + #my $parent = $self->parent; + #$self->parent->remove($self) + # if $parent; + + my @children = $self->get_children; + foreach (@children) + { + my @children2 = $_->get_children; + foreach my $child(@children2) + { + $_->remove($child); + } + $self->remove($_); + $_->destroy; + } + $self->{rowContainers} = []; + $self->{enhanceInformation} = []; + + # TODO : This will be different with many lists + #$self->{scroll}->add_with_viewport($self) + # if $parent; + + $self->{initializing} = 1; + } + + sub done + { + my ($self, $splash, $refresh) = @_; + if ($refresh) + { + $self->refresh(0, $splash); + } + $self->{initializing} = 0; + } + + sub setColumnsNumber + { + my ($self, $columns, $refresh) = @_; + $self->{columns} = $columns; + my $init = $self->{initializing}; + $self->{initializing} = 1; + $self->refresh($refresh) if $refresh; + $self->show_all; + $self->{initializing} = $init; + } + + sub getColumnsNumber + { + my $self = shift; + return $self->{columns}; + } + + sub createImageBox + { + my ($self, $info) = @_; + + my $imageBox = new GCImageListItem($self, $info); + return $imageBox; + } + + sub getFromCache + { + my ($self, $info) = @_; + if (! $self->{cache}->[$info->{idx}]) + { + my $item = {}; + $item->{imageBox} = $self->createImageBox($info); + $self->{cache}->[$info->{idx}] = $item; + } + return $self->{cache}->[$info->{idx}]; + } + + sub findPlace + { + my ($self, $item, $sortvalue) = @_; + my $refSortValue = $sortvalue || $item->{sortValue}; + $refSortValue = uc($refSortValue); + + # First search where it should be inserted + my $place = 0; + my $itemsIdx = 0; + if ($self->{currentOrder} == 1) + { + foreach my $followingItem(@{$self->{itemsArray}}) + { + my $testSortValue = uc($followingItem->{sortValue}); + my $cmp = GCUtils::gccmpe($testSortValue, $refSortValue); + $itemsIdx++ if ! ($cmp > 0); + + next if !$followingItem->{displayed}; + last if ($cmp > 0); + $place++; + } + } + else + { + foreach my $followingItem(@{$self->{itemsArray}}) + { + my $testSortValue = uc($followingItem->{sortValue}); + my $cmp = GCUtils::gccmpe($refSortValue, $testSortValue); + $itemsIdx++ if ! ($cmp > 0); + next if !$followingItem->{displayed}; + last if ($cmp > 0); + $place++; + } + } + return ($place, $itemsIdx) if wantarray; + return $place; + } + + sub createItemInfo + { + my ($self, $idx, $info) = @_; + my $displayedImage = GCUtils::getDisplayedImage($info->{$self->{coverField}}, + undef, + $self->{parent}->{options}->file, + $self->{collectionDir}); + my $item = { + idx => $idx, + title => $self->{parent}->transformTitle($info->{$self->{titleField}}), + picture => $displayedImage, + borrower => $info->{$self->{borrowerField}}, + sortValue => $self->{sortField} eq $self->{titleField} + ? $self->{parent}->transformTitle($info->{$self->{titleField}}) + : $info->{$self->{sortField}}, + favourite => $info->{favourite}, + displayed => 1, + autoid => $info->{$self->{idField}} + }; + return $item; + } + + sub addItem + { + my ($self, $info, $immediate, $idx, $keepConversionTables) = @_; + + my $item = $self->createItemInfo($idx, $info); + + if ($immediate) + { + # When the flag is set, that means we modified an item and that it had + # to be added to that group. In this case, we don't want to de-select + # the current one. + if (!$keepConversionTables) + { + $self->restorePrevious; + # To force the selection + $self->{current} = -1; + } + # First search where it should be inserted + my ($place, $itemsArrayIdx) = $self->findPlace($item); + # Prepare the conversions displayed <-> index + if (!$keepConversionTables) + { + $self->{displayedToIdx}->{$place} = $idx; + $self->{idxToDisplayed}->{$idx} = $place; + } + # Then we insert it at correct position + $self->addDisplayedItem($item, $place); + splice @{$self->{itemsArray}}, $itemsArrayIdx, 0, $item; + } + else + { + # Here we know it will be sorted after + push @{$self->{itemsArray}}, $item; + } + + $self->{count}++; + $self->{displayedNumber}++; + $self->{header}->show_all if $self->{header} && $self->{displayedNumber} > 0; + } + + # Params: + # $info: Information already formated for this class + # $place: Optional value to indicate where it should be inserted + sub addDisplayedItem + { + # info is an iternal info generated + my ($self, $info, $place) = @_; + return if ! $self->{columns}; + my $item = $self->getFromCache($info); + my $imageBox = $item->{imageBox}; + my $i = $info->{idx}; + if (!defined $place) + { + $self->{displayedToIdx}->{$self->{number}} = $i; + $self->{idxToDisplayed}->{$i} = $self->{number}; + } + $imageBox->prepareHandlers($i, $info); + + if (($self->{number} % $self->{columns}) == 0) + { + #New row begin + $self->{currentRow} = new Gtk2::HBox(0,0); + push @{$self->{rowContainers}}, $self->{currentRow}; + $self->pack_start($self->{currentRow},0,0,0); + $self->{currentRow}->show_all if ! $self->{initializing}; + } + + if (defined($place)) + { + # Get the row and col where it should be inserted + my $itemLine = int $place / $self->{columns}; + my $itemCol = $place % $self->{columns}; + # Insert it at correct place + $self->{rowContainers}->[$itemLine]->pack_start($imageBox,0,0,0); + $self->{rowContainers}->[$itemLine]->reorder_child($imageBox, $itemCol); + $imageBox->show_all; + $self->shiftItems($place, 1, 0, scalar @{$self->{boxes}}); + splice @{$self->{boxes}}, $place, 0, $imageBox; + $self->initConversionTables; + } + else + { + $self->{currentRow}->pack_start($imageBox,0,0,0); + $self->{idxToDisplayed}->{$i} = $self->{number}; + push @{$self->{boxes}}, $imageBox; + } + + $self->{number}++; + } + + sub grab_focus + { + my $self = shift; + $self->SUPER::grab_focus; + $self->{boxes}->[$self->{current}]->grab_focus; + } + + sub displayedToItemsArrayIdx + { + my ($self, $displayed) = @_; + return 0 if ! exists $self->{boxes}->[$displayed]; + # If we have nothing, that means we have no filter. So displayed and idx are the same + return $displayed if ! exists $self->{displayedToItemsArray}->{$displayed}; + return $self->{displayedToItemsArray}->{$displayed}; + } + + sub shiftItems + { + my ($self, $place, $direction, $justFromView, $maxPlace) = @_; + my $idx = $self->{displayedToIdx}->{$place}; + my $itemLine = int $place / $self->{columns}; + my $itemCol = $place % $self->{columns}; + # Did we already remove or add the item ? + my $alreadyChanged = ($direction < 0) || (defined $maxPlace); + # Useful to always have the same comparison a few lines below + # Should be >= for $direction == 1 + # This difference is because we didn't added it yet while it has + # already been removed in the other direction + #$itemCol-- if ! (defined $maxPlace); + $itemCol++ if ($direction < 0); + # Same here + $idx-- if $alreadyChanged; + my $newDisplayed = 0; + my $currentLine = 0; + my $currentCol; + my $shifting = 0; + # Limit indicates which value for column should make use take action + # For backward, it's the 1st one. For forward, the last one + my $limit = 0; + $limit = ($self->{columns} - 1) if $direction > 0; + foreach my $item(@{$self->{itemsArray}}) + { + if (!$item->{displayed}) + { + $item->{idx} += $direction if ((!defined $maxPlace) && ($item->{idx} > $idx)); + next; + } + $currentLine = int $newDisplayed / $self->{columns}; + $currentCol = $newDisplayed % $self->{columns}; + $shifting = $direction if (!$shifting) + && ( + ($currentLine > $itemLine) + || (($currentLine == $itemLine) + && ($currentCol >= $itemCol)) + ); + $shifting = 0 if (defined $maxPlace) && ($newDisplayed > $maxPlace); + # When using maxPlace, we are only moving in view + if ((!defined $maxPlace) && ($item->{idx} > $idx)) + { + $item->{idx} += $direction; + $self->{cache}->[$item->{idx}]->{imageBox}->{idx} = $item->{idx} + if ($item->{idx} > 0) && $self->{cache}->[$item->{idx}]; + } + if ($shifting) + { + # Is this the first/last one in the line? + if ($currentCol == $limit) + { + $self->{rowContainers}->[$currentLine]->remove( + $self->{cache}->[$item->{idx}]->{imageBox} + ); + $self->{rowContainers}->[$currentLine + $direction]->pack_start( + $self->{cache}->[$item->{idx}]->{imageBox}, + 0,0,0 + ); + # We can't directly insert on the beginning. + # So we need a little adjustement here + if ($direction > 0) + { + $self->{rowContainers}->[$currentLine + $direction]->reorder_child( + $self->{cache}->[$item->{idx}]->{imageBox}, + 0 + ); + } + } + } + $newDisplayed++; + } + } + + sub shiftIndexes + { + my ($self, $indexes) = @_; + my $nbIndexes = scalar @$indexes; + my $nbLower; + my $currentIdx; + my @cache; + foreach my $box(@{$self->{boxes}}) + { + # Find how many are lowers in our indexes + # We suppose they are sorted + $nbLower = 0; + $currentIdx = $box->{info}->{idx}; + foreach (@$indexes) + { + last if $_ > $currentIdx; + $nbLower++; + } + $box->{info}->{idx} -= $nbLower; + $cache[$box->{info}->{idx}] = $self->{cache}->[$box->{info}->{idx} + $nbLower]; + } + $self->{cache} = \@cache; + } + + sub initConversionTables + { + my $self = shift; + my $displayed = 0; + $self->{displayedToIdx} = {}; + $self->{idxToDisplayed} = {}; + foreach (@{$self->{boxes}}) + { + $self->{displayedToIdx}->{$displayed} = $_->{info}->{idx}; + $self->{idxToDisplayed}->{$_->{info}->{idx}} = $displayed; + $_->{idx} = $_->{info}->{idx}; + $displayed++; + } + } + + sub convertIdxToDisplayed + { + my ($self, $idx) = @_; + return $self->{idxToDisplayed}->{$idx}; + } + + sub convertDisplayedToIdx + { + my ($self, $displayed) = @_; + return $self->{displayedToIdx}->{$displayed}; + } + + sub removeItem + { + my ($self, $idx, $justFromView) = @_; + $self->{count}--; + $self->{displayedNumber}--; + # Fix to remove header only when items are grouped + $self->{header}->hide if $self->{container}->{groupItems} && $self->{displayedNumber} <= 0; + my $displayed = $self->{idxToDisplayed}->{$idx}; + my $itemLine = int $displayed / $self->{columns}; + #my $itemCol = $displayed % $self->{columns}; + $self->{rowContainers}->[$itemLine]->remove( + $self->{cache}->[$idx]->{imageBox} + ); + + # Remove event box from cache + my $itemsArrayIdx = $self->displayedToItemsArrayIdx($displayed); + + $self->{cache}->[$idx]->{imageBox}->destroy; + $self->{cache}->[$idx]->{imageBox} = 0; + + splice @{$self->{cache}}, $idx, 1 if !$justFromView; + splice @{$self->{boxes}}, $self->{idxToDisplayed}->{$idx}, 1; + + if ($justFromView) + { + $self->shiftItems($displayed, -1, 0, scalar @{$self->{boxes}}); + } + else + { + $self->shiftItems($displayed, -1); + } + $self->initConversionTables; + + splice @{$self->{itemsArray}}, $itemsArrayIdx, 1; + my $next = $self->{displayedToIdx}->{$displayed}; + if ($displayed >= (scalar(@{$self->{boxes}}))) + { + $next = $self->{displayedToIdx}->{--$displayed} + } + $self->{current} = $displayed; + + my $last = scalar @{$self->{itemsArray}}; + delete $self->{displayedToIdx}->{$last}; + # To be sure we still have consistent data, we re-initialize the other hash by swapping keys and values. + $self->{idxToDisplayed} = {}; + my ($k,$v); + $self->{idxToDisplayed}->{$v} = $k while (($k,$v) = each %{$self->{displayedToIdx}}); + + # Fix to remove items from "displayed" list on delete + my $numDisplayed = scalar(keys %{$self->{container}->{displayed}}); + delete $self->{container}->{displayed}->{$numDisplayed-1}; + + $self->{number}--; + return $next; + } + + sub removeCurrentItems + { + my ($self) = @_; + my @indexes = sort {$a <=> $b} keys %{$self->{selectedIndexes}}; + my $nbRemoved = 0; + $self->restorePrevious; + my $next; + foreach my $idx(@indexes) + { + $next = $self->removeItem($idx - $nbRemoved); + $nbRemoved++; + } + $self->{selectedIndexes} = {}; + $self->select($next, 1); + + return $next; + } + + sub restoreItem + { + my ($self, $idx) = @_; + + my $previous = $self->{idxToDisplayed}->{$idx}; + next if ($previous == -1) || (!defined $previous) || (!$self->{boxes}->[$previous]); + + $self->{boxes}->[$previous]->unhighlight; + delete $self->{selectedIndexes}->{$idx}; + } + + sub restorePrevious + { + my ($self, $fromContainer) = @_; + foreach my $idx(keys %{$self->{selectedIndexes}}) + { + $self->restoreItem($idx); + } + $self->{container}->clearSelected($self) if !$fromContainer; + } + + sub selectAll + { + my $self = shift; + + $self->restorePrevious; + $self->select($self->{displayedToIdx}->{0}, 1, 0); + foreach my $displayed(1..scalar(@{$self->{boxes}}) - 1) + { + $self->select($self->{displayedToIdx}->{$displayed}, 0, 1); + } + $self->{parent}->display(keys %{$self->{selectedIndexes}}); + } + + sub selectMany + { + my ($self, $lastSelected) = @_; + + my ($min, $max); + if ($self->{previousSelectedDisplayed} > $self->{idxToDisplayed}->{$lastSelected}) + { + $min = $self->{idxToDisplayed}->{$lastSelected}; + $max = $self->{previousSelectedDisplayed}; + } + else + { + $min = $self->{previousSelectedDisplayed}; + $max = $self->{idxToDisplayed}->{$lastSelected}; + } + foreach my $displayed($min..$max) + { + $self->select($self->{displayedToIdx}->{$displayed}, 0, 1); + } + + } + + sub select + { + my ($self, $idx, $init, $keepPrevious) = @_; + $self->{container}->setCurrentList($self); + $idx = $self->{displayedToIdx}->{0} if $idx == -1; + my $displayed = $self->{idxToDisplayed}->{$idx}; + if (! $self->{columns}) + { + $self->{toBeSelectedLater} = 1; + return $idx; + } + my @boxes = @{$self->{boxes}}; + + return $idx if ! scalar(@boxes); + my $alreadySelected = 0; + $alreadySelected = $boxes[$displayed]->{selected} + if exists $boxes[$displayed]; + my $nbSelected = scalar keys %{$self->{selectedIndexes}}; + + return $idx if $alreadySelected && ($nbSelected < 2) && (!$init); + if ($keepPrevious) + { + if (($alreadySelected) && ($nbSelected > 1)) + { + + $self->restoreItem($idx); + # Special case where user has deselect items, so now only one item is left selected + # and menus need to be updated to reflect that + $self->updateMenus(1) + if $nbSelected <= 2; + + return $idx; + } + $self->{selectedIndexes}->{$idx} = 1; + } + else + { + $self->restorePrevious; + $self->{selectedIndexes} = {$idx => 1}; + } + + $self->{current} = $displayed; + + $boxes[$displayed]->highlight + if exists $boxes[$displayed]; + + $self->grab_focus; + $self->{container}->setCurrentList($self) + if $self->{container}; + + # Update menu items to reflect number of items selected + $self->updateMenus(scalar keys %{$self->{selectedIndexes}}); + return $idx; + } + + sub displayDetails + { + my ($self, $createWindow, @idx) = @_; + if ($createWindow) + { + $self->{parent}->displayInWindow($idx[0]); + } + else + { + $self->{parent}->display(@idx); + } + } + + sub showPopupMenu + { + my ($self, $button, $time) = @_; + + $self->{parent}->{context}->popup(undef, undef, undef, undef, $button, $time); + } + + sub setPreviousSelectedDisplayed + { + my ($self, $idx) = @_; + $self->{previousSelectedDisplayed} = $self->{idxToDisplayed}->{$idx} + if !exists $self->{previousSelectedDisplayed}; + } + + sub unsetPreviousSelectedDisplayed + { + my ($self, $idx) = @_; + delete $self->{previousSelectedDisplayed}; + } + + sub updateMenus + { + # Update menu items to reflect number of items selected + my ($self, $nbSelected) = @_; + foreach ( + # Menu labels + [$self->{parent}->{menubar}, 'duplicateItem', 'MenuDuplicate'], + [$self->{parent}->{menubar}, 'deleteCurrentItem', 'MenuEditDeleteCurrent'], + # Context menu labels + [$self->{parent}, 'contextNewWindow', 'MenuNewWindow'], + [$self->{parent}, 'contextDuplicateItem', 'MenuDuplicate'], + [$self->{parent}, 'contextItemDelete', 'MenuEditDeleteCurrent'], + ) + { + $self->{parent}->{menubar}->updateItem( + $_->[0]->{$_->[1]}, + $_->[2].(($nbSelected > 1) ? 'Plural' : '')); + } + } + + sub setHeader + { + my ($self, $header) = @_; + $self->{header} = $header; + } + + sub showCurrent + { + my $self = shift; + return if ! $self->{columns}; + if ($self->{initializing}) + { + Glib::Timeout->add(100 ,\&showCurrent, $self); + return; + } + + my $adj = $self->{scroll}->get_vadjustment; + my $totalRows = int $self->{number} / $self->{columns}; + my $row = (int $self->{current} / $self->{columns}); + + my $ypos = 0; + if ($self->{header}) + { + $ypos = $self->{header}->allocation->y; + # We scroll also the size of the header. + # But we don't do that for the 1st row to have it displayed then. + $ypos += $self->{header}->allocation->height + if $row; + } + # Add the items before + $ypos += (($row - 1) * $self->{style}->{vboxHeight}); + + $adj->set_value($ypos); + return 0; + } + + sub changeItem + { + my ($self, $idx, $previous, $new, $withSelect) = @_; + return $self->changeCurrent($previous, $new, $idx, 0); + } + + sub changeCurrent + { + my ($self, $previous, $new, $idx, $wantSelect) = @_; + my $forceSelect = 0; + #To ease comparison, do some modifications. + #empty borrower is equivalent to 'none'. + $previous->{$self->{borrowerField}} = 'none' if $previous->{$self->{borrowerField}} eq ''; + $new->{$self->{borrowerField}} = 'none' if $new->{$self->{borrowerField}} eq ''; + my $previousDisplayed = $self->{idxToDisplayed}->{$idx}; + my $newDisplayed = $previousDisplayed; + if ($new->{$self->{sortField}} ne $previous->{$self->{sortField}}) + { + # Adjust title + my $newTitle = $self->{parent}->transformTitle($new->{$self->{titleField}}); + my $newSort = $self->{sortField} eq $self->{titleField} ? $newTitle : $new->{$self->{sortField}}; + + $self->{boxes}->[$previousDisplayed]->{info}->{title} = $newTitle; + $self->{tooltips}->set_tip($self->{boxes}->[$previousDisplayed], $newTitle, ''); + my $newItemsArrayIdx; + ($newDisplayed, $newItemsArrayIdx) = $self->findPlace(undef, $newSort); + # We adjust the index as we'll remove an item + $newDisplayed-- if $newDisplayed > $previousDisplayed; + if ($previousDisplayed != $newDisplayed) + { + #$self->restorePrevious; + my $itemPreviousLine = int $previousDisplayed / $self->{columns}; + my $itemNewLine = int $newDisplayed / $self->{columns}; + my $itemNewCol = $newDisplayed % $self->{columns}; + my ($direction, $origin, $limit); + if ($previousDisplayed > $newDisplayed) + { + $direction = 1; + $origin = $newDisplayed; + $limit = $previousDisplayed - 1; + } + else + { + $direction = -1; + $origin = $previousDisplayed; + $limit = $newDisplayed; + $itemNewCol++ if ($itemNewLine > $itemPreviousLine) && ($itemNewCol != 0) + } + my $box = $self->{cache}->[$idx]->{imageBox}; + my $previousItemsArrayIdx = $self->displayedToItemsArrayIdx($previousDisplayed); + $self->{rowContainers}->[$itemPreviousLine]->remove($box); + splice @{$self->{boxes}}, $previousDisplayed, 1; + $self->{rowContainers}->[$itemNewLine]->pack_start($box,0,0,0); + $self->{rowContainers}->[$itemNewLine]->reorder_child($box, $itemNewCol); + + $self->shiftItems($origin, $direction, 0, $limit); + my $item = splice @{$self->{itemsArray}}, $previousItemsArrayIdx, 1; + $newItemsArrayIdx-- if $previousItemsArrayIdx < $newItemsArrayIdx; + splice @{$self->{itemsArray}}, $newItemsArrayIdx, 0, $item; + splice @{$self->{boxes}}, $newDisplayed, 0, $box; + $self->initConversionTables; + } + } + + my @boxes = @{$self->{boxes}}; + my $item = $self->createItemInfo($idx, $new); + if (($previous->{$self->{coverField}} ne $new->{$self->{coverField}}) + || ($previous->{$self->{borrowerField}} ne $new->{$self->{borrowerField}}) + || ($previous->{favourite} ne $new->{favourite})) + { + $boxes[$newDisplayed]->refreshInfo($item, 1); + $forceSelect = 1; + $wantSelect = 1 if $wantSelect ne ''; + } + else + { + # Popup is refreshed by previous call. + # So we just need to explicitely do it here + if ($boxes[$newDisplayed]) + { + $boxes[$newDisplayed]->setInfo($item); + $boxes[$newDisplayed]->refreshPopup; + } + } + if ($self->{filter}) + { + # Test visibility + my $previouslyVisible = $self->{filter}->test($previous); + my $visible = $self->{filter}->test($new); + if ($previouslyVisible && ! $visible) + { + $self->{displayedNumber}--; + $self->restorePrevious if $wantSelect; + my $itemLine = int $newDisplayed / $self->{columns}; + + $self->{rowContainers}->[$itemLine]->remove( + $self->{cache}->[$idx]->{imageBox} + ); + my $info = $self->{boxes}->[$newDisplayed]->{info}; + splice @{$self->{boxes}}, $newDisplayed, 1; + $self->shiftItems($newDisplayed, -1, 0, scalar @{$self->{boxes}}); + $self->initConversionTables; + $info->{displayed} = $visible; + $idx = $self->getFirstVisibleIdx($newDisplayed); + $wantSelect = 0 if ! scalar @{$self->{boxes}} + } + } + $self->select($idx, $forceSelect) if $wantSelect; + return $idx; + } + + sub showSearch + { + my ($self, $char) = @_; + $self->{searchEntry}->set_text($char); + $self->{searchEntry}->show_all; + $self->activateSearch; + $self->{container}->{searchTimeOut} = Glib::Timeout->add(4000, sub { + $self->hideSearch; + $self->{searchTimeOut} = 0; + return 0; + }); + } + + sub activateSearch + { + my ($self) = @_; + $self->{searchEntry}->grab_focus; + $self->{searchEntry}->select_region(length($self->{searchEntry}->get_text), -1); + } + + sub hideSearch + { + my $self = shift; + $self->{searchEntry}->set_text(''); + $self->{searchEntry}->hide; + $self->grab_focus; + $self->{previousSearch} = ''; + } + + sub internalSearch + { + my $self = shift; + + my $query = $self->{searchEntry}->get_text; + return if !$query; + my $newDisplayed = -1; + + my $current = 0; + my $length = length($query); + if ($self->{currentOrder}) + { + if (($length > 1) && ($length > length($self->{previousSearch}))) + { + $current = $self->{idxToDisplayed}->{$self->{itemsArray}->[$self->{current}]->{idx}}; + } + foreach(@{$self->{itemsArray}}[$current..$self->{count} - 1]) + { + next if !$_->{displayed}; + if ($_->{title} ge $query) + { + $newDisplayed = $self->{idxToDisplayed}->{$_->{idx}}; + last; + } + } + } + else + { + foreach(@{$self->{itemsArray}}[$current..$self->{count} - 1]) + { + next if !$_->{displayed}; + if (($_->{title} =~ m/^\Q$query\E/i) || ($_->{title} lt $query)) + { + $newDisplayed = $self->{idxToDisplayed}->{$_->{idx}}; + last; + } + } + } + + if ($newDisplayed != -1) + { + my $valueIdx = $self->{displayedToIdx}->{$newDisplayed}; + $self->select($valueIdx); + $self->{parent}->display($valueIdx); + $self->{boxes}->[$newDisplayed]->grab_focus; + $self->showCurrent; + $self->activateSearch; + } + $self->{previousSearch} = $query; + } + +} + +{ + package GCImageList; + + use base "Gtk2::VBox"; + use File::Temp qw/ tempfile /; + + my $defaultGroup = 'GCMAINDEFAULTGROUP'; + + sub new + { + my ($proto, $parent, $columns) = @_; + my $class = ref($proto) || $proto; + my $self = $class->SUPER::new(0,0); + bless ($self, $class); + + $self->{preferences} = $parent->{model}->{preferences}; + $self->{parent} = $parent; + $self->{columns} = $columns; + + $self->{borrowerField} = $parent->{model}->{commonFields}->{borrower}->{name}; + + $self->{scroll} = new Gtk2::ScrolledWindow; + $self->{scroll}->set_policy ('automatic', 'automatic'); + $self->{scroll}->set_shadow_type('none'); + + $self->{searchEntry} = new Gtk2::Entry; + #$self->{list} = new GCBaseImageList($self, $columns); + + $self->{orderSet} = 0; + $self->{sortButton} = Gtk2::Button->new; + $self->setSortButton($self->{preferences}->sortOrder); + $self->{searchEntry}->signal_connect('changed' => sub { + return if ! $self->{searchEntry}->get_text; + $self->internalSearch; + }); + $self->{searchEntry}->signal_connect('key-press-event' => sub { + my ($widget, $event) = @_; + Glib::Source->remove($self->{searchTimeOut}) + if $self->{searchTimeOut}; + return if ! $self->{searchEntry}->get_text; + my $key = Gtk2::Gdk->keyval_name($event->keyval); + if ($key eq 'Escape') + { + $self->hideSearch; + return 1; + } + $self->{searchTimeOut} = Glib::Timeout->add(4000, sub { + $self->hideSearch; + $self->{searchTimeOut} = 0; + return 0; + }); + + return 0; + }); + + #$self->{scroll}->add_with_viewport($self->{list}); + $self->{mainList} = new Gtk2::VBox(0,0); + $self->{scroll}->add_with_viewport($self->{mainList}); + #$self->{list}->initPixmaps; + + $self->pack_start($self->{sortButton},0,0,0); + $self->pack_start($self->{scroll},1,1,0); + $self->pack_start($self->{searchEntry},0,0,0); + + $self->{sortButton}->signal_connect('clicked' => sub { + $self->setSortOrder(-1); + $self->setSortButton; + }); + + $self->initStyle; + $self->setGroupingInformation; + $self->{empty} = 1; + $self->{orderedLists} = []; + $self->{displayed} = {}; + return $self; + } + + sub setSortButton + { + my ($self, $order) = @_; + $order = $self->{currentOrder} + if !defined $order; + my $image = Gtk2::Image->new_from_stock($order + ? 'gtk-sort-descending' + : 'gtk-sort-ascending', + 'button'); + my $stockItem = Gtk2::Stock->lookup($order + ? 'gtk-sort-ascending' + : 'gtk-sort-descending'); + $stockItem->{label} =~ s/_//g; + $self->{sortButton}->set_label($stockItem->{label}); + $self->{sortButton}->set_image($image); + + } + + sub show_all + { + my $self = shift; + $self->SUPER::show_all; + $self->{mainList}->show_all; + $self->{searchEntry}->hide; + } + + sub done + { + my $self = shift; + foreach (values %{$self->{lists}}) + { + $_->done; +# $self->{style}->{vboxWidth} = $_->{style}->{vboxWidth} +# if !exists $self->{style}->{vboxWidth}; + } + # We set a number of ms to wait before enhancing the pictures + my $offset = 0; + foreach (@{$self->{orderedLists}}) + { + $self->{lists}->{$_}->{offset} = $offset; + $offset += $timeOutBetweenEnhancements * ($self->{lists}->{$_}->{displayedNumber} + 1); + } + if ($self->{columns} == 0) + { + $self->signal_connect('size-allocate' => sub { + $self->computeAllocation; + }); + $self->computeAllocation; + } + else + { + foreach (values %{$self->{lists}}) + { + $_->setColumnsNumber($self->{columns}, 0); + } + } + } + + sub computeAllocation + { + my $self = shift; + return if !$self->{style}->{vboxWidth}; + my $width = $self->{scroll}->child->allocation->width - 15; + return if $width < 0; + if (($self->{scroll}->get_hscrollbar->visible) + || ($width > (($self->{columns} + 1) * $self->{style}->{vboxWidth}))) + { + my $columns = int ($width / $self->{style}->{vboxWidth}); + if ($columns) + { + return if $columns == $self->{columns}; + $self->{columns} = $columns; + foreach (values %{$self->{lists}}) + { + $_->setColumnsNumber($columns, 1); + } + # TODO : We should maybe select an item here + #$self->{parent}->display($self->select(-1, 1)) + # if !$self->{current}; + } + else + { + $self->{columns} = 1; + } + } + + } + + sub initStyle + { + my $self = shift; + my $parent = $self->{parent}; + + my $size = $self->{preferences}->listImgSize; + $self->{style}->{withAnimation} = $self->{preferences}->animateImgList; + $self->{style}->{withImage} = $self->{preferences}->listBgPicture; + $self->{style}->{useOverlays} = ($self->{preferences}->useOverlays) && ($parent->{model}->{collection}->{options}->{overlay}->{image}); + $self->{preferences}->listImgSkin($GCStyle::defaultList) if ! $self->{preferences}->exists('listImgSkin'); + $self->{style}->{skin} = $self->{preferences}->listImgSkin; + # Reflect setting can be enabled using "withReflect=1" in the listbg style file + $self->{style}->{withReflect} = 0; + $self->{preferences}->listImgSize(2) if ! $self->{preferences}->exists('listImgSize'); + + my $bgdir; + # Load in extra settings from the style file + if ($self->{style}->{withImage}) + { + $bgdir = $ENV{GCS_SHARE_DIR}.'/list_bg/'.$self->{style}->{skin}; + if (open STYLE, $bgdir.'/style') + { + while (