RSK World - Swift iOS Calculator - Project Files Browser | RSK World

CustomFormulaBuilderViewController.swift GeometryCalculatorViewController.swift

CustomFormulaBuilderViewController.swift

//
//  CustomFormulaBuilderViewController.swift
//  Swift iOS Calculator
//
//  Created by RSK World on 23/01/2026.
//  Copyright © 2026 RSK World. All rights reserved.
//
//  Developer: Molla Samser (Founder, RSK World)
//  Designer & Tester: Rima Khatun
//  Contact: info@rskworld.com, +91 93305 39277
//  Website: https://rskworld.in
//  Address: Nutanhat, Mongolkote, Purba Burdwan, West Bengal, India - 713147
//

import UIKit

class CustomFormulaBuilderViewController: UIViewController {
    
    // MARK: - Outlets
    @IBOutlet weak var formulaNameTextField: UITextField!
    @IBOutlet weak var formulaExpressionTextView: UITextView!
    @IBOutlet weak var variablesTableView: UITableView!
    @IBOutlet weak var addVariableButton: UIButton!
    @IBOutlet weak var saveFormulaButton: UIButton!
    @IBOutlet weak var calculateButton: UIButton!
    @IBOutlet weak var clearButton: UIButton!
    @IBOutlet weak var savedFormulasTableView: UITableView!
    
    // MARK: - Properties
    private var variables: [FormulaVariable] = []
    private var savedFormulas: [CustomFormula] = []
    private let customFormulaManager = CustomFormulaManager()
    
    struct FormulaVariable {
        let id = UUID()
        var name: String
        var value: Double
        var unit: String
        
        init(name: String, value: Double = 0.0, unit: String = "") {
            self.name = name
            self.value = value
            self.unit = unit
        }
    }
    
    struct CustomFormula {
        let id = UUID()
        var name: String
        var expression: String
        var variables: [String]
        var createdAt: Date
        
        init(name: String, expression: String, variables: [String]) {
            self.name = name
            self.expression = expression
            self.variables = variables
            self.createdAt = Date()
        }
    }
    
    // MARK: - Lifecycle
    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
        setupTableViews()
        loadSavedFormulas()
    }
    
    // MARK: - Setup
    private func setupUI() {
        title = "Custom Formula Builder"
        view.backgroundColor = CalculatorTheme.shared.backgroundColor
        
        // Setup text field
        formulaNameTextField.backgroundColor = CalculatorTheme.shared.displayBackgroundColor
        formulaNameTextField.textColor = CalculatorTheme.shared.textColor
        formulaNameTextField.layer.cornerRadius = 8
        formulaNameTextField.layer.borderWidth = 1
        formulaNameTextField.layer.borderColor = CalculatorTheme.shared.buttonBackgroundColor.cgColor
        formulaNameTextField.placeholder = "Enter formula name"
        
        // Setup text view
        formulaExpressionTextView.backgroundColor = CalculatorTheme.shared.displayBackgroundColor
        formulaExpressionTextView.textColor = CalculatorTheme.shared.textColor
        formulaExpressionTextView.layer.cornerRadius = 8
        formulaExpressionTextView.layer.borderWidth = 2
        formulaExpressionTextView.layer.borderColor = CalculatorTheme.shared.accentColor.cgColor
        formulaExpressionTextView.font = UIFont.systemFont(ofSize: 16, weight: .medium)
        formulaExpressionTextView.text = "Enter formula (e.g., a * b + c)"
        
        // Setup buttons
        setupButton(addVariableButton, title: "+ Add Variable", color: .systemBlue)
        setupButton(saveFormulaButton, title: "Save Formula", color: .systemGreen)
        setupButton(calculateButton, title: "Calculate", color: .systemOrange)
        setupButton(clearButton, title: "Clear", color: .systemRed)
    }
    
    private func setupButton(_ button: UIButton, title: String, color: UIColor) {
        button.setTitle(title, for: .normal)
        button.backgroundColor = color
        button.setTitleColor(.white, for: .normal)
        button.layer.cornerRadius = 8
        button.titleLabel?.font = UIFont.systemFont(ofSize: 14, weight: .medium)
    }
    
    private func setupTableViews() {
        // Setup variables table view
        variablesTableView.delegate = self
        variablesTableView.dataSource = self
        variablesTableView.backgroundColor = CalculatorTheme.shared.backgroundColor
        variablesTableView.layer.cornerRadius = 8
        variablesTableView.separatorStyle = .none
        
        // Setup saved formulas table view
        savedFormulasTableView.delegate = self
        savedFormulasTableView.dataSource = self
        savedFormulasTableView.backgroundColor = CalculatorTheme.shared.backgroundColor
        savedFormulasTableView.layer.cornerRadius = 8
        savedFormulasTableView.separatorStyle = .none
        
        // Register cells
        variablesTableView.register(UINib(nibName: "VariableCell", bundle: nil), forCellReuseIdentifier: "VariableCell")
        savedFormulasTableView.register(UINib(nibName: "FormulaCell", bundle: nil), forCellReuseIdentifier: "FormulaCell")
    }
    
    private func loadSavedFormulas() {
        savedFormulas = customFormulaManager.getAllFormulas()
        savedFormulasTableView.reloadData()
    }
    
    // MARK: - Actions
    @IBAction func addVariableButtonPressed(_ sender: UIButton) {
        showAddVariableAlert()
    }
    
    @IBAction func saveFormulaButtonPressed(_ sender: UIButton) {
        saveFormula()
    }
    
    @IBAction func calculateButtonPressed(_ sender: UIButton) {
        calculateFormula()
    }
    
    @IBAction func clearButtonPressed(_ sender: UIButton) {
        clearAll()
    }
    
    // MARK: - Methods
    private func showAddVariableAlert() {
        let alert = UIAlertController(title: "Add Variable", message: "Enter variable details", preferredStyle: .alert)
        
        alert.addTextField { textField in
            textField.placeholder = "Variable name (e.g., x, a, b)"
        }
        
        alert.addTextField { textField in
            textField.placeholder = "Value"
            textField.keyboardType = .decimalPad
        }
        
        alert.addTextField { textField in
            textField.placeholder = "Unit (optional)"
        }
        
        let addAction = UIAlertAction(title: "Add", style: .default) { [weak self] _ in
            guard let nameField = alert.textFields?[0],
                  let valueField = alert.textFields?[1],
                  let unitField = alert.textFields?[2],
                  let name = nameField.text, !name.isEmpty,
                  let value = Double(valueField.text ?? "0") else {
                return
            }
            
            let unit = unitField.text ?? ""
            let variable = FormulaVariable(name: name, value: value, unit: unit)
            self?.variables.append(variable)
            self?.variablesTableView.reloadData()
        }
        
        alert.addAction(addAction)
        alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))
        
        present(alert, animated: true)
    }
    
    private func saveFormula() {
        guard let name = formulaNameTextField.text, !name.isEmpty,
              let expression = formulaExpressionTextView.text, !expression.isEmpty else {
            showAlert(title: "Error", message: "Please enter formula name and expression")
            return
        }
        
        let variableNames = variables.map { $0.name }
        let formula = CustomFormula(name: name, expression: expression, variables: variableNames)
        
        customFormulaManager.saveFormula(formula)
        loadSavedFormulas()
        
        showAlert(title: "Success", message: "Formula saved successfully!")
    }
    
    private func calculateFormula() {
        guard let expression = formulaExpressionTextView.text, !expression.isEmpty else {
            showAlert(title: "Error", message: "Please enter a formula expression")
            return
        }
        
        let result = customFormulaManager.evaluateFormula(expression: expression, variables: variables)
        
        switch result {
        case .success(let value):
            let message = """
            Formula Result:
            
            Expression: \(expression)
            Result: \(String(format: "%.6f", value))
            
            Variables used:
            \(variables.map { "\($0.name) = \($0.value) \($0.unit)" }.joined(separator: "\n"))
            """
            
            showAlert(title: "Calculation Result", message: message)
            
            // Save to history
            saveToHistory(expression: expression, result: value)
            
        case .failure(let error):
            showAlert(title: "Calculation Error", message: error.localizedDescription)
        }
    }
    
    private func clearAll() {
        formulaNameTextField.text = ""
        formulaExpressionTextView.text = "Enter formula (e.g., a * b + c)"
        variables.removeAll()
        variablesTableView.reloadData()
    }
    
    private func saveToHistory(expression: String, result: Double) {
        let historyItem = CalculationHistoryItem(
            expression: "Custom: \(expression)",
            result: "Result: \(String(format: "%.6f", result))",
            category: "Custom Formula",
            date: Date()
        )
        
        CalculationHistoryManager.shared.addHistoryItem(historyItem)
    }
    
    private func showAlert(title: String, message: String) {
        let alert = UIAlertController(title: title, message: message, preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: "OK", style: .default))
        present(alert, animated: true)
    }
}

