Untitled

package ics2606_1csa_activity9_galvez.java;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class ICS2606_1CSA_Activity9_GalvezJava {

    public static void main(String[] args) {
        new ShapeCalculatorGUI();
    }
    
}

class ShapeCalculatorGUI extends JFrame implements ActionListener {

    private JLabel titleLabel;
    private JLabel circleLabel;
    private JLabel rectangleLabel;
    private JLabel rightTriangleLabel;
    private JLabel squareLabel;
    private JLabel triangleLabel;

    private JLabel radiusLabel;
    private JLabel widthLabel;
    private JLabel baseLabel;
    private JLabel sideLabel;
    private JLabel heightLabel;

    private JLabel circlePerimeterLabel;
    private JLabel circleAreaLabel;
    private JLabel rectanglePerimeterLabel;
    private JLabel rectangleAreaLabel;
    private JLabel rightTrianglePerimeterLabel;
    private JLabel rightTriangleAreaLabel;
    private JLabel squarePerimeterLabel;
    private JLabel squareAreaLabel;
    private JLabel trianglePerimeterLabel;
    private JLabel triangleAreaLabel;

    private JTextField radiusTextField;
    private JTextField widthTextField;
    private JTextField baseTextField;
    private JTextField sideTextField;
    private JTextField heightTextField;

    private JTextField circlePerimeterTextField;
    private JTextField circleAreaTextField;
    private JTextField rectanglePerimeterTextField;
    private JTextField rectangleAreaTextField;
    private JTextField rightTrianglePerimeterTextField;
    private JTextField rightTriangleAreaTextField;
    private JTextField squarePerimeterTextField;
    private JTextField squareAreaTextField;
    private JTextField trianglePerimeterTextField;
    private JTextField triangleAreaTextField;

    private JTextField maxPerimeterTextField;
    private JTextField maxAreaTextField;

    private JButton computeButton;

