UIQ3/net.sourceforge.uiq3.fx603p/Key_M

Key_M

class Key_M : Key_Simple

The Mode key was clicked

Author

"Martin Krischik" «krischik@users.sourceforge.net»

Constructors

constructor(Owner: Calculator, Normal: Short, Text: Short, Inv_Normal: Short, Normal_Alpha: Short, Inv_Alpha: Short)

Types

enum Status_Type

Properties

val a_b_c: Short = 33

Normal: a b/c
INF: d/c
Base-N: AND (binary and)
ALPHA: L

val AC: Short = 11

Normal: AC (all clear)
INF: SAC (statistic clear)
2ndF: MAC (memory clear)

val ALPHA: Short = 52

val Alpha_Text: Array<String>

private val AR_Text: Array<Short>

Text to be displayed when Mode.

Backup_A_Active

private open var Backup_A_Active: AlphaRegisterType

Active A register.

Backup_Display_Mode_Numeric

private open var Backup_Display_Mode_Numeric: DisplayType

Current display mode

Display_Alpha: Displays the content of the Alpha register.
Display_L: Displays the content of the L0 aka X register.
Display_Formated: Displays the content of the L0 aka X register inside an alpha

Backup_Display_Mode_Text

private open var Backup_Display_Mode_Text: DisplayType

Current display mode

Display_Alpha: Displays the content of the Alpha register.
Display_L: Displays the content of the L0 aka X register.
Display_Formated: Displays the content of the L0 aka X register inside an alpha

val Base_N_Text: Array<String>

val Begin_Plane_1: Int = 20

each memory plane contains 20 register.

val Begin_Plane_2: Int = 40

each memory plane contains 20 register.

val Begin_Plane_3: Int = 60

each memory plane contains 20 register.

val Begin_Plane_4: Int = 80

each memory plane contains 20 register.

val BST: Short = 30

Normal: BST (back step)
INF: RSSAVE (Serial save)

Button_Memory_F

val Button_Memory_F: String

Button_Memory_n

val Button_Memory_n: String

Button_Memory_sn

val Button_Memory_sn: String

Button_Memory_sn1

val Button_Memory_sn1: String

Button_Memory_SX

val Button_Memory_SX: String

Button_Memory_SX2

val Button_Memory_SX2: String

Button_Memory_xmean

val Button_Memory_xmean: String

Button_Mode_BaseN

val Button_Mode_BaseN: String

Button_Mode_COMP

val Button_Mode_COMP: String

Button_Mode_DEG

val Button_Mode_DEG: String

Button_Mode_GRA

val Button_Mode_GRA: String

val Button_Mode_IO: String

Button_Mode_PCL

val Button_Mode_PCL: String

Button_Mode_RAD

val Button_Mode_RAD: String

Button_Mode_RUN

val Button_Mode_RUN: String

Button_Mode_WRT

val Button_Mode_WRT: String

val Button_RND_FIX: String

val C: Short = 10

Normal: C<(clear)/dd>

val cos: Short = 42

Normal: cos
INF: cos⁻¹
hyp: cosh
INV hyp: cosh⁻¹
Base-N: 𝔼
ALPHA: U

val degree: Short = 35

Normal: °'"
INF: °'"←
Base-N: XOR (binary exclusive or)
ALPHA: N

val Divide: Short = 13

Normal: ÷
INF: ˣ√y
ALPHA: ÷
INF ALPHA:: /

val Dot: Short = 16

Normal: . (decimal point)
INF: RAN# (random number)
ALPHA: .
INF ALPHA

val eng: Short = 34

Normal: eng
INF: eng←
ALPHA: M

val Equal: Short = 18

Normal: =
INF: %
ALPHA: =
INF ALPHA: # (x recall)

val EXE: Short = 19

Normal: EXE (execute)
INF: SEXE (shift execute)
2ndF: FEXE (2nd function execute)
ALPHA: EXE (execute)
INF ALPHA:: (space)

val EXP: Short = 17

Normal: EXP (exponent)
INF: π
ALPHA: ⅇ
INF ALPHA: π
Memory: F

F_Token_Divider

val F_Token_Divider: Int = 16

f register are not neatly aligned and need some magic to calculate the token

val F_Token_Offset: Int = 5

offset between 0f an 1f operations.

val FST: Short = 31

Normal: FST (forwards step)
INF: RSDLOAD (serial load)
2ndF: SAC (NOP)
INF ALPHA: ar (alpha recall)

val GOTO: Short = 28

Normal: GOTO
INF: SAVE
2ndF: POKE
ALPHA: I

val GSB: Short = 29

Normal: GSB (Go subroutine)
INF: LOAD
2ndF: PEEK
ALPHA: J

val HLT: Short = 26

Normal: HLT (halt)
INF: PAUSE
2ndF: VER
ALPHA: G

val hyp: Short = 40

Normal: hyp
Base-N: ℂ
ALPHA: S

protected val Inv_Alpha: Short

Invers Normal_Alpha characters

protected val Inv_Normal: Short

Inverse operation

val LBL: Short = 27

Normal: LBL (label)
INF: IND (indirect)
2ndF: PRD (Print)
ALPHA: H

val ln: Short = 37

Normal: ln
INF: eˣ
Base-N: HEX
INF Base-N: OCT
ALPHA: P

val log: Short = 36

Normal: log
INF: 10ˣ
Base-N: DEC
INF Base-N: BIN
ALPHA: O

private val logger: Logger

private val logger: Logger

class logger instance

val M_Minus: Short = 48

Normal: M- (memory subtract)
INF: ¹/x
ALPHA: ; (alpha append)

val M_Plus: Short = 49

Normal: M+ (memory add)
INF: X!
ALPHA: ar (alpha recal)

val M_Token_Offset: Int = 80