// MARK: - UITableViewDataSource & UITableViewDelegate
extension CustomFormulaBuilderViewController: UITableViewDataSource, UITableViewDelegate {
    
    // MARK: - Variables Table View
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        if tableView == variablesTableView {
            return variables.count
        } else {
            return savedFormulas.count
        }
    }
    
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        if tableView == variablesTableView {
            let cell = tableView.dequeueReusableCell(withIdentifier: "VariableCell", for: indexPath) as! VariableCell
            let variable = variables[indexPath.row]
            cell.configure(with: variable, delegate: self)
            return cell
        } else {
            let cell = tableView.dequeueReusableCell(withIdentifier: "FormulaCell", for: indexPath) as! FormulaCell
            let formula = savedFormulas[indexPath.row]
            cell.configure(with: formula, delegate: self)
            return cell
        }
    }
    
    func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
        return UITableView.automaticDimension
    }
    
    func tableView(_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
        return 60
    }
    
    func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCell.EditingStyle, forRowAt indexPath: IndexPath) {
        if tableView == variablesTableView && editingStyle == .delete {
            variables.remove(at: indexPath.row)
            tableView.deleteRows(at: [indexPath], with: .fade)
        } else if tableView == savedFormulasTableView && editingStyle == .delete {
            let formula = savedFormulas[indexPath.row]
            customFormulaManager.deleteFormula(formula)
            savedFormulas.remove(at: indexPath.row)
            tableView.deleteRows(at: [indexPath], with: .fade)
        }
    }
}

// MARK: - Custom Formula Manager
class CustomFormulaManager {
    
    private let userDefaults = UserDefaults.standard
    private let formulasKey = "CustomFormulas"
    
    func saveFormula(_ formula: CustomFormulaBuilderViewController.CustomFormula) {
        var formulas = getAllFormulas()
        formulas.append(formula)
        saveFormulas(formulas)
    }
    
    func getAllFormulas() -> [CustomFormulaBuilderViewController.CustomFormula] {
        guard let data = userDefaults.data(forKey: formulasKey),
              let formulas = try? JSONDecoder().decode([CustomFormulaBuilderViewController.CustomFormula].self, from: data) else {
            return []
        }
        return formulas
    }
    
    func deleteFormula(_ formula: CustomFormulaBuilderViewController.CustomFormula) {
        var formulas = getAllFormulas()
        formulas.removeAll { $0.id == formula.id }
        saveFormulas(formulas)
    }
    
