| 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; |