Myzel394/NumberHub
1
0
Fork 0
mirror of https://github.com/Myzel394/NumberHub.git synced 2025-06-19 08:45:27 +02:00
Code Issues Packages Projects Releases Wiki Activity

Introduce Token object

Browse Source
This commit is contained in:
Sad Ellie 2023-02-27 01:23:55 +04:00
parent 878d96c386
commit 61aff9c3ae
12 changed files with 322 additions and 458 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
core/base/src/main/java/com/sadellie/unitto/core/base/KeypadSymbols.kt
View File

@ -1,101 +0,0 @@
/*
* Unitto is a unit converter for Android
* Copyright (c) 2022-2023 Elshan Agaev
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.sadellie.unitto.core.base
const val KEY_1 = "1"
const val KEY_2 = "2"
const val KEY_3 = "3"
const val KEY_4 = "4"
const val KEY_5 = "5"
const val KEY_6 = "6"
const val KEY_7 = "7"
const val KEY_8 = "8"
const val KEY_9 = "9"
const val KEY_0 = "0"
const val KEY_BASE_A = "A"
const val KEY_BASE_B = "B"
const val KEY_BASE_C = "C"
const val KEY_BASE_D = "D"
const val KEY_BASE_E = "E"
const val KEY_BASE_F = "F"
const val KEY_DOT = "."
const val KEY_COMMA = ","
const val KEY_E = "E"
const val KEY_PLUS = "+"
const val KEY_MINUS = "-"
const val KEY_MINUS_DISPLAY = "–"
const val KEY_DIVIDE = "/"
const val KEY_DIVIDE_DISPLAY = "÷"
const val KEY_MULTIPLY = "*"
const val KEY_MULTIPLY_DISPLAY = "×"
const val KEY_LEFT_BRACKET = "("
const val KEY_RIGHT_BRACKET = ")"
const val KEY_EXPONENT = "^"
const val KEY_SQRT = "√"
const val KEY_PI = "π"
const val KEY_FACTORIAL = "!"
const val KEY_SIN = "sin("
const val KEY_COS = "cos("
const val KEY_TAN = "tan("
const val KEY_E_SMALL = "e"
const val KEY_MODULO = "#"
const val KEY_LN = "ln("
const val KEY_LOG = "log("
const val KEY_PERCENT = "%"
val OPERATORS by lazy {
listOf(
KEY_PLUS,
KEY_MINUS,
KEY_MINUS_DISPLAY,
KEY_MULTIPLY,
KEY_MULTIPLY_DISPLAY,
KEY_DIVIDE,
KEY_DIVIDE_DISPLAY,
KEY_SQRT,
KEY_EXPONENT,
)
}
val DIGITS by lazy {
listOf(
KEY_1,
KEY_2,
KEY_3,
KEY_4,
KEY_5,
KEY_6,
KEY_7,
KEY_8,
KEY_9,
KEY_0,
)
}
val INTERNAL_DISPLAY: Map<String, String> = hashMapOf(
KEY_MINUS to KEY_MINUS_DISPLAY,
KEY_MULTIPLY to KEY_MULTIPLY_DISPLAY,
KEY_DIVIDE to KEY_DIVIDE_DISPLAY
)

117
core/base/src/main/java/com/sadellie/unitto/core/base/Token.kt Normal file
View File

@ -0,0 +1,117 @@
/*
* Unitto is a unit converter for Android
* Copyright (c) 2022-2023 Elshan Agaev
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.sadellie.unitto.core.base
object Token {
const val _1 = "1"
const val _2 = "2"
const val _3 = "3"
const val _4 = "4"
const val _5 = "5"
const val _6 = "6"
const val _7 = "7"
const val _8 = "8"
const val _9 = "9"
const val _0 = "0"
const val baseA = "A"
const val baseB = "B"
const val baseC = "C"
const val baseD = "D"
const val baseE = "E"
const val baseF = "F"
const val dot = "."
const val comma = ","
const val E = "E"
const val plus = "+"
const val minus = "-"
const val minusDisplay = "–"
const val divide = "/"
const val divideDisplay = "÷"
const val multiply = "*"
const val multiplyDisplay = "×"
const val leftBracket = "("
const val rightBracket = ")"
const val exponent = "^"
const val sqrt = "√"
const val pi = "π"
const val factorial = "!"
const val sin = "sin("
const val cos = "cos("
const val tan = "tan("
const val e = "e"
const val modulo = "#"
const val ln = "ln("
const val log = "log("
const val percent = "%"
val operators by lazy {
listOf(
plus,
minus,
minusDisplay,
multiply,
multiplyDisplay,
divide,
divideDisplay,
sqrt,
exponent,
)
}
val digits by lazy {
listOf(
_1,
_2,
_3,
_4,
_5,
_6,
_7,
_8,
_9,
_0,
)
}
val internalToDisplay: Map<String, String> = hashMapOf(
minus to minusDisplay,
multiply to multiplyDisplay,
divide to divideDisplay
)
val knownSymbols: List<String> by lazy {
listOf(
sin, cos, tan, ln, log,
leftBracket, rightBracket,
exponent, sqrt, factorial,
modulo, e, percent, pi,
multiply, multiplyDisplay,
plus, minus, minusDisplay, divide, divideDisplay,
baseA, baseB, baseC, baseD, baseE, baseF,
_1, _2, _3, _4, _5, _6, _7, _8, _9, _0,
dot
)
}
}

29
core/ui/src/main/java/com/sadellie/unitto/core/ui/Formatter.kt
View File

@ -20,12 +20,7 @@ package com.sadellie.unitto.core.ui
import androidx.compose.runtime.Composable
import androidx.compose.ui.res.stringResource
import com.sadellie.unitto.core.base.INTERNAL_DISPLAY
import com.sadellie.unitto.core.base.KEY_0
import com.sadellie.unitto.core.base.KEY_COMMA
import com.sadellie.unitto.core.base.KEY_DOT
import com.sadellie.unitto.core.base.KEY_E
import com.sadellie.unitto.core.base.KEY_MINUS
import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.core.base.Separator
import java.math.BigDecimal
import java.math.RoundingMode
@ -51,7 +46,7 @@ open class UnittoFormatter {
/**
* Fractional part separator.
*/
var fractional = KEY_COMMA
var fractional = Token.comma
private val timeDivisions by lazy {
mapOf(
@ -77,7 +72,7 @@ open class UnittoFormatter {
Separator.COMMA -> COMMA
else -> SPACE
}
fractional = if (separator == Separator.PERIOD) KEY_COMMA else KEY_DOT
fractional = if (separator == Separator.PERIOD) Token.comma else Token.dot
}
/**
@ -92,7 +87,7 @@ open class UnittoFormatter {
*/
fun format(input: String): String {
// Don't do anything to engineering string.
if (input.contains(KEY_E)) return input.replace(KEY_DOT, fractional)
if (input.contains(Token.E)) return input.replace(Token.dot, fractional)
var output = input
@ -103,7 +98,7 @@ open class UnittoFormatter {
output = output.replace(it, formatNumber(it))
}
INTERNAL_DISPLAY.forEach {
Token.internalToDisplay.forEach {
output = output.replace(it.key, it.value)
}
@ -134,7 +129,7 @@ open class UnittoFormatter {
Separator.COMMA -> COMMA
else -> SPACE
}
val sFractional = if (separator == Separator.PERIOD) KEY_COMMA else KEY_DOT
val sFractional = if (separator == Separator.PERIOD) Token.comma else Token.dot
return input
.replace(sGrouping, grouping)
@ -144,7 +139,7 @@ open class UnittoFormatter {
fun removeFormat(input: String): String {
return input
.replace(grouping, "")
.replace(fractional, KEY_DOT)
.replace(fractional, Token.dot)
}
/**
@ -182,25 +177,25 @@ open class UnittoFormatter {
*/
@Composable
fun formatTime(input: String, basicUnit: BigDecimal?): String {
if (basicUnit == null) return KEY_0
if (basicUnit == null) return Token._0
try {
// Don't need magic if the input is zero
if (BigDecimal(input).compareTo(BigDecimal.ZERO) == 0) return KEY_0
if (BigDecimal(input).compareTo(BigDecimal.ZERO) == 0) return Token._0
} catch (e: NumberFormatException) {
// For case such as "10-" and "("
return KEY_0
return Token._0
}
// Attoseconds don't need "magic"
if (basicUnit.compareTo(BigDecimal.ONE) == 0) return formatNumber(input)
var result = if (input.startsWith(KEY_MINUS)) KEY_MINUS else ""
var result = if (input.startsWith(Token.minus)) Token.minus else ""
var remainingSeconds = BigDecimal(input)
.abs()
.multiply(basicUnit)
.setScale(0, RoundingMode.HALF_EVEN)
if (remainingSeconds.compareTo(BigDecimal.ZERO) == 0) return KEY_0
if (remainingSeconds.compareTo(BigDecimal.ZERO) == 0) return Token._0
timeDivisions.forEach { (timeStr, divider) ->
val division = remainingSeconds.divideAndRemainder(divider)

15
feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/CalculatorViewModel.kt
View File

@ -20,10 +20,7 @@ package com.sadellie.unitto.feature.calculator
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
import com.sadellie.unitto.core.base.KEY_MINUS
import com.sadellie.unitto.core.base.KEY_MINUS_DISPLAY
import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.data.calculator.CalculatorHistoryRepository
import com.sadellie.unitto.data.common.setMinimumRequiredScale
import com.sadellie.unitto.data.common.toStringWith
@ -44,8 +41,8 @@ import kotlinx.coroutines.launch
import org.mariuszgromada.math.mxparser.Expression
import java.math.BigDecimal
import javax.inject.Inject
import org.mariuszgromada.math.mxparser.mXparser as MathParser
import org.mariuszgromada.math.mxparser.License as MathParserLicense
import org.mariuszgromada.math.mxparser.mXparser as MathParser
@HiltViewModel
internal class CalculatorViewModel @Inject constructor(
@ -169,11 +166,11 @@ internal class CalculatorViewModel @Inject constructor(
*/
private val String.clean: String
get() {
val leftBrackets = count { it.toString() == KEY_LEFT_BRACKET }
val rightBrackets = count { it.toString() == KEY_RIGHT_BRACKET }
val leftBrackets = count { it.toString() == Token.leftBracket }
val rightBrackets = count { it.toString() == Token.rightBracket }
val neededBrackets = leftBrackets - rightBrackets
return replace(KEY_MINUS_DISPLAY, KEY_MINUS)
.plus(KEY_RIGHT_BRACKET.repeat(neededBrackets.coerceAtLeast(0)))
return replace(Token.minusDisplay, Token.minus)
.plus(Token.rightBracket.repeat(neededBrackets.coerceAtLeast(0)))
}
init {

71
feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/TextFieldController.kt
View File

@ -20,44 +20,7 @@ package com.sadellie.unitto.feature.calculator
import androidx.compose.ui.text.TextRange
import androidx.compose.ui.text.input.TextFieldValue
import com.sadellie.unitto.core.base.KEY_0
import com.sadellie.unitto.core.base.KEY_1
import com.sadellie.unitto.core.base.KEY_2
import com.sadellie.unitto.core.base.KEY_3
import com.sadellie.unitto.core.base.KEY_4
import com.sadellie.unitto.core.base.KEY_5
import com.sadellie.unitto.core.base.KEY_6
import com.sadellie.unitto.core.base.KEY_7
import com.sadellie.unitto.core.base.KEY_8
import com.sadellie.unitto.core.base.KEY_9
import com.sadellie.unitto.core.base.KEY_BASE_A
import com.sadellie.unitto.core.base.KEY_BASE_B
import com.sadellie.unitto.core.base.KEY_BASE_C
import com.sadellie.unitto.core.base.KEY_BASE_D
import com.sadellie.unitto.core.base.KEY_BASE_E
import com.sadellie.unitto.core.base.KEY_BASE_F
import com.sadellie.unitto.core.base.KEY_COS
import com.sadellie.unitto.core.base.KEY_DIVIDE
import com.sadellie.unitto.core.base.KEY_DIVIDE_DISPLAY
import com.sadellie.unitto.core.base.KEY_DOT
import com.sadellie.unitto.core.base.KEY_EXPONENT
import com.sadellie.unitto.core.base.KEY_E_SMALL
import com.sadellie.unitto.core.base.KEY_FACTORIAL
import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
import com.sadellie.unitto.core.base.KEY_LN
import com.sadellie.unitto.core.base.KEY_LOG
import com.sadellie.unitto.core.base.KEY_MINUS
import com.sadellie.unitto.core.base.KEY_MINUS_DISPLAY
import com.sadellie.unitto.core.base.KEY_MODULO
import com.sadellie.unitto.core.base.KEY_MULTIPLY
import com.sadellie.unitto.core.base.KEY_MULTIPLY_DISPLAY
import com.sadellie.unitto.core.base.KEY_PERCENT
import com.sadellie.unitto.core.base.KEY_PI
import com.sadellie.unitto.core.base.KEY_PLUS
import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
import com.sadellie.unitto.core.base.KEY_SIN
import com.sadellie.unitto.core.base.KEY_SQRT
import com.sadellie.unitto.core.base.KEY_TAN
import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.core.base.Separator
import com.sadellie.unitto.core.ui.UnittoFormatter
import kotlinx.coroutines.flow.MutableStateFlow
@ -80,20 +43,6 @@ class TextFieldController @Inject constructor() {
private val cursorFixer by lazy { CursorFixer() }
private val knownSymbols: List<String> by lazy {
listOf(
KEY_SIN, KEY_COS, KEY_TAN, KEY_LN, KEY_LOG,
KEY_LEFT_BRACKET, KEY_RIGHT_BRACKET,
KEY_EXPONENT, KEY_SQRT, KEY_FACTORIAL,
KEY_MODULO, KEY_E_SMALL, KEY_PERCENT, KEY_PI,
KEY_MULTIPLY, KEY_MULTIPLY_DISPLAY,
KEY_PLUS, KEY_MINUS, KEY_MINUS_DISPLAY, KEY_DIVIDE, KEY_DIVIDE_DISPLAY,
KEY_BASE_A, KEY_BASE_B, KEY_BASE_C, KEY_BASE_D, KEY_BASE_E, KEY_BASE_F,
KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_0,
KEY_DOT,
)
}
fun addToInput(symbols: String) {
val text = input.value.text
@ -175,7 +124,7 @@ class TextFieldController @Inject constructor() {
fun inputTextWithoutFormatting() = input.value.text
.replace(localFormatter.grouping, "")
.replace(localFormatter.fractional, KEY_DOT)
.replace(localFormatter.fractional, Token.dot)
private fun String.fixFormat(): String = localFormatter.reFormat(this)
@ -184,7 +133,7 @@ class TextFieldController @Inject constructor() {
var garbage = clearStr
// String with unknown symbols
knownSymbols.forEach {
Token.knownSymbols.forEach {
garbage = garbage.replace(it, " ")
}
@ -194,17 +143,21 @@ class TextFieldController @Inject constructor() {
}
clearStr = clearStr
.replace(KEY_DIVIDE, KEY_DIVIDE_DISPLAY)
.replace(KEY_MULTIPLY, KEY_MULTIPLY_DISPLAY)
.replace(KEY_MINUS, KEY_MINUS_DISPLAY)
.replace(Token.divide, Token.divideDisplay)
.replace(Token.multiply, Token.multiplyDisplay)
.replace(Token.minus, Token.minusDisplay)
return clearStr
}
inner class CursorFixer {
val illegalTokens by lazy {
private val illegalTokens by lazy {
listOf(
KEY_COS, KEY_SIN, KEY_LN, KEY_LOG, KEY_TAN
Token.cos,
Token.sin,
Token.ln,
Token.log,
Token.tan
)
}

150
feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/components/CalculatorKeyboard.kt
View File

@ -46,35 +46,7 @@ import androidx.compose.ui.draw.rotate
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import com.sadellie.unitto.core.base.KEY_0
import com.sadellie.unitto.core.base.KEY_1
import com.sadellie.unitto.core.base.KEY_2
import com.sadellie.unitto.core.base.KEY_3
import com.sadellie.unitto.core.base.KEY_4
import com.sadellie.unitto.core.base.KEY_5
import com.sadellie.unitto.core.base.KEY_6
import com.sadellie.unitto.core.base.KEY_7
import com.sadellie.unitto.core.base.KEY_8
import com.sadellie.unitto.core.base.KEY_9
import com.sadellie.unitto.core.base.KEY_COS
import com.sadellie.unitto.core.base.KEY_DIVIDE_DISPLAY
import com.sadellie.unitto.core.base.KEY_DOT
import com.sadellie.unitto.core.base.KEY_EXPONENT
import com.sadellie.unitto.core.base.KEY_E_SMALL
import com.sadellie.unitto.core.base.KEY_FACTORIAL
import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
import com.sadellie.unitto.core.base.KEY_LN
import com.sadellie.unitto.core.base.KEY_LOG
import com.sadellie.unitto.core.base.KEY_MINUS_DISPLAY
import com.sadellie.unitto.core.base.KEY_MODULO
import com.sadellie.unitto.core.base.KEY_MULTIPLY_DISPLAY
import com.sadellie.unitto.core.base.KEY_PERCENT
import com.sadellie.unitto.core.base.KEY_PI
import com.sadellie.unitto.core.base.KEY_PLUS
import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
import com.sadellie.unitto.core.base.KEY_SIN
import com.sadellie.unitto.core.base.KEY_SQRT
import com.sadellie.unitto.core.base.KEY_TAN
import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.core.ui.Formatter
import com.sadellie.unitto.core.ui.common.KeyboardButtonAdditional
import com.sadellie.unitto.core.ui.common.KeyboardButtonFilled
@ -163,7 +135,7 @@ private fun PortraitKeyboard(
clearSymbols: () -> Unit,
evaluate: () -> Unit
) {
val fractionalIcon = remember { if (Formatter.fractional == KEY_DOT) UnittoIcons.Dot else UnittoIcons.Comma }
val fractionalIcon = remember { if (Formatter.fractional == Token.dot) UnittoIcons.Dot else UnittoIcons.Comma }
var showAdditional: Boolean by remember { mutableStateOf(false) }
val expandRotation: Float by animateFloatAsState(
targetValue = if (showAdditional) 0f else 180f,
@ -190,24 +162,24 @@ private fun PortraitKeyboard(
// Additional buttons
Column(modifier = weightModifier) {
Row(Modifier, horizontalArrangement = Arrangement.spacedBy(2.dp)) {
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.SquareRoot, allowVibration) { addSymbol(KEY_SQRT) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Pi, allowVibration) { addSymbol(KEY_PI) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Exponent, allowVibration) { addSymbol(KEY_EXPONENT) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Factorial, allowVibration) { addSymbol(KEY_FACTORIAL) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.SquareRoot, allowVibration) { addSymbol(Token.sqrt) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Pi, allowVibration) { addSymbol(Token.pi) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Exponent, allowVibration) { addSymbol(Token.exponent) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Factorial, allowVibration) { addSymbol(Token.factorial) }
}
AnimatedVisibility(visible = showAdditional) {
Column {
Row(Modifier, horizontalArrangement = Arrangement.spacedBy(2.dp)) {
KeyboardButtonAdditional(additionalButtonModifier, if (angleMode == AngleMode.DEG) UnittoIcons.Deg else UnittoIcons.Rad, allowVibration) { toggleAngleMode() }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Sin, allowVibration) { addSymbol(KEY_SIN) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Cos, allowVibration) { addSymbol(KEY_COS) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Tan, allowVibration) { addSymbol(KEY_TAN) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Sin, allowVibration) { addSymbol(Token.sin) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Cos, allowVibration) { addSymbol(Token.cos) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Tan, allowVibration) { addSymbol(Token.tan) }
}
Row(Modifier, horizontalArrangement = Arrangement.spacedBy(2.dp)) {
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Modulo, allowVibration) { addSymbol(KEY_MODULO) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.E, allowVibration) { addSymbol(KEY_E_SMALL) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Ln, allowVibration) { addSymbol(KEY_LN) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Log, allowVibration) { addSymbol(KEY_LOG) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Modulo, allowVibration) { addSymbol(Token.modulo) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.E, allowVibration) { addSymbol(Token.e) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Ln, allowVibration) { addSymbol(Token.ln) }
KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Log, allowVibration) { addSymbol(Token.log) }
}
}
}
@ -222,33 +194,33 @@ private fun PortraitKeyboard(
}
Row(weightModifier) {
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.LeftBracket, allowVibration) { addSymbol(KEY_LEFT_BRACKET) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.RightBracket, allowVibration) { addSymbol(KEY_RIGHT_BRACKET) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Percent, allowVibration) { addSymbol(KEY_PERCENT) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Divide, allowVibration) { addSymbol(KEY_DIVIDE_DISPLAY) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.LeftBracket, allowVibration) { addSymbol(Token.leftBracket) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.RightBracket, allowVibration) { addSymbol(Token.rightBracket) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Percent, allowVibration) { addSymbol(Token.percent) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Divide, allowVibration) { addSymbol(Token.divideDisplay) }
}
Row(weightModifier) {
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key7, allowVibration) { addSymbol(KEY_7) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key8, allowVibration) { addSymbol(KEY_8) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key9, allowVibration) { addSymbol(KEY_9) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Multiply, allowVibration) { addSymbol(KEY_MULTIPLY_DISPLAY) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key7, allowVibration) { addSymbol(Token._7) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key8, allowVibration) { addSymbol(Token._8) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key9, allowVibration) { addSymbol(Token._9) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Multiply, allowVibration) { addSymbol(Token.multiplyDisplay) }
}
Row(weightModifier) {
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key4, allowVibration) { addSymbol(KEY_4) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key5, allowVibration) { addSymbol(KEY_5) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key6, allowVibration) { addSymbol(KEY_6) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Minus, allowVibration) { addSymbol(KEY_MINUS_DISPLAY) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key4, allowVibration) { addSymbol(Token._4) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key5, allowVibration) { addSymbol(Token._5) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key6, allowVibration) { addSymbol(Token._6) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Minus, allowVibration) { addSymbol(Token.minusDisplay) }
}
Row(weightModifier) {
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key1, allowVibration) { addSymbol(KEY_1) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key2, allowVibration) { addSymbol(KEY_2) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key3, allowVibration) { addSymbol(KEY_3) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Plus, allowVibration) { addSymbol(KEY_PLUS) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key1, allowVibration) { addSymbol(Token._1) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key2, allowVibration) { addSymbol(Token._2) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key3, allowVibration) { addSymbol(Token._3) }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Plus, allowVibration) { addSymbol(Token.plus) }
}
Row(weightModifier) {
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key0, allowVibration) { addSymbol(KEY_0) }
KeyboardButtonLight(mainButtonModifier, fractionalIcon, allowVibration) { addSymbol(KEY_DOT) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key0, allowVibration) { addSymbol(Token._0) }
KeyboardButtonLight(mainButtonModifier, fractionalIcon, allowVibration) { addSymbol(Token.dot) }
KeyboardButtonLight(mainButtonModifier, UnittoIcons.Delete, allowVibration, clearSymbols) { deleteSymbol() }
KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Equal, allowVibration) { evaluate() }
}
@ -266,52 +238,52 @@ private fun LandscapeKeyboard(
clearSymbols: () -> Unit,
evaluate: () -> Unit
) {
val fractionalIcon = remember { if (Formatter.fractional == KEY_DOT) UnittoIcons.Dot else UnittoIcons.Comma }
val fractionalIcon = remember { if (Formatter.fractional == Token.dot) UnittoIcons.Dot else UnittoIcons.Comma }
Column(modifier = modifier) {
val buttonModifier = Modifier.weight(1f).padding(2.dp)
Row(Modifier.weight(1f)) {
KeyboardButtonAdditional(buttonModifier, if (angleMode == AngleMode.DEG) UnittoIcons.Deg else UnittoIcons.Rad, allowVibration) { toggleAngleMode() }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.SquareRoot, allowVibration) { addSymbol(KEY_SQRT) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Pi, allowVibration) { addSymbol(KEY_PI) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.SquareRoot, allowVibration) { addSymbol(Token.sqrt) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Pi, allowVibration) { addSymbol(Token.pi) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key7, allowVibration) { addSymbol(KEY_7) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key8, allowVibration) { addSymbol(KEY_8) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key9, allowVibration) { addSymbol(KEY_9) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.LeftBracket, allowVibration) { addSymbol(KEY_LEFT_BRACKET) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.RightBracket, allowVibration) { addSymbol(KEY_RIGHT_BRACKET) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key7, allowVibration) { addSymbol(Token._7) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key8, allowVibration) { addSymbol(Token._8) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key9, allowVibration) { addSymbol(Token._9) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.LeftBracket, allowVibration) { addSymbol(Token.leftBracket) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.RightBracket, allowVibration) { addSymbol(Token.rightBracket) }
}
Row(Modifier.weight(1f)) {
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Modulo, allowVibration) { addSymbol(KEY_MODULO) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Exponent, allowVibration) { addSymbol(KEY_EXPONENT) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Factorial, allowVibration) { addSymbol(KEY_FACTORIAL) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Modulo, allowVibration) { addSymbol(Token.modulo) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Exponent, allowVibration) { addSymbol(Token.exponent) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Factorial, allowVibration) { addSymbol(Token.factorial) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key4, allowVibration) { addSymbol(KEY_4) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key5, allowVibration) { addSymbol(KEY_5) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key6, allowVibration) { addSymbol(KEY_6) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Multiply, allowVibration) { addSymbol(KEY_MULTIPLY_DISPLAY) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Divide, allowVibration) { addSymbol(KEY_DIVIDE_DISPLAY) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key4, allowVibration) { addSymbol(Token._4) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key5, allowVibration) { addSymbol(Token._5) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key6, allowVibration) { addSymbol(Token._6) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Multiply, allowVibration) { addSymbol(Token.multiplyDisplay) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Divide, allowVibration) { addSymbol(Token.divideDisplay) }
}
Row(Modifier.weight(1f)) {
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Sin, allowVibration) { addSymbol(KEY_SIN) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Cos, allowVibration) { addSymbol(KEY_COS) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Tan, allowVibration) { addSymbol(KEY_TAN) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Sin, allowVibration) { addSymbol(Token.sin) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Cos, allowVibration) { addSymbol(Token.cos) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Tan, allowVibration) { addSymbol(Token.tan) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key1, allowVibration) { addSymbol(KEY_1) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key2, allowVibration) { addSymbol(KEY_2) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key3, allowVibration) { addSymbol(KEY_3) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Minus, allowVibration) { addSymbol(KEY_MINUS_DISPLAY) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Percent, allowVibration) { addSymbol(KEY_PERCENT) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key1, allowVibration) { addSymbol(Token._1) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key2, allowVibration) { addSymbol(Token._2) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key3, allowVibration) { addSymbol(Token._3) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Minus, allowVibration) { addSymbol(Token.minusDisplay) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Percent, allowVibration) { addSymbol(Token.percent) }
}
Row(Modifier.weight(1f)) {
KeyboardButtonAdditional(buttonModifier, UnittoIcons.E, allowVibration) { addSymbol(KEY_E_SMALL) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Ln, allowVibration) { addSymbol(KEY_LN) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Log, allowVibration) { addSymbol(KEY_LOG) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key0, allowVibration) { addSymbol(KEY_0) }
KeyboardButtonLight(buttonModifier, fractionalIcon, allowVibration) { addSymbol(KEY_DOT) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.E, allowVibration) { addSymbol(Token.e) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Ln, allowVibration) { addSymbol(Token.ln) }
KeyboardButtonAdditional(buttonModifier, UnittoIcons.Log, allowVibration) { addSymbol(Token.log) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Key0, allowVibration) { addSymbol(Token._0) }
KeyboardButtonLight(buttonModifier, fractionalIcon, allowVibration) { addSymbol(Token.dot) }
KeyboardButtonLight(buttonModifier, UnittoIcons.Delete, allowVibration, clearSymbols) { deleteSymbol() }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Plus, allowVibration) { addSymbol(KEY_PLUS) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Plus, allowVibration) { addSymbol(Token.plus) }
KeyboardButtonFilled(buttonModifier, UnittoIcons.Equal, allowVibration) { evaluate() }
}
}

2
feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/components/InputTextField.kt
View File

@ -50,7 +50,7 @@ internal fun InputTextField(
derivedStateOf {
value.copy(
// We replace this because internally input value is already formatted, but uses
// COMMA as separator.
// comma as separator.
Formatter.fromSeparator(value.text, Separator.COMMA)
)
}

6
feature/converter/src/main/java/com/sadellie/unitto/feature/converter/ConverterUIState.kt
View File

@ -18,7 +18,7 @@
package com.sadellie.unitto.feature.converter
import com.sadellie.unitto.core.base.KEY_0
import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.data.model.AbstractUnit
/**
@ -37,9 +37,9 @@ import com.sadellie.unitto.data.model.AbstractUnit
* @property allowVibration When true will vibrate on button clicks.
*/
data class ConverterUIState(
val inputValue: String = KEY_0,
val inputValue: String = Token._0,
val calculatedValue: String? = null,
val resultValue: String = KEY_0,
val resultValue: String = Token._0,
val showLoading: Boolean = true,
val showError: Boolean = false,
val unitFrom: AbstractUnit? = null,

115
feature/converter/src/main/java/com/sadellie/unitto/feature/converter/ConverterViewModel.kt
View File

@ -22,27 +22,7 @@ import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.github.keelar.exprk.ExpressionException
import com.github.keelar.exprk.Expressions
import com.sadellie.unitto.core.base.DIGITS
import com.sadellie.unitto.core.base.KEY_0
import com.sadellie.unitto.core.base.KEY_1
import com.sadellie.unitto.core.base.KEY_2
import com.sadellie.unitto.core.base.KEY_3
import com.sadellie.unitto.core.base.KEY_4
import com.sadellie.unitto.core.base.KEY_5
import com.sadellie.unitto.core.base.KEY_6
import com.sadellie.unitto.core.base.KEY_7
import com.sadellie.unitto.core.base.KEY_8
import com.sadellie.unitto.core.base.KEY_9
import com.sadellie.unitto.core.base.KEY_DIVIDE
import com.sadellie.unitto.core.base.KEY_DOT
import com.sadellie.unitto.core.base.KEY_EXPONENT
import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
import com.sadellie.unitto.core.base.KEY_MINUS
import com.sadellie.unitto.core.base.KEY_MULTIPLY
import com.sadellie.unitto.core.base.KEY_PLUS
import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
import com.sadellie.unitto.core.base.KEY_SQRT
import com.sadellie.unitto.core.base.OPERATORS
import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.data.common.setMinimumRequiredScale
import com.sadellie.unitto.data.common.toStringWith
import com.sadellie.unitto.data.common.trimZeros
@ -103,7 +83,7 @@ class ConverterViewModel @Inject constructor(
/**
* Current input. Used when converting units.
*/
private val _input: MutableStateFlow<String> = MutableStateFlow(KEY_0)
private val _input: MutableStateFlow<String> = MutableStateFlow(Token._0)
/**
* Calculation result. Null when [_input] is not an expression.
@ -118,7 +98,7 @@ class ConverterViewModel @Inject constructor(
/**
* Conversion result.
*/
private val _result: MutableStateFlow<String> = MutableStateFlow(KEY_0)
private val _result: MutableStateFlow<String> = MutableStateFlow(Token._0)
/**
* True when loading something from network.
@ -180,23 +160,23 @@ class ConverterViewModel @Inject constructor(
val lastSecondSymbol: String? = lastTwoSymbols.getOrNull(0)
when (symbolToAdd) {
KEY_PLUS, KEY_DIVIDE, KEY_MULTIPLY, KEY_EXPONENT -> {
Token.plus, Token.divide, Token.multiply, Token.exponent -> {
when {
// Don't need expressions that start with zero
(_input.value == KEY_0) -> {}
(_input.value == KEY_MINUS) -> {}
(lastSymbol == KEY_LEFT_BRACKET) -> {}
(lastSymbol == KEY_SQRT) -> {}
(_input.value == Token._0) -> {}
(_input.value == Token.minus) -> {}
(lastSymbol == Token.leftBracket) -> {}
(lastSymbol == Token.sqrt) -> {}
/**
* For situations like "50+-", when user clicks "/" we delete "-" so it becomes
* "50+". We don't add "/' here. User will click "/" second time and the input
* will be "50/".
*/
(lastSecondSymbol in OPERATORS) and (lastSymbol == KEY_MINUS) -> {
(lastSecondSymbol in Token.operators) and (lastSymbol == Token.minus) -> {
deleteDigit()
}
// Don't allow multiple operators near each other
(lastSymbol in OPERATORS) -> {
(lastSymbol in Token.operators) -> {
deleteDigit()
setInputSymbols(symbolToAdd)
}
@ -205,29 +185,30 @@ class ConverterViewModel @Inject constructor(
}
}
}
KEY_0 -> {
Token._0 -> {
when {
// Don't add zero if the input is already a zero
(_input.value == KEY_0) -> {}
(lastSymbol == KEY_RIGHT_BRACKET) -> {
processInput(KEY_MULTIPLY)
(_input.value == Token._0) -> {}
(lastSymbol == Token.rightBracket) -> {
processInput(Token.multiply)
setInputSymbols(symbolToAdd)
}
// Prevents things like "-00" and "4+000"
((lastSecondSymbol in OPERATORS + KEY_LEFT_BRACKET) and (lastSymbol == KEY_0)) -> {}
((lastSecondSymbol in Token.operators + Token.leftBracket) and (lastSymbol == Token._0)) -> {}
else -> {
setInputSymbols(symbolToAdd)
}
}
}
KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9 -> {
Token._1, Token._2, Token._3, Token._4, Token._5,
Token._6, Token._7, Token._8, Token._9 -> {
// Replace single zero (default input) if it's here
when {
(_input.value == KEY_0) -> {
(_input.value == Token._0) -> {
setInputSymbols(symbolToAdd, false)
}
(lastSymbol == KEY_RIGHT_BRACKET) -> {
processInput(KEY_MULTIPLY)
(lastSymbol == Token.rightBracket) -> {
processInput(Token.multiply)
setInputSymbols(symbolToAdd)
}
else -> {
@ -235,16 +216,16 @@ class ConverterViewModel @Inject constructor(
}
}
}
KEY_MINUS -> {
Token.minus -> {
when {
// Replace single zero with minus (to support negative numbers)
(_input.value == KEY_0) -> {
(_input.value == Token._0) -> {
setInputSymbols(symbolToAdd, false)
}
// Don't allow multiple minuses near each other
(lastSymbol.compareTo(KEY_MINUS) == 0) -> {}
(lastSymbol.compareTo(Token.minus) == 0) -> {}
// Don't allow plus and minus be near each other
(lastSymbol == KEY_PLUS) -> {
(lastSymbol == Token.plus) -> {
deleteDigit()
setInputSymbols(symbolToAdd)
}
@ -253,22 +234,22 @@ class ConverterViewModel @Inject constructor(
}
}
}
KEY_DOT -> {
Token.dot -> {
if (!_input.value
.takeLastWhile { it.toString() !in OPERATORS.minus(KEY_DOT) }
.contains(KEY_DOT)
.takeLastWhile { it.toString() !in Token.operators.minus(Token.dot) }
.contains(Token.dot)
) {
setInputSymbols(symbolToAdd)
}
}
KEY_LEFT_BRACKET -> {
Token.leftBracket -> {
when {
// Replace single zero with minus (to support negative numbers)
(_input.value == KEY_0) -> {
(_input.value == Token._0) -> {
setInputSymbols(symbolToAdd, false)
}
(lastSymbol == KEY_RIGHT_BRACKET) || (lastSymbol in DIGITS) || (lastSymbol == KEY_DOT) -> {
processInput(KEY_MULTIPLY)
(lastSymbol == Token.rightBracket) || (lastSymbol in Token.digits) || (lastSymbol == Token.dot) -> {
processInput(Token.multiply)
setInputSymbols(symbolToAdd)
}
else -> {
@ -276,14 +257,14 @@ class ConverterViewModel @Inject constructor(
}
}
}
KEY_RIGHT_BRACKET -> {
Token.rightBracket -> {
when {
// Replace single zero with minus (to support negative numbers)
(_input.value == KEY_0) -> {}
(lastSymbol == KEY_LEFT_BRACKET) -> {}
(_input.value == Token._0) -> {}
(lastSymbol == Token.leftBracket) -> {}
(
_latestInputStack.filter { it == KEY_LEFT_BRACKET }.size ==
_latestInputStack.filter { it == KEY_RIGHT_BRACKET }.size
_latestInputStack.filter { it == Token.leftBracket }.size ==
_latestInputStack.filter { it == Token.rightBracket }.size
) -> {
}
else -> {
@ -291,14 +272,14 @@ class ConverterViewModel @Inject constructor(
}
}
}
KEY_SQRT -> {
Token.sqrt -> {
when {
// Replace single zero with minus (to support negative numbers)
(_input.value == KEY_0) -> {
(_input.value == Token._0) -> {
setInputSymbols(symbolToAdd, false)
}
(lastSymbol == KEY_RIGHT_BRACKET) || (lastSymbol in DIGITS) || (lastSymbol == KEY_DOT) -> {
processInput(KEY_MULTIPLY)
(lastSymbol == Token.rightBracket) || (lastSymbol in Token.digits) || (lastSymbol == Token.dot) -> {
processInput(Token.multiply)
setInputSymbols(symbolToAdd)
}
else -> {
@ -309,7 +290,7 @@ class ConverterViewModel @Inject constructor(
else -> {
when {
// Replace single zero with minus (to support negative numbers)
(_input.value == KEY_0) -> {
(_input.value == Token._0) -> {
setInputSymbols(symbolToAdd, false)
}
else -> {
@ -373,13 +354,13 @@ class ConverterViewModel @Inject constructor(
*/
fun deleteDigit() {
// Default input, don't delete
if (_input.value == KEY_0) return
if (_input.value == Token._0) return
val lastSymbol = _latestInputStack.removeLast()
// If this value are same, it means that after deleting there will be no symbols left, set to default
if (lastSymbol == _input.value) {
setInputSymbols(KEY_0, false)
setInputSymbols(Token._0, false)
} else {
_input.update { it.removeSuffix(lastSymbol) }
}
@ -389,7 +370,7 @@ class ConverterViewModel @Inject constructor(
* Clear [_input].
*/
fun clearInput() {
setInputSymbols(KEY_0, false)
setInputSymbols(Token._0, false)
}
fun toggleFormatTime() {
@ -438,10 +419,10 @@ class ConverterViewModel @Inject constructor(
// Now we close open brackets that user didn't close
// AUTOCLOSE ALL BRACKETS
val leftBrackets = _input.value.count { it.toString() == KEY_LEFT_BRACKET }
val rightBrackets = _input.value.count { it.toString() == KEY_RIGHT_BRACKET }
val leftBrackets = _input.value.count { it.toString() == Token.leftBracket }
val rightBrackets = _input.value.count { it.toString() == Token.rightBracket }
val neededBrackets = leftBrackets - rightBrackets
if (neededBrackets > 0) cleanInput += KEY_RIGHT_BRACKET.repeat(neededBrackets)
if (neededBrackets > 0) cleanInput += Token.rightBracket.repeat(neededBrackets)
// Now we evaluate expression in input
val evaluationResult: BigDecimal = try {
@ -466,7 +447,7 @@ class ConverterViewModel @Inject constructor(
// 123.456 will be true
// -123.456 will be true
// -123.456-123 will be false (first minus gets removed, ending with 123.456)
if (_input.value.removePrefix(KEY_MINUS).all { it.toString() !in OPERATORS }) {
if (_input.value.removePrefix(Token.minus).all { it.toString() !in Token.operators }) {
// No operators
_calculated.update { null }
} else {

98
feature/converter/src/main/java/com/sadellie/unitto/feature/converter/components/Keyboard.kt
View File

@ -27,31 +27,7 @@ import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import com.sadellie.unitto.core.base.KEY_0
import com.sadellie.unitto.core.base.KEY_1
import com.sadellie.unitto.core.base.KEY_2
import com.sadellie.unitto.core.base.KEY_3
import com.sadellie.unitto.core.base.KEY_4
import com.sadellie.unitto.core.base.KEY_5
import com.sadellie.unitto.core.base.KEY_6
import com.sadellie.unitto.core.base.KEY_7
import com.sadellie.unitto.core.base.KEY_8
import com.sadellie.unitto.core.base.KEY_9
import com.sadellie.unitto.core.base.KEY_BASE_A
import com.sadellie.unitto.core.base.KEY_BASE_B
import com.sadellie.unitto.core.base.KEY_BASE_C
import com.sadellie.unitto.core.base.KEY_BASE_D
import com.sadellie.unitto.core.base.KEY_BASE_E
import com.sadellie.unitto.core.base.KEY_BASE_F
import com.sadellie.unitto.core.base.KEY_DIVIDE
import com.sadellie.unitto.core.base.KEY_DOT
import com.sadellie.unitto.core.base.KEY_EXPONENT
import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
import com.sadellie.unitto.core.base.KEY_MINUS
import com.sadellie.unitto.core.base.KEY_MULTIPLY
import com.sadellie.unitto.core.base.KEY_PLUS
import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
import com.sadellie.unitto.core.base.KEY_SQRT
import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.core.ui.Formatter
import com.sadellie.unitto.core.ui.common.KeyboardButtonFilled
import com.sadellie.unitto.core.ui.common.KeyboardButtonLight
@ -119,7 +95,7 @@ private fun DefaultKeyboard(
deleteDigit: () -> Unit,
allowVibration: Boolean
) {
val fractionalIcon = remember { if (Formatter.fractional == KEY_DOT) UnittoIcons.Dot else UnittoIcons.Comma }
val fractionalIcon = remember { if (Formatter.fractional == Token.dot) UnittoIcons.Dot else UnittoIcons.Comma }
Column {
// Button modifier
val bModifier = Modifier
@ -129,34 +105,34 @@ private fun DefaultKeyboard(
// Column modifier
val cModifier = Modifier.weight(1f)
Row(cModifier) {
KeyboardButtonFilled(bModifier, UnittoIcons.LeftBracket, allowVibration) { addDigit(KEY_LEFT_BRACKET) }
KeyboardButtonFilled(bModifier, UnittoIcons.RightBracket, allowVibration) { addDigit(KEY_RIGHT_BRACKET) }
KeyboardButtonFilled(bModifier, UnittoIcons.Exponent, allowVibration) { addDigit(KEY_EXPONENT) }
KeyboardButtonFilled(bModifier, UnittoIcons.SquareRoot, allowVibration) { addDigit(KEY_SQRT) }
KeyboardButtonFilled(bModifier, UnittoIcons.LeftBracket, allowVibration) { addDigit(Token.leftBracket) }
KeyboardButtonFilled(bModifier, UnittoIcons.RightBracket, allowVibration) { addDigit(Token.rightBracket) }
KeyboardButtonFilled(bModifier, UnittoIcons.Exponent, allowVibration) { addDigit(Token.exponent) }
KeyboardButtonFilled(bModifier, UnittoIcons.SquareRoot, allowVibration) { addDigit(Token.sqrt) }
}
Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key7, allowVibration) { addDigit(KEY_7) }
KeyboardButtonLight(bModifier, UnittoIcons.Key8, allowVibration) { addDigit(KEY_8) }
KeyboardButtonLight(bModifier, UnittoIcons.Key9, allowVibration) { addDigit(KEY_9) }
KeyboardButtonFilled(bModifier, UnittoIcons.Divide, allowVibration) { addDigit(KEY_DIVIDE) }
KeyboardButtonLight(bModifier, UnittoIcons.Key7, allowVibration) { addDigit(Token._7) }
KeyboardButtonLight(bModifier, UnittoIcons.Key8, allowVibration) { addDigit(Token._8) }
KeyboardButtonLight(bModifier, UnittoIcons.Key9, allowVibration) { addDigit(Token._9) }
KeyboardButtonFilled(bModifier, UnittoIcons.Divide, allowVibration) { addDigit(Token.divide) }
}
Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key4, allowVibration) { addDigit(KEY_4) }
KeyboardButtonLight(bModifier, UnittoIcons.Key5, allowVibration) { addDigit(KEY_5) }
KeyboardButtonLight(bModifier, UnittoIcons.Key6, allowVibration) { addDigit(KEY_6) }
KeyboardButtonFilled(bModifier, UnittoIcons.Multiply, allowVibration) { addDigit(KEY_MULTIPLY) }
KeyboardButtonLight(bModifier, UnittoIcons.Key4, allowVibration) { addDigit(Token._4) }
KeyboardButtonLight(bModifier, UnittoIcons.Key5, allowVibration) { addDigit(Token._5) }
KeyboardButtonLight(bModifier, UnittoIcons.Key6, allowVibration) { addDigit(Token._6) }
KeyboardButtonFilled(bModifier, UnittoIcons.Multiply, allowVibration) { addDigit(Token.multiply) }
}
Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key1, allowVibration) { addDigit(KEY_1) }
KeyboardButtonLight(bModifier, UnittoIcons.Key2, allowVibration) { addDigit(KEY_2) }
KeyboardButtonLight(bModifier, UnittoIcons.Key3, allowVibration) { addDigit(KEY_3) }
KeyboardButtonFilled(bModifier, UnittoIcons.Minus, allowVibration) { addDigit(KEY_MINUS) }
KeyboardButtonLight(bModifier, UnittoIcons.Key1, allowVibration) { addDigit(Token._1) }
KeyboardButtonLight(bModifier, UnittoIcons.Key2, allowVibration) { addDigit(Token._2) }
KeyboardButtonLight(bModifier, UnittoIcons.Key3, allowVibration) { addDigit(Token._3) }
KeyboardButtonFilled(bModifier, UnittoIcons.Minus, allowVibration) { addDigit(Token.minus) }
}
Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key0, allowVibration) { addDigit(KEY_0) }
KeyboardButtonLight(bModifier, fractionalIcon, allowVibration) { addDigit(KEY_DOT) }
KeyboardButtonLight(bModifier, UnittoIcons.Key0, allowVibration) { addDigit(Token._0) }
KeyboardButtonLight(bModifier, fractionalIcon, allowVibration) { addDigit(Token.dot) }
KeyboardButtonLight(bModifier, UnittoIcons.Delete, allowVibration, clearInput) { deleteDigit() }
KeyboardButtonFilled(bModifier, UnittoIcons.Plus, allowVibration) { addDigit(KEY_PLUS) }
KeyboardButtonFilled(bModifier, UnittoIcons.Plus, allowVibration) { addDigit(Token.plus) }
}
}
}
@ -178,32 +154,32 @@ private fun BaseKeyboard(
val cModifier = Modifier.weight(1f)
Row(cModifier) {
KeyboardButtonFilled(bModifier, UnittoIcons.KeyA, allowVibration) { addDigit(KEY_BASE_A) }
KeyboardButtonFilled(bModifier, UnittoIcons.KeyB, allowVibration) { addDigit(KEY_BASE_B) }
KeyboardButtonFilled(bModifier, UnittoIcons.KeyC, allowVibration) { addDigit(KEY_BASE_C) }
KeyboardButtonFilled(bModifier, UnittoIcons.KeyA, allowVibration) { addDigit(Token.baseA) }
KeyboardButtonFilled(bModifier, UnittoIcons.KeyB, allowVibration) { addDigit(Token.baseB) }
KeyboardButtonFilled(bModifier, UnittoIcons.KeyC, allowVibration) { addDigit(Token.baseC) }
}
Row(cModifier) {
KeyboardButtonFilled(bModifier, UnittoIcons.KeyD, allowVibration) { addDigit(KEY_BASE_D) }
KeyboardButtonFilled(bModifier, UnittoIcons.KeyE, allowVibration) { addDigit(KEY_BASE_E) }
KeyboardButtonFilled(bModifier, UnittoIcons.KeyF, allowVibration) { addDigit(KEY_BASE_F) }
KeyboardButtonFilled(bModifier, UnittoIcons.KeyD, allowVibration) { addDigit(Token.baseD) }
KeyboardButtonFilled(bModifier, UnittoIcons.KeyE, allowVibration) { addDigit(Token.baseE) }
KeyboardButtonFilled(bModifier, UnittoIcons.KeyF, allowVibration) { addDigit(Token.baseF) }
}
Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key7, allowVibration) { addDigit(KEY_7) }
KeyboardButtonLight(bModifier, UnittoIcons.Key8, allowVibration) { addDigit(KEY_8) }
KeyboardButtonLight(bModifier, UnittoIcons.Key9, allowVibration) { addDigit(KEY_9) }
KeyboardButtonLight(bModifier, UnittoIcons.Key7, allowVibration) { addDigit(Token._7) }
KeyboardButtonLight(bModifier, UnittoIcons.Key8, allowVibration) { addDigit(Token._8) }
KeyboardButtonLight(bModifier, UnittoIcons.Key9, allowVibration) { addDigit(Token._9) }
}
Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key4, allowVibration) { addDigit(KEY_4) }
KeyboardButtonLight(bModifier, UnittoIcons.Key5, allowVibration) { addDigit(KEY_5) }
KeyboardButtonLight(bModifier, UnittoIcons.Key6, allowVibration) { addDigit(KEY_6) }
KeyboardButtonLight(bModifier, UnittoIcons.Key4, allowVibration) { addDigit(Token._4) }
KeyboardButtonLight(bModifier, UnittoIcons.Key5, allowVibration) { addDigit(Token._5) }
KeyboardButtonLight(bModifier, UnittoIcons.Key6, allowVibration) { addDigit(Token._6) }
}
Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key1, allowVibration) { addDigit(KEY_1) }
KeyboardButtonLight(bModifier, UnittoIcons.Key2, allowVibration) { addDigit(KEY_2) }
KeyboardButtonLight(bModifier, UnittoIcons.Key3, allowVibration) { addDigit(KEY_3) }
KeyboardButtonLight(bModifier, UnittoIcons.Key1, allowVibration) { addDigit(Token._1) }
KeyboardButtonLight(bModifier, UnittoIcons.Key2, allowVibration) { addDigit(Token._2) }
KeyboardButtonLight(bModifier, UnittoIcons.Key3, allowVibration) { addDigit(Token._3) }
}
Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key0, allowVibration) { addDigit(KEY_0) }
KeyboardButtonLight(bModifier, UnittoIcons.Key0, allowVibration) { addDigit(Token._0) }
KeyboardButtonLight(Modifier.fillMaxSize().weight(2f).padding(4.dp), UnittoIcons.Delete, allowVibration, clearInput) { deleteDigit() }
}
}

45
feature/converter/src/test/java/com/sadellie/unitto/feature/converter/ConverterViewModelTest.kt
View File

@ -19,29 +19,10 @@
package com.sadellie.unitto.feature.converter
import androidx.room.Room
import com.sadellie.unitto.core.base.KEY_0
import com.sadellie.unitto.core.base.KEY_1
import com.sadellie.unitto.core.base.KEY_2
import com.sadellie.unitto.core.base.KEY_3
import com.sadellie.unitto.core.base.KEY_4
import com.sadellie.unitto.core.base.KEY_5
import com.sadellie.unitto.core.base.KEY_6
import com.sadellie.unitto.core.base.KEY_7
import com.sadellie.unitto.core.base.KEY_8
import com.sadellie.unitto.core.base.KEY_9
import com.sadellie.unitto.core.base.KEY_COMMA
import com.sadellie.unitto.core.base.KEY_DIVIDE
import com.sadellie.unitto.core.base.KEY_DOT
import com.sadellie.unitto.core.base.KEY_EXPONENT
import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
import com.sadellie.unitto.core.base.KEY_MINUS
import com.sadellie.unitto.core.base.KEY_MULTIPLY
import com.sadellie.unitto.core.base.KEY_PLUS
import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
import com.sadellie.unitto.core.base.KEY_SQRT
import com.sadellie.unitto.data.units.AllUnitsRepository
import com.sadellie.unitto.data.database.UnittoDatabase
import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.data.database.UnitsRepository
import com.sadellie.unitto.data.database.UnittoDatabase
import com.sadellie.unitto.data.units.AllUnitsRepository
import com.sadellie.unitto.data.userprefs.DataStoreModule
import com.sadellie.unitto.data.userprefs.UserPreferencesRepository
import junit.framework.TestCase.assertEquals
@ -201,9 +182,11 @@ class ConverterViewModelTest {
}
listOf(
KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_0,
KEY_DOT, KEY_COMMA, KEY_LEFT_BRACKET, KEY_RIGHT_BRACKET,
KEY_PLUS, KEY_MINUS, KEY_DIVIDE, KEY_MULTIPLY, KEY_EXPONENT, KEY_SQRT
Token._1, Token._2, Token._3, Token._4, Token._5,
Token._6, Token._7, Token._8, Token._9, Token._0,
Token.dot, Token.comma, Token.leftBracket, Token.rightBracket,
Token.plus, Token.minus, Token.divide, Token.multiply,
Token.exponent, Token.sqrt
).forEach {
// We enter one symbol and delete it, should be default as a result
viewModel.processInput(it)
@ -216,9 +199,9 @@ class ConverterViewModelTest {
viewModel.deleteDigit()
// Now we check that we can delete multiple values
viewModel.processInput(KEY_3)
viewModel.processInput(KEY_SQRT)
viewModel.processInput(KEY_9)
viewModel.processInput(Token._3)
viewModel.processInput(Token.sqrt)
viewModel.processInput(Token._9)
viewModel.deleteDigit()
assertEquals("3*√", viewModel.uiStateFlow.value.inputValue)
@ -231,12 +214,12 @@ class ConverterViewModelTest {
viewModel.uiStateFlow.collect()
}
viewModel.processInput(KEY_3)
viewModel.processInput(Token._3)
viewModel.clearInput()
assertEquals(null, viewModel.uiStateFlow.value.calculatedValue)
viewModel.processInput(KEY_3)
viewModel.processInput(KEY_MULTIPLY)
viewModel.processInput(Token._3)
viewModel.processInput(Token.multiply)
viewModel.clearInput()
assertEquals(null, viewModel.uiStateFlow.value.calculatedValue)

31
feature/epoch/src/main/java/com/sadellie/unitto/feature/epoch/component/EpochKeyboard.kt
View File

@ -25,16 +25,7 @@ import androidx.compose.foundation.layout.padding
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import com.sadellie.unitto.core.base.KEY_0
import com.sadellie.unitto.core.base.KEY_1
import com.sadellie.unitto.core.base.KEY_2
import com.sadellie.unitto.core.base.KEY_3
import com.sadellie.unitto.core.base.KEY_4
import com.sadellie.unitto.core.base.KEY_5
import com.sadellie.unitto.core.base.KEY_6
import com.sadellie.unitto.core.base.KEY_7
import com.sadellie.unitto.core.base.KEY_8
import com.sadellie.unitto.core.base.KEY_9
import com.sadellie.unitto.core.base.Token
import com.sadellie.unitto.core.ui.common.KeyboardButtonLight
import com.sadellie.unitto.core.ui.common.key.UnittoIcons
import com.sadellie.unitto.core.ui.common.key.unittoicons.Delete
@ -71,22 +62,22 @@ internal fun EpochKeyboard(
.weight(2f)
.padding(4.dp)
Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key7, false) { addSymbol(KEY_7) }
KeyboardButtonLight(bModifier, UnittoIcons.Key8, false) { addSymbol(KEY_8) }
KeyboardButtonLight(bModifier, UnittoIcons.Key9, false) { addSymbol(KEY_9) }
KeyboardButtonLight(bModifier, UnittoIcons.Key7, false) { addSymbol(Token._7) }
KeyboardButtonLight(bModifier, UnittoIcons.Key8, false) { addSymbol(Token._8) }
KeyboardButtonLight(bModifier, UnittoIcons.Key9, false) { addSymbol(Token._9) }
}
Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key4, false) { addSymbol(KEY_4) }
KeyboardButtonLight(bModifier, UnittoIcons.Key5, false) { addSymbol(KEY_5) }
KeyboardButtonLight(bModifier, UnittoIcons.Key6, false) { addSymbol(KEY_6) }
KeyboardButtonLight(bModifier, UnittoIcons.Key4, false) { addSymbol(Token._4) }
KeyboardButtonLight(bModifier, UnittoIcons.Key5, false) { addSymbol(Token._5) }
KeyboardButtonLight(bModifier, UnittoIcons.Key6, false) { addSymbol(Token._6) }
}
Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key1, false) { addSymbol(KEY_1) }
KeyboardButtonLight(bModifier, UnittoIcons.Key2, false) { addSymbol(KEY_2) }
KeyboardButtonLight(bModifier, UnittoIcons.Key3, false) { addSymbol(KEY_3) }
KeyboardButtonLight(bModifier, UnittoIcons.Key1, false) { addSymbol(Token._1) }
KeyboardButtonLight(bModifier, UnittoIcons.Key2, false) { addSymbol(Token._2) }
KeyboardButtonLight(bModifier, UnittoIcons.Key3, false) { addSymbol(Token._3) }
}
Row(cModifier) {
KeyboardButtonLight(bModifier, UnittoIcons.Key0, false) { addSymbol(KEY_0) }
KeyboardButtonLight(bModifier, UnittoIcons.Key0, false) { addSymbol(Token._0) }
KeyboardButtonLight(dModifier, UnittoIcons.Delete, false, clearSymbols) { deleteSymbol() }
}
}