    func evaluateFormula(expression: String, variables: [CustomFormulaBuilderViewController.FormulaVariable]) -> Result<Double, Error> {
        var evaluatedExpression = expression
        
        // Replace variables with their values
        for variable in variables {
            evaluatedExpression = evaluatedExpression.replacingOccurrences(of: variable.name, with: "\(variable.value)")
        }
        
        // Replace mathematical functions
        evaluatedExpression = evaluatedExpression
            .replacingOccurrences(of: "sin", with: "Foundation.sin")
            .replacingOccurrences(of: "cos", with: "Foundation.cos")
            .replacingOccurrences(of: "tan", with: "Foundation.tan")
            .replacingOccurrences(of: "sqrt", with: "Foundation.sqrt")
            .replacingOccurrences(of: "log", with: "Foundation.log")
            .replacingOccurrences(of: "exp", with: "Foundation.exp")
            .replacingOccurrences(of: "abs", with: "Foundation.abs")
            .replacingOccurrences(of: "pi", with: "\(Double.pi)")
            .replacingOccurrences(of: "^", with: "**")
        
        // Evaluate using NSExpression
        guard let nsExpression = try? NSExpression(format: evaluatedExpression) else {
            return .failure(FormulaError.invalidExpression)
        }
        
        do {
            let result = try nsExpression.expressionValue(with: nil, context: nil)
            if let value = result as? Double {
                return .success(value)
            } else {
                return .failure(FormulaError.invalidResult)
            }
        } catch {
            return .failure(error)
        }
    }
    
    private func saveFormulas(_ formulas: [CustomFormulaBuilderViewController.CustomFormula]) {
        if let data = try? JSONEncoder().encode(formulas) {
            userDefaults.set(data, forKey: formulasKey)
        }
    }
}

// MARK: - Supporting Protocols and Classes
protocol VariableCellDelegate: AnyObject {
    func variableCell(_ cell: VariableCell, valueChanged: Double)
    func variableCell(_ cell: VariableCell, deleteVariable: FormulaVariable)
}

protocol FormulaCellDelegate: AnyObject {
    func formulaCell(_ cell: FormulaCell, loadFormula: CustomFormulaBuilderViewController.CustomFormula)
    func formulaCell(_ cell: FormulaCell, deleteFormula: CustomFormulaBuilderViewController.CustomFormula)
}

class VariableCell: UITableViewCell {
    
    @IBOutlet weak var nameLabel: UILabel!
    @IBOutlet weak var valueTextField: UITextField!
    @IBOutlet weak var unitLabel: UILabel!
    @IBOutlet weak var deleteButton: UIButton!
    
    weak var delegate: VariableCellDelegate?
    private var variable: CustomFormulaBuilderViewController.FormulaVariable?
    
    func configure(with variable: CustomFormulaBuilderViewController.FormulaVariable, delegate: VariableCellDelegate?) {
        self.variable = variable
        self.delegate = delegate
        
        nameLabel.text = variable.name
        valueTextField.text = String(format: "%.6f", variable.value)
        unitLabel.text = variable.unit
        
        // Apply theme
        backgroundColor = CalculatorTheme.shared.backgroundColor
        nameLabel.textColor = CalculatorTheme.shared.textColor
        valueTextField.backgroundColor = CalculatorTheme.shared.displayBackgroundColor
        valueTextField.textColor = CalculatorTheme.shared.textColor
        unitLabel.textColor = CalculatorTheme.shared.textColor
        
        // Setup text field
        valueTextField.layer.cornerRadius = 4
        valueTextField.layer.borderWidth = 1
        valueTextField.layer.borderColor = CalculatorTheme.shared.buttonBackgroundColor.cgColor
        valueTextField.textAlignment = .center
        valueTextField.keyboardType = .decimalPad
        
        // Setup delete button
        deleteButton.setTitle("Delete", for: .normal)
        deleteButton.backgroundColor = .systemRed
        deleteButton.setTitleColor(.white, for: .normal)
        deleteButton.layer.cornerRadius = 4
        
        // Add target
        valueTextField.addTarget(self, action: #selector(valueChanged), for: .editingChanged)
    }
    
    @objc private func valueChanged() {
        guard let text = valueTextField.text, let value = Double(text) else { return }
        variable?.value = value
        delegate?.variableCell(self, valueChanged: value)
    }
    
    @IBAction func deleteButtonPressed(_ sender: UIButton) {
        guard let variable = variable else { return }
        delegate?.variableCell(self, deleteVariable: variable)
    }
}

class FormulaCell: UITableViewCell {
    
    @IBOutlet weak var nameLabel: UILabel!
    @IBOutlet weak var expressionLabel: UILabel!
    @IBOutlet weak var variablesLabel: UILabel!
    @IBOutlet weak var loadButton: UIButton!
    @IBOutlet weak var deleteButton: UIButton!
    
    weak var delegate: FormulaCellDelegate?
    private var formula: CustomFormulaBuilderViewController.CustomFormula?
    
    func configure(with formula: CustomFormulaBuilderViewController.CustomFormula, delegate: FormulaCellDelegate?) {
        self.formula = formula
        self.delegate = delegate
        
        nameLabel.text = formula.name
        expressionLabel.text = formula.expression
        variablesLabel.text = "Variables: \(formula.variables.joined(separator: ", "))"
        
        // Apply theme
        backgroundColor = CalculatorTheme.shared.backgroundColor
        nameLabel.textColor = CalculatorTheme.shared.textColor
        expressionLabel.textColor = CalculatorTheme.shared.textColor
        variablesLabel.textColor = CalculatorTheme.shared.textColor
        
        // Setup buttons
        loadButton.setTitle("Load", for: .normal)
        loadButton.backgroundColor = .systemBlue
        loadButton.setTitleColor(.white, for: .normal)
        loadButton.layer.cornerRadius = 4
        
        deleteButton.setTitle("Delete", for: .normal)
        deleteButton.backgroundColor = .systemRed
        deleteButton.setTitleColor(.white, for: .normal)
        deleteButton.layer.cornerRadius = 4
    }
    
    @IBAction func loadButtonPressed(_ sender: UIButton) {
        guard let formula = formula else { return }
        delegate?.formulaCell(self, loadFormula: formula)
    }
    
    @IBAction func deleteButtonPressed(_ sender: UIButton) {
        guard let formula = formula else { return }
        delegate?.formulaCell(self, deleteFormula: formula)
    }
}

// MARK: - Error Types
enum FormulaError: LocalizedError {
    case invalidExpression
    case invalidResult
    case missingVariable
    