    public ShapeCalculatorGUI() {
        super("Shape Calculator");
        setLayout(null);

        titleLabel = new JLabel("Shape Calculator by Luis the Anthony Davis");
        titleLabel.setBounds(200, 10, 200000, 30);
        add(titleLabel);

        circleLabel = new JLabel("Circle");
        circleLabel.setBounds(20, 50, 100, 30);
        add(circleLabel);

        radiusLabel = new JLabel("Radius:");
        radiusLabel.setBounds(20, 90, 100, 30);
        add(radiusLabel);

        radiusTextField = new JTextField();
        radiusTextField.setBounds(120, 90, 100, 30);
        add(radiusTextField);

        circlePerimeterLabel = new JLabel("Perimeter:");
        circlePerimeterLabel.setBounds(20, 130, 100, 30);
        add(circlePerimeterLabel);

        circlePerimeterTextField = new JTextField();
        circlePerimeterTextField.setBounds(120, 130, 100, 30);
        circlePerimeterTextField.setEditable(false);
        add(circlePerimeterTextField);

        circleAreaLabel = new JLabel("Area:");
        circleAreaLabel.setBounds(20, 170, 100, 30);
        add(circleAreaLabel);

        circleAreaTextField = new JTextField();
        circleAreaTextField.setBounds(120, 170, 100, 30);
        circleAreaTextField.setEditable(false);
        add(circleAreaTextField);

        rectangleLabel = new JLabel("Rectangle");
        rectangleLabel.setBounds(20, 220, 100, 30);
        add(rectangleLabel);

        widthLabel = new JLabel("Width:");
        widthLabel.setBounds(20, 260, 100, 30);
        add(widthLabel);

        widthTextField = new JTextField();
        widthTextField.setBounds(120, 260, 100, 30);
        add(widthTextField);

        baseLabel = new JLabel("Length:");
        baseLabel.setBounds(20, 300, 100, 30);
        add(baseLabel);

        baseTextField = new JTextField();
        baseTextField.setBounds(120, 300, 100, 30);
        add(baseTextField);

        rectanglePerimeterLabel = new JLabel("Perimeter:");
        rectanglePerimeterLabel.setBounds(20, 340, 100, 30);
        add(rectanglePerimeterLabel);

        rectanglePerimeterTextField = new JTextField();
        rectanglePerimeterTextField.setBounds(120, 340, 100, 30);
        rectanglePerimeterTextField.setEditable(false);
        add(rectanglePerimeterTextField);

        rectangleAreaLabel = new JLabel("Area:");
        rectangleAreaLabel.setBounds(20, 380, 100, 30);
        add(rectangleAreaLabel);

        rectangleAreaTextField = new JTextField();
        rectangleAreaTextField.setBounds(120, 380, 100, 30);
        rectangleAreaTextField.setEditable(false);
        add(rectangleAreaTextField);

        rightTriangleLabel = new JLabel("Right Triangle");
        rightTriangleLabel.setBounds(250, 50, 120, 30);
        add(rightTriangleLabel);

        baseLabel = new JLabel("Base:");
        baseLabel.setBounds(250, 90, 100, 30);
        add(baseLabel);

        baseTextField = new JTextField();
        baseTextField.setBounds(350, 90, 100, 30);
        add(baseTextField);

        heightLabel = new JLabel("Height:");
        heightLabel.setBounds(250, 130, 100, 30);
        add(heightLabel);

        heightTextField = new JTextField();
        heightTextField.setBounds(350, 130, 100, 30);
        add(heightTextField);

        rightTrianglePerimeterLabel = new JLabel("Perimeter:");
        rightTrianglePerimeterLabel.setBounds(250, 170, 100, 30);
        add(rightTrianglePerimeterLabel);

        rightTrianglePerimeterTextField = new JTextField();
        rightTrianglePerimeterTextField.setBounds(350, 170, 100, 30);
        rightTrianglePerimeterTextField.setEditable(false);
        add(rightTrianglePerimeterTextField);

        rightTriangleAreaLabel = new JLabel("Area:");
        rightTriangleAreaLabel.setBounds(250, 210, 100, 30);
        add(rightTriangleAreaLabel);

        rightTriangleAreaTextField = new JTextField();
        rightTriangleAreaTextField.setBounds(350, 210, 100, 30);
        rightTriangleAreaTextField.setEditable(false);
        add(rightTriangleAreaTextField);

        squareLabel = new JLabel("Square");
        squareLabel.setBounds(250, 250, 100, 30);
        add(squareLabel);

        sideLabel = new JLabel("Side:");
        sideLabel.setBounds(250, 290, 100, 30);
        add(sideLabel);

        sideTextField = new JTextField();
        sideTextField.setBounds(350, 290, 100, 30);
        add(sideTextField);

        squarePerimeterLabel = new JLabel("Perimeter:");
        squarePerimeterLabel.setBounds(250, 330, 100, 30);
        add(squarePerimeterLabel);

        squarePerimeterTextField = new JTextField();
        squarePerimeterTextField.setBounds(350, 330, 100, 30);
        squarePerimeterTextField.setEditable(false);
        add(squarePerimeterTextField);

        squareAreaLabel = new JLabel("Area:");
        squareAreaLabel.setBounds(250, 370, 100, 30);
        add(squareAreaLabel);

        squareAreaTextField = new JTextField();
        squareAreaTextField.setBounds(350, 370, 100, 30);
        squareAreaTextField.setEditable(false);
        add(squareAreaTextField);

        triangleLabel = new JLabel("Triangle");
        triangleLabel.setBounds(250, 410, 100, 30);
        add(triangleLabel);

        sideLabel = new JLabel("Side:");
        sideLabel.setBounds(250, 450, 100, 30);
        add(sideLabel);

        sideTextField = new JTextField();
        sideTextField.setBounds(350, 450, 100, 30);
        add(sideTextField);

        trianglePerimeterLabel = new JLabel("Perimeter:");
        trianglePerimeterLabel.setBounds(250, 490, 100, 30);
        add(trianglePerimeterLabel);

        trianglePerimeterTextField = new JTextField();
        trianglePerimeterTextField.setBounds(350, 490, 100, 30);
        trianglePerimeterTextField.setEditable(false);
        add(trianglePerimeterTextField);

        triangleAreaLabel = new JLabel("Area:");
        triangleAreaLabel.setBounds(250, 530, 100, 30);
        add(triangleAreaLabel);

        triangleAreaTextField = new JTextField();
        triangleAreaTextField.setBounds(350, 530, 100, 30);
        triangleAreaTextField.setEditable(false);
        add(triangleAreaTextField);

        maxPerimeterTextField = new JTextField();
        maxPerimeterTextField.setBounds(250, 580, 200, 30);
        maxPerimeterTextField.setEditable(false);
        add(maxPerimeterTextField);

        maxAreaTextField = new JTextField();
        maxAreaTextField.setBounds(250, 620, 200, 30);
        maxAreaTextField.setEditable(false);
        add(maxAreaTextField);

        computeButton = new JButton("Compute");
        computeButton.setBounds(200, 670, 100, 30);
        computeButton.addActionListener(this);
        add(computeButton);

        setSize(500, 750);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        try {
            double radius = Double.parseDouble(radiusTextField.getText());
            double width = Double.parseDouble(widthTextField.getText());
            double lengthRectangle = Double.parseDouble(baseTextField.getText());
            double sideSquare = Double.parseDouble(sideTextField.getText());
            double heightRightTriangle = Double.parseDouble(heightTextField.getText());
            double baseTriangle = Double.parseDouble(baseTextField.getText());
            double heightTriangle = Double.parseDouble(heightTextField.getText());

            // Creating instances of each shape with provided parameters
            Circle circle = new Circle(radius);
            Rectangle rectangle = new Rectangle(lengthRectangle, width);
            RightTriangle rightTriangle = new RightTriangle(baseTriangle, heightRightTriangle);
            Square square = new Square(sideSquare);
            Triangle triangle = new Triangle(baseTriangle, heightTriangle);

            // Setting perimeter and area for each shape
            circlePerimeterTextField.setText(String.format("%.2f", circle.getPerimeter()));
            circleAreaTextField.setText(String.format("%.2f", circle.getArea()));

            rectanglePerimeterTextField.setText(String.format("%.2f", rectangle.getPerimeter()));
            rectangleAreaTextField.setText(String.format("%.2f", rectangle.getArea()));

            rightTrianglePerimeterTextField.setText(String.format("%.2f", rightTriangle.getPerimeter()));
            rightTriangleAreaTextField.setText(String.format("%.2f", rightTriangle.getArea()));

            squarePerimeterTextField.setText(String.format("%.2f", square.getPerimeter()));
            squareAreaTextField.setText(String.format("%.2f", square.getArea()));

            trianglePerimeterTextField.setText(String.format("%.2f", triangle.getPerimeter()));
            triangleAreaTextField.setText(String.format("%.2f", triangle.getArea()));

            // Calculating and displaying the maximum perimeter and area
            double maxPerimeter = Math.max(Math.max(Math.max(circle.getPerimeter(), rectangle.getPerimeter()),
                    Math.max(rightTriangle.getPerimeter(), square.getPerimeter())), triangle.getPerimeter());
            maxPerimeterTextField.setText(String.format("%.2f", maxPerimeter));

            double maxArea = Math.max(Math.max(Math.max(circle.getArea(), rectangle.getArea()),
                    Math.max(rightTriangle.getArea(), square.getArea())), triangle.getArea());
            maxAreaTextField.setText(String.format("%.2f", maxArea));
        } catch (NumberFormatException ex) {
            JOptionPane.showMessageDialog(this, "Please enter valid numerical values.");
        }
    }
}

