home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / powergui / slider / slidsync / slidsync.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-10-29  |  7.0 KB  |  222 lines
  1. //*********************************************************
  2. // Sliders - Synchronized Slider Controls
  3. //
  4. // Copyright (C) 1994, Law, Leong, Love, Olson, Tsuji.
  5. // Copyright (c) 1997 John Wiley & Sons, Inc. 
  6. // All Rights Reserved.
  7. //*********************************************************
  8. #include <iapp.hpp>
  9. #include <ipoint.hpp>
  10. #include <irect.hpp>
  11. #include <istring.hpp>
  12. #include <icconst.h>
  13. #include "slidsync.hpp"
  14.  
  15. #define ID_PROGIND     101
  16. #define ID_SLIDER      102
  17. #define ID_CSLIDER     103
  18. #define ID_DUMMY       0
  19.  
  20. #define LAST_TICK      10
  21. #define MIDDLE_TICK    ( LAST_TICK / 2 )
  22. #define TICK_COUNT     ( LAST_TICK + 1 )
  23. #define INITIAL_VALUE  3
  24.  
  25. void main ( )
  26. {
  27. #ifdef IC_WIN
  28. #ifdef PM_COMPATIBLE
  29.   IProgressIndicator::setDefaultStyle( IProgressIndicator::defaultStyle()
  30.                                         | IProgressIndicator::pmCompatible );
  31.   ISlider::setDefaultStyle( ISlider::defaultStyle()
  32.                              | IProgressIndicator::pmCompatible );
  33. #endif
  34. #endif
  35.  
  36.   // Create a window with a progress indicator, linear slider, and
  37.   // circular slider synchronized with the ISliderArmHandler class.
  38.   SynchronizedSliders
  39.     sliderWindow;
  40.  
  41.   // Give the window an initial value and input focus, and show it.
  42.   sliderWindow
  43.    .setValue( INITIAL_VALUE )
  44.    .setFocus()
  45.    .show();
  46.  
  47.   IApplication::current().run();
  48. }
  49.  
  50. SynchronizedSliders::SynchronizedSliders ( )
  51.   : IFrameWindow( "Synchronized Slider Controls" ),
  52.     canvasClient( IC_FRAME_CLIENT_ID, this, this ),
  53.     progressIndicatorLabel( ID_DUMMY, &canvasClient, &canvasClient ),
  54.     progressIndicator( ID_PROGIND, &canvasClient, &canvasClient,
  55.                        IRectangle(), TICK_COUNT, 0,
  56.                        ( IProgressIndicator::defaultStyle()
  57.                            & ~IProgressIndicator::alignCentered )
  58.                          | IProgressIndicator::alignBottom ),
  59.     sliderLabel( ID_DUMMY, &canvasClient, &canvasClient ),
  60.     slider( ID_SLIDER, &canvasClient, &canvasClient,
  61.             IRectangle(), TICK_COUNT, 0,
  62.             ( ISlider::defaultStyle()
  63.               & ~IProgressIndicator::alignCentered )
  64.              | IProgressIndicator::alignBottom ),
  65.     circularSliderLabel( ID_DUMMY, &canvasClient, &canvasClient ),
  66.     circularSlider( ID_CSLIDER, &canvasClient, &canvasClient ),
  67.     linearSliderArmHandler( this ),
  68.     circularSliderArmHandler( this )
  69. {
  70.   // Set up the progress indicator.
  71.   progressIndicatorLabel
  72.    .setText( "Progress indicator" );
  73.   progressIndicator
  74.    .setBackgroundColor( canvasClient.backgroundColor() )
  75.    .setMinimumSize( ISize( 100, 60 ) );
  76.   progressIndicator
  77.    .setTickLength( 10 )
  78.    .setTickText( 0,  "0" )
  79.    .setTickText( MIDDLE_TICK, IString( MIDDLE_TICK ) )
  80.    .setTickText( LAST_TICK, IString( LAST_TICK ) );
  81.  
  82.   // Set up the linear slider.
  83.   sliderLabel
  84.    .setText( "Linear slider" );
  85.   slider
  86.    .setBackgroundColor( canvasClient.backgroundColor() )
  87.    .setMinimumSize( ISize( 100, 60 ) );
  88.   slider
  89.    .setTickLength( 10 )
  90.    .setTickText( 0,  "0" )
  91.    .setTickText( MIDDLE_TICK, IString( MIDDLE_TICK ) )
  92.    .setTickText( LAST_TICK, IString( LAST_TICK ) )
  93.    .enableTabStop()
  94.    .enableGroup();
  95.  
  96.   // Set up the circular slider.
  97.   circularSliderLabel
  98.    .setText( "Circular slider" );
  99.   circularSlider
  100.    .setBackgroundColor( canvasClient.backgroundColor() )
  101.    .setMinimumSize( ISize( 150, 150 ) );
  102.   circularSlider
  103.    .setArmRange( IRange( 0, LAST_TICK ) )
  104.    .setTickSpacing( 1 )
  105.    .enableTabStop()
  106.    .enableGroup();
  107.  
  108.   // Define the positioning rules for controls on the multicell
  109.   // canvas.
  110.   canvasClient
  111.    .addToCell( &progressIndicatorLabel, 2, 2,  2 )
  112.    .addToCell( &progressIndicator,      3, 4     )
  113.    .addToCell( &sliderLabel,            2, 6,  2 )
  114.    .addToCell( &slider,                 3, 8     )
  115.    .addToCell( &circularSliderLabel,    2, 10, 2 )
  116.    .addToCell( &circularSlider,         3, 12    );
  117.   unsigned long
  118.     defaultCellHeight = IMultiCellCanvas::defaultCell().height();
  119.   canvasClient
  120.    .setRowHeight( 1,  defaultCellHeight * 2 )
  121.    .setRowHeight( 5,  defaultCellHeight * 2 )
  122.    .setRowHeight( 9,  defaultCellHeight * 2 )
  123.    .setRowHeight( 12, 1, true )
  124.    .setRowHeight( 13, defaultCellHeight )
  125.    .setColumnWidth( 3, 1, true )
  126.    .setColumnWidth( 4, IMultiCellCanvas::defaultCell().width() );
  127.  
  128.   // Before moving their arms, we need to size the progress indicator
  129.   // and linear slider.  We can do this by forcing their parent
  130.   // multicell canvas to to run its layout routine by requesting its
  131.   // minimum size.
  132.   ISize
  133.     clientSize( canvasClient.minimumSize() );
  134.   (*this)
  135.    .setValue( INITIAL_VALUE );
  136.  
  137.   linearSliderArmHandler
  138.    .handleEventsFor( &slider );
  139.   circularSliderArmHandler
  140.    .handleEventsFor( &circularSlider );
  141.  
  142.   (*this)
  143.    .setClient( &canvasClient )
  144.    .moveSizeToClient( IRectangle( IPoint( 100, 50 ),
  145.                                   ISize( clientSize.scaleBy( 2, 1 ) ) ) );
  146. }
  147.  
  148. SynchronizedSliders&
  149.   SynchronizedSliders::setValue ( unsigned long value )
  150. {
  151.   if ( progressIndicator.armTickOffset() != value )
  152.   {
  153.      progressIndicator
  154.       .moveArmToTick( value );
  155.   }
  156.   if ( slider.armTickOffset() != value )
  157.   {
  158.      slider
  159.       .moveArmToTick( value );
  160.   }
  161.   if ( circularSlider.value() != value )
  162.   {
  163.      circularSlider
  164.       .setValue( value );
  165.   }
  166.   return *this;
  167. }
  168.  
  169. SynchronizedSliders::
  170.   LinearSliderArmHandler::LinearSliderArmHandler
  171.                             ( SynchronizedSliders* window )
  172.   : ArmHandler( ),
  173.     sliderWindow( window )
  174. { }
  175.  
  176. SynchronizedSliders::LinearSliderArmHandler&
  177.   SynchronizedSliders::LinearSliderArmHandler::handleEventsFor
  178.                                              ( ISlider* slider )
  179. {
  180.   this->IHandler::handleEventsFor( slider );
  181.   return *this;
  182. }
  183.  
  184. IBase::Boolean
  185.   SynchronizedSliders::LinearSliderArmHandler::valueChange
  186.                                         ( IControlEvent& event )
  187. {
  188.   // Down-cast is safe here, because this handler can
  189.   // only be attached to an ISlider.
  190.   ISlider
  191.    *slider = (ISlider*)event.dispatchingWindow();
  192.   sliderWindow->setValue( slider->armTickOffset() );
  193.   return false;
  194. }
  195.  
  196. SynchronizedSliders::
  197.   CircularSliderArmHandler::CircularSliderArmHandler
  198.                                  ( SynchronizedSliders* window )
  199.   : ArmHandler( ),
  200.     sliderWindow( window )
  201. { }
  202.  
  203. SynchronizedSliders::CircularSliderArmHandler&
  204.   SynchronizedSliders::CircularSliderArmHandler::handleEventsFor
  205.                              ( ICircularSlider* circularSlider )
  206. {
  207.   this->IHandler::handleEventsFor( circularSlider );
  208.   return *this;
  209. }
  210.  
  211. IBase::Boolean
  212.   SynchronizedSliders::CircularSliderArmHandler::valueChange
  213.                                         ( IControlEvent& event )
  214. {
  215.   // Down-cast is safe here, because this handler can
  216.   // only be attached to an ICircularSlider.
  217.   ICircularSlider
  218.    *cslider = (ICircularSlider*)event.dispatchingWindow();
  219.   sliderWindow->setValue( cslider->value() );
  220.   return false;
  221. }
  222.