    var errorDescription: String? {
        switch self {
        case .invalidExpression:
            return "Invalid mathematical expression"
        case .invalidResult:
            return "Could not evaluate expression"
        case .missingVariable:
            return "Missing required variable"
        }
    }
}

// MARK: - Codable Extensions
extension CustomFormulaBuilderViewController.CustomFormula: Codable {
    enum CodingKeys: String, CodingKey {
        case id, name, expression, variables, createdAt
    }
    
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        let id = try container.decode(UUID.self, forKey: .id)
        let name = try container.decode(String.self, forKey: .name)
        let expression = try container.decode(String.self, forKey: .expression)
        let variables = try container.decode([String].self, forKey: .variables)
        let createdAt = try container.decode(Date.self, forKey: .createdAt)
        
        self.init(name: name, expression: expression, variables: variables)
        // Note: id and createdAt are read-only in the struct
    }
    
    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(id, forKey: .id)
        try container.encode(name, forKey: .name)
        try container.encode(expression, forKey: .expression)
        try container.encode(variables, forKey: .variables)
        try container.encode(createdAt, forKey: .createdAt)
    }
}

// MARK: - Delegate Implementations
extension CustomFormulaBuilderViewController: VariableCellDelegate {
    func variableCell(_ cell: VariableCell, valueChanged: Double) {
        // Variable value changed
    }
    
    func variableCell(_ cell: VariableCell, deleteVariable: CustomFormulaBuilderViewController.FormulaVariable) {
        if let index = variables.firstIndex(where: { $0.id == deleteVariable.id }) {
            variables.remove(at: index)
            variablesTableView.reloadData()
        }
    }
}

extension CustomFormulaBuilderViewController: FormulaCellDelegate {
    func formulaCell(_ cell: FormulaCell, loadFormula: CustomFormulaBuilderViewController.CustomFormula) {
        formulaNameTextField.text = formula.name
        formulaExpressionTextView.text = formula.expression
        
        // Clear existing variables and add formula variables
        variables.removeAll()
        for variableName in formula.variables {
            variables.append(FormulaVariable(name: variableName))
        }
        variablesTableView.reloadData()
    }
    
    func formulaCell(_ cell: FormulaCell, deleteFormula: CustomFormulaBuilderViewController.CustomFormula) {
        customFormulaManager.deleteFormula(deleteFormula)
        loadSavedFormulas()
    }
}

566 lines•22.1 KB

swift

GeometryCalculatorViewController.swift

Raw Download

//
//  GeometryCalculatorViewController.swift
//  Swift iOS Calculator
//
//  Created by RSK World on 23/01/2026.
//  Copyright © 2026 RSK World. All rights reserved.
//
//  Developer: Molla Samser (Founder, RSK World)
//  Designer & Tester: Rima Khatun
//  Contact: info@rskworld.com, +91 93305 39277
//  Website: https://rskworld.in
//  Address: Nutanhat, Mongolkote, Purba Burdwan, West Bengal, India - 713147
//

import UIKit

class GeometryCalculatorViewController: UIViewController {
    
    // MARK: - Outlets
    @IBOutlet weak var shapeSegmentedControl: UISegmentedControl!
    @IBOutlet weak var dimensionSegmentedControl: UISegmentedControl!
    @IBOutlet weak var inputContainerView: UIView!
    @IBOutlet weak var resultTextView: UITextView!
    @IBOutlet weak var calculateButton: UIButton!
    @IBOutlet weak var clearButton: UIButton!
    
    // 2D Shape Outlets
    @IBOutlet weak var length2DTextField: UITextField!
    @IBOutlet weak var width2DTextField: UITextField!
    @IBOutlet weak var radius2DTextField: UITextField!
    @IBOutlet weak var height2DTextField: UITextField!
    @IBOutlet weak var base2DTextField: UITextField!
    
    // 3D Shape Outlets
    @IBOutlet weak var length3DTextField: UITextField!
    @IBOutlet weak var width3DTextField: UITextField!
    @IBOutlet weak var height3DTextField: UITextField!
    @IBOutlet weak var radius3DTextField: UITextField!
    @IBOutlet weak var depth3DTextField: UITextField!
    
    // MARK: - Properties
    private var currentShape: GeometryShape = .rectangle
    private var currentDimension: GeometryDimension = .twoD
    private let geometryCalculator = GeometryCalculatorService()
    
    enum GeometryShape: String, CaseIterable {
        case rectangle = "Rectangle"
        case circle = "Circle"
        case triangle = "Triangle"
        case square = "Square"
        case ellipse = "Ellipse"
        case trapezoid = "Trapezoid"
        case cube = "Cube"
        case sphere = "Sphere"
        case cylinder = "Cylinder"
        case cone = "Cone"
        case pyramid = "Pyramid"
        case prism = "Prism"
        
        var icon: String {
            switch self {
            case .rectangle: return "rectangle"
            case .circle: return "circle"
            case .triangle: return "triangle"
            case .square: return "square"
            case .ellipse: return "oval"
            case .trapezoid: return "trapezoid"
            case .cube: return "cube"
            case .sphere: return "circle.fill"
            case .cylinder: return "cylinder"
            case .cone: return "cone"
            case .pyramid: return "pyramid"
            case .prism: return "prism"
            }
        }
        
        var is2D: Bool {
            switch self {
            case .rectangle, .circle, .triangle, .square, .ellipse, .trapezoid:
                return true
            default:
                return false
            }
        }
        
        var is3D: Bool {
            return !is2D
        }
    }
    
    enum GeometryDimension: String, CaseIterable {
        case twoD = "2D Shapes"
        case threeD = "3D Shapes"
    }
    