interface Shape {

    double getPerimeter();

    double getArea();

    void setPerimeter(double perimeter);

    void setArea(double area);

}

class Circle implements Shape {

    private double radius;
    private double perimeter;
    private double area;

    public Circle() {
        this.radius = 0.0;
        this.perimeter = 0.0;
        this.area = 0.0;
    }

    public Circle(double radius) {
        if (radius < 0) {
            throw new IllegalArgumentException("Radius cannot be negative.");
        }
        this.radius = radius;
        this.perimeter = computePerimeter();
        this.area = computeArea();
    }

    @Override
    public double getPerimeter() {
        return perimeter;
    }

    @Override
    public double getArea() {
        return area;
    }

    @Override
    public void setPerimeter(double perimeter) {
        this.perimeter = perimeter;
    }

    @Override
    public void setArea(double area) {
        this.area = area;
    }

    public double computePerimeter() {
        return 2 * Math.PI * radius;
    }

    public double computeArea() {
        return Math.PI * radius * radius;
    }

    public void setRadius(double radius) {
        if (radius < 0) {
            throw new IllegalArgumentException("Radius cannot be negative.");
        }
        this.radius = radius;
        this.perimeter = computePerimeter();
        this.area = computeArea();
    }

    public double getRadius() {
        return radius;
    }

