A!leys Galerie

```kotlin
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Keyboard
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalSoftwareKeyboardController
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.ui.window.TouchTargetSize
import androidx.compose.ui.window.serialization.LocalWindowSizeSerializer
import java.math.BigDecimal
import java.math.RoundingMode
import kotlin.math.pow

@Composable
fun MathsparkApp() {
    val history = remember { mutableListOf<String>() }
    val windowSizeSerializer = LocalWindowSizeSerializer.current
    var expression by remember { mutableStateOf("") }
    val keyboardController = LocalSoftwareKeyboardController.current
    var lastResult by remember { mutableStateOf("0") }
    var lastError by remember { mutableStateOf("") }

    MaterialTheme {
        Surface(
            modifier = Modifier.fillMaxSize(),
            color = MaterialTheme.colorScheme.background
        ) {
            Column(
                modifier = Modifier.fillMaxSize(),
                horizontalAlignment = Alignment.CenterHorizontally,
                verticalArrangement = Arrangement.spacedBy(8.dp)
            ) {
                HistoryDisplay(history)
                CalculatorDisplay(expression, lastResult, lastError)
                KeyboardController { closeKeyboard = { keyboardController?.hide() } }
                CalculatorButtons(
                    onNumberClick = { digit ->
                        expression += digit
                    },
                    onOperatorClick = { operator ->
                        if (expression.isNotEmpty() && !operator.isNone()) {
                            expression += operator
                        }
                    },
                    onFunctionClick = { function ->
                        when (function) {
                            "x²" -> expression = sqrt(expression).toString()
                            "1/x" -> expression = inverse(expression).toString()
                            "x!" -> expression = factorial(expression).toString()
                            "C" -> expression = ""
                            "⌫" -> expression = expression.dropLastOrNull() ?: ""
                            "=" -> {
                                try {
                                    val result = evaluate(expression)
                                    lastResult = result.toString()
                                    history.add("$expression = $result")
                                    expression = result.toString()
                                } catch (e: Exception) {
                                    lastError = "Error: ${e.message}"
                                }
                            }
                        }
                    }
                )
            }
        }
    }
}

@Composable
fun HistoryDisplay(history: List<String>) {
    val scrollState = rememberScrollState()
    Column(
        modifier = Modifier
            .fillMaxWidth()
            .height(100.dp)
            .padding(horizontal = 16.dp)
    ) {
        Text(
            text = "History",
            style = MaterialTheme.typography.titleMedium,
            modifier = Modifier.align(Alignment.Start)
        )
        Spacer(modifier = Modifier.height(8.dp))
        VerticalScrollbar(
            adapter = rememberScrollStateAdapter(scrollState),
            modifier = Modifier.align(Alignment.End)
        )
        LazyColumn(
            modifier = Modifier
                .fillMaxHeight()
                .weight(1f)
        ) {
            items(history) { item ->
                Text(
                    text = item,
                    style = MaterialTheme.typography.bodyMedium,
                    modifier = Modifier
                        .fillMaxWidth()
                        .padding(vertical = 4.dp)
                )
            }
        }
    }
}

@Composable
fun CalculatorDisplay(
    expression: String,
    result: String,
    error: String
) {
    Column(
        modifier = Modifier
            .fillMaxWidth()
            .padding(16.dp)
            .height(150.dp),
        horizontalAlignment = Alignment.End,
        verticalArrangement = Arrangement.Bottom
    ) {
        Text(
            text = expression,
            style = MaterialTheme.typography.displayMedium,
            color = MaterialTheme.colorScheme.onBackground,
            modifier = Modifier.align(Alignment.End)
        )
        Spacer(modifier = Modifier.height(8.dp))
        if (error.isNotEmpty()) {
            Text(
                text = error,
                style = MaterialTheme.typography.bodySmall,
                color = MaterialTheme.colorScheme.error,
                modifier = Modifier.align(Alignment.End)
            )
        } else {
            Text(
                text = result,
                style = MaterialTheme.typography.headlineMedium,
                color = MaterialTheme.colorScheme.primary,
                modifier = Modifier.align(Alignment.End)
            )
        }
    }
}

@Composable
fun KeyboardController(onClose: () -> Unit) {
    Text(
        text = "Press ENTER to calculate or SPACE to clear",
        style = MaterialTheme.typography.bodySmall,
        modifier = Modifier
            .padding(horizontal = 16.dp)
            .align(Alignment.CenterHorizontally)
    )
}

@Composable
fun CalculatorButtons(
    onNumberClick: (String) -> Unit,
    onOperatorClick: (String) -> Unit,
    onFunctionClick: (String) -> Unit
) {
    Column(
        modifier = Modifier
            .fillMaxWidth()
            .padding(16.dp)
            .weight(1f)
    ) {
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            CalculatorButton("C", onFunctionClick, "Clear")
            CalculatorButton("⌫", onFunctionClick, "Backspace")
            CalculatorButton("x²", onFunctionClick, "Square")
            CalculatorButton("1/x", onFunctionClick, "Reciprocal")
        }
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            CalculatorButton("x!", onFunctionClick, "Factorial")
            CalculatorButton("(", onOperatorClick, "Parentheses")
            CalculatorButton(")", onOperatorClick, "Parentheses")
            CalculatorButton("÷", onOperatorClick, "Divide")
        }
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.spacedBy(8