    // MARK: - Lifecycle
    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
        setupSegmentedControls()
        setupInputViews()
        showRectangleInputs()
    }
    
    // MARK: - Setup
    private func setupUI() {
        title = "Geometry Calculator"
        view.backgroundColor = CalculatorTheme.shared.backgroundColor
        
        // Setup result text view
        resultTextView.backgroundColor = CalculatorTheme.shared.displayBackgroundColor
        resultTextView.textColor = CalculatorTheme.shared.textColor
        resultTextView.layer.cornerRadius = 12
        resultTextView.layer.borderWidth = 2
        resultTextView.layer.borderColor = CalculatorTheme.shared.accentColor.cgColor
        resultTextView.font = UIFont.systemFont(ofSize: 16, weight: .medium)
        resultTextView.isEditable = false
        
        // Setup buttons
        setupButton(calculateButton, title: "Calculate", color: .systemGreen)
        setupButton(clearButton, title: "Clear", color: .systemRed)
    }
    
    private func setupButton(_ button: UIButton, title: String, color: UIColor) {
        button.setTitle(title, for: .normal)
        button.backgroundColor = color
        button.setTitleColor(.white, for: .normal)
        button.layer.cornerRadius = 8
        button.titleLabel?.font = UIFont.systemFont(ofSize: 16, weight: .medium)
    }
    
    private func setupSegmentedControls() {
        // Setup dimension segmented control
        dimensionSegmentedControl.removeAllSegments()
        for (index, dimension) in GeometryDimension.allCases.enumerated() {
            dimensionSegmentedControl.insertSegment(withTitle: dimension.rawValue, at: index, animated: false)
        }
        dimensionSegmentedControl.selectedSegmentIndex = 0
        dimensionSegmentedControl.backgroundColor = CalculatorTheme.shared.buttonBackgroundColor
        dimensionSegmentedControl.selectedSegmentTintColor = CalculatorTheme.shared.accentColor
        dimensionSegmentedControl.setTitleTextAttributes([NSAttributedString.Key.foregroundColor: CalculatorTheme.shared.textColor], for: .normal)
        dimensionSegmentedControl.setTitleTextAttributes([NSAttributedString.Key.foregroundColor: UIColor.white], for: .selected)
        
        // Setup shape segmented control
        updateShapeSegmentedControl()
    }
    
    private func updateShapeSegmentedControl() {
        shapeSegmentedControl.removeAllSegments()
        
        let shapes = currentDimension == .twoD ? 
            GeometryShape.allCases.filter { $0.is2D } : 
            GeometryShape.allCases.filter { $0.is3D }
        
        for (index, shape) in shapes.enumerated() {
            shapeSegmentedControl.insertSegment(withTitle: shape.rawValue, at: index, animated: false)
        }
        
        shapeSegmentedControl.selectedSegmentIndex = 0
        shapeSegmentedControl.backgroundColor = CalculatorTheme.shared.buttonBackgroundColor
        shapeSegmentedControl.selectedSegmentTintColor = CalculatorTheme.shared.accentColor
        shapeSegmentedControl.setTitleTextAttributes([NSAttributedString.Key.foregroundColor: CalculatorTheme.shared.textColor], for: .normal)
        shapeSegmentedControl.setTitleTextAttributes([NSAttributedString.Key.foregroundColor: UIColor.white], for: .selected)
        
        // Update current shape
        if let firstShape = shapes.first {
            currentShape = firstShape
        }
    }
    
    private func setupInputViews() {
        // Setup all text fields with consistent styling
        let textFields = [
            length2DTextField, width2DTextField, radius2DTextField, height2DTextField, base2DTextField,
            length3DTextField, width3DTextField, height3DTextField, radius3DTextField, depth3DTextField
        ].compactMap { $0 }
        
        for textField in textFields {
            textField.backgroundColor = CalculatorTheme.shared.displayBackgroundColor
            textField.textColor = CalculatorTheme.shared.textColor
            textField.layer.cornerRadius = 8
            textField.layer.borderWidth = 1
            textField.layer.borderColor = CalculatorTheme.shared.buttonBackgroundColor.cgColor
            textField.textAlignment = .center
            textField.font = UIFont.systemFont(ofSize: 16)
            textField.keyboardType = .decimalPad
        }
    }
    
    // MARK: - Actions
    @IBAction func dimensionChanged(_ sender: UISegmentedControl) {
        currentDimension = GeometryDimension.allCases[sender.selectedSegmentIndex]
        updateShapeSegmentedControl()
        switchToShape(currentShape)
    }
    
    @IBAction func shapeChanged(_ sender: UISegmentedControl) {
        let shapes = currentDimension == .twoD ? 
            GeometryShape.allCases.filter { $0.is2D } : 
            GeometryShape.allCases.filter { $0.is3D }
        
        if sender.selectedSegmentIndex < shapes.count {
            currentShape = shapes[sender.selectedSegmentIndex]
            switchToShape(currentShape)
        }
    }
    
    @IBAction func calculateButtonPressed(_ sender: UIButton) {
        performCalculation()
    }
    
    @IBAction func clearButtonPressed(_ sender: UIButton) {
        clearAllInputs()
    }
    
    // MARK: - Methods
    private func switchToShape(_ shape: GeometryShape) {
        hideAllInputViews()
        
        switch shape {
        case .rectangle:
            showRectangleInputs()
        case .circle:
            showCircleInputs()
        case .triangle:
            showTriangleInputs()
        case .square:
            showSquareInputs()
        case .ellipse:
            showEllipseInputs()
        case .trapezoid:
            showTrapezoidInputs()
        case .cube:
            showCubeInputs()
        case .sphere:
            showSphereInputs()
        case .cylinder:
            showCylinderInputs()
        case .cone:
            showConeInputs()
        case .pyramid:
            showPyramidInputs()
        case .prism:
            showPrismInputs()
        }
        
        clearResult()
    }
    
    private func hideAllInputViews() {
        inputContainerView.subviews.forEach { $0.isHidden = true }
    }
    
    private func showRectangleInputs() {
        length2DTextField.isHidden = false
        width2DTextField.isHidden = false
        
        length2DTextField.placeholder = "Length"
        width2DTextField.placeholder = "Width"
    }
    
    private func showCircleInputs() {
        radius2DTextField.isHidden = false
        radius2DTextField.placeholder = "Radius"
    }
    
    private func showTriangleInputs() {
        base2DTextField.isHidden = false
        height2DTextField.isHidden = false
        
        base2DTextField.placeholder = "Base"
        height2DTextField.placeholder = "Height"
    }
    
    private func showSquareInputs() {
        length2DTextField.isHidden = false
        length2DTextField.placeholder = "Side Length"
    }
    
    private func showEllipseInputs() {
        radius2DTextField.isHidden = false
        height2DTextField.isHidden = false
        
        radius2DTextField.placeholder = "Semi-Major Axis"
        height2DTextField.placeholder = "Semi-Minor Axis"
    }
    
    private func showTrapezoidInputs() {
        base2DTextField.isHidden = false
        height2DTextField.isHidden = false
        length2DTextField.isHidden = false
        
        base2DTextField.placeholder = "Base 1"
        length2DTextField.placeholder = "Base 2"
        height2DTextField.placeholder = "Height"
    }
    
    private func showCubeInputs() {
        length3DTextField.isHidden = false
        length3DTextField.placeholder = "Edge Length"
    }
    
    private func showSphereInputs() {
        radius3DTextField.isHidden = false
        radius3DTextField.placeholder = "Radius"
    }
    
    private func showCylinderInputs() {
        radius3DTextField.isHidden = false
        height3DTextField.isHidden = false
        
        radius3DTextField.placeholder = "Radius"
        height3DTextField.placeholder = "Height"
    }
    
    private func showConeInputs() {
        radius3DTextField.isHidden = false
        height3DTextField.isHidden = false
        
        radius3DTextField.placeholder = "Radius"
        height3DTextField.placeholder = "Height"
    }
    
    private func showPyramidInputs() {
        length3DTextField.isHidden = false
        width3DTextField.isHidden = false
        height3DTextField.isHidden = false
        
        length3DTextField.placeholder = "Base Length"
        width3DTextField.placeholder = "Base Width"
        height3DTextField.placeholder = "Height"
    }
    
    private func showPrismInputs() {
        length3DTextField.isHidden = false
        width3DTextField.isHidden = false
        height3DTextField.isHidden = false
        depth3DTextField.isHidden = false
        
        length3DTextField.placeholder = "Length"
        width3DTextField.placeholder = "Width"
        height3DTextField.placeholder = "Height"
        depth3DTextField.placeholder = "Depth"
    }
    
    private func performCalculation() {
        view.endEditing(true)
        
        switch currentShape {
        case .rectangle:
            calculateRectangle()
        case .circle:
            calculateCircle()
        case .triangle:
            calculateTriangle()
        case .square:
            calculateSquare()
        case .ellipse:
            calculateEllipse()
        case .trapezoid:
            calculateTrapezoid()
        case .cube:
            calculateCube()
        case .sphere:
            calculateSphere()
        case .cylinder:
            calculateCylinder()
        case .cone:
            calculateCone()
        case .pyramid:
            calculatePyramid()
        case .prism:
            calculatePrism()
        }
    }
    
    private func calculateRectangle() {
        guard let length = Double(length2DTextField.text ?? ""),
              let width = Double(width2DTextField.text ?? "") else {
            showError("Please enter valid length and width")
            return
        }
        
        let result = geometryCalculator.calculateRectangle(length: length, width: width)
        displayResult(result)
    }
    
    private func calculateCircle() {
        guard let radius = Double(radius2DTextField.text ?? "") else {
            showError("Please enter valid radius")
            return
        }
        
        let result = geometryCalculator.calculateCircle(radius: radius)
        displayResult(result)
    }
    
    private func calculateTriangle() {
        guard let base = Double(base2DTextField.text ?? ""),
              let height = Double(height2DTextField.text ?? "") else {
            showError("Please enter valid base and height")
            return
        }
        
        let result = geometryCalculator.calculateTriangle(base: base, height: height)
        displayResult(result)
    }
    
    private func calculateSquare() {
        guard let side = Double(length2DTextField.text ?? "") else {
            showError("Please enter valid side length")
            return
        }
        
        let result = geometryCalculator.calculateSquare(side: side)
        displayResult(result)
    }
    
    private func calculateEllipse() {
        guard let semiMajor = Double(radius2DTextField.text ?? ""),
              let semiMinor = Double(height2DTextField.text ?? "") else {
            showError("Please enter valid semi-major and semi-minor axes")
            return
        }
        
        let result = geometryCalculator.calculateEllipse(semiMajor: semiMajor, semiMinor: semiMinor)
        displayResult(result)
    }
    
    private func calculateTrapezoid() {
        guard let base1 = Double(base2DTextField.text ?? ""),
              let base2 = Double(length2DTextField.text ?? ""),
              let height = Double(height2DTextField.text ?? "") else {
            showError("Please enter valid base lengths and height")
            return
        }
        
        let result = geometryCalculator.calculateTrapezoid(base1: base1, base2: base2, height: height)
        displayResult(result)
    }
    
    private func calculateCube() {
        guard let edge = Double(length3DTextField.text ?? "") else {
            showError("Please enter valid edge length")
            return
        }
        
        let result = geometryCalculator.calculateCube(edge: edge)
        displayResult(result)
    }
    
    private func calculateSphere() {
        guard let radius = Double(radius3DTextField.text ?? "") else {
            showError("Please enter valid radius")
            return
        }
        
        let result = geometryCalculator.calculateSphere(radius: radius)
        displayResult(result)
    }
    
    private func calculateCylinder() {
        guard let radius = Double(radius3DTextField.text ?? ""),
              let height = Double(height3DTextField.text ?? "") else {
            showError("Please enter valid radius and height")
            return
        }
        
        let result = geometryCalculator.calculateCylinder(radius: radius, height: height)
        displayResult(result)
    }
    
    private func calculateCone() {
        guard let radius = Double(radius3DTextField.text ?? ""),
              let height = Double(height3DTextField.text ?? "") else {
            showError("Please enter valid radius and height")
            return
        }
        
        let result = geometryCalculator.calculateCone(radius: radius, height: height)
        displayResult(result)
    }
    
    private func calculatePyramid() {
        guard let length = Double(length3DTextField.text ?? ""),
              let width = Double(width3DTextField.text ?? ""),
              let height = Double(height3DTextField.text ?? "") else {
            showError("Please enter valid base dimensions and height")
            return
        }
        
        let result = geometryCalculator.calculatePyramid(length: length, width: width, height: height)
        displayResult(result)
    }
    
    private func calculatePrism() {
        guard let length = Double(length3DTextField.text ?? ""),
              let width = Double(width3DTextField.text ?? ""),
              let height = Double(height3DTextField.text ?? ""),
              let depth = Double(depth3DTextField.text ?? "") else {
            showError("Please enter valid dimensions")
            return
        }
        
        let result = geometryCalculator.calculatePrism(length: length, width: width, height: height, depth: depth)
        displayResult(result)
    }
    
    private func displayResult(_ result: GeometryCalculationResult) {
        let resultText = formatResult(result)
        resultTextView.text = resultText
        
        // Animate result appearance
        resultTextView.alpha = 0
        UIView.animate(withDuration: 0.5) {
            self.resultTextView.alpha = 1
        }
        
        // Save to history
        saveToHistory(result: resultText)
    }
    
    private func formatResult(_ result: GeometryCalculationResult) -> String {
        var formattedResult = ""
        
        switch result {
        case .rectangle(let area, let perimeter):
            formattedResult = """
            📐 Rectangle Results
            
            Area: \(String(format: "%.2f", area)) square units
            Perimeter: \(String(format: "%.2f", perimeter)) units
            
            Formulas:
            • Area = length × width
            • Perimeter = 2 × (length + width)
            """
            
        case .circle(let area, let circumference):
            formattedResult = """
            ⭕ Circle Results
            
            Area: \(String(format: "%.2f", area)) square units
            Circumference: \(String(format: "%.2f", circumference)) units
            
            Formulas:
            • Area = π × r²
            • Circumference = 2 × π × r
            """
            
        case .triangle(let area, let perimeter):
            formattedResult = """
            🔺 Triangle Results
            
            Area: \(String(format: "%.2f", area)) square units
            Perimeter: \(String(format: "%.2f", perimeter)) units
            
            Formulas:
            • Area = ½ × base × height
            • Perimeter = sum of all sides
            """
            
        case .square(let area, let perimeter):
            formattedResult = """
            ⬜ Square Results
            
            Area: \(String(format: "%.2f", area)) square units
            Perimeter: \(String(format: "%.2f", perimeter)) units
            
            Formulas:
            • Area = side²
            • Perimeter = 4 × side
            """
            
        case .ellipse(let area, let perimeter):
            formattedResult = """
            🥚 Ellipse Results
            
            Area: \(String(format: "%.2f", area)) square units
            Perimeter: \(String(format: "%.2f", perimeter)) units
            
            Formulas:
            • Area = π × a × b
            • Perimeter ≈ π × [3(a + b) - √((3a + b)(a + 3b))]
            """
            
        case .trapezoid(let area, let perimeter):
            formattedResult = """
            🔺 Trapezoid Results
            
            Area: \(String(format: "%.2f", area)) square units
            Perimeter: \(String(format: "%.2f", perimeter)) units
            
            Formulas:
            • Area = ½ × (base1 + base2) × height
            • Perimeter = sum of all sides
            """
            
        case .cube(let volume, let surfaceArea, let diagonal):
            formattedResult = """
            🎲 Cube Results
            
            Volume: \(String(format: "%.2f", volume)) cubic units
            Surface Area: \(String(format: "%.2f", surfaceArea)) square units
            Space Diagonal: \(String(format: "%.2f", diagonal)) units
            
            Formulas:
            • Volume = edge³
            • Surface Area = 6 × edge²
            • Diagonal = edge × √3
            """
            
        case .sphere(let volume, let surfaceArea):
            formattedResult = """
            🌐 Sphere Results
            
            Volume: \(String(format: "%.2f", volume)) cubic units
            Surface Area: \(String(format: "%.2f", surfaceArea)) square units
            
            Formulas:
            • Volume = (4/3) × π × r³
            • Surface Area = 4 × π × r²
            """
            
        case .cylinder(let volume, let surfaceArea):
            formattedResult = """
            🥫 Cylinder Results
            
            Volume: \(String(format: "%.2f", volume)) cubic units
            Surface Area: \(String(format: "%.2f", surfaceArea)) square units
            
            Formulas:
            • Volume = π × r² × h
            • Surface Area = 2πr(r + h)
            """
            
        case .cone(let volume, let surfaceArea):
            formattedResult = """
            🎯 Cone Results
            
            Volume: \(String(format: "%.2f", volume)) cubic units
            Surface Area: \(String(format: "%.2f", surfaceArea)) square units
            
            Formulas:
            • Volume = (1/3) × π × r² × h
            • Surface Area = πr(r + √(r² + h²))
            """
            
        case .pyramid(let volume, let surfaceArea):
            formattedResult = """
            🔺 Pyramid Results
            
            Volume: \(String(format: "%.2f", volume)) cubic units
            Surface Area: \(String(format: "%.2f", surfaceArea)) square units
            
            Formulas:
            • Volume = (1/3) × base_area × height
            • Surface Area = base_area + lateral_area
            """
            
        case .prism(let volume, let surfaceArea):
            formattedResult = """
            🔷 Prism Results
            
            Volume: \(String(format: "%.2f", volume)) cubic units
            Surface Area: \(String(format: "%.2f", surfaceArea)) square units
            
            Formulas:
            • Volume = base_area × height
            • Surface Area = 2 × base_area + lateral_area
            """
        }
        
        return formattedResult
    }
    
    private func clearAllInputs() {
        let textFields = [
            length2DTextField, width2DTextField, radius2DTextField, height2DTextField, base2DTextField,
            length3DTextField, width3DTextField, height3DTextField, radius3DTextField, depth3DTextField
        ].compactMap { $0 }
        
        for textField in textFields {
            textField.text = ""
        }
        
        clearResult()
    }
    
    private func clearResult() {
        resultTextView.text = "Results will appear here..."
    }
    
    private func saveToHistory(result: String) {
        let historyItem = CalculationHistoryItem(
            expression: "\(currentShape.rawValue) Calculation",
            result: result,
            category: "Geometry Calculator",
            date: Date()
        )
        
        CalculationHistoryManager.shared.addHistoryItem(historyItem)
    }
    
    private func showError(_ message: String) {
        let alert = UIAlertController(title: "Error", message: message, preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: "OK", style: .default))
        present(alert, animated: true)
    }
}

