/* SevenSegmentsApplet.java by Kari Laitinen

   http://www.naturalprogramming.com/

   2010-03-22 File received from Ari-Pekka Männikkö
              Tabs replaced with three spaces.
   2013-02-03 Last modification.

   This program provides classes with which it is possible
   to create seven-segment digits to the screen.


   SEE: http://en.wikipedia.org/wiki/Seven-segment_display

*/


import java.awt.* ;
import java.awt.event.* ;
import java.awt.geom.* ;  //  Classes Line2D, Ellipse2D, etc.
import javax.swing.* ;

class Segment
{
   int segment_position_x ;
   int segment_position_y ;
   
   Color segment_color = Color.RED ;

   boolean segment_is_on = false ;


   GeneralPath segment_path = new GeneralPath() ;

   int    segment_type ;
   double segment_magnification = 1.0 ;

   public static final int HORIZONTAL = 1 ;
   public static final int VERTICAL   = 2 ;

   public Segment( int given_segment_type,
                   int given_position_x,
                   int given_position_y,
                   double given_magnification )
   {
      segment_type       = given_segment_type ;
      segment_position_x = given_position_x ;
      segment_position_y = given_position_y ;
      segment_magnification = given_magnification ;

      // Next we create a segment shape whose length is 38 pixels
      // (2 gap pixels included).

      segment_path.moveTo(  1,  0 ) ;
      segment_path.lineTo(  5, -4 ) ;
      segment_path.lineTo( 33, -4 ) ;
      segment_path.lineTo( 37,  0 ) ;
      segment_path.lineTo( 33,  4 ) ;
      segment_path.lineTo(  5,  4 ) ;

      segment_path.closePath() ;

      // Next we'll transform the segment shape so that it corresponds
      // to the requested digit size.

      AffineTransform segment_transform = new AffineTransform() ;

      segment_transform.scale( given_magnification, given_magnification ) ;

      segment_path.transform( segment_transform ) ;
   }

   public void activateSegment()
   {
      segment_is_on = true ;
   }
   
   public void deactivateSegment()
   {
      segment_is_on = false ;
   }
   
   public void draw( Graphics2D graphics2D )
   {
      if ( segment_path != null )
      {
         if ( segment_is_on == true )
         {
            AffineTransform  saved_graphics_transform  =  graphics2D.getTransform() ;

            graphics2D.translate( segment_position_x, segment_position_y ) ;

            if ( segment_type == VERTICAL )
            {
               graphics2D.rotate( Math.PI / 2 ) ; // 90 degrees clockwise
            }

            graphics2D.setColor( segment_color ) ;
            graphics2D.fill( segment_path ) ;
            graphics2D.setColor( Color.BLACK ) ;
            graphics2D.draw( segment_path ) ;
   
            //  Finally we restore the original coordinate system.
            graphics2D.setTransform( saved_graphics_transform ) ;
         }
      }
   }
}


class Digit
{
   // The GeneralPath inside class Segment is defined according to
   // to following values. Two gap pixels are included in the segment length.

   // The digit width is segment_length + segment_thickness

   int segment_length    = 38 ;
   int segment_thickness =  8 ;
    
   int digit_position_x = 100 ;
   int digit_position_y = 100 ;
    
   int digit_value = 0;
    
   double digit_magnification = 1.0 ;
    
   Segment segment_a, segment_d, segment_g ;
   Segment segment_b, segment_c, segment_e, segment_f ;



   /* The segments of a 7-segment number are marked
      with letters in the following way:

          aaaaaa
         f      b
         f      b
         f      b
         f      b
          gggggg
         e      c
         e      c
         e      c
         e      c
          dddddd

      When we create the segment objects we need to specify
      a position and orientation for them.

   */

   protected void create_segments()
   {
      segment_a = new Segment( Segment.HORIZONTAL,
                     digit_position_x + segment_thickness / 2,
                     digit_position_y + segment_thickness / 2,
                     digit_magnification ) ;

      segment_d = new Segment( Segment.HORIZONTAL,
                     digit_position_x + segment_thickness / 2,
                     digit_position_y + segment_thickness / 2 
                                      + 2 * segment_length,
                     digit_magnification ) ;

      segment_g = new Segment( Segment.HORIZONTAL,
                     digit_position_x + segment_thickness / 2,
                     digit_position_y + segment_thickness / 2 
                                      + segment_length,
                     digit_magnification ) ;

      segment_b = new Segment( Segment.VERTICAL,
                     digit_position_x + segment_thickness / 2
                                      + segment_length,
                     digit_position_y + segment_thickness / 2,
                     digit_magnification ) ;

      segment_c = new Segment( Segment.VERTICAL,
                     digit_position_x + segment_thickness / 2
                                      + segment_length,
                     digit_position_y + segment_thickness / 2 
                                      + segment_length,
                     digit_magnification ) ;

      segment_e = new Segment( Segment.VERTICAL,
                     digit_position_x + segment_thickness / 2,
                     digit_position_y + segment_thickness / 2 
                                      + segment_length,
                     digit_magnification ) ;

      segment_f = new Segment( Segment.VERTICAL,
                     digit_position_x + segment_thickness / 2,
                     digit_position_y + segment_thickness / 2,
                     digit_magnification ) ;

   }


