sub send_to_shell {
    my ($widget,$file) = @_;
    my $string;
    my $opus = MIDI::Opus->new({ 'from_file' => $file,
        'exclusive_event_callback' => sub{
                my $temp = $_[2];
                chomp $temp;
                if($_[0] eq 'text_event'){
                    if($_[1] == 0){
                    }else{
                        $string = $string . $_[2];
                        push @arr_lyr, $_[2];
                    }
                }elsif($_[0] eq 'track_name'){
                    $marker = $_[2];
                }
            },
        'include' => \@MIDI::Event::All_events,
        'exclude' => \@MIDI::Event::MIDI_events,
    });
    @line_lyrics = split(/\/|\\/,$string);
    shift @line_lyrics;
    print "Marker: $marker\n";
    print "_____START_____\n";
    $start = 0;

    # start song
    my $cmd = "timidity '$file'";
    print $wfh "$cmd\n";

}
[download]

my $pixbuf = Gtk2::Gdk::Pixbuf->new_from_file_at_scale('karaoke/b1.jpg
+',$uw,$uh,1);
[download]

my $pixbuf = do {
        my $loader = Gtk2::Gdk::PixbufLoader->new();
        $loader->write( $bunny );
        $loader->close();
        $loader->get_pixbuf();
    };
[download]

The do construct was something shown to me awhile back by the venerable aristotle. The difference is this, if my mind serves me correctly:-):

With the "_from_file" method, you need to be reading from a disk file.

With the loader method, you can load image data which is in a scalar string, or slurped in from a disk file, often referred to as blobs in ImageMagick terminolgy. ( See Convert Gnome2::Canvas::Pixbuf to Image::Magick Array ). This is often quite handy, like when you pull an image in from the web, and want to display it, without first writing it to a disk file. Like:

  my $graph_image = get($http_request_string);
 $graph_image at this point is a string, with a PNG-looking header.
 my $loader = Gtk2::Gdk::PixbufLoader->new;
  $loader->write($png_data);
  $loader->close;
  my $pixbuf = $loader->get_pixbuf;
[download]

Even though there is Gtk2::Gdk::Pixbuf->new_from_data, it does not automatically handle autodetection of file type as well as the Gtk2::Gdk::PixbufLoader. In other words, the Pixbufloader will autodetect from it's list of recognized types, making it the best method to use if you want an easy load.

Here is a simple way to list the autodetected file types which your Gtk2 build recognizes.

#!/usr/bin/perl
use strict;
use warnings;
use Gtk2;

my @formats = Gtk2::Gdk::Pixbuf->get_formats();
my @exts;

foreach my $format ( @formats ) {
    foreach my $key ( keys( %$format ) ) {
           next unless $key eq 'extensions';  
         
       foreach my $elem ( @{ $format->{ $key } } ) {
                push @exts, $elem;
            }
     } 
 }
print "@exts\n";
[download]

And finally, [the original message from [aristotle]:
<p><quote aristotle>

OT: I like to partition things like into smaller scopes:

    my $pixbuf = do {
        my $loader = Gtk2::Gdk::PixbufLoader->new();
        $loader->write( $image_data );
        $loader->close();
        $loader->get_pixbuf();
    };

So the next guy who looks at it doesn't have to wonder if $loader
is used anywhere later, and can see that the entire point of this
mumbo jumbo is to load something into $pixbuf.
Regards,
#Aristotle
</quote aristotle>
[download]

So in summary, if you want to learn one good method for foolproof loading of images, use the pixbufloader construct, it will seldom let you down.

---

I'm not really a human, but I play one on earth.
Old Perl Programmer Haiku