home *** CD-ROM | disk | FTP | other *** search
/ Dynamic HTML in Action / Dynamicke-HTML-v-akci-covermount.bin / XML / PARSER / XMLINST.EXE / viewer / Scroller.java < prev    next >
Encoding:
Java Source  |  1997-10-31  |  5.6 KB  |  201 lines
  1. //******************************************************************************
  2. // Scroller.java:    
  3. //
  4. //******************************************************************************
  5. import java.awt.*;
  6. import BufferedCanvas;
  7.  
  8.  
  9. class Scroller extends Panel 
  10. {
  11.     Scrollbar vert;
  12.     Scrollbar horz;
  13.     BufferedCanvas canvas;
  14.  
  15.     final int HORZ = 0;
  16.     final int VERT = 1;
  17.  
  18.     public Scroller(BufferedCanvas canvas) 
  19.     {
  20.         this.canvas = canvas;
  21.  
  22.         //Create horizontal scrollbar.
  23.         horz = new Scrollbar(Scrollbar.HORIZONTAL);
  24.  
  25.         //Create vertical scrollbar.
  26.         vert = new Scrollbar(Scrollbar.VERTICAL);
  27.  
  28.         //Add Components to the Applet.
  29.         setLayout(new BorderLayout());
  30.         add("Center", canvas);
  31.         add("East", vert);
  32.         add("South", horz);
  33.  
  34.         validate();
  35.  
  36.         //Now that we've validated, then assuming this Applet is
  37.         //visible, the canvas size is valid and we can adjust the
  38.         //scrollbars to match the image area. [CHECK]
  39.         resizeHorizontal();
  40.         resizeVertical();
  41.     }
  42.     
  43.     private void quickScroll( Object target, int scrollAmt )
  44.     {
  45.         if( target == vert )
  46.         {
  47.             canvas.scrollVert( scrollAmt );
  48.             resizeVertical();
  49.         }
  50.         else if( target == horz )
  51.         {
  52.             canvas.scrollHorz( scrollAmt );
  53.             resizeHorizontal();
  54.         }
  55.     }
  56.  
  57.     private void quickScroll( int dir, int scrollAmt )
  58.     {
  59.         if( dir == VERT ) // vert
  60.         {                    
  61.             canvas.scrollVert( scrollAmt );
  62.             resizeVertical();
  63.         }
  64.         if( dir == HORZ ) // horz
  65.         {
  66.             canvas.scrollHorz( scrollAmt );
  67.             resizeHorizontal();
  68.         }
  69.     }
  70.  
  71.     public boolean handleEvent( Event evt )
  72.     {
  73.         switch( evt.id )
  74.         {
  75.         case Event.SCROLL_LINE_UP:
  76.         case Event.SCROLL_LINE_DOWN:
  77.         case Event.SCROLL_ABSOLUTE:
  78.             {
  79.                 int newPos = ( ( Integer ) evt.arg ).intValue();
  80.                 if( evt.target == vert )
  81.                 {
  82.                     canvas.scrollVert( newPos - canvas.getVertLines() );
  83.                     resizeVertical();
  84.                 }
  85.                 else if( evt.target == horz )
  86.                 {
  87.                     canvas.scrollHorz( newPos - canvas.getHorzLines() );
  88.                     resizeHorizontal();
  89.                 }
  90.                 return true;
  91.             }
  92.         case Event.SCROLL_PAGE_UP:
  93.         case Event.SCROLL_PAGE_DOWN:
  94.             {
  95.                 if( evt.target == vert )
  96.                 {
  97.                     resizeVertical();
  98.                 }
  99.                 else if( evt.target == horz )
  100.                 {
  101.                     resizeHorizontal();
  102.                 }
  103.                 return true;
  104.             }            
  105.         case canvas.DISPLAY_SIZE_CHANGE:
  106.             {
  107.                 update();
  108.                 return true;
  109.             }
  110.         }
  111.         
  112.         return super.handleEvent( evt );
  113.     }
  114.  
  115.     public boolean keyDown( Event evt, int key )
  116.     {
  117.         switch( evt.key )                                     
  118.         {                
  119.         case Event.UP:                    
  120.             quickScroll( VERT, -1 );            
  121.             break;            
  122.         case Event.PGUP:                         
  123.             quickScroll( VERT, -1 * canvas.getCanvasHeightLines() );
  124.             break;            
  125.         case Event.DOWN:                          
  126.             quickScroll( VERT, 1 );
  127.             break;            
  128.         case Event.PGDN:                                              
  129.             quickScroll( VERT, canvas.getCanvasHeightLines() );
  130.             break;            
  131.         case Event.RIGHT:        
  132.             quickScroll( HORZ, 1 );            
  133.             break;            
  134.         case Event.LEFT:                          
  135.             quickScroll( HORZ, -1 );               
  136.             break;           
  137.         }           
  138.         return false;
  139.     }
  140.  
  141.     void resizeHorizontal() 
  142.     {
  143.         int canvasWidthLines = canvas.getCanvasWidthLines();
  144.         int displayWidthLines = canvas.getDisplayWidthLines();
  145.  
  146.         if( canvasWidthLines <= 0 ) {
  147.             return;
  148.         }
  149.  
  150.         horz.setValues( canvas.getHorzLines(), 
  151.                         (int)(canvasWidthLines * 0.9), 
  152.                         0,
  153.                         displayWidthLines-1 );
  154.         
  155.         horz.setPageIncrement( ( int ) ( canvasWidthLines * 0.9 ));
  156.         return;
  157.     }
  158.  
  159.     void resizeVertical() 
  160.     {
  161.         int canvasHeightLines = canvas.getCanvasHeightLines();
  162.         int displayHeightLines = canvas.getDisplayHeightLines();
  163.  
  164.         // To keep things simpler, the vertical scrollbar will always
  165.         // appear, regardless of need.
  166.  
  167.         if( canvasHeightLines <= 0 || canvasHeightLines > displayHeightLines) {
  168.             vert.setValues( 0, 
  169.                             1, 
  170.                             0,
  171.                             1);
  172.         }
  173.  
  174.         vert.setValues( canvas.getVertLines(), 
  175.                         canvasHeightLines, 
  176.                         0,
  177.                         displayHeightLines-1);
  178.         
  179.         vert.setPageIncrement( canvasHeightLines );
  180.         return;
  181.     }
  182.  
  183.     public void update( Graphics g ) 
  184.     {
  185.         resizeHorizontal();
  186.         resizeVertical();
  187.     }
  188.  
  189.     public void update()
  190.     {
  191.         resizeHorizontal();
  192.         resizeVertical();
  193.     }
  194.  
  195.     public void paint( Graphics g ) 
  196.     {
  197.         resizeHorizontal();
  198.         resizeVertical();
  199.     }
  200. }
  201.