Calculator

Repository

I developed this calculator application using JavaFX to create a polished, modern desktop utility. Beyond basic arithmetic, the project implements a custom parsing engine capable of handling operator precedence (BODMAS/PEMDAS) and features a dynamic UI with support for light and dark themes. This project was an exercise in bridging complex backend logic with a responsive, user-friendly graphical interface.

Dynamic UI and Theme Management

The user interface is built using JavaFX and styled with CSS to achieve a modern aesthetic. I implemented a robust theme-switching mechanism that allows users to toggle between light and dark modes in real-time. This is achieved by dynamically swapping stylesheet references and updating icon assets without requiring an application restart. The layout uses a VBox and GridPane architecture to ensure responsiveness across different window sizes.

1// Simplified Theme Toggle Logic
2themeToggleBtn.setOnAction(e -> {
3    Scene scene = themeToggleBtn.getScene();
4    scene.getStylesheets().clear();
5
6    if (isDarkMode) {
7        scene.getStylesheets().add(getClass().getResource("style.css").toExternalForm());
8        themeIcon.setImage(new Image(getClass().getResourceAsStream("sun.png")));
9    } else {
10        scene.getStylesheets().add(getClass().getResource("style-dark.css").toExternalForm());
11        themeIcon.setImage(new Image(getClass().getResourceAsStream("moon.png")));
12    }
13    isDarkMode = !isDarkMode;
14});

Operator Precedence Logic

The core calculation engine is designed to handle multi-step equations by respecting standard mathematical precedence. Instead of a simple sequential evaluator, I implemented a two-pass algorithm. The first pass handles high-precedence operations (Multiplication and Division), while the second pass processes Addition and Subtraction. This ensures that an expression like 2 + 3 * 4 correctly evaluates to 14 rather than 20.

1public void calculateAll() {
2    if (isValidEquation()) {
3        try {
4            String[] parts = currentEquation.split(" ");
5
6            // First Pass: Handling '*' and '/'
7            for (int i = 1; i < parts.length; i++) {
8                if (parts[i].equals("*") || parts[i].equals("/")) {
9                    double left = Double.parseDouble(parts[i - 1]);
10                    double right = Double.parseDouble(parts[i + 1]);
11                    double res = parts[i].equals("*") ? left * right : left / right;
12
13                    if (parts[i].equals("/") && right == 0) throw new ArithmeticException();
14
15                    // Collapse the processed parts of the array
16                    parts[i - 1] = String.valueOf(res);
17                    System.arraycopy(parts, i + 2, parts, i, parts.length - (i + 2));
18                    parts = Arrays.copyOf(parts, parts.length - 2);
19                    i--;
20                }
21            }
22            // ... second pass for '+' and '-'
23        } catch (Exception e) {
24            this.result = "#ERROR#";
25        }
26    }
27}

State-Driven Event Handling

To manage complex user interactions like negation, undo operations, and chained calculations, I used a state-driven approach. Each button interaction updates a central Calculator state object, which then triggers a UI refresh. I mapped operator buttons to their respective symbols using a HashMap, reducing boilerplate code and making the application's action-dispatching logic more maintainable and extensible.

1// Operator Action Mapping
2Map<Button, String> operatorMap = new HashMap<>();
3operatorMap.put(addBtn, "+");
4operatorMap.put(subBtn, "-");
5// ... mapping other operators
6
7operatorMap.forEach((btn, op) ->
8    btn.setOnAction(e -> {
9        if (!calc.currentNumber.isEmpty()) {
10            calc.allNumbers.add(calc.currentNumber);
11            calc.currentNumber = "";
12            calc.allOperations.add(op);
13        } else if (!calc.allOperations.isEmpty()) {
14            // Allow changing the last operator
15            calc.allOperations.set(calc.allOperations.size() - 1, op);
16        }
17        equationLabel.setText(calc.getCurrentEquation());
18    })
19);

Technical Implementation Details

The application leverages Maven for dependency management and follows a clean MVC-lite architecture. I utilized FXML for the structural layout while maintaining all styling in external CSS files to ensure a clear separation of concerns. This project provided deep insights into JavaFX event loops, regular expression parsing, and the challenges of building a reliable, stateful desktop application.

Try It Out

Download

If you want to try this app out for yourself, click on the download button and install from GitHub.

Video Demonstration

External Media Required

This video requires third-party cookies from YouTube to be displayed. Accepting will enable all external media across the site.