Inheritance

 use AWT;
 use AWT::Event;
 use artofillusion qw (RGBColor);
 
 use strict;
 
 package ColorSlider;
 use vars qw($VERSION @ISA @EXPORT @EXPORT_OK);
 
 @ISA    = qw(Canvas MouseListener MouseMoutionListener Adjuster::Std);
 @EXPORT = qw (); #defer this
 
 $ColorSlider::HORIZONTAL = 1;
 $ColorSlider::VERTICAL = 0;
 
 sub new {
 
     my $self = new Canvas ();
     $self->{_ColorSlider} = {
 			 preferredMajor => 200,
 			 preferredMinor => 18,
 
 			 bubblePos => 50,
 			 tempBubblePos => 50,
 
 			 dragging => 0,
 
 			 orientation => 0,
 			 mode => $RGBColor::HSV_MODE,
 	       };
 
     my ($minimum,  $maximum,  $value, $orientation, $c1, $c2) = @_;
 
     $self->{_ColorSlider}{minimum} = $minimum;
     $self->{_ColorSlider}{maximum} = $maximum;
     $self->{_ColorSlider}{value} = $value;
     $self->{_ColorSlider}{orientation} = $orientation;
     $self->{_ColorSlider}{startColor} = new RGBColor ($c1);
     $self->{_ColorSlider}{endColor} = new RGBColor ($c2);
 
     $self->setSize (200, 18);
     $self->addMouseListener ($self);
     $self->addMouseMotionListener ($self);
 
 }
 
 sub getPreferredSize {
   my ($w, $h) = (200, 18);
   $_[0]->getOrientation ? ($w, $h) :  ($h, $w);
 }
 
 sub getOrientation {
    $_[0]->{_ColorSlider}{orientation};
 }
 sub setSize {
   Canvas::setSize (@_);
   $_[0]->_drawImage ();
 }
 
 sub setColors {
   my ($self, $c1, $c2) = @_;
   $self->{_ColorSlider}{startColor}->copy ($c1);
   $self->{_ColorSlider}{endColor}->copy ($c2);
   $self->_drawImage ();
 }
 
 sub setMode {
   my ($self, $mode) = @_;
   $self->{_ColorSlider}{mode} = $mode;
   $self->_drawImage ();
 }
 
 sub _drawImage {
   my $self = shift;
   my ($w, $h) = getSize ();
   my $startColor = $self->{_ColorSlider}{startColor};
   my $endColor = $self->{_ColorSlider}{endColor};
   my $mode = $self->{_ColorSlider}{mode};
   my @pixels = new PixelArray ($w * $h);
 
   if ($self->getOrientation) {
     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->{_ColorSlider}{image} = new Image (@pixels);
 }
 
 sub _dragging {
   $_[0]->{_ColorSlider}->{dragging};
 }
 
 sub mouseDragged {
   my ($self, $event) = @_;
   return if (!$self->_dragging);
 
   my ($minor, $major) = ColorSlider::_getAxes ($event);
 
   my ($w, $h) = $self->getSize ();
   my $minorMax = $self->getOrientation ? $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]->{_ColorSlider}{tempBubblePos} = $_[1];
 }
 
 sub mouseReleased {
   my ($self, $event) = @_;
 
   $self->{_ColorSlider}{bubblePos} = $self->{_ColorSlider}{tempBubblePos};
 
   $self->{_ColorSlider}{dragging} = 0;
   $self->repaint;
   $self->fireAdjustmentPerformed ();
 }
 
 sub _getAxes {
   my $event = shift;
   $_[0]->getOrientation ? ($event->{w}, $event->{h}) 
     : ($event->{h}, $event->{w});
 }
 
 sub mousePressed {
   my ($self, $event) = @_;
 
   my ($minor, $major) = _getAxes ();
   $self->{_ColorSlider}->{tempBubblePos} = $major;
   $self->{_ColorSlider}->{dragging} = 1;
   $self->repaint;
 }
 
 sub paint {
 
   my ($self, $gc) = @_;
 
   my ($width, $height) = $self->getSize ();
 
   $self->drawImage () unless $self->{_ColorSlider}{image};
 
 my ($bubblePos, $tempBubblePos) = 
   ($self->{_ColorSlider}{bubblePos}, $self->{_ColorSlider}{tempBubblePos});
 
   if ($self->getOrientation) {
     my $h = $self->{_ColorSlider}{preferredMinor};
     my $w = $width;
     my $top = ($height - $h) / 2;
     $gc->drawImage ($self->{_ColorSlider}{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->{_ColorSlider}{bubblePos} / 200;
   $self->{_ColorSlider}{value} = $value;
   $value * $self->getMaximum + $self->getMinimum;
 }
 
 sub getMaximum {
   $_[0]->{_ColorSlider}{maximum};
 }
 
 sub getMinimum {
   $_[0]->{_ColorSlider}{minimum};
 }
 
 sub setValue {
   my ($self, $value) = @_;
   $value -= $self->getMinimum;
   $value /= $self->getMaximum;
   $self->{_ColorSlider}{bubblePos} = $value * 200;
   $self->{_ColorSlider}{tempBubblePos} = $self->{_ColorSlider}{bubblePos};
   $self->{_ColorSlider}{value} = $value;
   $self->repaint;
 }