Row.java

package de._82grfl1bif.KPI_Visualizer.layouts.TreeMap;

import de._82grfl1bif.KPI_Visualizer.structures.Structure;

import java.awt.*;
import java.util.HashMap;
import java.util.Map;

public class Row {

    double broad;
    boolean horizontal;

    public HashMap<Rectangle, Structure> getRectangles() {
        return rectangles;
    }

    HashMap<Rectangle, Structure> rectangles;
    Rectangle space;

    public Row(Rectangle space) {
        this.space = space;
        this.rectangles = new HashMap<>();
        this.broad = 0;
        this.horizontal = (space.getWidth() >= space.getHeight());
    }

    private double getSideRelation() {
        double currentMax = 0;
        for (Map.Entry<Rectangle, Structure> entry : rectangles.entrySet()) {
            Rectangle r = entry.getKey();
            currentMax = Math.max(r.getSideRelation(), currentMax);
        }
        return currentMax;
    }

    public void addRectangle(double area, Structure structure) {
        double currentArea = getCurrentArea() + area;
        if (horizontal) {
            this.broad = currentArea / space.getHeight(); //calculating the new broad
            int currentHeight = this.space.getOrigin().y; //new temp for height of origins
            for (Map.Entry<Rectangle, Structure> entry : rectangles.entrySet()) {
                Rectangle r = entry.getKey();
                r.setWidth(this.broad);//setting new width&Height for all existing rectangles
                r.setOrigin(new Point(this.space.getOrigin().x, currentHeight));//setting new origins for all existing rectangles
                currentHeight += (int) Math.round(r.getHeight());//for next origin
            }
            rectangles.put((new Rectangle(area, this.broad, new Point(this.space.getOrigin().x, currentHeight))), structure);//add new Rectangle
        } else {
            this.broad = currentArea / space.getWidth(); //calculating the new broad
            int currentWidth = this.space.getOrigin().x; //new temp for width of origins
            for (Map.Entry<Rectangle, Structure> entry : rectangles.entrySet()) {
                Rectangle r = entry.getKey();
                r.setHeight(this.broad);//setting new width&Height for all existing rectangles
                r.setOrigin(new Point(currentWidth, space.getOrigin().y));//setting new origins for all existing rectangles
                currentWidth += (int) Math.round(r.getHeight());//for next origin
            }
            rectangles.put(new Rectangle(area, area / this.broad, new Point(currentWidth, space.getOrigin().y)), structure);
        }
    }

    private double getCurrentArea() {
        double currentArea = 0;
        for (Map.Entry<Rectangle, Structure> entry : rectangles.entrySet()) {
            Rectangle r = entry.getKey();
            currentArea += r.getArea();
        }
        return currentArea;
    }

    public boolean checkInsert(double area) {
        if (!rectangles.isEmpty()) {
            double currentArea = getCurrentArea() + area;
            double broadTemp = horizontal ? currentArea / space.getHeight() : currentArea / space.getWidth();
            for (Map.Entry<Rectangle, Structure> entry : rectangles.entrySet()) {
                Rectangle r = entry.getKey();
                if (!r.checkSideRelation(broadTemp))
                    return false;//returns false if one of the existing rectangles gets worse
            }
            return !(new Rectangle(area, broad, new Point(0, 0)).getSideRelation() > getSideRelation()); //returns false if the inserted rectangle is worse, than any other before
        }else {
            return true;
        }
    }

    public Rectangle getLeftover() {
        Point origin;
        double width;
        if (horizontal) {
            origin = new Point(space.getOrigin().x + (int)(broad), space.getOrigin().y);
            width = space.getWidth() - getWidth();
        } else {
            origin = new Point(space.getOrigin().x, space.getOrigin().y + (int)(broad));
            width = getWidth();
        }
        return new Rectangle(this.space.getArea() - getCurrentArea(), width, origin);
    }

    public double getWidth() {
        if (horizontal) {
            return this.broad;
        } else {
            return this.space.getWidth();
        }
    }

    public double getHeight() {
        if (horizontal) {
            return this.space.getHeight();
        } else {
            return this.broad;
        }
    }

    public boolean isFull(){
        return (Math.round(this.space.getArea()) <= Math.round(this.getCurrentArea()));
    }
}