UIQ3/net.sourceforge.uiq3.fx602p/Key_Simple

Key_Simple

A simple key without hyperbol was clicked. A simple key is a key which can be directly mapped to two operations and two alpha characters.

Author

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

Inheritors

Constructors

Key_Simple

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

Create Key and attach to owner calculator.

Properties

val AC: Short = 11

Normal: AC (all clear)

Alpha_Text

val Alpha_Text: Array<String>

BST

val BST: Short = 30

Normal: BST (back step)
INF: MAC (memory clear)
INF ALPHA: ; (alpha append)

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_DEG

val Button_Mode_DEG: String

Button_Mode_GRA

val Button_Mode_GRA: 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

Button_RND_FIX

val Button_RND_FIX: String

val C: Short = 10

Normal: C<(clear)/dd>

cos

val cos: Short = 42

Normal: cos
INF: cos⁻¹
hyp: cosh
INV hyp: cosh⁻¹
ALPHA: S

degree

val degree: Short = 35

Normal: °'"
INF: °'"←
ALPHA: L

Divide

val Divide: Short = 13

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

Dot

val Dot: Short = 16

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

eng

val eng: Short = 34

Normal: eng
INF: eng←
ALPHA: L

Equal

val Equal: Short = 18

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

EXE

val EXE: Short = 19

Normal: EXE (execute)
INF: invEXE (INV execute)
ALPHA: EXE (execute)
INF ALPHA: (space)

EXP

val EXP: Short = 17

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

FST

val FST: Short = 31

Normal: FST (forwards step)
INF: SAC (statistic clear)
INF ALPHA: ar (alpha recall)

GOTO

val GOTO: Short = 28

Normal: GOTO
INF: SAVE
ALPHA: H

GSB

val GSB: Short = 29

Normal: GSB (Go subroutine)
INF: LOAD
ALPHA: I

HLT

val HLT: Short = 26

Normal: HLT (halt)
INF: PAUSE
ALPHA: F

hyp

val hyp: Short = 33

Normal: hyp
ALPHA: J

INV

val INV: Short = 32

Normal: INV (Inverse)
ALPHA: lower caps

Inv_Alpha

protected val Inv_Alpha: Short

Invers Normal_Alpha characters

Inv_Normal

protected val Inv_Normal: Short

Inverse operation

LBL

val LBL: Short = 27

Normal: LBL (label)
INF: IND (indirect)
ALPHA: G

val ln: Short = 37

Normal: ln
INF: eˣ
ALPHA: N

log

val log: Short = 36

Normal: log
INF: 10ˣ
ALPHA: M

Logger

private val Logger: Logger

Class logger instance.

M_Minus

val M_Minus: Short = 48

Normal: M- (memory subtract)
INF: ¹/x
ALPHA: Y

M_Plus

val M_Plus: Short = 49

Normal: M+ (memory add)
INF: X!
ALPHA: Z

Min

val Min: Short = 46

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

Minus

val Minus: Short = 15

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

MODE

val MODE: Short = 25

Normal: MODE
INF: ALPHA

val MR: Short = 47

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

Multiply

val Multiply: Short = 12

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

No_Text

val No_Text: String

Normal

protected val Normal: Short

Normal operations

Normal_Alpha

protected val Normal_Alpha: Short

Normal_Alpha characters

Normal_Text

val Normal_Text: Array<String>

Num_0

val Num_0: Short = 0

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

Num_1

val Num_1: Short = 1

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

Num_2

val Num_2: Short = 2

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

Num_3

val Num_3: Short = 3

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

Num_4

val Num_4: Short = 4

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

Num_5

val Num_5: Short = 5

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

Num_6

val Num_6: Short = 6

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

Num_7

val Num_7: Short = 7

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

Num_8

val Num_8: Short = 8

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

Num_9

val Num_9: Short = 9

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

Owner

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 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

P_Close

val P_Close: Short = 40

Normal: )
INF: FRAC (fracture)
ALPHA: Q

P_Open

val P_Open: Short = 39

Normal

(

INF

INT (integer)

ALPHA

Plus

val Plus: Short = 14

Normal

INF

R→P (rectangular to polar)

ALPHA

INF ALPHA

→

Plus_Minus

val Plus_Minus: Short = 38

Normal: ±
INF: ABS
ALPHA: O

Shift_Alpha_Text

val Shift_Alpha_Text: Array<String>

Shift_Text

val Shift_Text: Array<String>

sin

val sin: Short = 41

Normal: sin⁻¹
INF: sin⁻¹
hyp: sinh
INV hyp: sinh⁻¹
ALPHA: R

TAG

private val TAG: String

Class logger tag.

tan

val tan: Short = 43

Normal: tan
INF: tan⁻¹
hyp: tanh
INV hyp: tanh⁻¹
ALPHA: T

X_M

val X_M: Short = 45

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

val Xd: Short = 44

Normal: Xd
INF: xdel
ALPHA: U

Functions

Clear

open fun Clear(All_Clear: Boolean)

Clean Key - no operation as most keys are not actually state full keys which need cleaning

clone

protected open fun clone(): Any

equals

open fun equals(obj: Any): Boolean

Execute

open fun Execute(Key_Code: Short)

finalize

protected open fun finalize()

getClass

fun getClass(): Class<out Any>

hashCode

open fun hashCode(): Int

notify

fun notify()

notifyAll

fun notifyAll()

toString

open fun toString(): String

wait

fun wait()

µReset

fun µReset()

reset indirect and token plane