    @Override
    public String toString() {
        return String.format("Shape: Circle\nRadius = %.2f\nPerimeter = %.2f\nArea = %.2f\n", radius, perimeter, area);
    }
}

class Rectangle implements Shape {

    private double length;
    private double width;
    private double perimeter;
    private double area;

    public Rectangle() {
        this.length = 0.0;
        this.width = 0.0;
        this.perimeter = 0.0;
        this.area = 0.0;
    }

    public Rectangle(double width, double length) {
        if (length < 0 || width < 0) {
            throw new IllegalArgumentException("Length and width cannot be negative.");
        }
        this.length = length;
        this.width = width;
        this.perimeter = computePerimeter();
        this.area = computeArea();
    }

    @Override
    public double getPerimeter() {
        return perimeter;
    }

    @Override
    public double getArea() {
        return area;
    }

    @Override
    public void setPerimeter(double perimeter) {
        this.perimeter = perimeter;
    }

    @Override
    public void setArea(double area) {
        this.area = area;
    }

    public double computePerimeter() {
        return 2 * (length + width);
    }

    public double computeArea() {
        return length * width;
    }

    public void setLength(double length) {
        if (length < 0) {
            throw new IllegalArgumentException("Length cannot be negative.");
        }
        this.length = length;
        this.perimeter = computePerimeter();
        this.area = computeArea();
    }

    public double getLength() {
        return length;
    }

    public void setWidth(double width) {
        if (width < 0) {
            throw new IllegalArgumentException("Width cannot be negative.");
        }
        this.width = width;
        this.perimeter = computePerimeter();
        this.area = computeArea();
    }

    public double getWidth() {
        return width;
    }

    @Override
    public String toString() {
        return String.format("Shape: Rectangle\nLength = %.2f\nWidth = %.2f\nPerimeter = %.2f\nArea = %.2f\n", length, width, perimeter, area);
    }
}

class RightTriangle implements Shape {

    private double base;
    private double height;
    private double perimeter;
    private double area;

    public RightTriangle() {
        this.base = 0.0;
        this.height = 0.0;
        this.perimeter = 0.0;
        this.area = 0.0;
    }

    public RightTriangle(double base, double height) {
        if (base < 0 || height < 0) {
            throw new IllegalArgumentException("Base and height cannot be negative.");
        }
        this.base = base;
        this.height = height;
        this.perimeter = computePerimeter();
        this.area = computeArea();
    }

    @Override
    public double getPerimeter() {
        return perimeter;
    }

    @Override
    public double getArea() {
        return area;
    }

    @Override
    public void setPerimeter(double perimeter) {
        this.perimeter = perimeter;
    }

    @Override
    public void setArea(double area) {
        this.area = area;
    }

