Author Topic: InForm Calculator by Terry Ritchie  (Read 975 times)

0 Members and 1 Guest are viewing this topic.

Offline Qwerkey

  • Forum Resident
  • Posts: 766
InForm Calculator by Terry Ritchie
« on: March 03, 2020, 09:25:04 AM »
InForm Calculator

Author: @TerryRitchie
Source: qb64.org Forum
URL: https://www.qb64.org/forum/index.php?topic=507.0
Version: 1
Tags: [InForm], [Calculator]

Description:
This is a calculator program I have been working on.  This little program gave me the general feel for InForm and got me back into programming QB64, a win-win.

Source Code:
Code: QB64: [Select]
  1. ':  ____ ____ ____ ____ ____ ____ ____ ____ ____ ____
  2. ': ||C |||A |||L |||C |||U |||L |||A |||T |||O |||R ||
  3. ': ||__|||__|||__|||__|||__|||__|||__|||__|||__|||__||
  4. ': |/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|
  5. ':
  6. ': QB64 Calculator V1.0
  7. ': Terry Ritchie - 08/29/18
  8. ':
  9. ': Built as a clone of the Windows 7 standard calculator
  10. ': An exersize in getting to know the InForm library
  11. ':
  12. ': This program uses
  13. ': InForm - GUI library for QB64 - Beta version 7
  14. ': Fellippe Heitor, 2016-2018 - fellippe@qb64.org - [member=2]FellippeHeitor[/member]
  15. ': https://github.com/FellippeHeitor/InForm
  16. '----------------------------------------------------------------------------------------------------------------------
  17.  
  18. ': Program constants: -------------------------------------------------------------------------------------------------
  19.  
  20. CONST EQUATE = 0
  21. CONST ADDITION = 1
  22. CONST SUBTRACTION = 2
  23. CONST MULTIPLICATION = 3
  24. CONST DIVISION = 4
  25.  
  26. ': Controls' IDs: -----------------------------------------------------------------------------------------------------
  27.  
  28. DIM SHARED Calculator AS LONG
  29. DIM SHARED frmResults AS LONG
  30. DIM SHARED mnuEdit AS LONG
  31. DIM SHARED mnuHelp AS LONG
  32. DIM SHARED butMplus AS LONG
  33. DIM SHARED butMminus AS LONG
  34. DIM SHARED butSign AS LONG
  35. DIM SHARED butSQR AS LONG
  36. DIM SHARED butDivide AS LONG
  37. DIM SHARED butPercent AS LONG
  38. DIM SHARED butMultiply AS LONG
  39. DIM SHARED butReciprocate AS LONG
  40. DIM SHARED butSubtract AS LONG
  41. DIM SHARED butPoint AS LONG
  42. DIM SHARED butAdd AS LONG
  43. DIM SHARED butEqual AS LONG
  44. DIM SHARED mnuCopy AS LONG
  45. DIM SHARED mnuPaste AS LONG
  46. DIM SHARED mnuAbout AS LONG
  47. DIM SHARED lblAnswer AS LONG
  48. DIM SHARED lblMemory AS LONG
  49. DIM SHARED lblHistory AS LONG
  50.  
  51. ': Program variables: -------------------------------------------------------------------------------------------------
  52.  
  53. DIM SHARED operand$ '                       current operand
  54. DIM SHARED history$ '                       calculation history
  55. DIM SHARED operand1 AS DOUBLE '             first operand enetered
  56. DIM SHARED operand2 AS DOUBLE '             second operand entered
  57. DIM SHARED operator AS INTEGER '            current operator selected
  58. DIM SHARED operator$(4)
  59. DIM SHARED previousoperator AS INTEGER '    previous operator saved
  60. DIM SHARED resetoperand AS INTEGER '        True when operand entry needs reset
  61. DIM SHARED memory AS DOUBLE '               value stored in memory
  62. DIM SHARED nohistory AS INTEGER
  63.  
  64. ': External modules: --------------------------------------------------------------------------------------------------
  65.  
  66. '$INCLUDE:'InForm\InForm.ui'
  67. '$INCLUDE:'InForm\xp.uitheme'
  68. '$INCLUDE:'Calculator.frm'
  69.  
  70. ': Windows libraries : ------------------------------------------------------------------------------------------------
  71.  
  72. ' Windows system sounds
  73. ' Code contributed by QB64.org Wiki - Author unknown
  74. ' http://qb64.org/wiki/Windows_Libraries#Windows_Sounds
  75. ' Note: this Windows library will fail in SDL versions of QB64
  76. '       change DECLARE LIBRARY to DECLARE DYNAMIC LIBRARY "Wimmm"
  77. '       to allow this library to work with SDL versions of QB64
  78.  
  79.     FUNCTION PlaySound (pszSound AS STRING, BYVAL hmod AS INTEGER, BYVAL fdwSound AS INTEGER)
  80.  
  81. ': Program procedures: ------------------------------------------------------------------------------------------------
  82.  
  83. '----------------------------------------------------------------------------------------------------------------------
  84. SUB ALERT () '                                                                                                  ALERT()
  85.     '------------------------------------------------------------------------------------------------------------------
  86.  
  87.     ' Plays Windows default sounds
  88.     ' Sounds can be invoked using the following strings:
  89.     ' "SystemDefault","SystemExclamation","SystemExit","SystemHand","SystemQuestion","SystemStart","SystemWelcome"
  90.  
  91.     s = PlaySound("SystemDefault" + CHR$(0), 0, 65537) '                play Windows default system sound
  92.  
  93.  
  94. '----------------------------------------------------------------------------------------------------------------------
  95. FUNCTION CLEAN$ (n AS DOUBLE) '                                                                                CLEAN$()
  96.     '------------------------------------------------------------------------------------------------------------------
  97.  
  98.     ' Return number (n) as a string with no leading/trailing spaces
  99.     ' Add leading zero if necessary
  100.  
  101.     DIM c$ ' n converted to a clean string
  102.  
  103.     c$ = LTRIM$(RTRIM$(STR$(n))) '                                      create clean string
  104.     IF ASC(c$, 1) = 46 THEN '                                           first character a decimal point?
  105.         c$ = "0" + c$ '                                                 yes, add leading zero
  106.     ELSEIF ASC(c$, 1) = 45 AND ASC(c$, 2) = 46 THEN '                   no, minus sign then decimal point?
  107.         c$ = "-0" + RIGHT$(c$, LEN(c$) - 1) '                           yes, add leading zero
  108.     END IF
  109.     CLEAN$ = c$ '                                                       return cleaned string
  110.  
  111.  
  112. '----------------------------------------------------------------------------------------------------------------------
  113. SUB UPDATEOPERAND (n$) '                                                                                UPDATEOPERAND()
  114.     '------------------------------------------------------------------------------------------------------------------
  115.  
  116.     ' Add user entries to operand
  117.     ' Keep operand to a max length of 16 numbers (not including decimal point)
  118.     ' Reset user operand input as needed
  119.     ' Keep leading zero for decimal values between one and negative one
  120.  
  121.     DIM olen AS INTEGER ' operand length
  122.  
  123.     IF resetoperand THEN '                                              new operand input?
  124.         operand$ = "" '                                                 yes, reset operand
  125.         resetoperand = False '                                          reset trigger
  126.     END IF
  127.     IF n$ = "." THEN '                                                  adding decimal point?
  128.         IF INSTR(operand$, ".") = 0 THEN '                              yes, already a decimal point?
  129.             IF operand$ = "" THEN '                                     no, has operand been reset?
  130.                 n$ = "0." '                                             yes, add leading zero
  131.             END IF
  132.         ELSE '                                                          yes, decimal point exists
  133.             n$ = "" '                                                   ignore user request for decimal point
  134.         END IF
  135.     END IF
  136.     operand$ = operand$ + n$ '                                          update operand with user entry
  137.     olen = LEN(operand$) '                                              get length of operand
  138.     IF INSTR(operand$, ".") > 0 THEN olen = olen - 1 '                  don't count decimal point if preset
  139.     IF olen > 16 THEN operand$ = LEFT$(operand$, LEN(operand$) - 1) '   keep operand within 16 number limit
  140.  
  141.  
  142. '----------------------------------------------------------------------------------------------------------------------
  143. SUB CALCULATE () '                                                                                          CALCULATE()
  144.     '------------------------------------------------------------------------------------------------------------------
  145.  
  146.     ' Calculate operand values based on operator previously used
  147.     ' Store result back into current operand
  148.  
  149.     SELECT CASE previousoperator '                                      which operator to use?
  150.         CASE ADDITION '                                                 add the operands
  151.             operand$ = CLEAN$(operand1 + operand2) '                    perform clculation
  152.         CASE SUBTRACTION '                                              subtract the operands
  153.             operand$ = CLEAN$(operand1 - operand2) '                    perform calculation
  154.         CASE MULTIPLICATION '                                           multiply the operands
  155.             operand$ = CLEAN$(operand1 * operand2) '                    perform calculation
  156.         CASE DIVISION '                                                 divide the operands
  157.             IF operand2 = 0 THEN '                                      dividing by zero?
  158.                 ALERT '                                                 get user's attention
  159.                 operand$ = "Can't divide by zero!" '                    yes, not in this universe!
  160.             ELSE '                                                      no, physics is safe for now
  161.                 operand$ = CLEAN$(operand1 / operand2) '                perform calculation
  162.             END IF
  163.     END SELECT
  164.     calculated = True
  165.  
  166.  
  167. '----------------------------------------------------------------------------------------------------------------------
  168. SUB COMMITOPERAND () '                                                                                  COMMITOPERAND()
  169.     '------------------------------------------------------------------------------------------------------------------
  170.  
  171.     ' Get value of current operand
  172.     ' Calculate operands if necessary
  173.     ' Save current operand value
  174.     ' Remember the operator that invoked this routine
  175.  
  176.     operand2 = VAL(operand$) '                                          store value of current operand
  177.     IF previousoperator THEN '                                          previous operator selected?
  178.         CALCULATE '                                                     yes, calculate
  179.     END IF
  180.     operand1 = VAL(operand$) '                                          move current total to previous value
  181.     previousoperator = operator '                                       move current operator to previous operator
  182.     resetoperand = True '                                               trigger an operand reset
  183.  
  184.  
  185. '----------------------------------------------------------------------------------------------------------------------
  186. SUB SCANKEYBOARD () '                                                                                    SCANKEYBOARD()
  187.     '------------------------------------------------------------------------------------------------------------------
  188.  
  189.     ' Scan the keyboard for user keystrokes
  190.     ' Invoke the appropriate button for the desired key
  191.  
  192.     DIM k$ ' key pressed by user
  193.     DIM ctrl AS INTEGER
  194.  
  195.     k$ = INKEY$ '                                                       look for a key press
  196.     IF k$ <> "" THEN '                                                  was a key pressed?
  197.         SELECT CASE k$ '                                                yes, which one?
  198.             CASE "0" '                                                  zero key pressed
  199.                 __UI_Click (but0) '                                     manually click the zero button
  200.             CASE "1" '                                                  etc..
  201.                 __UI_Click (but1) '                                     etc..
  202.             CASE "2"
  203.                 __UI_Click (but2)
  204.             CASE "3"
  205.                 __UI_Click (but3)
  206.             CASE "4"
  207.                 __UI_Click (but4)
  208.             CASE "5"
  209.                 __UI_Click (but5)
  210.             CASE "6"
  211.                 __UI_Click (but6)
  212.             CASE "7"
  213.                 __UI_Click (but7)
  214.             CASE "8"
  215.                 __UI_Click (but8)
  216.             CASE "9"
  217.                 __UI_Click (but9)
  218.             CASE "."
  219.                 __UI_Click (butPoint)
  220.             CASE "+"
  221.                 __UI_Click (butAdd)
  222.             CASE "-"
  223.                 __UI_Click (butSubtract)
  224.             CASE "*"
  225.                 __UI_Click (butMultiply)
  226.             CASE "/"
  227.                 __UI_Click (butDivide)
  228.             CASE "%"
  229.                 __UI_Click (butPercent)
  230.             CASE "=", CHR$(13) '                                        treat ENTER and = the same
  231.                 __UI_Click (butEqual)
  232.             CASE CHR$(8) '                                              backspace key pressed
  233.                 __UI_Click (butBS)
  234.  
  235.             CASE "c", "C" '                                             CTRL-C copy
  236.                 ctrl = _KEYDOWN(100305) OR _KEYDOWN(100306)
  237.                 IF ctrl THEN BEEP
  238.  
  239.                 ' Will need to investigate how to capture CTRL-C and CTRL-V
  240.                 ' Neither the code above or below works
  241.  
  242.             CASE "v", "V" '                                             CTRL-V paste
  243.                 IF __UI_CtrlIsDown THEN '                               is CTRL key presses?
  244.  
  245.                     BEEP
  246.  
  247.                 END IF
  248.  
  249.         END SELECT
  250.     END IF
  251.  
  252.  
  253. '----------------------------------------------------------------------------------------------------------------------
  254. SUB ADDHISTORY (h$) '                                                                                      ADDHISTORY()
  255.     '------------------------------------------------------------------------------------------------------------------
  256.  
  257.     IF nohistory THEN
  258.         nohistory = False
  259.     ELSE
  260.         history$ = history$ + h$
  261.     END IF
  262.  
  263.  
  264. '----------------------------------------------------------------------------------------------------------------------
  265.  
  266. ': Event procedures: --------------------------------------------------------------------------------------------------
  267.  
  268. SUB __UI_BeforeInit
  269.  
  270.  
  271. SUB __UI_OnLoad
  272.  
  273.     operator$(1) = " + " ' define operator strings
  274.     operator$(2) = " - "
  275.     operator$(3) = " * "
  276.     operator$(4) = " / "
  277.  
  278.  
  279. SUB __UI_BeforeUpdateDisplay
  280.     'This event occurs at approximately 30 frames per second.
  281.     'You can change the update frequency by calling SetFrameRate DesiredRate%
  282.  
  283.     DIM answer$ ' current operand displayed
  284.  
  285.     SCANKEYBOARD '                                                      process keys pressed by user
  286.  
  287.     Caption(lblHistory) = history$ + operator$(operator) '              update history display
  288.  
  289.     answer$ = operand$ '                                                copy operand
  290.     IF answer$ = "" THEN answer$ = "0" '                                set to zero if empty
  291.  
  292.     Caption(lblAnswer) = answer$ '                                      display current operand
  293.  
  294.     IF memory THEN '                                                    does memory have value?
  295.         Caption(lblMemory) = "M" '                                      yes, apply screen indication
  296.     ELSE '                                                              no
  297.         Caption(lblMemory) = "" '                                       remove screen indication
  298.     END IF
  299.  
  300.  
  301. SUB __UI_BeforeUnload
  302.     'If you set __UI_UnloadSignal = False here you can
  303.     'cancel the user's request to close.
  304.  
  305.  
  306. SUB __UI_Click (id AS LONG)
  307.     SELECT CASE id
  308.         CASE Calculator
  309.  
  310.         CASE frmResults
  311.  
  312.         CASE mnuEdit
  313.  
  314.         CASE mnuHelp
  315.  
  316.             ': memory buttons: ----------------------------------------------------------------------------------------
  317.  
  318.         CASE butMC '                                                    memory clear clicked
  319.             memory = 0 '                                                reset memory value
  320.  
  321.         CASE butMR '                                                    memory recall clicked
  322.             IF memory THEN '                                            memory available?
  323.                 operand$ = CLEAN$(memory) '                             Yes, make it the current operand
  324.                 resetoperand = True '                                   trigger an operand reset
  325.             END IF
  326.  
  327.         CASE butMS '                                                    memory store clicked
  328.             memory = VAL(operand$) '                                    overwrite memory with current operand
  329.             resetoperand = True '                                       trigger an operand reset
  330.  
  331.         CASE butMplus '                                                 memory addition clicked
  332.             memory = memory + VAL(operand$) '                           add current operand to memory
  333.             resetoperand = True '                                       trigger an operand reset
  334.  
  335.         CASE butMminus '                                                memory subtraction clicked
  336.             memory = memory - VAL(operand$) '                           subtract current operand from memory
  337.             resetoperand = True '                                       trigger an operand reset
  338.  
  339.             ': clear buttons: -----------------------------------------------------------------------------------------
  340.  
  341.         CASE butCE '                                                    clear entry clicked
  342.             operand$ = "" '                                             reset current operand
  343.  
  344.         CASE butC '                                                     clear clicked
  345.             operand1 = 0 '                                              initialize all values
  346.             operand2 = 0
  347.             operator = 0
  348.             previousoperator = 0
  349.             operand$ = ""
  350.             history$ = ""
  351.  
  352.         CASE butBS '                                                    backspace clicked
  353.             IF LEN(operand$) THEN '                                     characters in operand?
  354.                 operand$ = LEFT$(operand$, LEN(operand$) - 1) '         yes, remove right-most character
  355.             END IF
  356.  
  357.             ': calculation buttons: -----------------------------------------------------------------------------------
  358.  
  359.         CASE butReciprocate '                                           reciprocate clicked
  360.             IF VAL(operand$) THEN '                                     dividing by zero?
  361.  
  362.                 ADDHISTORY (operator$(previousoperator) + "Reciproc(" + operand$ + ")")
  363.                 nohistory = True '                                      skip operand history next time
  364.                 operator = EQUATE
  365.  
  366.                 operand$ = CLEAN$(1 / VAL(operand$)) '                  no, calculate reciprocate
  367.             ELSE '                                                      yes, physics will collapse!
  368.                 ALERT '                                                 get user's attention
  369.                 operand$ = "Can't divide by zero!" '                    report error to user
  370.             END IF
  371.             resetoperand = True '                                       trigger an operand reset
  372.  
  373.         CASE butSQR '                                                   square root clicked
  374.             IF VAL(operand$) >= 0 THEN '                                positive value?
  375.  
  376.                 ADDHISTORY (operator$(previousoperator) + "SQRT(" + operand$ + ")")
  377.                 nohistory = True '                                      skip operand history next time
  378.                 operator = EQUATE
  379.  
  380.                 operand$ = CLEAN$(SQR(VAL(operand$))) '                 yes, calculate square root
  381.             ELSE '                                                      no, value is negative
  382.                 ALERT '                                                 get user's attention
  383.                 operand$ = "Invalid input!" '                           nice try buddy
  384.             END IF
  385.             resetoperand = True '                                       trigger an operand reset
  386.  
  387.         CASE butPercent '                                               percent clicked
  388.             operand$ = CLEAN$(operand1 * VAL(operand$) / 100) '         calculate percentage of previous operand
  389.             resetoperand = True
  390.  
  391.         CASE butSign '                                                  sign clicked
  392.             IF VAL(operand$) THEN '                                     value equal to zero?
  393.                 operand$ = CLEAN$(-VAL(operand$)) '                     no, reverse sign of operand
  394.             END IF
  395.  
  396.             ': number buttons: ----------------------------------------------------------------------------------------
  397.  
  398.         CASE but0 '                                                     zero clicked
  399.             IF VAL(operand$) OR INSTR(operand$, ".") THEN '             ok to add a zero?
  400.                 UPDATEOPERAND ("0") '                                   yes, append zero
  401.             END IF
  402.  
  403.         CASE but1 '                                                     one clicked
  404.             UPDATEOPERAND ("1") '                                       append one
  405.  
  406.         CASE but2 '                                                     etc..
  407.             UPDATEOPERAND ("2") '                                       etc..
  408.  
  409.         CASE but3
  410.             UPDATEOPERAND ("3")
  411.  
  412.         CASE but4
  413.             UPDATEOPERAND ("4")
  414.  
  415.         CASE but5
  416.             UPDATEOPERAND ("5")
  417.  
  418.         CASE but6
  419.             UPDATEOPERAND ("6")
  420.  
  421.         CASE but7
  422.             UPDATEOPERAND ("7")
  423.  
  424.         CASE but8
  425.             UPDATEOPERAND ("8")
  426.  
  427.         CASE but9
  428.             UPDATEOPERAND ("9")
  429.  
  430.         CASE butPoint
  431.             UPDATEOPERAND (".")
  432.  
  433.             ': operator buttons: --------------------------------------------------------------------------------------
  434.  
  435.         CASE butDivide '                                                divide clicked
  436.  
  437.             ADDHISTORY (operator$(previousoperator) + operand$)
  438.  
  439.             operator = DIVISION '                                       remember operator selected
  440.             COMMITOPERAND '                                             save operand
  441.  
  442.         CASE butMultiply '                                              multiply clicked
  443.  
  444.             ADDHISTORY (operator$(previousoperator) + operand$)
  445.  
  446.             operator = MULTIPLICATION '                                 remember operator selected
  447.             COMMITOPERAND '                                             save operand
  448.  
  449.         CASE butSubtract '                                              subtract clicked
  450.  
  451.             ADDHISTORY (operator$(previousoperator) + operand$)
  452.  
  453.             operator = SUBTRACTION '                                    remember operator selected
  454.             COMMITOPERAND '                                             save operand
  455.  
  456.         CASE butAdd '                                                   addition clicked
  457.  
  458.             ADDHISTORY (operator$(previousoperator) + operand$)
  459.  
  460.             operator = ADDITION '                                       remember operator selected
  461.             COMMITOPERAND '                                             save operand
  462.  
  463.         CASE butEqual '                                                 equal clicked
  464.  
  465.             history$ = ""
  466.             operator = EQUATE '                                         remember operator selected
  467.             COMMITOPERAND '                                             save operand
  468.             previousoperator = 0
  469.  
  470.  
  471.         CASE mnuCopy
  472.  
  473.         CASE mnuPaste
  474.  
  475.         CASE mnuAbout
  476.             operand$ = "InForm Calculator 1.0"
  477.             resetoperand = True
  478.  
  479.         CASE lblAnswer
  480.  
  481.         CASE lblMemory
  482.  
  483.         CASE lblHistory
  484.  
  485.     END SELECT
  486.  
  487. SUB __UI_MouseEnter (id AS LONG)
  488.     SELECT CASE id
  489.         CASE Calculator
  490.  
  491.         CASE frmResults
  492.  
  493.         CASE mnuEdit
  494.  
  495.         CASE mnuHelp
  496.  
  497.         CASE butMC
  498.  
  499.         CASE butMR
  500.  
  501.         CASE butMS
  502.  
  503.         CASE butMplus
  504.  
  505.         CASE butMminus
  506.  
  507.         CASE butBS
  508.  
  509.         CASE butCE
  510.  
  511.         CASE butC
  512.  
  513.         CASE butSign
  514.  
  515.         CASE butSQR
  516.  
  517.         CASE but7
  518.  
  519.         CASE but8
  520.  
  521.         CASE but9
  522.  
  523.         CASE butDivide
  524.  
  525.         CASE butPercent
  526.  
  527.         CASE but4
  528.  
  529.         CASE but5
  530.  
  531.         CASE but6
  532.  
  533.         CASE butMultiply
  534.  
  535.         CASE butReciprocate
  536.  
  537.         CASE but1
  538.  
  539.         CASE but2
  540.  
  541.         CASE but3
  542.  
  543.         CASE butSubtract
  544.  
  545.         CASE but0
  546.  
  547.         CASE butPoint
  548.  
  549.         CASE butAdd
  550.  
  551.         CASE butEqual
  552.  
  553.         CASE mnuCopy
  554.  
  555.         CASE mnuPaste
  556.  
  557.         CASE mnuAbout
  558.  
  559.         CASE lblAnswer
  560.  
  561.         CASE lblMemory
  562.  
  563.         CASE lblHistory
  564.  
  565.     END SELECT
  566.  
  567. SUB __UI_MouseLeave (id AS LONG)
  568.     SELECT CASE id
  569.         CASE Calculator
  570.  
  571.         CASE frmResults
  572.  
  573.         CASE mnuEdit
  574.  
  575.         CASE mnuHelp
  576.  
  577.         CASE butMC
  578.  
  579.         CASE butMR
  580.  
  581.         CASE butMS
  582.  
  583.         CASE butMplus
  584.  
  585.         CASE butMminus
  586.  
  587.         CASE butBS
  588.  
  589.         CASE butCE
  590.  
  591.         CASE butC
  592.  
  593.         CASE butSign
  594.  
  595.         CASE butSQR
  596.  
  597.         CASE but7
  598.  
  599.         CASE but8
  600.  
  601.         CASE but9
  602.  
  603.         CASE butDivide
  604.  
  605.         CASE butPercent
  606.  
  607.         CASE but4
  608.  
  609.         CASE but5
  610.  
  611.         CASE but6
  612.  
  613.         CASE butMultiply
  614.  
  615.         CASE butReciprocate
  616.  
  617.         CASE but1
  618.  
  619.         CASE but2
  620.  
  621.         CASE but3
  622.  
  623.         CASE butSubtract
  624.  
  625.         CASE but0
  626.  
  627.         CASE butPoint
  628.  
  629.         CASE butAdd
  630.  
  631.         CASE butEqual
  632.  
  633.         CASE mnuCopy
  634.  
  635.         CASE mnuPaste
  636.  
  637.         CASE mnuAbout
  638.  
  639.         CASE lblAnswer
  640.  
  641.         CASE lblMemory
  642.  
  643.         CASE lblHistory
  644.  
  645.     END SELECT
  646.  
  647. SUB __UI_FocusIn (id AS LONG)
  648.     SELECT CASE id
  649.         CASE butMC
  650.  
  651.         CASE butMR
  652.  
  653.         CASE butMS
  654.  
  655.         CASE butMplus
  656.  
  657.         CASE butMminus
  658.  
  659.         CASE butBS
  660.  
  661.         CASE butCE
  662.  
  663.         CASE butC
  664.  
  665.         CASE butSign
  666.  
  667.         CASE butSQR
  668.  
  669.         CASE but7
  670.  
  671.         CASE but8
  672.  
  673.         CASE but9
  674.  
  675.         CASE butDivide
  676.  
  677.         CASE butPercent
  678.  
  679.         CASE but4
  680.  
  681.         CASE but5
  682.  
  683.         CASE but6
  684.  
  685.         CASE butMultiply
  686.  
  687.         CASE butReciprocate
  688.  
  689.         CASE but1
  690.  
  691.         CASE but2
  692.  
  693.         CASE but3
  694.  
  695.         CASE butSubtract
  696.  
  697.         CASE but0
  698.  
  699.         CASE butPoint
  700.  
  701.         CASE butAdd
  702.  
  703.         CASE butEqual
  704.  
  705.     END SELECT
  706.  
  707. SUB __UI_FocusOut (id AS LONG)
  708.     'This event occurs right before a control loses focus.
  709.     'To prevent a control from losing focus, set __UI_KeepFocus = True below.
  710.     SELECT CASE id
  711.         CASE butMC
  712.  
  713.         CASE butMR
  714.  
  715.         CASE butMS
  716.  
  717.         CASE butMplus
  718.  
  719.         CASE butMminus
  720.  
  721.         CASE butBS
  722.  
  723.         CASE butCE
  724.  
  725.         CASE butC
  726.  
  727.         CASE butSign
  728.  
  729.         CASE butSQR
  730.  
  731.         CASE but7
  732.  
  733.         CASE but8
  734.  
  735.         CASE but9
  736.  
  737.         CASE butDivide
  738.  
  739.         CASE butPercent
  740.  
  741.         CASE but4
  742.  
  743.         CASE but5
  744.  
  745.         CASE but6
  746.  
  747.         CASE butMultiply
  748.  
  749.         CASE butReciprocate
  750.  
  751.         CASE but1
  752.  
  753.         CASE but2
  754.  
  755.         CASE but3
  756.  
  757.         CASE butSubtract
  758.  
  759.         CASE but0
  760.  
  761.         CASE butPoint
  762.  
  763.         CASE butAdd
  764.  
  765.         CASE butEqual
  766.  
  767.     END SELECT
  768.  
  769. SUB __UI_MouseDown (id AS LONG)
  770.     SELECT CASE id
  771.         CASE Calculator
  772.  
  773.         CASE frmResults
  774.  
  775.         CASE mnuEdit
  776.  
  777.         CASE mnuHelp
  778.  
  779.         CASE butMC
  780.  
  781.         CASE butMR
  782.  
  783.         CASE butMS
  784.  
  785.         CASE butMplus
  786.  
  787.         CASE butMminus
  788.  
  789.         CASE butBS
  790.  
  791.         CASE butCE
  792.  
  793.         CASE butC
  794.  
  795.         CASE butSign
  796.  
  797.         CASE butSQR
  798.  
  799.         CASE but7
  800.  
  801.         CASE but8
  802.  
  803.         CASE but9
  804.  
  805.         CASE butDivide
  806.  
  807.         CASE butPercent
  808.  
  809.         CASE but4
  810.  
  811.         CASE but5
  812.  
  813.         CASE but6
  814.  
  815.         CASE butMultiply
  816.  
  817.         CASE butReciprocate
  818.  
  819.         CASE but1
  820.  
  821.         CASE but2
  822.  
  823.         CASE but3
  824.  
  825.         CASE butSubtract
  826.  
  827.         CASE but0
  828.  
  829.         CASE butPoint
  830.  
  831.         CASE butAdd
  832.  
  833.         CASE butEqual
  834.  
  835.         CASE mnuCopy
  836.  
  837.         CASE mnuPaste
  838.  
  839.         CASE mnuAbout
  840.  
  841.         CASE lblAnswer
  842.  
  843.         CASE lblMemory
  844.  
  845.         CASE lblHistory
  846.  
  847.     END SELECT
  848.  
  849. SUB __UI_MouseUp (id AS LONG)
  850.     SELECT CASE id
  851.         CASE Calculator
  852.  
  853.         CASE frmResults
  854.  
  855.         CASE mnuEdit
  856.  
  857.         CASE mnuHelp
  858.  
  859.         CASE butMC
  860.  
  861.         CASE butMR
  862.  
  863.         CASE butMS
  864.  
  865.         CASE butMplus
  866.  
  867.         CASE butMminus
  868.  
  869.         CASE butBS
  870.  
  871.         CASE butCE
  872.  
  873.         CASE butC
  874.  
  875.         CASE butSign
  876.  
  877.         CASE butSQR
  878.  
  879.         CASE but7
  880.  
  881.         CASE but8
  882.  
  883.         CASE but9
  884.  
  885.         CASE butDivide
  886.  
  887.         CASE butPercent
  888.  
  889.         CASE but4
  890.  
  891.         CASE but5
  892.  
  893.         CASE but6
  894.  
  895.         CASE butMultiply
  896.  
  897.         CASE butReciprocate
  898.  
  899.         CASE but1
  900.  
  901.         CASE but2
  902.  
  903.         CASE but3
  904.  
  905.         CASE butSubtract
  906.  
  907.         CASE but0
  908.  
  909.         CASE butPoint
  910.  
  911.         CASE butAdd
  912.  
  913.         CASE butEqual
  914.  
  915.         CASE mnuCopy
  916.  
  917.         CASE mnuPaste
  918.  
  919.         CASE mnuAbout
  920.  
  921.         CASE lblAnswer
  922.  
  923.         CASE lblMemory
  924.  
  925.         CASE lblHistory
  926.  
  927.     END SELECT
  928.  
  929. SUB __UI_KeyPress (id AS LONG)
  930.     'When this event is fired, __UI_KeyHit will contain the code of the key hit.
  931.     'You can change it and even cancel it by making it = 0
  932.  
  933.     SELECT CASE id
  934.         CASE butMC
  935.  
  936.         CASE butMR
  937.  
  938.         CASE butMS
  939.  
  940.         CASE butMplus
  941.  
  942.         CASE butMminus
  943.  
  944.         CASE butBS
  945.  
  946.         CASE butCE
  947.  
  948.         CASE butC
  949.  
  950.         CASE butSign
  951.  
  952.         CASE butSQR
  953.  
  954.         CASE but7
  955.  
  956.         CASE but8
  957.  
  958.         CASE but9
  959.  
  960.         CASE butDivide
  961.  
  962.         CASE butPercent
  963.  
  964.         CASE but4
  965.  
  966.         CASE but5
  967.  
  968.         CASE but6
  969.  
  970.         CASE butMultiply
  971.  
  972.         CASE butReciprocate
  973.  
  974.         CASE but1
  975.  
  976.         CASE but2
  977.  
  978.         CASE but3
  979.  
  980.         CASE butSubtract
  981.  
  982.         CASE but0
  983.  
  984.         CASE butPoint
  985.  
  986.         CASE butAdd
  987.  
  988.         CASE butEqual
  989.  
  990.     END SELECT
  991.  
  992. SUB __UI_TextChanged (id AS LONG)
  993.     SELECT CASE id
  994.     END SELECT
  995.  
  996. SUB __UI_ValueChanged (id AS LONG)
  997.     SELECT CASE id
  998.     END SELECT
  999.  
  1000. SUB __UI_FormResized
  1001.  
  1002.  

 
« Last Edit: March 27, 2020, 05:53:33 AM by Qwerkey »