11.1.1. The Screenshot.

11.1.2. The Code.

The program can be found here: 'Image Manipulation'

	
 #! /usr/bin/perl -w
 
 use strict;
 use Glib qw/TRUE FALSE/;
 use Gtk2 '-init';
 use Gtk2::Gdk::Keysyms;
 
 #create the stock item
 &create_stock_item;
  
 #standard window creation, placement, and signal connecting
 my $window = Gtk2::Window->new('toplevel');
 $window->signal_connect('delete_event' => sub { Gtk2->main_quit; });
 $window->set_border_width(5);
 $window->set_position('center_always');
 
 #this vbox will return the bulk of the gui
 my $vbox = &ret_vbox();
 
 #add and show the vbox
 $window->add($vbox);
 $window->show();
 
 
 #our main event-loop
 Gtk2->main();
 
 sub create_stock_item {
 #this sub will add a stockitem:
 
 # the stock id our stock item will be accessed with
 my $stock_id = 'dylan';
 
 # add a new entry to the stock system with our id
 Gtk2::Stock->add ({
 		stock_id => $stock_id,
 		label    => '_Dylan - Stock image sizes',
 		modifier => [],
 		keyval   => $Gtk2::Gdk::Keysyms{D},
 		translation_domain => 'gtk2_image',
 	});
 	
 	# create an icon set, with only one member in this particular case
 	my $icon_set = Gtk2::IconSet->new_from_pixbuf (
 		Gtk2::Gdk::Pixbuf->new_from_file ("./pix/dylan.jpg"));
 		
 # create a new icon factory to handle rendering the image at various sizes...
 my $icon_factory = Gtk2::IconFactory->new;
 # add our new stock icon to it...
 $icon_factory->add ($stock_id, $icon_set);
 # and then add this custom icon factory to the list of default places in
 # which to search for stock ids, so any gtk+ code can find our stock icon.
 $icon_factory->add_default;
 
 }
 
 
 sub ret_vbox {
 
 my $vbox = Gtk2::VBox->new(FALSE,5);
 
 #the stock images
 	my $frame = Gtk2::Frame->new();
 		#to prove that a Gtk2::Frame can contain something else
 		
 	$frame->set_shadow_type ('out');
 	#method of Gtk2::Container
 	$frame->set_border_width(5);
 	
 		my $btn_dylan = Gtk2::Button->new_from_stock('dylan');
 	
 	$frame->set_label_widget ($btn_dylan);
 	
 		#create a hbox that will contain the various stock image sizes
 		my $hbox_stock = Gtk2::HBox->new(FALSE,5);
 		my @sizes =qw/menu small-toolbar large-toolbar button dnd dialog /;
 		foreach my $size(@sizes){
 		$hbox_stock->pack_start(Gtk2::Label->new($size.":"),FALSE,FALSE,0);
 			my $img_stock = Gtk2::Image->new_from_stock('dylan',$size);	
 		$hbox_stock->pack_start($img_stock,FALSE,FALSE,0);
 		}	
 	$frame->add($hbox_stock);
 	
 $vbox->pack_start($frame,FALSE,FALSE,0);
 
 #scaling the image
 	$frame = Gtk2::Frame->new('Fetching the image from a file, and scaling the original:');
 	$frame->set_shadow_type ('out');
 	#method of Gtk2::Container
 	$frame->set_border_width(5);
 	
 		#create a hbox that will contain the original and scaled images
 		my $hbox_scale = Gtk2::HBox->new(FALSE,5);
 		
 			my $lbl_type = Gtk2::Label->new("original\n(100x100):");
 		$hbox_scale->pack_start($lbl_type,FALSE,FALSE,0);
 			
 	#________
 	#the Gtk2::Gdk::PixbufLoader is used in
 	# the acquisition of images in "raw" format.
 	#This will typically be data from a database
 			my $pixbufloader = Gtk2::Gdk::PixbufLoader->new;
 				my $raw_data = `cat ./pix/dylan.jpg`;
 			$pixbufloader->write($raw_data);
 			$pixbufloader->close;		
 			my $pixbuf = $pixbufloader->get_pixbuf;
 			 
 			my $img_orig = Gtk2::Image->new_from_pixbuf($pixbuf);	
 		$hbox_scale->pack_start($img_orig,FALSE,FALSE,0);
 			
 		$lbl_type = Gtk2::Label->new("Scale\n(150x150):");
 		$hbox_scale->pack_start($lbl_type,FALSE,FALSE,0);
 							
 			my $pixbuf_larger = $pixbuf->scale_simple(150,150,'bilinear');
 			my $img_larger = Gtk2::Image->new_from_pixbuf($pixbuf_larger);
 		$hbox_scale->pack_start($img_larger,FALSE,FALSE,0);
 		
 		$lbl_type = Gtk2::Label->new("Scale\n(50x50):");
 		$hbox_scale->pack_start($lbl_type,FALSE,FALSE,0);
 							
 			my $pixbuf_smaller = $pixbuf->scale_simple(50,50,'bilinear');
 			my $img_smaller = Gtk2::Image->new_from_pixbuf($pixbuf_smaller);
 		$hbox_scale->pack_start($img_smaller,FALSE,FALSE,0);
 			
 	$frame->add($hbox_scale);
 			
 $vbox->pack_start($frame,FALSE,FALSE,0);
 
 #cut and zoom
 $frame = Gtk2::Frame->new('Fetching a piece of a pixbuff, and scaling it:');
 	$frame->set_shadow_type ('out');
 	#method of Gtk2::Container
 	$frame->set_border_width(5);
 	
 	my $pixbuf_head = $pixbuf->new_subpixbuf (13, 11, 50, 50);
 	my $pixbuf_head_large = $pixbuf_head->scale_simple(150,150,'bilinear');
 	
 	#create a hbox that will contain the original and scaled head images
 	my $hbox_head_scale = Gtk2::HBox->new(0,5);
 		
 		$lbl_type = Gtk2::Label->new("Original head:");
 	$hbox_head_scale->pack_start($lbl_type,FALSE,FALSE,0);
 		my $img_head = Gtk2::Image->new_from_pixbuf($pixbuf_head);
 	$hbox_head_scale->pack_start($img_head,FALSE,FALSE,0);
 	
 	$lbl_type = Gtk2::Label->new("Scaled head:");
 	$hbox_head_scale->pack_start($lbl_type,FALSE,FALSE,0);
 		my $img_head_large = Gtk2::Image->new_from_pixbuf($pixbuf_head_large);
 	$hbox_head_scale->pack_start($img_head_large,FALSE,FALSE,0);
 			
 	$frame->add($hbox_head_scale);
 	
 $vbox->pack_start($frame,FALSE,FALSE,0);	
 	
 $vbox->show_all();
 return $vbox;
 }