offset between even and odd even memory operations.

val Memory_Digit_1: Int = 2

first digit to display while entering the key

val Memory_Digit_2: Int = 3

second digit to display while entering the key

Memory_Register

private open var Memory_Register: Int

current dot value

private val Memory_Text: Array<Short>

Text to be displayed when Mode.

val Min: Short = 46

Normal: Min (memory in)
INF: √
ALPHA: Y

val Minus: Short = 15

Normal: − (substract)
INF: P→R (polar to rectangle)
ALPHA: -
INF ALPHA: ←

val MODE: Short = 53

Normal: MODE

val Mode_Text: Array<String>

val MR: Short = 47

Normal: MR (memory recall)
INF: x²
ALPHA: Z

val Multiply: Short = 12

Normal: ×
INF: xʸ
ALPHA: ×
INF ALPHA: *

private val No_Text: String

protected val Normal: Short

Normal operations

protected val Normal_Alpha: Short

Normal_Alpha characters

val Normal_Text: Array<String>

val Num_0: Short = 0

Normal: 0
INF: RND
ALPHA: 0
INF ALPHA: :

val Num_1: Short = 1

Normal: 1
INF: DSZ (decrement and skip zero)
ALPHA: 1
INF ALPHA: █

val Num_2: Short = 2

Normal: 2
INF: x=0 (x equals 0)
ALPHA: 2
INF ALPHA: ?

val Num_3: Short = 3

Normal: 3
INF: x=F
ALPHA: 3
INF ALPHA: !

val Num_4: Short = 4

Normal: 4
INF: ISZ (increment and skip on zero)
ALPHA: 4
INF ALPHA: µ

val Num_5: Short = 5

Normal: 5
INF: x≥0
ALPHA: 5
INF ALPHA: <

val Num_6: Short = 6

Normal: 6
INF: x≥F
ALPHA: 6
INF ALPHA: >

val Num_7: Short = 7

Normal: 7
INF: x (mean)
ALPHA: 7
INF ALPHA

val Num_8: Short = 8

Normal: 8
INF: σn
ALPHA: 8
INF ALPHA: (

val Num_9: Short = 9

Normal: 9
INF: σn-1
ALPHA: 9
INF ALPHA: )

protected val Owner: Calculator

Owner instance of this Operation

val P0: Short = 20

Normal: P0 (program 0)
INF: P5 (program 5)
ALPHA: A

val P1: Short = 21

Normal: P1 (program 1)
INF: P6 (program 6)
ALPHA: B

val P1_: Short = 25

Normal: P_ (Programm 10 … 19)
ALPHA: F

val P2: Short = 22

Normal: P2 (program 2)
INF: P7 (program 7)
ALPHA: D

val P3: Short = 23

Normal: P3 (program 3)
INF: P8 (program 8)
ALPHA: E

val P4: Short = 24

Normal: P4 (program 4)
INF: P9 (program 9)
ALPHA: F

val P_Close: Short = 39

Normal: )
INF: FRAC (fracture)
Base-N: 𝔹
ALPHA: R

val P_Open: Short = 38

Normal

(

INF

INT (integer)

Base-N

𝔸

ALPHA

Q

val Plus: Short = 14

Normal

+

INF

R→P (rectangular to polar)

ALPHA

+

INF ALPHA

→

val Plus_Minus: Short = 32

Normal: ±
INF: ABS
Base-N: NEG (arithmetic negative)
ALPHA: K

val SecondF: Short = 51

Normal: 2ndF (secound function)
ALPHA: caps lock

val SecondF_Text: Array<String>

val SHIFT: Short = 50

Normal: SHIFT (shift function)
ALPHA: upper caps

Shift_Alpha_Text

val Shift_Alpha_Text: Array<String>

Shift_Base_N_Text

val Shift_Base_N_Text: Array<String>

val Shift_Text: Array<String>

val sin: Short = 41

Normal: sin⁻¹
INF: sin⁻¹
hyp: sinh
INV hyp: sinh⁻¹
Base-N: ⅅ
ALPHA: T

private open var Status: Key_M.Status_Type

We start with status none.

private val TAG: String

private val TAG: String

class logger tag.

val tan: Short = 43

Normal: tan
INF: tan⁻¹
hyp: tanh
INV hyp: tanh⁻¹
Base-N: 𝔽
ALPHA: V

private val Text: Short

The character which make the difference between Min, MR, M+ M-

val X_M: Short = 45

Normal: X↔︎M
INF: X↔︎Y
ALPHA: X

val Xd: Short = 44

Normal: Xd
INF: xdel
Base-N: NOT (binary negative)
ALPHA: W

Functions

open fun Clear(All_Clear: Boolean)

Clean Key state.

protected open fun clone(): Any

open fun equals(obj: Any): Boolean

open fun Execute(Key_Code: Short)

Execute_Digit_1

private open fun Execute_Digit_1(Key_Code: Short)

Execute_Digit_2

private open fun Execute_Digit_2(Key_Code: Short)

private open fun Execute_None()

protected open fun finalize()

open fun Get_Text(Key_Code: Short, Shift: Boolean, SecondF: Boolean, Alpha: Boolean, Caps: Boolean, nBase: Boolean, Mode: Boolean): String

fun getClass(): Class<out Any>

open fun hashCode(): Int

open fun Is_Char(Key_Code: Short): Boolean

Test if a keyboard token is a character token suitable for the CAPS operation.

open fun Is_Num(Key_Code: Short): Boolean

Test if a keyboard token is a numeric token (0 ..

fun notify()

fun notifyAll()

Store_Operation

private open fun Store_Operation(F_Register: Boolean)

open fun toString(): String

open fun toString(): String

Operation as java string

fun wait()

open fun µReset(Owner: Calculator)

reset indirect and token plane