// MARK: - Geometry Calculator Service
class GeometryCalculatorService {
    
    func calculateRectangle(length: Double, width: Double) -> GeometryCalculationResult {
        let area = length * width
        let perimeter = 2 * (length + width)
        return .rectangle(area: area, perimeter: perimeter)
    }
    
    func calculateCircle(radius: Double) -> GeometryCalculationResult {
        let area = Double.pi * radius * radius
        let circumference = 2 * Double.pi * radius
        return .circle(area: area, circumference: circumference)
    }
    
    func calculateTriangle(base: Double, height: Double) -> GeometryCalculationResult {
        let area = 0.5 * base * height
        // Assuming isosceles triangle for perimeter calculation
        let side = sqrt(pow(base/2, 2) + pow(height, 2))
        let perimeter = base + 2 * side
        return .triangle(area: area, perimeter: perimeter)
    }
    
    func calculateSquare(side: Double) -> GeometryCalculationResult {
        let area = side * side
        let perimeter = 4 * side
        return .square(area: area, perimeter: perimeter)
    }
    
    func calculateEllipse(semiMajor: Double, semiMinor: Double) -> GeometryCalculationResult {
        let area = Double.pi * semiMajor * semiMinor
        // Approximation for ellipse perimeter
        let h = pow((semiMajor - semiMinor), 2) / pow((semiMajor + semiMinor), 2)
        let perimeter = Double.pi * (semiMajor + semiMinor) * (1 + (3 * h) / (10 + sqrt(4 - 3 * h)))
        return .ellipse(area: area, perimeter: perimeter)
    }
    
