home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / VSCPPv8.zip / VACPP / IBMCPP / samples / VISBUILD / CALCULAT / CPPOV13 / ICALCTLY.CPP < prev    next >
Text File  |  1995-04-17  |  7KB  |  270 lines
  1. //****************************************************************************
  2. // ICalcTally Class - C++ Code File (icalctly.cpp)                           *
  3. //                                                                           *
  4. // COPYRIGHT: Copyright (C) International Business Machines Corp., 1994,1995 *
  5. //                                                                           *
  6. // DISCLAIMER OF WARRANTIES:                                                 *
  7. //   The following [enclosed] code is sample code created by IBM             *
  8. //   Corporation.  This sample code is not part of any standard IBM product  *
  9. //   and is provided to you solely for the purpose of assisting you in the   *
  10. //   development of your applications.  The code is provided "AS IS",        *
  11. //   without warranty of any kind.  IBM shall not be liable for any damages  *
  12. //   arising out of your use of the sample code, even if they have been      *
  13. //   advised of the possibility of such damages.                             *
  14. //****************************************************************************
  15. //NOTE: WE RECOMMEND USING A FIXED-SPACE FONT TO LOOK AT THE SOURCE.
  16. //
  17. // VERSION 2
  18. //
  19. // Changes:
  20. //   9/23/94 - Removed File Dialog creation and manipulation.  Now handled
  21. //             by connecting standard FileDialogProxy part.
  22. //****************************************************************************
  23.  
  24. #include "icalctly.hpp" 
  25.  
  26. #include <inotifev.hpp>
  27.  
  28. /*******************************************************************
  29.  * Contructors/Destructors
  30.  *******************************************************************/
  31.  
  32. ICalcTally :: ICalcTally()
  33. {
  34.    reset();
  35. }
  36.  
  37. ICalcTally :: ~ICalcTally()
  38. {
  39. }
  40.  
  41. //
  42. // List of Events
  43. //
  44.  
  45. INotificationId ICalcTally :: bufferId = "ICaclTally::buffer";
  46. INotificationId ICalcTally :: nextTallyLineId = "ICalcTally::nextTallyLine";
  47. INotificationId ICalcTally :: notEmptyId = "ICalcTally::notEmpty";
  48.  
  49. /*******************************************************************
  50.  * Access Member Functions (Part Attributes/Actions)
  51.  *******************************************************************/
  52.  
  53. IString ICalcTally :: buffer () const
  54. {
  55.   return dBuffer;
  56. }
  57.  
  58.  
  59. //
  60. // Set the Tally Chip buffer attribute.
  61. // This attribute must be kept in sync with the calculator display.
  62. //
  63.  
  64. ICalcTally & ICalcTally :: setBuffer
  65.   (IString iBuffer)
  66. {
  67.    dBuffer = iBuffer;
  68.  
  69.    //
  70.    // If the buffer is being cleared, make sure will attempt to send
  71.    // the buffer to the Tally Display.  Otherwise the buffer is a
  72.    // candidate for sending to the Tally Display.
  73.    //
  74.  
  75.    if (dBuffer == "") dUpdateTally = false;
  76.    else dUpdateTally = true;
  77.  
  78.    //
  79.    // If the buffer is being updated because of some functional
  80.    // operation as opposed to keypad input, then send this
  81.    // string to the Tally Display.
  82.    //
  83.  
  84.    if (dUpdateTally && dResultExpected) {
  85.       setNextTallyLine(dBuffer);
  86.  
  87.       //
  88.       // If there is an accompanying operator symbol, send the operator
  89.       // symbol to the Tally Display as well.
  90.       //
  91.  
  92.       if (dLastOperator != "") setNextTallyLine(dLastOperator);
  93.  
  94.       dUpdateTally = false;
  95.       dResultExpected = false;
  96.       dLastOperator = "";
  97.    }
  98.    
  99.       return *this;
  100. }
  101.  
  102.  
  103. //
  104. // Query the NextTallyLine attribute.
  105. //
  106.  
  107. IString ICalcTally :: nextTallyLine () const
  108. {
  109.    return dNextTallyLine;
  110. }
  111.  
  112.  
  113. //
  114. // Set the NextTallyLine attribute.
  115. // Construct the actual string to be added to the Tally MLE.
  116. // This includes the proper carriage control and notification
  117. // of any state change of the Tally (empty to not empty).
  118. //
  119.  
  120. ICalcTally & ICalcTally :: setNextTallyLine 
  121.   (IString iString)
  122. {
  123.    if (iString != "") {
  124.  
  125.       //
  126.       // Set the required carriage control to force MLE to add
  127.       // lines the way I want them added and issue event indicating
  128.       // that the line is ready to be added to the Tally Display (MLE).
  129.       //
  130.  
  131.       if (!dEmptyMark) dNextTallyLine = "\r\n";
  132.       else dNextTallyLine = "";
  133.  
  134.       dNextTallyLine += iString ;
  135.       notifyObservers(INotificationEvent(nextTallyLineId, *this));
  136.  
  137.       //
  138.       // Issue event of state change of Tally from empty to not empty
  139.       // when appropriate.
  140.       //
  141.  
  142.       if (dEmptyMark) {
  143.          dEmptyMark = false;
  144.          notifyObservers(INotificationEvent(notEmptyId, *this));
  145.       }
  146.  
  147.    }
  148.  
  149.    return *this;
  150. }
  151.  
  152.  
  153. /***************************************************************************
  154.  Implementor Member Functions (Part Actions)
  155. ****************************************************************************/
  156.  
  157. //
  158. // Reset the Tally object.
  159. //
  160.  
  161. Boolean ICalcTally :: reset ()
  162. {
  163.    dBuffer = "";
  164.    dNextTallyLine = "";
  165.    dUpdateTally = false;
  166.    dProcessBinaryOp = false;
  167.    dEmptyMark = true;
  168.    dResultExpected = false;
  169.    dLastOperator = "";
  170.    return dEmptyMark;
  171. }
  172.  
  173.  
  174. //
  175. // Process a Binary operator.
  176. //
  177.  
  178. Boolean ICalcTally :: processBinaryOperator (IString iBinaryOpSym)
  179. {
  180.    Boolean updated;
  181.     
  182.    //
  183.    // If there is something in the Tally Chip buffer which needs to be
  184.    // sent to the Tally Display, then do it.
  185.    // Otherwise indicate that the Tally Display has not been updated from the
  186.    // Tally Chip buffer.
  187.    //
  188.  
  189.    if (dUpdateTally) {
  190.       setNextTallyLine(buffer());
  191.       dUpdateTally = false;
  192.       updated = true;
  193.       }
  194.  
  195.    else updated = false;
  196.  
  197.    //
  198.    // If previous operator not a binary operator, send this operator
  199.    // symbol to the Tally Display
  200.    //
  201.  
  202.    if (!dProcessBinaryOp) {
  203.       setNextTallyLine(iBinaryOpSym);
  204.       dProcessBinaryOp = true;
  205.       dResultExpected = false;
  206.       dLastOperator = "";
  207.       }
  208.  
  209.    //
  210.    // Else the previous operator was a binary operator and if Tally Display
  211.    // was not updated from the Tally Chip Buffer, send this operator to
  212.    // the Tally Display.  Otherwise, save this operator for later display
  213.    // because need to display Tally Chip Buffer contents before displaying
  214.    // the binary operator symbol associated with the buffer contents.
  215.    //
  216.  
  217.    else {
  218.       if (!updated) {
  219.          setNextTallyLine(iBinaryOpSym);
  220.          dLastOperator = "";
  221.       }
  222.        
  223.       else dLastOperator = iBinaryOpSym;
  224.  
  225.       dResultExpected = true;   // Are expecting a buffer update as a result
  226.                                 // of some binary function operation.
  227.  
  228.       } 
  229.  
  230.    return updated;
  231. }
  232.  
  233.  
  234. //
  235. // Process a Unary Operator
  236. //
  237.  
  238. Boolean ICalcTally :: processUnaryOperator (IString iUnaryOpSym)
  239. {
  240.    Boolean updated;
  241.    
  242.    //
  243.    // If there is something in the Tally Chip buffer which needs to be
  244.    // sent to the Tally Display, then do it.
  245.    // Otherwise indicate that the Tally Display has not been updated from the
  246.    // Tally Chip buffer.
  247.    //
  248.  
  249.    if (dUpdateTally) {
  250.       setNextTallyLine(buffer());
  251.       dUpdateTally = false;
  252.       updated = true;
  253.       }
  254.  
  255.    else updated = false;
  256.  
  257.    //
  258.    // Send the unary operator symbol to the Tally Display.
  259.    // Expect some update from the unary function operation.
  260.    // No delay waiting for completion of a binary operation.
  261.    //
  262.  
  263.    setNextTallyLine(iUnaryOpSym);
  264.    dResultExpected = true;
  265.    dProcessBinaryOp = false;
  266.    
  267.    return updated;
  268. }
  269.  
  270.