11.1.3. Discussing the program.

Gtk2::Stock

We will start our discussion by looking at Gtk2::Stock. Up to now, we only used available stock items. Stock items can be used in various places, is a nice way to standardize, and eases internationalization.

If you expect to see the standard stock icons stored somewhere in your file system, you are in for a surprise. These icons are data structures, compiled into Gtk+.

Gtk2::Stock has the ability to add new stock items to it. These new items will only be available while the program run, and is destroyed as soon as it terminates. We follow a few standard steps to create a stock item.

• To add the new stock item, we use the add method, and supply data to a hash of key/value pairs

  # add a new entry to the stock system with our id
  Gtk2::Stock->add ({
  		stock_id => $stock_id,
  		label    => '_Dylan - Stock image sizes',
  		modifier => [],
  		keyval   => $Gtk2::Gdk::Keysyms{D},
  		translation_domain => 'gtk2_image',
  	});
  		

  Two important hash keys are "stock_id" and "label". The rest are used for more advanced functions, that will not be needed in our program. At this stage the new stock item is ready to be used. If you want to incorporate an icon with it (like we want to) you need a few extra steps.

• Create a Gtk2::IconSet, with only one member in this particular case.

  my $icon_set = Gtk2::IconSet->new_from_pixbuf (
  		Gtk2::Gdk::Pixbuf->new_from_file ("./pix/dylan.jpg"));

  The data for the pixbuf can be from various sources, in our example we opt for an image file.

• Create a new Gtk2::IconFactory factory to handle rendering the image at various sizes.

  my $icon_factory = Gtk2::IconFactory->new;

  We will show in our program the various sizes available for stock icons.

• Add our new stock icon to it.

  $icon_factory->add ($stock_id, $icon_set);

  This will tie the icon to the stock item.

• Then add this custom Gtk2::IconFactory to the list of default places in which to search for stock ids, so any Gtk+ code can find our stock icon.

  $icon_factory->add_default;

  This finish the steps to add the icon to the Gtk2::Stock item.

Getting image data

Sometimes the images you want to show in your application can not be fetched using the typical 'from_file' methods. Images from a database is a classic example. Rather than writing them to a temp file, and reading the temp file, we can directly use them. In our sample program we simulate this situation.

#the Gtk2::Gdk::PixbufLoader is used in
# the acquisition of images in "raw" format.
#This will typically be data from a database
		my $pixbufloader = Gtk2::Gdk::PixbufLoader->new;
			my $raw_data = `cat ./pix/dylan.jpg`;
		$pixbufloader->write($raw_data);
		$pixbufloader->close;		
	my $pixbuf = $pixbufloader->get_pixbuf;
			 
my $img_orig = Gtk2::Image->new_from_pixbuf($pixbuf);	

Image manipulation

In our program, we use available methods of Gtk2::Gdk::Pixbuf to manipulate an image.

• To scale a image we use:

  pixbuf = $src->scale_simple ($dest_width, $dest_height, $interp_type) 

  This allow various values for "$interp_type", but most end results are the same. We used 'bilinear'.

• To grab only a piece of an exitsing Gtk2::Gdk::Pixbuf:

   pixbuf = $src_pixbuf->new_subpixbuf ($src_x, $src_y, $width, $height) 

  All the arguments should be easy to understand.

General

Remember that manipulating a Gtk2::Gdk::Pixbuf does not show it on screen. To do that, we have to show it in a Gtk2::Image widget.

When displaying stock images, you need to supply the size of the image. Our program list, and show all available sizes for stock images.