   protected void update_segments()
   {
      switch ( digit_value )
      {
         case 0 :
            segment_a.activateSegment() ;
            segment_b.activateSegment() ;
            segment_c.activateSegment() ;
            segment_d.activateSegment() ;
            segment_e.activateSegment() ;
            segment_f.activateSegment() ;
            segment_g.deactivateSegment() ; 
            break;
         case 1 :
            segment_a.deactivateSegment() ;
            segment_b.activateSegment() ;
            segment_c.activateSegment() ;
            segment_d.deactivateSegment() ;
            segment_e.deactivateSegment() ;
            segment_f.deactivateSegment() ;
            segment_g.deactivateSegment() ;            
            break;
         case 2 :
            segment_a.activateSegment() ;
            segment_b.activateSegment() ;
            segment_c.deactivateSegment() ;
            segment_d.activateSegment() ;
            segment_e.activateSegment() ;
            segment_f.deactivateSegment() ;
            segment_g.activateSegment() ;
            break;
         case 3 :
            segment_a.activateSegment() ;
            segment_b.activateSegment() ;
            segment_c.activateSegment() ;
            segment_d.activateSegment() ;
            segment_e.deactivateSegment() ;
            segment_f.deactivateSegment() ;
            segment_g.activateSegment() ; 
            break;
         case 4 :
            segment_a.deactivateSegment() ;
            segment_b.activateSegment() ;
            segment_c.activateSegment() ;
            segment_d.deactivateSegment() ;
            segment_e.deactivateSegment() ;
            segment_f.activateSegment() ;
            segment_g.activateSegment() ;
            break;
         case 5 :
            segment_a.activateSegment() ;
            segment_b.deactivateSegment() ;
            segment_c.activateSegment() ;
            segment_d.activateSegment() ;
            segment_e.deactivateSegment() ;
            segment_f.activateSegment() ;
            segment_g.activateSegment() ;
            break;
         case 6 :
            segment_a.activateSegment() ;
            segment_b.deactivateSegment() ;
            segment_c.activateSegment() ;
            segment_d.activateSegment() ;
            segment_e.activateSegment() ;
            segment_f.activateSegment() ;
            segment_g.activateSegment() ; 
            break;
         case 7 :
            segment_a.activateSegment() ;
            segment_b.activateSegment() ;
            segment_c.activateSegment() ;
            segment_d.deactivateSegment() ;
            segment_e.deactivateSegment() ;
            segment_f.deactivateSegment() ;
            segment_g.deactivateSegment() ; 
            break;
         case 8 :
            segment_a.activateSegment() ;
            segment_b.activateSegment() ;
            segment_c.activateSegment() ;
            segment_d.activateSegment() ;
            segment_e.activateSegment() ;
            segment_f.activateSegment() ;
            segment_g.activateSegment() ; 
            break;
         case 9 :
            segment_a.activateSegment() ;
            segment_b.activateSegment() ;
            segment_c.activateSegment() ;
            segment_d.activateSegment() ;
            segment_e.deactivateSegment() ;
            segment_f.activateSegment() ;
            segment_g.activateSegment() ; 
            break ;
            
      }
   }

   
   public Digit( int given_position_x,
                 int given_position_y,
                 int given_digit_width,
                 int given_initial_value )
   {
      digit_magnification = (double) given_digit_width /
                             (double) ( segment_length + segment_thickness )  ;

      segment_length = (int) ( digit_magnification * segment_length ) ;
      segment_thickness = (int) ( digit_magnification * segment_thickness ) ;

      digit_position_x = given_position_x ;
      digit_position_y = given_position_y ;

      create_segments() ;

      set_value( given_initial_value ) ;
   }

    
   public void set_value( int new_value )
   {
      if ( new_value >= 0 && new_value <= 9 )
      {
         digit_value = new_value ;
      }
   }