    func calculateTrapezoid(base1: Double, base2: Double, height: Double) -> GeometryCalculationResult {
        let area = 0.5 * (base1 + base2) * height
        // Assuming isosceles trapezoid for perimeter calculation
        let side = sqrt(pow(abs(base1 - base2) / 2, 2) + pow(height, 2))
        let perimeter = base1 + base2 + 2 * side
        return .trapezoid(area: area, perimeter: perimeter)
    }
    
    func calculateCube(edge: Double) -> GeometryCalculationResult {
        let volume = edge * edge * edge
        let surfaceArea = 6 * edge * edge
        let diagonal = edge * sqrt(3)
        return .cube(volume: volume, surfaceArea: surfaceArea, diagonal: diagonal)
    }
    
    func calculateSphere(radius: Double) -> GeometryCalculationResult {
        let volume = (4.0 / 3.0) * Double.pi * pow(radius, 3)
        let surfaceArea = 4 * Double.pi * radius * radius
        return .sphere(volume: volume, surfaceArea: surfaceArea)
    }
    
    func calculateCylinder(radius: Double, height: Double) -> GeometryCalculationResult {
        let volume = Double.pi * radius * radius * height
        let surfaceArea = 2 * Double.pi * radius * (radius + height)
        return .cylinder(volume: volume, surfaceArea: surfaceArea)
    }
    
