home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / powergui / thread / picalc / picalc.cpp < prev   
C/C++ Source or Header  |  1996-10-29  |  6KB  |  218 lines

  1. /***************************************************************
  2. * FILE NAME: picalc.cpp                                        *
  3. *                                                              *
  4. * DESCRIPTION:                                                 *
  5. *   Another thread sample; this time using a PiCalculator      *
  6. *   object instead of a plain function.                        *
  7. *                                                              *
  8. * COPYRIGHT:                                                   *
  9. *   Licensed Materials - Property of Solution Frameworks       *
  10. *   Copyright (C) 1996, Solution Frameworks                    *
  11. *   All Rights Reserved                                        *
  12. ***************************************************************/
  13. #ifndef _ITHREAD_
  14.   #include <ithread.hpp>
  15. #endif
  16. #ifndef _IFRAME_
  17.   #include <iframe.hpp>
  18. #endif
  19. #ifndef _IMLE_
  20.   #include <imle.hpp>
  21. #endif
  22. #ifndef _IMCELCV_
  23.   #include <imcelcv.hpp>
  24. #endif
  25. #ifndef _IPUSHBUT_
  26.   #include <ipushbut.hpp>
  27. #endif
  28. #ifndef _ISTATTXT_
  29.   #include <istattxt.hpp>
  30. #endif
  31. #ifndef _IENTRYFD_
  32.   #include <ientryfd.hpp>
  33. #endif
  34. #ifndef _ICMDHDR_
  35.   #include <icmdhdr.hpp>
  36. #endif
  37. #ifndef _ISTRING_
  38.   #include <istring.hpp>
  39. #endif
  40.  
  41. #include "userevt.hpp"
  42. #include "pi.hpp"
  43.  
  44. /*----------------------- PiCalculator -------------------------
  45. | Simple class with a member function to calculate pi to       |
  46. | some number of digits and then send a user-defined event     |
  47. | to a frame window, passing the result.                       |
  48. --------------------------------------------------------------*/
  49. class PiCalculator {
  50. public: 
  51. // Construct with an MLE to be updated with the results.
  52.   PiCalculator( IMultiLineEdit &mle )
  53.     : digits( 0 ), results( mle ) {
  54.     }
  55. // This function calculates pi and updates the result window.
  56. void
  57.   calculate ( )
  58.     {
  59.     IString  result = pi( digits );
  60.     UserEvent( 0, (char*)result ).sendTo( results.handle() );
  61.     }
  62. // Use this function to set the number of digits to calculate.
  63. void
  64.   setDigits ( unsigned long numDigits ) {
  65.     digits = numDigits;
  66.   }
  67. private:
  68. unsigned long
  69.   digits;
  70. IMultiLineEdit 
  71.  &results;
  72. PiCalculator ( const PiCalculator& );
  73. operator = ( const PiCalculator& );
  74. };
  75.  
  76. /*---------------------- ResultHandler -------------------------
  77. | Handler for user-defined event that occurs when a result     |
  78. | has been calculated.  We simply add the result as the        |
  79. | last line of the associated MLE.                             |
  80. --------------------------------------------------------------*/
  81. struct ResultHandler : public UserHandler {
  82.   ResultHandler ( IMultiLineEdit &output )
  83.     : UserHandler( 0 ), output( output ) {
  84.     handleEventsFor( &output );
  85.   }   
  86.   ~ResultHandler ( ) {
  87.     stopHandlingEventsFor( &output );
  88.   }
  89. virtual Boolean
  90.   handleUserEvent ( UserEvent &event ) {
  91.     output
  92.       .addLineAsLast( (char*)event.parameter1() )
  93.       .refresh();
  94.     return false;
  95.   }
  96. private:
  97. IMultiLineEdit
  98.  &output;
  99. ResultHandler ( const ResultHandler& );
  100. operator = ( const ResultHandler& );
  101. }; // ResultHandler
  102.  
  103. /*------------------------ Controller --------------------------
  104. | This class is basically a command handler that ties          |
  105. | together the various parts of our pi calculator user         |
  106. | interface.                                                   |
  107. |                                                              |
  108. | It wires together a frame window, a button, and input and    |
  109. | output controls.  When the button is pressed, it takes       |
  110. | the input field and calculates pi to however many digits     |
  111. | is specified.  The results are written to the output         |
  112. | control (an MLE).                                            |
  113. --------------------------------------------------------------*/
  114. struct Controller : public ICommandHandler {
  115.   Controller ( IFrameWindow   &frame,
  116.                IPushButton    &button,
  117.                IEntryField    &input,
  118.                IMultiLineEdit &output )
  119.     : frame( frame ),
  120.       button( button ),
  121.       input( input ), 
  122.       output( output ),
  123.       resultHandler( output ),
  124.       calculator( output ) {
  125.     this->handleEventsFor( &frame );
  126.   }
  127.   ~Controller ( ) {
  128.     stopHandlingEventsFor( &frame );
  129.   }
  130. virtual Boolean
  131.   command ( ICommandEvent &event ) {
  132.     Boolean
  133.       result = false;
  134.     if ( event.commandId() == button.id() ) {
  135.       unsigned long
  136.         numDigits( input.text().asUnsigned() );
  137.       output
  138.         .addLineAsLast( "Calculating pi to " 
  139.                         + 
  140.                         IString(numDigits) 
  141.                         + 
  142.                         " digits..." );
  143.       calculator.setDigits( numDigits );
  144.       IThread
  145.         calculatePi;
  146.  
  147.       calculatePi.start(
  148.             new IThreadMemberFn<PiCalculator>( 
  149.                              calculator,
  150.                              PiCalculator::calculate ) );
  151.  
  152.       result = true;
  153.     }
  154.     return result;
  155.   }
  156. private:
  157. IFrameWindow
  158.  &frame;
  159. IPushButton
  160.  &button;
  161. IEntryField
  162.  &input;
  163. IMultiLineEdit
  164.  &output;
  165. ResultHandler
  166.   resultHandler;
  167. PiCalculator
  168.   calculator;
  169.   Controller( const Controller & );
  170.   operator= ( const Controller & );
  171. }; // Controller
  172.  
  173. void main ( ) {
  174.   IFrameWindow
  175.     frame( "Pi Calculator" );
  176.   IMultiLineEdit
  177.     client( 0, &frame, &frame );
  178.   frame.setClient( &client );
  179.  
  180.   IMultiCellCanvas
  181.     canvas( 0, &frame, &frame );
  182.   IPushButton
  183.     start( 1, &canvas, &canvas );
  184.   IStaticText
  185.     prompt( 2, &canvas, &canvas );
  186.   IEntryField
  187.     input( 3, &canvas, &canvas );
  188.  
  189.   frame.addExtension( &canvas, IFrameWindow::aboveClient, 38 );
  190.  
  191.   canvas
  192.     .setDefaultCell( ISize( 3, 2 ) );
  193.  
  194.   canvas
  195.     .addToCell( &start, 2, 2, 1 )
  196.     .addToCell( &prompt, 4, 2, 2 )
  197.     .addToCell( &input, 7, 2, 3 )
  198.     .setRowHeight( 1, 2 )
  199.     .setRowHeight( 2, 34, true )
  200.     .setRowHeight( 3, 2 )
  201.     .setColumnWidth( 2, 100, true )
  202.     .setColumnWidth( 4, 200, true )
  203.     .setColumnWidth( 7, 300, true );
  204.  
  205.   start.setText( "Calculate" );
  206.  
  207.   prompt.setText( "Number of digits:" );
  208.   prompt.setAlignment( IStaticText::centerRight );
  209.  
  210.   input.setText( "100" );
  211.  
  212.   Controller
  213.     controller( frame, start, input, client );
  214.  
  215.   frame.setFocus();
  216.   frame.showModally();
  217. }
  218.