home *** CD-ROM | disk | FTP | other *** search
/ C!T ROM 21 / CTROM21B.mdf / win95 / zakelijk / esbcalc / setup.exe / file0007.bin < prev    next >
Encoding:
Text File  |  1999-07-07  |  26.5 KB  |  1,131 lines
  1. {: Main Unit of ESBCalc v1.4 - Requires Delphi 4 Pro or C/S
  2.     as it uses the Math Unit and Dynamic Arrays.
  3.  
  4.     (c) 1998-1999 ESB Consultancy <p>
  5.  
  6.     These routines are used by ESB Consultancy within the
  7.     development of their Customised Application. <p>
  8.  
  9.     ESB Consultancy retains full copyright. <p>
  10.  
  11.     ESB Consultancy grants users of this code royalty free rights
  12.     to do with this code as they wish. <p>
  13.  
  14.     The Source code is made Freely available to users of LMD Tools
  15.     and we thank them for making such a great suite. LMD Tools v4.0
  16.     is required to compile the source. <p>
  17.  
  18.     ESB Consultancy makes no guarantees nor excepts any liabilities
  19.     due to the use of these routines. <p>
  20.  
  21.     We do ask that if this code helps you in you development
  22.     that you send as an email mailto:esb@gold.net.au or even
  23.     a local postcard. It would also be nice if you gave us a
  24.     mention in your About Box or Help File. <p>
  25.  
  26.     ESB Consultancy Home Page: http://www.esbconsult.com.au<p>
  27.  
  28.     Mail Address: PO Box 2259, Boulder, WA 6432 AUSTRALIA <p>
  29.  
  30.     Reference:
  31.     Handbook of Mathematical Functions by Abramowitz & Stegun, Dover, 1965
  32.  
  33.     History
  34.     1.4 7 July 1999
  35.         Now uses LMD 4.5
  36.         Add Constants SubMenu containing various Physical Constraints
  37.         Added an Internal UseConstant Routine
  38.         Added a Minimize Button to Caption with Aleksey Xacker's CaptBtn
  39.             Freeware Component - Zipped Unit Included in Source Dir
  40.         Stopped using LMDHideNonVC
  41.  
  42.     1.3 5 April 1999
  43.         Added Percentage Operator
  44.         Added Exit & Minimize to Option Button
  45.         Fixed up some of the Hints
  46.  
  47.     1.2.1 12 March 1999
  48.         Minor updates to LMD and ASPACK.
  49.         Updated About Box
  50.  
  51.     1.2 2 February 1999
  52.         Added Option Button Next to Memory at the bottom
  53.         Added Option to display thousands separator - on by Default
  54.         Exe now ASPacked
  55.         Source now uses a LMDHideNonVC to make the form a little more manageable.
  56.  
  57.     1.1    Fixed problems with Hints Flickering
  58.         Added 10 Most Recent results (i.e. when equals was pressed)
  59.  
  60.     1.0.2    Added support for Radians or Degrees in Trig
  61.         Added Saving of Radians Status to Registry
  62.         Added Saving of Number of Decimals to Registry
  63.         Added Saving of Memory to Registry
  64.     1.0.1     Added Backspace.
  65.         Changed the Maximum number of Decimals to 18.
  66.         Added About Box.
  67.         Improved Exception Handling.
  68.     1.0 Initial Release
  69. }
  70.  
  71. unit ESBCalcs;
  72.  
  73. interface
  74.  
  75. uses
  76.   Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  77.   lmdclass, lmdcont, StdCtrls, lmdstdcA, lmdctrl, lmdstdcS, lmdbtn,
  78.   ESBExtra, lmddlgS, Menus, lmdnonvS, lmdnonvA, lmdcompo, lmdcctrl,
  79.   lmdformA, CaptBtn;
  80.  
  81. type
  82.   TESBCalcForm = class(TForm)
  83.     CalcPanel: TLMDSimplePanel;
  84.     ZeroBtn: TLMDSpeedButton;
  85.     PointBtn: TLMDSpeedButton;
  86.     ChangeSignBtn: TLMDSpeedButton;
  87.     OneBtn: TLMDSpeedButton;
  88.     TwoBtn: TLMDSpeedButton;
  89.     ThreeBtn: TLMDSpeedButton;
  90.     FourBtn: TLMDSpeedButton;
  91.     FiveBtn: TLMDSpeedButton;
  92.     SixBtn: TLMDSpeedButton;
  93.     SevenBtn: TLMDSpeedButton;
  94.     EightBtn: TLMDSpeedButton;
  95.     NineBtn: TLMDSpeedButton;
  96.     EqualsBtn: TLMDSpeedButton;
  97.     SubtractBtn: TLMDSpeedButton;
  98.     AddBtn: TLMDSpeedButton;
  99.     DivideBtn: TLMDSpeedButton;
  100.     MultiplyBtn: TLMDSpeedButton;
  101.     LeftBracketBtn: TLMDSpeedButton;
  102.     RightBracketBtn: TLMDSpeedButton;
  103.     Decimals: TLMDSpinEdit;
  104.     ValueDisplay: TLMDLabel;
  105.     AllClearBtn: TLMDSpeedButton;
  106.     ClearBtn: TLMDSpeedButton;
  107.     MemoryClearBtn: TLMDSpeedButton;
  108.     MemoryAddBtn: TLMDSpeedButton;
  109.     MemorySubtractBtn: TLMDSpeedButton;
  110.     MemoryRecall: TLMDSpeedButton;
  111.     PowerBtn: TLMDSpeedButton;
  112.     PiButton: TLMDSpeedButton;
  113.     EBtn: TLMDSpeedButton;
  114.     SquareBtn: TLMDSpeedButton;
  115.     SqRootBtn: TLMDSpeedButton;
  116.     InverseBtn: TLMDSpeedButton;
  117.     LogBtn: TLMDSpeedButton;
  118.     LNBtn: TLMDSpeedButton;
  119.     ExitBtn: TLMDSpeedButton;
  120.     CopyBtn: TLMDSpeedButton;
  121.     PasteBtn: TLMDSpeedButton;
  122.     SinBtn: TLMDSpeedButton;
  123.     CosBtn: TLMDSpeedButton;
  124.     TanBtn: TLMDSpeedButton;
  125.     InvBtn: TLMDSpeedButton;
  126.     Bmps: TLMDBitmapList;
  127.     BackSpaceBtn: TLMDSpeedButton;
  128.     AboutBtn: TLMDSpeedButton;
  129.     ESBCalcAbout: TLMDAboutDlg;
  130.     RadBtn: TLMDSpeedButton;
  131.     RegCtrl: TLMDIniCtrl;
  132.     PopupMenu1: TPopupMenu;
  133.     MRU: TLMDMRUList;
  134.     HistoryBtn: TLMDSpeedButton;
  135.     tempitem: TMenuItem;
  136.     MemoryDisplay: TLMDLabel;
  137.     OptionsBtn: TLMDSpeedButton;
  138.     OptionsPM: TPopupMenu;
  139.     ThouSepItem: TMenuItem;
  140.     N1: TMenuItem;
  141.     MinItem: TMenuItem;
  142.     ExitItem: TMenuItem;
  143.     PercentBtn: TLMDSpeedButton;
  144.     N2: TMenuItem;
  145.     C1: TMenuItem;
  146.     GammaItem: TMenuItem;
  147.     LightItem: TMenuItem;
  148.     GravityItem: TMenuItem;
  149.     CaptionButton1: TCaptionButton;
  150.     procedure SevenBtnClick(Sender: TObject);
  151.     procedure ZeroBtnClick(Sender: TObject);
  152.     procedure OneBtnClick(Sender: TObject);
  153.     procedure TwoBtnClick(Sender: TObject);
  154.     procedure ThreeBtnClick(Sender: TObject);
  155.     procedure FourBtnClick(Sender: TObject);
  156.     procedure FiveBtnClick(Sender: TObject);
  157.     procedure SixBtnClick(Sender: TObject);
  158.     procedure EightBtnClick(Sender: TObject);
  159.     procedure NineBtnClick(Sender: TObject);
  160.     procedure PointBtnClick(Sender: TObject);
  161.     procedure AddBtnClick(Sender: TObject);
  162.     procedure FormCreate(Sender: TObject);
  163.     procedure MultiplyBtnClick(Sender: TObject);
  164.     procedure DivideBtnClick(Sender: TObject);
  165.     procedure SubtractBtnClick(Sender: TObject);
  166.     procedure EqualsBtnClick(Sender: TObject);
  167.     procedure DecimalsChange(Sender: TObject);
  168.     procedure ChangeSignBtnClick(Sender: TObject);
  169.     procedure LeftBracketBtnClick(Sender: TObject);
  170.     procedure RightBracketBtnClick(Sender: TObject);
  171.     procedure AllClearBtnClick(Sender: TObject);
  172.     procedure ClearBtnClick(Sender: TObject);
  173.     procedure PowerBtnClick(Sender: TObject);
  174.     procedure PiButtonClick(Sender: TObject);
  175.     procedure EBtnClick(Sender: TObject);
  176.     procedure MemoryClearBtnClick(Sender: TObject);
  177.     procedure MemoryAddBtnClick(Sender: TObject);
  178.     procedure MemorySubtractBtnClick(Sender: TObject);
  179.     procedure MemoryRecallClick(Sender: TObject);
  180.     procedure SquareBtnClick(Sender: TObject);
  181.     procedure InverseBtnClick(Sender: TObject);
  182.     procedure SqRootBtnClick(Sender: TObject);
  183.     procedure ExitBtnClick(Sender: TObject);
  184.     procedure LogBtnClick(Sender: TObject);
  185.     procedure LNBtnClick(Sender: TObject);
  186.     procedure SinBtnClick(Sender: TObject);
  187.     procedure CosBtnClick(Sender: TObject);
  188.     procedure TanBtnClick(Sender: TObject);
  189.     procedure InvBtnClick(Sender: TObject);
  190.     procedure PasteBtnClick(Sender: TObject);
  191.     procedure CopyBtnClick(Sender: TObject);
  192.     procedure FormKeyPress(Sender: TObject; var Key: Char);
  193.     procedure FormKeyDown(Sender: TObject; var Key: Word;
  194.      Shift: TShiftState);
  195.     procedure BackSpaceBtnClick(Sender: TObject);
  196.     procedure AboutBtnClick(Sender: TObject);
  197.     procedure RadBtnClick(Sender: TObject);
  198.     procedure FormDestroy(Sender: TObject);
  199.     procedure MRUClick(Sender: TObject; const aValue: String;
  200.      var Remove: Boolean);
  201.     procedure ThouSepItemClick(Sender: TObject);
  202.     procedure MinItemClick(Sender: TObject);
  203.     procedure ExitItemClick(Sender: TObject);
  204.     procedure PercentBtnClick(Sender: TObject);
  205.     procedure GammaItemClick(Sender: TObject);
  206.     procedure LightItemClick(Sender: TObject);
  207.     procedure GravityItemClick(Sender: TObject);
  208.     procedure CaptionButton1Click(Sender: TObject);
  209.   private
  210.     { Private declarations }
  211.   public
  212.     { Public declarations }
  213.     Inv: Boolean;
  214.     OperandN: Integer;
  215.     OperandStack: TDynFloatArray;
  216.     OperatorN: Integer;
  217.     OperatorStack: TDynCharArray;
  218.     Radians: Boolean;
  219.     Memory: Extended;
  220.     ThouSep: Boolean;
  221.     Value: String;
  222.     procedure Arithmetic (Ch: Char);
  223.     procedure EqualsPressed;
  224.     procedure DisplayMemory;
  225.     procedure DisplayValue (X: Extended);
  226.     function HigherPrecedence (Op1, Op2: Char): Boolean;
  227.     procedure StackManipulation;
  228.     procedure UseConstant (const CValue: Extended);
  229.   end;
  230.  
  231. var
  232.   ESBCalcForm: TESBCalcForm;
  233.  
  234. implementation
  235.  
  236. {$R *.DFM}
  237.  
  238. uses
  239.     Math,
  240.     Clipbrd;
  241.  
  242. procedure TESBCalcForm.FormCreate(Sender: TObject);
  243. begin
  244.     PointBtn.Caption := DecimalSeparator;
  245.  
  246.     Inv := False;
  247.     Radians := True;
  248.     ThouSep := True;
  249.     OperandN := -1;
  250.     SetLength (OperandStack, 10);
  251.     OperatorN := -1;
  252.     SetLength (OperatorStack, 10);
  253.     Value := '';
  254.     ValueDisplay.Caption := '0';
  255.     Memory := 0.0;
  256.  
  257.     Radians := RegCtrl.ReadBool('Properties', 'Radians', Radians);
  258.     Decimals.Value := RegCtrl.ReadInteger ('Properties', 'Decimals', Decimals.Value);
  259.     Memory := RegCtrl.ReadFloat ('Properties', 'Memory', Memory);
  260.     ThouSep := RegCtrl.ReadBool('Properties', 'UseThousandsSep', ThouSep);
  261.  
  262.     ThouSepItem.Checked := ThouSep;
  263.  
  264.     if Radians then
  265.         RadBtn.Caption := 'rad'
  266.     else
  267.         RadBtn.Caption := 'deg';
  268.  
  269.     Application.HintPause := 500;
  270.     Application.HintHidePause := 5000;
  271.     Application.HintShortPause := 200;
  272.  
  273.     DisplayMemory
  274. end;
  275.  
  276. procedure TESBCalcForm.DisplayValue (X: Extended);
  277. begin
  278.     if ThouSep then
  279.         ValueDisplay.Caption := LeftStr (Ext2CEStr (X, Decimals.Value), 16)
  280.     else
  281.         ValueDisplay.Caption := LeftStr (Ext2EStr (X, Decimals.Value), 16);
  282. end;
  283.  
  284. procedure TESBCalcForm.UseConstant (const CValue: Extended);
  285. begin
  286.     DisplayValue (CValue);
  287.     Value := '';
  288.     if OperandN >= High (OperandStack) then
  289.         SetLength (OperandStack, OperandN + 5);
  290.     Inc (OperandN);
  291.     OperandStack [OperandN] := CValue;
  292. end;
  293.  
  294. procedure TESBCalcForm.DisplayMemory;
  295. begin
  296.     if ThouSep then
  297.         MemoryDisplay.Caption := LeftStr (Ext2CEStr (Memory, Decimals.Value), 16)
  298.     else
  299.         MemoryDisplay.Caption := LeftStr (Ext2EStr (Memory, Decimals.Value), 16)
  300. end;
  301.  
  302. function TESBCalcForm.HigherPrecedence (Op1, Op2: Char): Boolean;
  303. begin
  304.     Result := ((Op1 in ['*', '/']) and (Op2 in ['+', '-']))
  305.         or ((Op1 in ['^', '@', '%']) and (Op2 in ['*', '/', '+', '-']))
  306.         or (Op2 = '(');
  307. end;
  308.  
  309. procedure TESBCalcForm.StackManipulation;
  310. begin
  311.     try
  312.         case OperatorStack [OperatorN] of
  313.             '+' :
  314.             begin
  315.                 OperandStack [OperandN - 1] :=
  316.                     OperandStack [OperandN - 1] + OperandStack [OperandN];
  317.                 Dec (OperandN);
  318.             end;
  319.             '-' :
  320.             begin
  321.                 OperandStack [OperandN - 1] :=
  322.                     OperandStack [OperandN - 1] - OperandStack [OperandN];
  323.                 Dec (OperandN);
  324.             end;
  325.             '*' :
  326.             begin
  327.                 OperandStack [OperandN - 1] :=
  328.                     OperandStack [OperandN - 1] * OperandStack [OperandN];
  329.                 Dec (OperandN);
  330.             end;
  331.             '/' :
  332.             begin
  333.                 if OperandStack [OperandN] = 0 then
  334.                     raise Exception.Create ('Division by Zero')
  335.                 else
  336.                 begin
  337.                     OperandStack [OperandN - 1] :=
  338.                         OperandStack [OperandN - 1] / OperandStack [OperandN];
  339.                     Dec (OperandN);
  340.                 end;
  341.             end;
  342.             '^' :
  343.             begin
  344.                 OperandStack [OperandN - 1] :=
  345.                         Power (OperandStack [OperandN - 1], OperandStack [OperandN]);
  346.                 Dec (OperandN);
  347.             end;
  348.             '%' :
  349.             begin
  350.                 OperandStack [OperandN - 1] :=
  351.                         OperandStack [OperandN - 1] * OperandStack [OperandN] / 100.0;
  352.                 Dec (OperandN);
  353.             end;
  354.             '@' :
  355.             begin
  356.                 OperandStack [OperandN - 1] :=
  357.                     Power (OperandStack [OperandN - 1], 1 / OperandStack [OperandN]);
  358.                 Dec (OperandN);
  359.             end;
  360.         end;
  361.         Dec (OperatorN);
  362.     except
  363.         AllClearBtn.Click;
  364.         ValueDisplay.Caption := 'Error!';
  365.         raise;
  366.     end;
  367. end;
  368.  
  369. procedure TESBCalcForm.Arithmetic (Ch: Char);
  370. begin
  371.     try
  372.         if Value <> '' then
  373.         begin
  374.             if OperandN >= High (OperandStack) then
  375.                 SetLength (OperandStack, OperandN + 5);
  376.             Inc (OperandN);
  377.             OperandStack [OperandN] := Str2Ext (Value);
  378.             Value := '';
  379.         end;
  380.  
  381.         while (OperatorN > -1) and not HigherPrecedence (Ch, OperatorStack [OperatorN]) do
  382.             StackManipulation;
  383.         if OperatorN >= High (OperatorStack) then
  384.             SetLength (OperandStack, OperatorN + 5);
  385.         Inc (OperatorN);
  386.         OperatorStack [OperatorN] := Ch;
  387.  
  388.         if OperandN >= 0 then
  389.             DisplayValue (OperandStack [OperandN])
  390.         else
  391.             ValueDisplay.Caption := '0';
  392.     except
  393.         AllClearBtn.Click;
  394.         ValueDisplay.Caption := 'Error!';
  395.     end;
  396.     Inv := False;
  397. end;
  398.  
  399. procedure TESBCalcForm.EqualsPressed;
  400. begin
  401.     try
  402.         if Value <> '' then
  403.         begin
  404.             if OperandN >= High (OperandStack) then
  405.                 SetLength (OperandStack, OperandN + 5);
  406.             Inc (OperandN);
  407.             OperandStack [OperandN] := Str2Ext (Value);
  408.             Value := '';
  409.         end;
  410.  
  411.         while (OperatorN >= 0) do
  412.             StackManipulation;
  413.         if OperandN > 0 then
  414.         begin
  415.             OperandStack [0] := OperandStack [OperandN];
  416.             OperandN := 0;
  417.         end;
  418.  
  419.         if OperandN >= 0 then
  420.             DisplayValue (OperandStack [OperandN])
  421.         else
  422.             ValueDisplay.Caption := '0';
  423.         Inv := False;
  424.     except
  425.         AllClearBtn.Click;
  426.         ValueDisplay.Caption := 'Error!';
  427.     end;
  428. end;
  429.  
  430. procedure TESBCalcForm.ZeroBtnClick(Sender: TObject);
  431. begin
  432.     Value := Value + '0';
  433.     DisplayValue (Str2Ext (Value));
  434.     Inv := False;
  435. end;
  436.  
  437. procedure TESBCalcForm.OneBtnClick(Sender: TObject);
  438. begin
  439.     Value := Value + '1';
  440.     DisplayValue (Str2Ext (Value));
  441.     Inv := False;
  442. end;
  443.  
  444. procedure TESBCalcForm.TwoBtnClick(Sender: TObject);
  445. begin
  446.     Value := Value + '2';
  447.     DisplayValue (Str2Ext (Value));
  448.     Inv := False;
  449. end;
  450.  
  451. procedure TESBCalcForm.ThreeBtnClick(Sender: TObject);
  452. begin
  453.     Value := Value + '3';
  454.     DisplayValue (Str2Ext (Value));
  455.     Inv := False;
  456. end;
  457.  
  458. procedure TESBCalcForm.FourBtnClick(Sender: TObject);
  459. begin
  460.     Value := Value + '4';
  461.     DisplayValue (Str2Ext (Value));
  462.     Inv := False;
  463. end;
  464.  
  465. procedure TESBCalcForm.FiveBtnClick(Sender: TObject);
  466. begin
  467.     Value := Value + '5';
  468.     DisplayValue (Str2Ext (Value));
  469.     Inv := False;
  470. end;
  471.  
  472. procedure TESBCalcForm.SixBtnClick(Sender: TObject);
  473. begin
  474.     Value := Value + '6';
  475.     DisplayValue (Str2Ext (Value));
  476.     Inv := False;
  477. end;
  478.  
  479. procedure TESBCalcForm.SevenBtnClick(Sender: TObject);
  480. begin
  481.     Value := Value + '7';
  482.     DisplayValue (Str2Ext (Value));
  483.     Inv := False;
  484. end;
  485.  
  486. procedure TESBCalcForm.EightBtnClick(Sender: TObject);
  487. begin
  488.     Value := Value + '8';
  489.     DisplayValue (Str2Ext (Value));
  490.     Inv := False;
  491. end;
  492.  
  493. procedure TESBCalcForm.NineBtnClick(Sender: TObject);
  494. begin
  495.     Value := Value + '9';
  496.     DisplayValue (Str2Ext (Value));
  497.     Inv := False;
  498. end;
  499.  
  500. procedure TESBCalcForm.PointBtnClick(Sender: TObject);
  501. begin
  502.     if Pos (DecimalSeparator, Value) = 0 then
  503.         Value := Value + DecimalSeparator
  504.     else
  505.         Beep;
  506.     DisplayValue (Str2Ext (Value));
  507.     Inv := False;
  508. end;
  509.  
  510. procedure TESBCalcForm.AddBtnClick(Sender: TObject);
  511. begin
  512.     Arithmetic ('+');
  513. end;
  514.  
  515. procedure TESBCalcForm.MultiplyBtnClick(Sender: TObject);
  516. begin
  517.     Arithmetic ('*');
  518. end;
  519.  
  520. procedure TESBCalcForm.DivideBtnClick(Sender: TObject);
  521. begin
  522.     Arithmetic ('/');
  523. end;
  524.  
  525. procedure TESBCalcForm.SubtractBtnClick(Sender: TObject);
  526. begin
  527.     Arithmetic ('-');
  528. end;
  529.  
  530. procedure TESBCalcForm.EqualsBtnClick(Sender: TObject);
  531. begin
  532.     EqualsPressed;
  533.     MRU.Add (ValueDisplay.Caption);
  534. end;
  535.  
  536. procedure TESBCalcForm.DecimalsChange(Sender: TObject);
  537. begin
  538.     if Value <> '' then
  539.         DisplayValue (Str2Ext (Value))
  540.     else
  541.         DisplayValue (OperandStack [OperandN])
  542. end;
  543.  
  544. procedure TESBCalcForm.ChangeSignBtnClick(Sender: TObject);
  545. var
  546.     X: Extended;
  547. begin
  548.     if Value <> '' then
  549.         X := -1 * (Str2Ext (Value))
  550.     else if OperandN > - 1 then
  551.         X := -1 * (OperandStack [OperandN])
  552.     else
  553.         X := 0;
  554.  
  555.     DisplayValue (X);
  556.     Value := '';
  557.     if OperandN >= High (OperandStack) then
  558.         SetLength (OperandStack, OperandN + 5);
  559.     Inc (OperandN);
  560.     OperandStack [OperandN] := X;
  561. end;
  562.  
  563. procedure TESBCalcForm.LeftBracketBtnClick(Sender: TObject);
  564. begin
  565.     Value := '';
  566.     if OperatorN >= High (OperatorStack) then
  567.         SetLength (OperatorStack, OperatorN + 5);
  568.     Inc (OperatorN);
  569.     OperatorStack [OperatorN] := '(';
  570.  
  571.     if OperandN >= 0 then
  572.         DisplayValue (OperandStack [OperandN])
  573.     else
  574.         ValueDisplay.Caption := '0';
  575. end;
  576.  
  577. procedure TESBCalcForm.RightBracketBtnClick(Sender: TObject);
  578. begin
  579.     if Value <> '' then
  580.     begin
  581.         if OperandN >= High (OperandStack) then
  582.             SetLength (OperandStack, OperandN + 5);
  583.         Inc (OperandN);
  584.         OperandStack [OperandN] := Str2Ext (Value);
  585.         Value := '';
  586.     end;
  587.  
  588.     while (OperatorN > -1) and (OperatorStack [OperatorN] <> '(')  do
  589.         StackManipulation;
  590.     if OperatorN > -1 then
  591.         Dec (OperatorN);
  592.  
  593.     if OperandN >= 0 then
  594.         DisplayValue (OperandStack [OperandN])
  595.     else
  596.         ValueDisplay.Caption := '0';
  597. end;
  598.  
  599. procedure TESBCalcForm.AllClearBtnClick(Sender: TObject);
  600. begin
  601.     OperandN := -1;
  602.     OperatorN := -1;
  603.     Value := '';
  604.     ValueDisplay.Caption := '0';
  605. end;
  606.  
  607. procedure TESBCalcForm.ClearBtnClick(Sender: TObject);
  608. begin
  609.     Value := '';
  610.     ValueDisplay.Caption := '0';
  611. end;
  612.  
  613. procedure TESBCalcForm.PowerBtnClick(Sender: TObject);
  614. begin
  615.     if Inv then
  616.         Arithmetic ('@')
  617.     else
  618.         Arithmetic ('^');
  619.     Inv := False;
  620. end;
  621.  
  622. procedure TESBCalcForm.PiButtonClick(Sender: TObject);
  623. begin
  624.     UseConstant (Pi);
  625. end;
  626.  
  627. procedure TESBCalcForm.EBtnClick(Sender: TObject);
  628. begin
  629.     UseConstant (Exp (1));
  630. end;
  631.  
  632. procedure TESBCalcForm.MemoryClearBtnClick(Sender: TObject);
  633. begin
  634.     Memory := 0;
  635.     DisplayMemory;
  636.     Inv := False;
  637. end;
  638.  
  639. procedure TESBCalcForm.MemoryAddBtnClick(Sender: TObject);
  640. begin
  641.     if Value <> '' then
  642.         Memory := Memory + Str2Ext (Value)
  643.     else if OperandN > - 1 then
  644.         Memory := Memory + OperandStack [OperandN];
  645.     DisplayMemory;
  646.     Inv := False;
  647. end;
  648.  
  649. procedure TESBCalcForm.MemorySubtractBtnClick(Sender: TObject);
  650. begin
  651.     if Value <> '' then
  652.         Memory := Memory - Str2Ext (Value)
  653.     else if OperandN > -1 then
  654.         Memory := Memory - OperandStack [OperandN];
  655.     DisplayMemory;
  656.     Inv := False;
  657. end;
  658.  
  659. procedure TESBCalcForm.MemoryRecallClick(Sender: TObject);
  660. begin
  661.     DisplayValue (Memory);
  662.     Value := '';
  663.     if OperandN >= High (OperandStack) then
  664.         SetLength (OperandStack, OperandN + 5);
  665.     Inc (OperandN);
  666.     OperandStack [OperandN] := Memory;
  667.     Inv := False;
  668. end;
  669.  
  670. procedure TESBCalcForm.SquareBtnClick(Sender: TObject);
  671. var
  672.     X: Extended;
  673. begin
  674.     if Inv then
  675.     begin
  676.         Inv := False;
  677.         SqRootBtn.Click;
  678.     end;
  679.     try
  680.         if Value <> '' then
  681.             X := Sqr (Str2Ext (Value))
  682.         else if OperandN > - 1 then
  683.             X := Sqr (OperandStack [OperandN])
  684.         else
  685.             X := 0;
  686.  
  687.         DisplayValue (X);
  688.         Value := '';
  689.         if OperandN >= High (OperandStack) then
  690.             SetLength (OperandStack, OperandN + 5);
  691.         Inc (OperandN);
  692.         OperandStack [OperandN] := X;
  693.     except
  694.         AllClearBtn.Click;
  695.         ValueDisplay.Caption := 'Error!'
  696.     end;
  697. end;
  698.  
  699. procedure TESBCalcForm.InverseBtnClick(Sender: TObject);
  700. var
  701.     X: Extended;
  702. begin
  703.     Inv := False;
  704.     try
  705.         if Value <> '' then
  706.         begin
  707.             X := Str2Ext (Value);
  708.             if X = 0 then
  709.                 raise Exception.Create ('Division by Zero')
  710.             else
  711.                 X := 1 / X;
  712.         end
  713.         else if OperandN > - 1 then
  714.         begin
  715.             if OperandStack [OperandN] = 0 then
  716.                 raise Exception.Create ('Division by Zero')
  717.             else
  718.                 X := 1 / OperandStack [OperandN]
  719.         end
  720.         else
  721.             raise Exception.Create ('Invalid Inverse');
  722.  
  723.         DisplayValue (X);
  724.         Value := '';
  725.         if OperandN >= High (OperandStack) then
  726.             SetLength (OperandStack, OperandN + 5);
  727.         Inc (OperandN);
  728.         OperandStack [OperandN] := X;
  729.     except
  730.         AllClearBtn.Click;
  731.         ValueDisplay.Caption := 'Error!'
  732.     end;
  733. end;
  734.  
  735. procedure TESBCalcForm.SqRootBtnClick(Sender: TObject);
  736. var
  737.     X: Extended;
  738. begin
  739.     if Inv then
  740.     begin
  741.         Inv := False;
  742.         SquareBtn.Click;
  743.     end;
  744.  
  745.     try
  746.         if Value <> '' then
  747.         begin
  748.             X := Str2Ext (Value);
  749.             if X < 0 then
  750.                 raise Exception.Create ('Square Root of Negative')
  751.             else
  752.                 X := Sqrt (X)
  753.         end
  754.         else if OperandN > - 1 then
  755.         begin
  756.             if OperandStack [OperandN] < 0 then
  757.                 raise Exception.Create ('Square Root of Negative')
  758.             else
  759.                 X := Sqrt (OperandStack [OperandN])
  760.         end
  761.         else
  762.             X := 0;
  763.  
  764.         DisplayValue (X);
  765.         Value := '';
  766.         if OperandN >= High (OperandStack) then
  767.             SetLength (OperandStack, OperandN + 5);
  768.         Inc (OperandN);
  769.         OperandStack [OperandN] := X;
  770.     except
  771.         AllClearBtn.Click;
  772.         ValueDisplay.Caption := 'Error!'
  773.     end;
  774. end;
  775.  
  776. procedure TESBCalcForm.ExitBtnClick(Sender: TObject);
  777. begin
  778.     Close;
  779. end;
  780.  
  781. procedure TESBCalcForm.LogBtnClick(Sender: TObject);
  782. var
  783.     X: Extended;
  784. begin
  785.     try
  786.         if Value <> '' then
  787.         begin
  788.             if Inv then
  789.                 X := Power (10, Str2Ext (Value))
  790.             else
  791.                 X := Log10 (Str2Ext (Value))
  792.         end
  793.         else if OperandN > - 1 then
  794.         begin
  795.             if Inv then
  796.                 X := Power (10, OperandStack [OperandN])
  797.             else
  798.                 X := Log10 (OperandStack [OperandN])
  799.         end
  800.         else
  801.             X := 0;
  802.         Inv := False;
  803.  
  804.         DisplayValue (X);
  805.         Value := '';
  806.         if OperandN >= High (OperandStack) then
  807.             SetLength (OperandStack, OperandN + 5);
  808.         Inc (OperandN);
  809.         OperandStack [OperandN] := X;
  810.     except
  811.         AllClearBtn.Click;
  812.         ValueDisplay.Caption := 'Error!'
  813.     end;
  814. end;
  815.  
  816. procedure TESBCalcForm.LNBtnClick(Sender: TObject);
  817. var
  818.     X: Extended;
  819. begin
  820.     try
  821.         if Value <> '' then
  822.         begin
  823.             if Inv then
  824.                 X := Exp (Str2Ext (Value))
  825.             else
  826.                 X := Ln (Str2Ext (Value))
  827.         end
  828.         else if OperandN > - 1 then
  829.         begin
  830.             if Inv then
  831.                 X := Exp (OperandStack [OperandN])
  832.             else
  833.                 X := Ln (OperandStack [OperandN])
  834.         end
  835.         else
  836.             X := 0;
  837.         Inv := False;
  838.  
  839.         DisplayValue (X);
  840.         Value := '';
  841.         if OperandN >= High (OperandStack) then
  842.             SetLength (OperandStack, OperandN + 5);
  843.         Inc (OperandN);
  844.         OperandStack [OperandN] := X;
  845.     except
  846.         AllClearBtn.Click;
  847.         ValueDisplay.Caption := 'Error!'
  848.     end;
  849. end;
  850.  
  851. procedure TESBCalcForm.SinBtnClick(Sender: TObject);
  852. var
  853.     X: Extended;
  854. begin
  855.     try
  856.         if Value <> '' then
  857.             X := Str2Ext (Value)
  858.         else if OperandN > - 1 then
  859.             X := OperandStack [OperandN]
  860.         else
  861.             X := 0;
  862.  
  863.         if Inv then
  864.         begin
  865.             X := ArcSin (X);
  866.             if not Radians then
  867.                 X := X * 180.0 / Pi;
  868.         end
  869.         else
  870.         begin
  871.             if not Radians then
  872.                 X := X * Pi / 180.0;
  873.             X := Sin (X)
  874.         end;
  875.         Inv := False;
  876.  
  877.         DisplayValue (X);
  878.         Value := '';
  879.         if OperandN >= High (OperandStack) then
  880.             SetLength (OperandStack, OperandN + 5);
  881.         Inc (OperandN);
  882.         OperandStack [OperandN] := X;
  883.     except
  884.         AllClearBtn.Click;
  885.         ValueDisplay.Caption := 'Error!'
  886.     end;
  887. end;
  888.  
  889. procedure TESBCalcForm.CosBtnClick(Sender: TObject);
  890. var
  891.     X: Extended;
  892. begin
  893.     try
  894.         if Value <> '' then
  895.             X := Str2Ext (Value)
  896.         else if OperandN > - 1 then
  897.             X := OperandStack [OperandN]
  898.         else
  899.             X := 0;
  900.  
  901.         if Inv then
  902.         begin
  903.             X := ArcCos (X);
  904.             if not Radians then
  905.                 X := X * 180.0 / Pi;
  906.         end
  907.         else
  908.         begin
  909.             if not Radians then
  910.                 X := X * Pi / 180.0;
  911.             X := Cos (X)
  912.         end;
  913.         Inv := False;
  914.  
  915.         DisplayValue (X);
  916.         Value := '';
  917.         if OperandN >= High (OperandStack) then
  918.             SetLength (OperandStack, OperandN + 5);
  919.         Inc (OperandN);
  920.         OperandStack [OperandN] := X;
  921.     except
  922.         AllClearBtn.Click;
  923.         ValueDisplay.Caption := 'Error!'
  924.     end;
  925. end;
  926.  
  927. procedure TESBCalcForm.TanBtnClick(Sender: TObject);
  928. var
  929.     X: Extended;
  930. begin
  931.     try
  932.         if Value <> '' then
  933.             X := Str2Ext (Value)
  934.         else if OperandN > - 1 then
  935.             X := OperandStack [OperandN]
  936.         else
  937.             X := 0;
  938.  
  939.         if Inv then
  940.         begin
  941.             X := ArcTan (X);
  942.             if not Radians then
  943.                 X := X * 180.0 / Pi;
  944.         end
  945.         else
  946.         begin
  947.             if not Radians then
  948.                 X := X * Pi / 180.0;
  949.             X := Tan (X)
  950.         end;
  951.         Inv := False;
  952.  
  953.         DisplayValue (X);
  954.         Value := '';
  955.         if OperandN >= High (OperandStack) then
  956.             SetLength (OperandStack, OperandN + 5);
  957.         Inc (OperandN);
  958.         OperandStack [OperandN] := X;
  959.     except
  960.         AllClearBtn.Click;
  961.         ValueDisplay.Caption := 'Error!'
  962.     end;
  963. end;
  964.  
  965. procedure TESBCalcForm.InvBtnClick(Sender: TObject);
  966. begin
  967.     Inv := not Inv;
  968. end;
  969.  
  970. procedure TESBCalcForm.PasteBtnClick(Sender: TObject);
  971. var
  972.     X: Extended;
  973. begin
  974.     if Clipboard.HasFormat (CF_Text) then
  975.     begin
  976.         X := Str2Ext (Clipboard.AsText);
  977.         DisplayValue (X);
  978.         Value := '';
  979.         if OperandN >= High (OperandStack) then
  980.             SetLength (OperandStack, OperandN + 5);
  981.         Inc (OperandN);
  982.         OperandStack [OperandN] := X;
  983.     end;
  984. end;
  985.  
  986. procedure TESBCalcForm.CopyBtnClick(Sender: TObject);
  987. begin
  988.     Clipboard.AsText := ValueDisplay.Caption;      
  989. end;
  990.  
  991. procedure TESBCalcForm.FormKeyPress(Sender: TObject; var Key: Char);
  992. begin
  993.     case Key of
  994.         #8: BackSpaceBtn.Click;
  995.         #13: EqualsBtn.Click;
  996.         #27: ExitBtn.Click;
  997.         '(': LeftBracketBtn.Click;
  998.         ')': RightBracketBtn.Click;
  999.         '*': MultiplyBtn.Click;
  1000.         '+': AddBtn.Click;
  1001.         '-': SubtractBtn.Click;
  1002.         '/': DivideBtn.Click;
  1003.         '0': ZeroBtn.Click;
  1004.         '1': OneBtn.Click;
  1005.         '2': TwoBtn.Click;
  1006.         '3': ThreeBtn.Click;
  1007.         '4': FourBtn.Click;
  1008.         '5': FiveBtn.Click;
  1009.         '6': SixBtn.Click;
  1010.         '7': SevenBtn.Click;
  1011.         '8': EightBtn.Click;
  1012.         '9': NineBtn.Click;
  1013.         'A': AllClearBtn.Click;
  1014.         'C': ClearBtn.Click;
  1015.     end;
  1016.     if Key = DecimalSeparator then
  1017.         PointBtn.Click;
  1018. end;
  1019.  
  1020. procedure TESBCalcForm.FormKeyDown(Sender: TObject; var Key: Word;
  1021.   Shift: TShiftState);
  1022. begin
  1023.     if ssCtrl in Shift then
  1024.     begin
  1025.         case Key of
  1026.             VK_C, VK_Insert: CopyBtn.Click;
  1027.             VK_V: PasteBtn.Click;
  1028.             VK_X: ExitBtn.Click;
  1029.         end;
  1030.     end;
  1031.     if ssShift in Shift then
  1032.     begin
  1033.         case Key of
  1034.             VK_Insert: PasteBtn.Click;
  1035.         end;
  1036.     end;
  1037. end;
  1038.  
  1039. procedure TESBCalcForm.BackSpaceBtnClick(Sender: TObject);
  1040. begin
  1041.     if Value <> '' then
  1042.     begin
  1043.         Value := Copy (Value, 1, Length (Value) - 1);
  1044.         DisplayValue (Str2Ext (Value));
  1045.     end;
  1046.     Inv := False;
  1047. end;
  1048.  
  1049. procedure TESBCalcForm.AboutBtnClick(Sender: TObject);
  1050. begin
  1051.     ESBCalcAbout.Execute
  1052. end;
  1053.  
  1054. procedure TESBCalcForm.RadBtnClick(Sender: TObject);
  1055. begin
  1056.     Radians := not Radians;
  1057.     if Radians then
  1058.         RadBtn.Caption := 'rad'
  1059.     else
  1060.         RadBtn.Caption := 'deg';
  1061. end;
  1062.  
  1063. procedure TESBCalcForm.FormDestroy(Sender: TObject);
  1064. begin
  1065.     RegCtrl.WriteBool('Properties', 'Radians', Radians);
  1066.     RegCtrl.WriteInteger ('Properties', 'Decimals', Decimals.Value);
  1067.     RegCtrl.WriteFloat ('Properties', 'Memory', Memory);
  1068.     RegCtrl.WriteBool('Properties', 'UseThousandsSep', ThouSep);
  1069. end;
  1070.  
  1071. procedure TESBCalcForm.MRUClick(Sender: TObject; const aValue: String;
  1072.   var Remove: Boolean);
  1073. var
  1074.     X: Extended;
  1075. begin
  1076.     X := Str2Ext (aValue);
  1077.     DisplayValue (X);
  1078.     Value := '';
  1079.     if OperandN >= High (OperandStack) then
  1080.         SetLength (OperandStack, OperandN + 5);
  1081.     Inc (OperandN);
  1082.     OperandStack [OperandN] := X;
  1083.     Inv := False;
  1084. end;
  1085.  
  1086. procedure TESBCalcForm.ThouSepItemClick(Sender: TObject);
  1087. begin
  1088.     ThouSep := not ThouSep;
  1089.     ThouSepItem.Checked := ThouSep;
  1090.     DisplayMemory;
  1091.     Inv := False;
  1092. end;
  1093.  
  1094. procedure TESBCalcForm.MinItemClick(Sender: TObject);
  1095. begin
  1096.     Application.Minimize;
  1097. end;
  1098.  
  1099. procedure TESBCalcForm.ExitItemClick(Sender: TObject);
  1100. begin
  1101.     Close;
  1102. end;
  1103.  
  1104. procedure TESBCalcForm.PercentBtnClick(Sender: TObject);
  1105. begin
  1106.     Arithmetic ('%');
  1107.     Inv := False;
  1108. end;
  1109.  
  1110. procedure TESBCalcForm.GammaItemClick(Sender: TObject);
  1111. begin
  1112.     UseConstant (0.577215664901532860606512);
  1113. end;
  1114.  
  1115. procedure TESBCalcForm.LightItemClick(Sender: TObject);
  1116. begin
  1117.     UseConstant (299792.500);
  1118. end;
  1119.  
  1120. procedure TESBCalcForm.GravityItemClick(Sender: TObject);
  1121. begin
  1122.     UseConstant (9.80665);
  1123. end;
  1124.  
  1125. procedure TESBCalcForm.CaptionButton1Click(Sender: TObject);
  1126. begin
  1127.     Application.Minimize;
  1128. end;
  1129.  
  1130. end.
  1131.