Wrangler/Wx/Previewer.pm untested

filter: Statementstmt 0.0% 0 / 303 Branchbran 0.0% 0 / 110 Conditioncond 0.0% 0 / 54 MC/DCmcdc n/a Subroutinesub 0.0% 0 / 27 Podpod 0.0% 0 / 20 totaltotal 0.0% 0 / 514 CC 56 SCAR 40.1
CC
56
Cov
0%
Populate
182.0
_recalc
90.0
new
56.0
CRAP 55.4
1 package Wrangler::Wx::Previewer;
2  
3 use strict;
4 use warnings;
5  
6 use base 'Wx::Panel';
7 use Wx ':everything';
8 use Wx::Event qw(EVT_PAINT EVT_SIZE EVT_MENU EVT_LEFT_DCLICK EVT_ENTER_WINDOW EVT_LEAVE_WINDOW EVT_LEFT_DOWN EVT_LEFT_UP EVT_RIGHT_UP EVT_TIMER EVT_MOUSEWHEEL);
9 use IO::Scalar;
10 use Image::MetaData::JPEG ();
11  
12 # todo: As a hackish temp solution, video thumbnailing and metadata extraction
13 # ended up here for the 2.x branch. This probably has to be moved away again, into
14 # the metadata abstraction once the "on-demand value"-facility fully arrives.
15  
16 sub new {
17 my $class = shift;
18 my $parent = shift;
19 my $self = $class->SUPER::new( $parent, -1, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER);
20  
21 bless $self, $class;
22  
23 # hook-up access to $wrangler
24 $self->{wrangler} = $parent->{wrangler};
25 $self->{config} = $self->{wrangler}->config();
26  
27 ## tell central $wishlist what we need
28 $Wrangler::wishlist->{'Filesystem::Path'} = 1;
29 $Wrangler::wishlist->{'MIME::mediaType'} = 1;
30 $Wrangler::wishlist->{'MIME::subType'} = 1;
31  
32 ## wrangler events
33 Wrangler::PubSub::subscribe('selection.changed', sub {
34 # Wrangler::debug("Previewer: event selection.changed: @_");
35  
36 $self->{timer}->Stop() if $self->{timer}->IsRunning();
37  
38 if($_[0] && $_[0] > 1){
39 # Wrangler::debug("Previewer: $_[0] files selected: event ignored.");
40 return;
41 }
42  
43 if($_[1]){
44 $self->Populate(${ $_[1] }[0]); # richlist_item
45 }else{
46 $self->LoadDefault();
47 }
48 },__PACKAGE__);
49  
50 ## Wx events
51 EVT_PAINT($self, \&OnPaint );
52 EVT_SIZE($self, \&OnSize );
53 EVT_LEFT_DCLICK($self, sub {
54 Wrangler::debug('Wrangler::Wx::Previewer: DoubleClick on Thumbnail');
55  
56 # emit appropriate event
57 Wrangler::PubSub::publish('file.activated', $self->{path}, $self->{richlist_item}) if $self->{path};
58 });
59  
60 $self->SetBackgroundColour(Wx::Colour->new(50, 50, 50));
61  
62 # init scale and center_offset for initial draw event
63 $self->{scale} = 1;
64 $self->{center_offset} = [0,0];
65  
66 $self->{timer} = Wx::Timer->new();
67  
68 EVT_ENTER_WINDOW($self, \&OnMouseOver);
69 EVT_LEAVE_WINDOW($self, \&OnMouseLeave);
70 EVT_LEFT_DOWN($self, \&OnMouseDown);
71 EVT_LEFT_UP($self, \&OnMouseUp);
72 EVT_RIGHT_UP($self,sub { \&OnRightClick(@_); });
73 EVT_TIMER($self->{timer}, $self->{timer}, sub {
74 Wrangler::debug("Wrangler::Wx::Previewer: Timer: (load best_quality)");
75  
76 $self->Populate(undef,'best_quality');
77 });
78 EVT_MOUSEWHEEL($self, sub {
79 my $multiplier = $_[1]->GetWheelRotation() > 1 ? 1 : -1;
80 my @mouse_pos = ($_[1]->GetX(),$_[1]->GetY());
81 my @center = ( int($self->{win_w}/2), int($self->{win_h}/2) );
82 # $self->{center_offset} = [$mouse_pos[0] - $center[0], $mouse_pos[1] - $center[1]];
83 $self->{center_offset} = [ ($center[0] - $mouse_pos[0]) * -1, ($center[1] - $mouse_pos[1]) * -1];
84 $self->{scale} += 0.1 * $multiplier; $self->{scale} = 1 if $self->{scale} < 0.1;
85 Wrangler::debug("Wrangler::Wx::Previewer: Mousewheel: at:@mouse_pos, center:@center, center-offset:@{$self->{center_offset}}, multiplier:$multiplier, scale:$self->{scale}");
86  
87 $self->_recalc();
88  
89 $self->Refresh();
90 });
91  
92 return $self;
93 }
94  
95 sub OnMouseOver {
96 my ($previewer, $event) = @_;
97  
98 ## do nothing if we don't display an image
99 return if !$previewer->{BmpScaled};
100  
101 $previewer->SetBackgroundColour(Wx::Colour->new(55, 55, 55));
102  
103 return if !$previewer->{displayed_media_type} || $previewer->{displayed_media_type} ne 'video';
104  
105 $previewer->VideoMetadata($previewer->{path}) unless $previewer->{current_meta};
106  
107 $previewer->{show_nav} = 1;
108 }
109 sub OnMouseLeave {
110 my ($self, $event) = @_;
111  
112 ## do nothing if we don't display an image
113 return if !$self->{BmpScaled};
114  
115 $self->SetBackgroundColour(Wx::Colour->new(50, 50, 50));
116  
117 $self->{show_nav} = 0;
118 }
119 sub OnMouseDown {
120 my ($self, $event) = @_;
121  
122 if($self->{show_nav}){
123 my $sleft = $self->{slider_pos} - 2;
124 my $sright= $self->{slider_pos} + 2;
125  
126 # if( $event->GetPosition->y within top and bottom of slider){
127 # if( $event->GetPosition->x within left and right side of slider){
128 ## commented out, as having to hit the slider on mouse-down is a bit uncomfortable
129 # my $xpos = $event->GetPosition->x;
130 # if($xpos >= $sleft && $xpos <= $sright){
131 $self->{slider_hit} = 1;
132 # }
133 # }
134 }
135 }
136 sub OnMouseUp {
137 my ($self, $event) = @_;
138  
139 if($self->{show_nav}){
140 if($self->{slider_hit}){
141 if($event->GetPosition->x < 20){
142 $self->{slider_pos} = 20+1;
143 }elsif($event->GetPosition->x > $self->{win_w} - 20){
144 $self->{slider_pos} = $self->{win_w} - 20-1;
145 }else{
146 $self->{slider_pos} = $event->GetPosition->x - 20;
147 my $video_pos_percent = $self->{slider_pos} / $self->{slider_1percent};
148 $self->{slider_pos_sec} = int( ($self->{runtime_seconds} / 100) * $video_pos_percent );
149 Wrangler::debug("Previewer::OnMouseUp: ".int($video_pos_percent)."% (pos:$self->{slider_pos}) = $self->{slider_pos_sec}");
150  
151 $self->LoadRef( $self->VideoThumbnail( $self->{path}, $self->{slider_pos_sec} ) );
152 $self->{slider_hit} = undef;
153 }
154 }
155 }
156 $self->Refresh();
157 }
158  
159 # OnPaint Events happen often!! (be sure to filter when we *need* a Refresh()!)
160 sub OnPaint {
161 my ($self, $event) = @_;
162  
163 if($self->{BmpScaled}){
164 # Wrangler::debug("Previewer::OnPaint: we display an image");
165  
166 ## assumes a correctly scaled bmp
167 my $dc = Wx::PaintDC->new($self);
168 $dc->SetUserScale($self->{scale},$self->{scale}) if $self->{scale} && $self->{scale} != 1;
169 $dc->DrawBitmap($self->{BmpScaled}, @{ $self->{Position} }, 1);
170  
171 if($self->{show_nav}){
172 ## draw slider background
173 # as long as we can't get the background to render semi-transparent - commented out
174 # $dc->SetBrush( Wx::Brush->new( Wx::Colour->new(0,0,0,128), wxSOLID ) );
175 # $dc->SetPen( Wx::Pen->new( Wx::Colour->new(0,0,0), 1, wxSOLID ) );
176 # $dc->DrawRectangle( 10, $self->{win_h} - 50, $self->{win_w}-20, $self->{win_h} - 50 );
177  
178 ## draw slider border
179 my $start_y = ($self->{win_h} - 20 - 20); # top-left start point is 40px above bottom
180 my $start_x = 20; # nav start 20px right of left border
181 my $width = ($self->{win_w} - 20 - 20); # end nav 20px from right minus left margin
182 $dc->SetBrush( Wx::Brush->new( Wx::Colour->new(0,0,0,128), wxTRANSPARENT ) );
183 $dc->SetPen( Wx::Pen->new( Wx::Colour->new(100,100,100), 1, wxSOLID ) );
184 $dc->DrawRectangle( $start_x, $start_y, $width, 20 );
185  
186 my $slider_length = $width;
187 $self->{slider_1percent} = $slider_length / 100;
188  
189 ## draw slider indicator
190 # todo: this pixels to seconds algo is *not working!*
191 if(!$self->{slider_pos}){
192 my $pos_percent = 20; # default start percentage
193 $self->{slider_pos} = $self->{slider_1percent} * $pos_percent;
194 }
195 $dc->SetPen( Wx::Pen->new( Wx::Colour->new(130,130,130), 2, wxSOLID ) );
196 $dc->DrawLine( int($self->{slider_pos}+20), $start_y +1, int($self->{slider_pos}+20), $start_y + 18 );
197  
198 ## prepare dc for some timcode numbers
199 $dc->SetFont( Wx::Font->new(8, wxFONTFAMILY_MAX, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
200 $dc->SetTextForeground( Wx::Colour->new(130,130,130) );
201  
202 ## draw video duration (right)
203 if( $self->{current_meta} ){
204 my $runtime_timecode = $self->{current_meta}->{runtime_timecode};
205 $self->{runtime_seconds} = $self->{current_meta}->{runtime_seconds}; # store for later
206  
207 my ($text_width,$text_height) = $dc->GetTextExtent($runtime_timecode);
208 $dc->DrawText($runtime_timecode, $self->{win_w} - $text_width - 20, $self->{win_h} - $text_height - 3);
209 }
210  
211 ## draw slider's timecode position (left)
212 if($self->{slider_pos_sec}){
213 my $hrs = int($self->{slider_pos_sec} / (60*60));
214 my $rest= $self->{slider_pos_sec} % (60*60);
215 my $min = int($rest / 60);
216 $rest = $rest % 60;
217 my $sec = $rest;
218 my ($text_width,$text_height) = $dc->GetTextExtent('00:'.sprintf("%02d", $min).':'.sprintf("%02d", $sec));
219 $dc->DrawText(sprintf("%02d", $hrs).':'.sprintf("%02d", $min).':'.sprintf("%02d", $sec), 20, $self->{win_h} - $text_height - 3);
220 }
221 }
222 }
223 }
224  
225 sub OnSize {
226 my ($self, $event) = @_;
227  
228 if($self->{BmpScaled}){
229 # Wrangler::debug("Previewer::OnSize: we display an image");
230  
231 ## onSize events most probably result from a resize, so do transform BmpScaled
232 $self->_recalc();
233  
234 ## everything calculated. force an OnPaint event by calling Refresh()
235 $self->Refresh();
236 }
237 }
238  
239 sub _recalc {
240 my ($self,$update)=@_;
241  
242 # update values of $self->{Position}, $self->{BmpScaled}, based on $self->{ImgCurrent} and Window Size
243  
244 # Check the Panel dimensions and recalc if they changed, rescaling when needed
245 my $win_w = $self->GetClientSize()->GetWidth();
246 my $win_h = $self->GetClientSize()->GetHeight();
247  
248 $self->{win_w} = $win_w;
249 $self->{win_h} = $win_h;
250  
251 # Calculate new scaling factor
252 my($src_w, $src_h) = ($self->{ImgCurrent}->GetWidth(), $self->{ImgCurrent}->GetHeight());
253 my($scl_w, $scl_h) = ($self->{BmpScaled}->GetWidth(), $self->{BmpScaled}->GetHeight());
254 my $scale_x = $win_w / $src_w if $win_w && $src_w;
255 my $scale_y = $win_h / $src_h if $win_h && $src_h;
256 Wrangler::debug("Previewer: _recalc: crash prevented! (division by zero) :$src_w :$src_h") if !$src_w || !$src_h;
257 my $scale = $scale_x && $scale_x < $scale_y ? $scale_x : $scale_y ? $scale_y : 0;
258  
259 # Calculate new picture dimensions
260 my $new_w = int($src_w * $scale);
261 my $new_h = int($src_h * $scale);
262  
263 # Wrangler::debug("Wrangler::Previewer::_recalc: scale:$scale: $src_w x $src_h => $new_w x $new_h, to fit Window $win_w x $win_h");
264  
265 # If picture dimensions must change, rescale the bitmap
266 if($update || $new_w != $scl_w || $new_h != $scl_h){
267 $self->{BmpScaled} = Wx::Bitmap->new( $self->{ImgCurrent}->Scale($new_w,$new_h) );
268 }
269  
270 # Center the picture within the window
271 $self->{Position} = [0,0];
272 if($new_w < $win_w){
273 $self->{Position}->[0] = int(($win_w - $new_w) / 2) + round($self->{center_offset}->[0] * $self->{scale});
274 }
275 if($new_h < $win_h){
276 $self->{Position}->[1] = int(($win_h - $new_h) / 2) + round($self->{center_offset}->[1] * $self->{scale});
277 }
278 }
279  
280 sub round {
281 return $_[0] == 0 ? 0 : int($_[0] + $_[0]/abs($_[0]*2));
282 }
283  
284 my $regex_jpeg = qr/jpg|jpeg/i;
285 my $regex_supported = qr/bmp|png|jpg|jpeg|gif|pcx|portable-|tiff|tga|targa|xpixmap|xpm|icon/i;
286 sub Populate {
287 my ($previewer, $richlist_item, $best_quality) = @_;
288  
289 $previewer->{richlist_item} = $richlist_item ? $richlist_item : $previewer->{richlist_item};
290 $previewer->{path} = $richlist_item ? $richlist_item->{'Filesystem::Path'} : $previewer->{path}; # if supplied, set, else, use stored $path in panel's obj;
291 $richlist_item = $previewer->{richlist_item} unless $richlist_item;
292 $previewer->{displayed_media_type} = undef; # reset stuff
293 $previewer->{displaying_ref} = undef; # reset stuff
294 $previewer->{slider_pos} = undef;
295 $previewer->{current_meta} = undef;
296 $previewer->{scale} = 1;
297 $previewer->{center_offset} = [0,0];
298  
299 ## load from appropriate source
300 if($richlist_item->{'MIME::mediaType'}){
301 if($richlist_item->{'MIME::mediaType'} eq 'image' && $richlist_item->{'MIME::subType'} =~ $regex_supported){
302 Wrangler::debug("Previewer::Populate: an image");
303 if($best_quality){
304 Wrangler::debug(" ->Load() (actual file)");
305 $previewer->Load($previewer->{path});
306 return;
307 }
308  
309 $previewer->{timer}->Start($previewer->{config}->{'ui.previewer.image.load_original_timeout'} || 800, wxTIMER_ONE_SHOT); # schedule $best_quality load
310  
311 # 1st: try to extract an embedded thumbnail-preview, regardless of size
312 if($richlist_item->{'MIME::subType'} =~ $regex_jpeg){
313 my $file = Image::MetaData::JPEG->new($previewer->{path} , 'APP1', 'FASTREADONLY');
314 my $ref = eval { $file->get_Exif_data('THUMBNAIL') }; # above new may have die'd
315  
316 ## change preview area thumbnail, Load() is smart enough to show default on empty; ref might just be '' (empty)
317 if(ref($ref) && UNIVERSAL::isa($ref, 'SCALAR') && $$ref ne ''){
318 Wrangler::debug(" ->LoadRef()");
319 $previewer->LoadRef($ref);
320 return;
321 }
322 }
323  
324 # 2nd: load the actual full image, in case its size is small enough
325 my $max_size = $previewer->{config}->{'ui.previewer.image.original_as_preview_max_size'} ? ($previewer->{config}->{'ui.previewer.image.original_as_preview_max_size'} * 1000) : 300000;
326 if($richlist_item->{'Filesystem::Size'} < $max_size){
327 $previewer->{timer}->Stop();
328 Wrangler::debug(" ->Load() (actual file, as its size < max_size cap)");
329 $previewer->Load($previewer->{path});
330 return;
331 }
332 }elsif($richlist_item->{'MIME::mediaType'} eq 'video'){
333 Wrangler::debug("Previewer::Populate: a video");
334  
335 my $ref = $previewer->VideoThumbnail($previewer->{path}, $previewer->{config}->{'ui.previewer.video.default_thumbnail_position'});
336 if($ref){
337 $previewer->LoadRef( $ref );
338 $previewer->{displayed_media_type} = 'video';
339 return;
340 }
341 }
342 }
343  
344 Wrangler::debug("Previewer::Populate: (no preview)");
345 $previewer->LoadDefault(); # =load nothing, show "no preview"
346 }
347  
348 sub probe_helper {
349 my $previewer = shift;
350  
351 unless( defined($previewer->{helper_probed}) ){
352 my $test = `$Wrangler::Config::env{HelperFfmpeg}`;
353 if($test && $test =~ /usage/){
354 Wrangler::debug('Previewer: helper found');
355 $previewer->{helper_probed} = 1;
356 }else{
357 Wrangler::debug('Previewer: helper not found');
358 $previewer->{helper_probed} = 0;
359 }
360 }
361  
362 return $previewer->{helper_probed};
363 }
364  
365 sub VideoThumbnail {
366 my $previewer = shift;
367 my $path = quotemeta(shift);
368 my $thumbpos = shift || 2;
369  
370 return undef unless $previewer->probe_helper();
371  
372 my $out;
373 eval {
374 $out = `$Wrangler::Config::env{HelperFfmpeg} -y -ss $thumbpos -i $path -vframes 1 -an -f image2 - 1>&1 2>/dev/null`; # 1>&1 catches out, 2>&1 catches error, ..
375 };
376  
377 return \$out unless $@;
378  
379 Wrangler::debug("Previewer::VideoThumbnail: error:". $@);
380 return undef;
381 }
382  
383 sub VideoMetadata {
384 my $previewer = shift;
385 my $path = quotemeta(shift);
386 my $thumbpos = shift || 2;
387  
388 return undef unless $previewer->probe_helper();
389  
390 my $err;
391 eval {
392 $err = `$Wrangler::Config::env{HelperFfmpeg} -i $path 2>&1`; # catch stderr, where ffmpeg/avconv outputs stuff
393 };
394  
395 # Wrangler::debug("Previewer::VideoMetadata: $Wrangler::Config::env{HelperFfmpeg} said: ". $err);
396 # Duration: 00:00:30.7, start: 0.000000, bitrate: 191 kb/s
397 if($err =~ /\QDuration: \E([^,]+)\Q,\E/){
398 my $ff;
399 $ff->{runtime_timecode} = $1;
400 ( $ff->{runtime_hrs}, $ff->{runtime_min}, $ff->{runtime_sec} ) = split(/:|\./,$ff->{runtime_timecode});
401 $ff->{runtime_seconds} = $ff->{runtime_sec} + ($ff->{runtime_min} * 60) + ($ff->{runtime_hrs} *60*60);
402 $previewer->{current_meta}->{runtime_timecode} = $ff->{runtime_timecode};
403 $previewer->{current_meta}->{runtime_seconds} = $ff->{runtime_seconds};
404 return;
405 }
406  
407 Wrangler::debug("Previewer::VideoMetadata: error:". $@);
408 return undef;
409 }
410  
411  
412 sub LoadRef {
413 my($previewer,$ref) = @_;
414  
415 Wrangler::debug("Previewer::LoadRef: @_");
416  
417 ## load requested image or default, then init BmpScaled
418 $previewer->{ImgCurrent} = Wx::Image->new( IO::Scalar->new($ref), 'image/jpeg');
419 $previewer->{BmpScaled} = Wx::Bitmap->new( $previewer->{ImgCurrent} );
420  
421 ## recalc: transform $self->{BmpScaled}
422 $previewer->_recalc(1);
423  
424 ## trigger a Paint event
425 $previewer->Refresh();
426  
427 $previewer->{displaying_ref} = 1; # for SaveThumbnail
428 }
429  
430 sub Load {
431 my ($self,$path) = @_;
432  
433 Wrangler::debug("Previewer::Load: $path");
434  
435 ## load requested image or default, then init BmpScaled
436 $self->{ImgCurrent} = Wx::Image->new($path, wxBITMAP_TYPE_ANY);
437 $self->{BmpScaled} = Wx::Bitmap->new( $self->{ImgCurrent} );
438  
439 ## recalc: transform $self->{BmpScaled}
440 $self->_recalc(1);
441  
442 ## trigger a Paint event
443 $self->Refresh();
444 }
445  
446 sub LoadDefault {
447 my $self = shift;
448  
449 # Wrangler::debug("Previewer::LoadDefault: @_");
450  
451 ## generate a 'no_preview' bitmap, then init BmpScaled
452 unless($self->{no_thumb}){
453 Wrangler::debug("Previewer::LoadDefault: generate and cache no_thumb");
454 my $dc = Wx::MemoryDC->new();
455 $self->{no_thumb} = Wx::Bitmap->new(400, 300, -1);
456 $dc->SelectObject($self->{no_thumb});
457 $dc->SetBrush( Wx::Brush->new( Wx::Colour->new(0,0,0), wxSOLID ) );
458 $dc->DrawRectangle(0, 0, 400, 300); # make sure nothing shines through
459 $dc->GradientFillLinear(
460 Wx::Rect->new(0,30,399,160),
461 Wx::Colour->new(0,0,0),
462 Wx::Colour->new(100,100,100),
463 wxSOUTH
464 );
465 $dc->GradientFillLinear(
466 Wx::Rect->new(0,190,399,80),
467 Wx::Colour->new(100,100,100),
468 Wx::Colour->new(0,0,0),
469 wxSOUTH
470 );
471 $dc->SetTextForeground( Wx::Colour->new(220,220,220) );
472 $dc->SetFont( Wx::Font->new( 13, wxFONTFAMILY_SWISS , wxNORMAL, wxNORMAL ) );
473 my ($text_width) = $dc->GetTextExtent('no preview');
474 $dc->DrawText('no preview', int((400 / 2) - ($text_width / 2)), 200 );
475 $self->{no_thumb} = $self->{no_thumb}->ConvertToImage;
476 }
477 $self->{ImgCurrent} = $self->{no_thumb};
478 $self->{BmpScaled} = Wx::Bitmap->new( $self->{no_thumb} );
479  
480 ## recalc: transform $self->{BmpScaled}
481 $self->_recalc(1);
482  
483 ## trigger a Paint event
484 $self->Refresh();
485 }
486  
487 sub SaveThumbnail {
488 my $previewer = shift;
489  
490 # Wrangler::debug("Previewer: $previewer->{richlist_item}->{'Filesystem::Directory'} ");
491 my $default_directory = $previewer->{richlist_item}->{'Filesystem::Directory'} ? $previewer->{richlist_item}->{'Filesystem::Directory'} : '';
492 my $default_filename = 'thumbnail.jpg';
493 if($previewer->{richlist_item} && $previewer->{richlist_item}->{'Filesystem::Basename'}){
494 $default_filename = $previewer->{richlist_item}->{'Filesystem::Basename'} .'_thumb';
495 $default_filename .= '_'. $previewer->{slider_pos} if $previewer->{slider_pos} && $previewer->{slider_pos_sec};
496 # $default_filename .= '.'.$previewer->{richlist_item}->{'Filesystem::Suffix'} if $previewer->{richlist_item}->{'Filesystem::Suffix'};
497 $default_filename .= '.jpg';
498 }
499  
500 my $dialog = Wx::FileDialog->new($previewer, "Choose a filename and directory", $default_directory, $default_filename, "*.*", wxFD_SAVE|wxFD_OVERWRITE_PROMPT );
501  
502 return unless $dialog->ShowModal() == wxID_OK;
503  
504 # currently, LoadRef does not keep the original ref
505 # open(my $out, '>', $dialog->GetPath() ) or Wrangler::debug("SaveThumbnail: can't write thumbnail to file: $!");
506 # binmode($out);
507 # print $out ${ $self->{the_ref_if_we_had_it} };
508 # close($out);
509  
510 # so we use the built-in Wx solution
511 $previewer->{ImgCurrent}->SaveFile($dialog->GetPath(), 'image/jpeg') or Wrangler::debug("SaveThumbnail: can't write thumbnail to file: $!");
512 }
513  
514 sub OnDeselected {
515 my($self,$path) = @_;
516  
517 $self->{BmpScaled} = undef;
518  
519 ## trigger a Paint event
520 $self->Refresh(1);
521 }
522  
523 sub OnRightClick {
524 my $previewer = shift;
525 my $event = shift;
526  
527 my $menu = Wx::Menu->new();
528  
529 my $itemSave = Wx::MenuItem->new($menu, -1, "Save preview...", 'Save currently displayed thumbnail as a JPEG file');
530 $menu->Append($itemSave);
531 if( $previewer->{displaying_ref} ){
532 $menu->Enable($itemSave->GetId(),1);
533 EVT_MENU( $previewer, $itemSave, sub { $previewer->SaveThumbnail(); });
534 }else{
535 $menu->Enable($itemSave->GetId(),0);
536 }
537 $menu->AppendSeparator();
538 EVT_MENU( $previewer, $menu->Append(-1, "Settings", 'Settings'), sub { Wrangler::PubSub::publish('show.settings', 2, 0); } );
539  
540 $previewer->PopupMenu( $menu, wxDefaultPosition );
541 }
542  
543 sub Destroy {
544 my $self = shift;
545  
546 Wrangler::PubSub::unsubscribe_owner(__PACKAGE__);
547  
548 $self->SUPER::Destroy();
549 }
550  
551 1;