Delegation

 use AWT;
 use AWT::Event;
 use artofillusion qw (RGBColor);
 
 use strict;
 
 package ColorSlider;
 use vars qw($VERSION @ISA @EXPORT @EXPORT_OK);
 
 @ISA = qw (Component);
 @EXPORT = qw (); #defer this
 
 $ColorSlider::HORIZONTAL = 1;
 $ColorSlider::VERTICAL = 0;
 
 sub new {
 
     my $self = {
 		preferredMajor => 200,
 		preferredMinor => 18,
 
 		bubblePos => 50,
 		tempBubblePos => 50,
 
 		dragging => 0,
 
 		orientation => 0,
 		mode => $RGBColor::HSV_MODE,
 
 		baseImpl => new Canvas ()
 	       };
 
     my ($minimum,  $maximum,  $value, $orientation, $c1, $c2) = @_;
 
     $self->{minimum} = $minimum;
     $self->{maximum} = $maximum;
     $self->{value} = $value;
     $self->{orientation} = $orientation;
     $self->{startColor} = new RGBColor ($c1);
     $self->{endColor} = new RGBColor ($c2);
 
     my $canvas = $self->baseImpl;
     $canvas->setSize (200, 18);
     $canvas->addMouseListener ($self);
     $canvas->addMouseMotionListener ($self);
     $canvas->setOnPaint (\&paint);
     $canvas->setSubImpl ($self);
 
     #So that routines that deal with components know where
     #to go for native widget stuff
     $self->setBaseImpl ($canvas);
     $self->setOnSetSize (sub {$_[0]->_drawImage ()});
 }
 
 
 sub getPreferredSize {
   my ($w, $h) = (200, 18);
   $_[0]->getOrientation ? ($w, $h) :  ($h, $w);
 }
 
 
 sub setColors {
   my ($self, $c1, $c2) = @_;
   $self->{startColor}->copy ($c1);
   $self->{endColor}->copy ($c2);
   $self->_drawImage ();
 }
 
 sub setMode {
   my ($self, $mode) = @_;
   $self->{mode} = $mode;
   $self->_drawImage ();
 }
 
 sub _drawImage {
   my $self = shift;
   my ($w, $h) = getSize ();
   my $startColor = $self->{startColor};
   my $endColor = $self->{endColor};
   my $mode = $self->{mode};
   my $pixels = new PixelArray ($w, $h);
 
   if ($self->{orientation}) {
     $pixels->map (sub { 
 		    my ($x, $y, $p) = @_; #or they could be auto-assigned?
 		    my $c = RGBColor::interp ($startColor, $endColor, 
                             $mode, $x / $w)->getARGB | 0xff000000; 
 		  });
   } else {
     $pixels->map (sub { 
 		    my ($x, $y, $p) = @_; 
 		    my $c = RGBColor::interp ($startColor, $endColor, 
 			    $mode,  $y / $h)->getARGB | 0xff000000;
 		  });
 }
 
   $self->{image} = new Image (@pixels);
 }
 
 
 sub _drawImageFast {
   my $self = shift;
   my ($w, $h) = getSize ();
   my $startColor = $self->{startColor};
   my $endColor = $self->{endColor};
   my $mode = $self->{mode};
   my $pixels = new PixelArray ($w * $h);
 
   if ($self->{orientation}) {
     for (my $x = 0; $x < $w; $x++) {
       my $c = RGBColor::interp ($startColor, $endColor, 
               $mode, $x / $w)->getARGB | 0xff000000;
       $pixels->[$x + $_ * $w] = $c for (1..$h);
     }
   } else {
     my $i = 0;
     for (my $y = 0; $y < $h; $y++) {
       my $c = RGBColor::interp ($startColor, $endColor, 
               $mode,  $y / $h)->getARGB | 0xff000000;
       $pixels->[$i++] = $c for (1..$w);
     }
   }
 
   $self->{image} = new Image (@pixels);
 }
 
 sub _dragging {
   $_[0]->{dragging};
 }
 
 sub mouseDragged {
   my ($self, $event) = @_;
   return if (!$self->_dragging);
 
   my ($minor, $major) = ColorSlider::_getAxes ($event);
 
   my ($w, $h) = $self->getSize ();
   my $minorMax = $self->{orientation} ? $h : $w;
   if ($minor > 0 && $minor < $minorMax) {
     if ($major < 0) {
       $self->setTempBubblePos (0);
     } elsif ($major > 200) {
       $self->setTempBubblePos (200);
     } else {
       $self->setTempBubblePos ($major);
     }
     $self->repaint;
   }
 }
 sub setTempBubblePos {
   $_[0]->{tempBubblePos} = $_[1];
 }
 
 sub mouseReleased {
   my ($self, $event) = @_;
 
   $self->{bubblePos} = $self->{tempBubblePos};
 
   $self->{dragging} = 0;
   $self->repaint;
   $self->fireAdjustmentPerformed ();
 }
 
 sub _getAxes {
   my $event = shift;
   $_[0]->{orientation} ? ($event->{w}, $event->{h})
     : ($event->{h}, $event->{w});
 }
 
 sub mousePressed {
   my ($self, $event) = @_;
 
   my ($minor, $major) = _getAxes ();
   $self->{tempBubblePos} = $major;
   $self->{dragging} = 1;
   $self->repaint;
 }
 
 sub paint {
 
   my ($self, $gc) = @_;
 
   my ($width, $height) = $self->getSize ();
 
   $self->drawImage () unless $self->{image};
 
   my ($bubblePos, $tempBubblePos) = 
     ($self->{bubblePos}, $self->{tempBubblePos});
 
   if ($self->{orientation}) {
     my $h = $self->{preferredMinor};
     my $w = $width;
     my $top = ($height - $h) / 2;
     $gc->drawImage ($self->{image}, 0, 6 + $top);
 
     #outline
     $gc->drawRect (0, 6 + $top,  200, 6);
 
     #top of position marker
     $gc->fillRect ($bubblePos, $top,  2, 6);
 
     #bottom of position marker
     $gc->fillRect ($bubblePos, 12 + $top, 2, $h - 12);
 
     #top of temp position marker
     $gc->fillRect ($tempBubblePos, $top, 2, 6);
 
     #bottom of temp position marker
     $gc->fillRect ($tempBubblePos, 12 + $top, 2, $h - 12);
 
   } else {
     #literate programming lets me ignore this case for now
   }
 }
 
 sub getValue {
   my $self = shift;
   my $value = $self->{bubblePos} / 200;
   $self->{value} = $value;
   $value * $self->{maximum} + $self->{minimum};
 }
 
 
 sub setValue {
   my ($self, $value) = @_;
   $value = ($value - $self->{minimum}) / $self->{maximum};
   $self->{bubblePos} = $value * 200;
   $self->{tempBubblePos} = $self->{bubblePos};
   $self->{value} = $value;
   $self->repaint;
 }