   public boolean increase_value() 
   {
      // This method will return true when the value is
      // set to zero. With this information it should
      // be easy to 'chain' digits to display 
      // multi-digit numbers.

      boolean zero_value_reached = false ;

      if ( digit_value >= 9 )
      {
         digit_value = 0 ;
         zero_value_reached = true ;
      }
      else
      {
         digit_value ++ ;
      }

      return zero_value_reached ;
   }

   public boolean contains_point( Point given_point )
   {
      int digit_width = segment_length + segment_thickness ;
      int digit_height = 2 * segment_length + segment_thickness ;

      return (
         given_point.x  >=  digit_position_x  &&
         given_point.x  <=  digit_position_x  +  digit_width  &&
         given_point.y  >=  digit_position_y  &&
         given_point.y  <=  digit_position_y  +  digit_height ) ;
   }


   public void draw( Graphics2D graphics2D )
   {
      update_segments() ;

      segment_a.draw( graphics2D ) ;
      segment_b.draw( graphics2D ) ;
      segment_c.draw( graphics2D ) ;
      segment_d.draw( graphics2D ) ;
      segment_e.draw( graphics2D ) ;
      segment_f.draw( graphics2D ) ;
      segment_g.draw( graphics2D ) ;

   }
}


public class SevenSegmentsApplet extends JApplet
                                     implements MouseListener
{
   Digit left_digit   = new Digit( 100, 100, 100, 7 ) ;

   Digit middle_digit = new Digit( 220, 100, 100, 8 ) ;

   Digit right_digit  = new Digit( 340, 100, 100, 9 ) ;

   public void init()
   {
      addMouseListener( this ) ;
   }
      
      
   public void mouseExited( MouseEvent event ){}
   public void mouseEntered( MouseEvent event ){}

   public void mouseClicked( MouseEvent event )
   {
   }

   public void mousePressed( MouseEvent event )
   {
      Point clicked_point = event.getPoint() ;

      if ( left_digit.contains_point( clicked_point ) )
      {
         left_digit.increase_value() ;
      }

      if ( middle_digit.contains_point( clicked_point ) )
      {
         middle_digit.increase_value() ;
      }

      if ( right_digit.contains_point( clicked_point ) )
      {
         right_digit.increase_value() ;
      }

      repaint() ;
   }

   public void mouseReleased( MouseEvent event ){}

   public void paint( Graphics graphics )
   {
      //  The superclass version of paint() method draws the buttons
      //  and the color selection menu to the screen.

      super.paint( graphics ) ;

      Graphics2D  graphics2D  =  (Graphics2D) graphics ;

      left_digit.draw( graphics2D ) ;
                         
      middle_digit.draw( graphics2D ) ;

      right_digit.draw( graphics2D ) ;
                         
   }
}



/***  The following classes were used in an early version of this program.
      As they differ very little, it was found out that it is better to
      use a single Segment class.


class HorizontalSegment extends Segment
{
   int horizontalSegmentHeight   =  6;
   int horizontalSegmentWidth    =  30;

   public HorizontalSegment(int x,int y)
   {
      segment_position_x = x;
      segment_position_y = y;

   }

   public void draw( Graphics2D graphics2D )
   {
      if ( segment_path != null )
      {

         if ( segment_is_on == true )
         {
            AffineTransform  saved_graphics_transform  =  graphics2D.getTransform() ;

            
            graphics2D.translate( segment_position_x, segment_position_y ) ;
   

            graphics2D.setColor( segment_color ) ;
            graphics2D.fill( segment_path ) ;
            graphics2D.setColor( Color.BLACK ) ;
            graphics2D.draw( segment_path ) ;
   
            //  Finally we restore the original coordinate system.
            graphics2D.setTransform( saved_graphics_transform ) ;
         }
      }
   }
}


class VerticalSegment extends Segment
{
   int verticalSegmentHeight  =  30;
   int verticalSegmentWidth   =  6;

   VerticalSegment(int x,   int y)
   {
      segment_position_x = x;
      segment_position_y = y;

   }
   
   public void draw( Graphics2D graphics2D )
   {
      if ( segment_path != null )
      {

         if ( segment_is_on == true )
         {
            AffineTransform  saved_graphics_transform  =  graphics2D.getTransform() ;

            
            graphics2D.translate( segment_position_x, segment_position_y ) ;

            graphics2D.rotate( Math.PI / 2 ) ; // 90 degrees clockwise
   
            graphics2D.setColor( segment_color ) ;
            graphics2D.fill( segment_path ) ;
            graphics2D.setColor( Color.BLACK ) ;
            graphics2D.draw( segment_path ) ;
   
            //  Finally we restore the original coordinate system.
            graphics2D.setTransform( saved_graphics_transform ) ;
         }
      }
   }
}



***/