    func calculateCone(radius: Double, height: Double) -> GeometryCalculationResult {
        let volume = (1.0 / 3.0) * Double.pi * radius * radius * height
        let slantHeight = sqrt(radius * radius + height * height)
        let surfaceArea = Double.pi * radius * (radius + slantHeight)
        return .cone(volume: volume, surfaceArea: surfaceArea)
    }
    
    func calculatePyramid(length: Double, width: Double, height: Double) -> GeometryCalculationResult {
        let volume = (1.0 / 3.0) * length * width * height
        let baseArea = length * width
        let slantHeight1 = sqrt(pow(length/2, 2) + pow(height, 2))
        let slantHeight2 = sqrt(pow(width/2, 2) + pow(height, 2))
        let lateralArea = 0.5 * length * slantHeight1 + 0.5 * width * slantHeight2
        let surfaceArea = baseArea + lateralArea
        return .pyramid(volume: volume, surfaceArea: surfaceArea)
    }
    
    func calculatePrism(length: Double, width: Double, height: Double, depth: Double) -> GeometryCalculationResult {
        let volume = length * width * height
        let baseArea = length * width
        let lateralArea = 2 * (length * depth + width * depth)
        let surfaceArea = 2 * baseArea + lateralArea
        return .prism(volume: volume, surfaceArea: surfaceArea)
    }
}

// MARK: - Supporting Types
enum GeometryCalculationResult {
    case rectangle(area: Double, perimeter: Double)
    case circle(area: Double, circumference: Double)
    case triangle(area: Double, perimeter: Double)
    case square(area: Double, perimeter: Double)
    case ellipse(area: Double, perimeter: Double)
    case trapezoid(area: Double, perimeter: Double)
    case cube(volume: Double, surfaceArea: Double, diagonal: Double)
    case sphere(volume: Double, surfaceArea: Double)
    case cylinder(volume: Double, surfaceArea: Double)
    case cone(volume: Double, surfaceArea: Double)
    case pyramid(volume: Double, surfaceArea: Double)
    case prism(volume: Double, surfaceArea: Double)
}

817 lines•29.7 KB

swift

Theme Settings

Color Scheme

Display Options

Font Size