    public double computePerimeter() {
        return base + height + Math.sqrt(base * base + height * height);
    }

    public double computeArea() {
        return 0.5 * base * height;
    }

    public void setBase(double base) {
        if (base < 0) {
            throw new IllegalArgumentException("Base cannot be negative.");
        }
        this.base = base;
        this.perimeter = computePerimeter();
        this.area = computeArea();
    }

    public double getBase() {
        return base;
    }

    public void setHeight(double height) {
        if (height < 0) {
            throw new IllegalArgumentException("Height cannot be negative.");
        }
        this.height = height;
        this.perimeter = computePerimeter();
        this.area = computeArea();
    }

    public double getHeight() {
        return height;
    }

    @Override
    public String toString() {
        return String.format("Shape: Right Triangle\nBase = %.2f\nHeight = %.2f\nPerimeter = %.2f\nArea = %.2f\n", base, height, perimeter, area);
    }
}

class Square implements Shape {

    private double side;
    private double perimeter;
    private double area;

    public Square() {
        this.side = 0.0;
        this.perimeter = 0.0;
        this.area = 0.0;
    }

    public Square(double side) {
        if (side < 0) {
            throw new IllegalArgumentException("Side cannot be negative.");
        }
        this.side = side;
        this.perimeter = computePerimeter();
        this.area = computeArea();
    }

    @Override
    public double getPerimeter() {
        return perimeter;
    }

    @Override
    public double getArea() {
        return area;
    }

    @Override
    public void setPerimeter(double perimeter) {
        this.perimeter = perimeter;
    }

    @Override
    public void setArea(double area) {
        this.area = area;
    }

    public double computePerimeter() {
        return 4 * side;
    }

    public double computeArea() {
        return side * side;
    }

    public void setSide(double side) {
        if (side < 0) {
            throw new IllegalArgumentException("Side cannot be negative.");
        }
        this.side = side;
        this.perimeter = computePerimeter();
        this.area = computeArea();
    }

    public double getSide() {
        return side;
    }

    @Override
    public String toString() {
        return String.format("Shape: Square\nSide = %.2f\nPerimeter = %.2f\nArea = %.2f\n", side, perimeter, area);
    }
}

class Triangle implements Shape {

    private double base;
    private double height;
    private double perimeter;
    private double area;

    public Triangle() {
        this.base = 0.0;
        this.height = 0.0;
        this.perimeter = 0.0;
        this.area = 0.0;
    }

    public Triangle(double base, double height) {
        if (base < 0 || height < 0) {
            throw new IllegalArgumentException("Base and height cannot be negative.");
        }
        this.base = base;
        this.height = height;
        this.perimeter = computePerimeter();
        this.area = computeArea();
    }

    @Override
    public double getPerimeter() {
        return perimeter;
    }

    @Override
    public double getArea() {
        return area;
    }

    @Override
    public void setPerimeter(double perimeter) {
        this.perimeter = perimeter;
    }

    @Override
    public void setArea(double area) {
        this.area = area;
    }

    public double computePerimeter() {
        // For simplicity, assuming an equilateral triangle
        return 3 * base;
    }

    public double computeArea() {
        return 0.5 * base * height;
    }

    public void setBase(double base) {
        if (base < 0) {
            throw new IllegalArgumentException("Base cannot be negative.");
        }
        this.base = base;
        this.perimeter = computePerimeter();
        this.area = computeArea();
    }

    public double getBase() {
        return base;
    }

    public void setHeight(double height) {
        if (height < 0) {
            throw new IllegalArgumentException("Height cannot be negative.");
        }
        this.height = height;
        this.perimeter = computePerimeter();
        this.area = computeArea();
    }

    public double getHeight() {
        return height;
    }

    @Override
    public String toString() {
        return String.format("Shape: Triangle\nBase = %.2f\nHeight = %.2f\nPerimeter = %.2f\nArea = %.2f\n", base, height, perimeter, area);
    }
}