UIQ3/net.sourceforge.uiq3.fx603p/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

a_b_c

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)

ALPHA

val ALPHA: Short = 52

Alpha_Text

val Alpha_Text: Array<String>

Base_N_Text

val Base_N_Text: Array<String>

BST

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

Button_Mode_IO

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

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⁻¹
Base-N: 𝔼
ALPHA: U

degree

val degree: Short = 35

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

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

Equal

val Equal: Short = 18

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

EXE

val EXE: Short = 19

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

EXP

val EXP: Short = 17

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

FST

val FST: Short = 31

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

GOTO

val GOTO: Short = 28

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

GSB

val GSB: Short = 29

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

HLT

val HLT: Short = 26

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

hyp

val hyp: Short = 40

Normal: hyp
Base-N: ℂ
ALPHA: S

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)
2ndF: PRD (Print)
ALPHA: H

val ln: Short = 37

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

log

val log: Short = 36

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

logger

private val logger: Logger

class logger instance

M_Minus

val M_Minus: Short = 48

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

M_Plus

val M_Plus: Short = 49

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

Min

val Min: Short = 46

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

Minus

val Minus: Short = 15

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

MODE

val MODE: Short = 53

Normal: MODE

Mode_Text

val Mode_Text: Array<String>

val MR: Short = 47

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

Multiply

val Multiply: Short = 12

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

No_Text

private 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

P1_

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

P_Close

val P_Close: Short = 39

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

P_Open

val P_Open: Short = 38

Normal

(

INF

INT (integer)

Base-N

𝔸

ALPHA

Plus

val Plus: Short = 14

Normal

INF

R→P (rectangular to polar)

ALPHA

INF ALPHA

→

Plus_Minus

val Plus_Minus: Short = 32

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

SecondF

val SecondF: Short = 51

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

SecondF_Text

val SecondF_Text: Array<String>

SHIFT

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>

Shift_Text

val Shift_Text: Array<String>

sin

val sin: Short = 41

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

TAG

private val TAG: String

class logger tag.

tan

val tan: Short = 43

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

X_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

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

Get_Text

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

getClass

fun getClass(): Class<out Any>

hashCode

open fun hashCode(): Int

Is_Char

open fun Is_Char(Key_Code: Short): Boolean

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

Is_Num

open fun Is_Num(Key_Code: Short): Boolean

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

notify

fun notify()

notifyAll

fun notifyAll()

toString

open fun toString(): String

Operation as java string

wait

fun wait()

µReset

fun µReset()

open fun µReset(Owner: Calculator)

reset indirect and token plane