Is could someone please tell me why my paintComponent() is called infinitely?

package project;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JTextField;
import javax.swing.SwingConstants;

public class UserInterface extends JPanel
{
//    private JTextField orb1ChargeDensityTextField; // don't remember what I have this for or if it's a mistake
//    private JTextField orb2ChargeDensityTextField; // don't remember what I have this for or if it's a mistake
    private JFrame frame;
    private JTextField orb1ChargeTextField;
    private JTextField orb2ChargeTextField;
    private JTextField orb1InitialVelocityTextField;
    private JTextField orb2InitialVelocityTextField;
    private JTextField gravityConstantTextField;
    private JCheckBox considerGravity;
    private JCheckBox considerElectricity;
    private JRadioButton inVacuumRadioButton;
    private JRadioButton inAirRadioButton;
    private JRadioButton inOtherMediumRadioButton;
    private JPanel graphicsPanel = this;
    private JPanel buttonsPanel;
    private Orb orb1;
    private Orb orb2;
    private boolean regularComponentsAdded = false;
    private JLabel orb1InitialVelocityLabel;
    private JLabel orb2InitialVelocityLabel;
    private JLabel orb1ChargeLabel;
    private JLabel orb2ChargeLabel;
    private JLabel gravityConstantLabel;
//    private JPanel orb1InitialVelocityPanel;
//    private JPanel orb2InitialVelocityPanel;
//    private JPanel gravityConstantPanel;
    private JButton simulateButton;
    private GridBagConstraints c;
    private boolean simulationStarted = false;
    private Common common = new Common();
    private JLabel planetaryRadiusLabel;
    private JTextField planetaryRadiusTextField;
    private JLabel planetaryMassLabel;
    private JTextField planetaryMassTextField;
    private JLabel dielectricConstantPanel;
    private JTextField dielectricConstantTextField;
    private JLabel orb1HeightLabel;
    private JLabel orb2HeightLabel;
    private JTextField orb1HeightTextField;
    private JTextField orb2HeightTextField;
    private JLabel separationDistanceLabel;
    private JTextField separationDistanceTextField;
    private JLabel dragCoefficientLabel;
    private JTextField dragCoefficientTextField;
    private JLabel orb1RadiusLabel;
    private JTextField orb1RadiusTextField;
    private JLabel orb2RadiusLabel;
    private JTextField orb2RadiusTextField;

    public UserInterface()
    {
        createPanels();
        createOrbs();
        setLabelProperties();
        setTextFieldProperties();
        setCheckBoxProperties();
        setRegularButtonProperties();
        setRadioButtonProperties();
        setPanelProperties();
        setFrameProperties();
    }

    public void setLabelProperties()
    {
        orb1InitialVelocityLabel = new JLabel("First orb's initial velocity (m/s): ");
        orb1InitialVelocityLabel.setVerticalAlignment(SwingConstants.TOP);
        orb2InitialVelocityLabel = new JLabel("Second orb's initial velocity (m/s): ");
        orb2InitialVelocityLabel.setVerticalAlignment(SwingConstants.TOP); // CHECK!!!
        orb1ChargeLabel = new JLabel("First orb's charge (C): ");
        orb2ChargeLabel = new JLabel("Second orb's charge (C): ");
        gravityConstantLabel = new JLabel("Gravity constant (m/s^2): ");
        planetaryRadiusLabel = new JLabel("Planetary radius (m): ");
        planetaryMassLabel = new JLabel("Planetary mass (kg): ");
        dielectricConstantPanel = new JLabel("Dielectric constant: ");
        orb1HeightLabel = new JLabel("First orb's height (m): ");
        orb2HeightLabel = new JLabel("Second orb's height (m): ");
        separationDistanceLabel = new JLabel("Separation distance (m): ");
        dragCoefficientLabel = new JLabel("Drag coefficient: ");
        orb1RadiusLabel = new JLabel("First orb's radius (m): ");
        orb2RadiusLabel = new JLabel("Second orb's radius (m): ");
    }

    public void setPanelProperties() // layout needs some serious fixing!!!
    {
        if(!regularComponentsAdded)
        {
            // Initial GridBagLayout settings
            c = new GridBagConstraints();
            c.anchor = GridBagConstraints.FIRST_LINE_START;
            c.weighty = 0; //etho
            c.fill = GridBagConstraints.HORIZONTAL;
            c.gridheight = 1; // is for the the specific component when adding - not height for all components together

            buttonsPanel.setSize(400, 200);
            buttonsPanel.setLayout(new GridBagLayout());

            buttonsPanel.setBackground(Color.CYAN);
            graphicsPanel.setBackground(Color.GREEN);

            c.gridx = 1; c.gridy = 1;
            buttonsPanel.add(considerElectricity, c);
            considerElectricity.setBackground(Color.YELLOW);

            c.gridx = 2; c.gridy = 1;
            buttonsPanel.add(considerGravity, c);

            c.gridx = 1; c.gridy = 2; c.gridwidth = 1; c.weighty = 0; // etho
            buttonsPanel.add(orb1InitialVelocityLabel, c);

            c.gridx = 2; c.gridy = 2;
            buttonsPanel.add(orb1InitialVelocityTextField, c);

            c.gridx = 1; c.gridy = 3;
            buttonsPanel.add(orb2InitialVelocityLabel, c);

            c.gridx = 2; c.gridy = 3;
            buttonsPanel.add(orb2InitialVelocityTextField, c);

            c.gridx = 1; c.gridy = 5; c.gridwidth = 1;
            buttonsPanel.add(gravityConstantLabel, c);
            c.gridx = 2; c.gridy = 5;
            buttonsPanel.add(gravityConstantTextField, c);

            c.gridx = 1; c.gridy = 6;
            buttonsPanel.add(orb1ChargeLabel, c);

            c.gridx = 2; c.gridy = 6;
            buttonsPanel.add(orb1ChargeTextField, c);

            c.gridx = 1; c.gridy = 7;
            buttonsPanel.add(orb2ChargeLabel, c);

            c.gridx = 2; c.gridy = 7;
            buttonsPanel.add(orb2ChargeTextField, c);

            c.gridx = 1; c.gridy = 8;
            buttonsPanel.add(planetaryRadiusLabel, c);

            c.gridx = 2; c.gridy = 8;
            buttonsPanel.add(planetaryRadiusTextField, c);

            c.gridx = 1; c.gridy = 9;
            buttonsPanel.add(planetaryMassLabel, c);

            c.gridx = 2; c.gridy = 9;
            buttonsPanel.add(planetaryMassTextField, c);

            c.gridx = 1; c.gridy = 10;
            buttonsPanel.add(dielectricConstantPanel, c);

            c.gridx = 2; c.gridy = 10;
            buttonsPanel.add(dielectricConstantTextField, c);

            c.gridx = 1; c. gridy = 11;
            buttonsPanel.add(orb1HeightLabel, c);

            c.gridx = 2; c.gridy = 11;
            buttonsPanel.add(orb1HeightTextField, c);

            c.gridx = 1; c.gridy = 12;
            buttonsPanel.add(orb2HeightLabel, c);

            c.gridx = 2; c.gridy = 12;
            buttonsPanel.add(orb2HeightTextField, c);

            c.gridx = 1; c.gridy = 13;
            buttonsPanel.add(separationDistanceLabel, c);

            c.gridx = 2; c.gridy = 13;
            buttonsPanel.add(separationDistanceTextField, c);

            c.gridx = 1; c.gridy = 14;
            buttonsPanel.add(dragCoefficientLabel, c);

            c.gridx = 2; c.gridy = 14;
            buttonsPanel.add(dragCoefficientTextField, c);

            c.gridx = 1; c.gridy = 15;
            buttonsPanel.add(orb1RadiusLabel, c);

            c.gridx = 2; c.gridy = 15;
            buttonsPanel.add(orb1RadiusTextField, c);

            c.gridx = 1; c.gridy = 16;
            buttonsPanel.add(orb2RadiusLabel, c);

            c.gridx = 2; c.gridy = 16;
            buttonsPanel.add(orb2RadiusTextField, c);

            c.gridx = 1; c.gridy = 17;
            buttonsPanel.add(inVacuumRadioButton, c);

            c.gridx = 1; c.gridy = 18;
            buttonsPanel.add(inAirRadioButton, c);

            c.gridx = 1; c.gridy = 19; c.weighty = 1;
            buttonsPanel.add(inOtherMediumRadioButton, c);

            c.gridx = 1; c.gridy = 20; c.weighty = 0; c.gridwidth = 2;
            buttonsPanel.add(simulateButton, c);

        }
        if(considerElectricity.isSelected())
        {
            orb1ChargeLabel.setVisible(true);
            orb1ChargeTextField.setVisible(true);
            orb2ChargeLabel.setVisible(true);
            orb2ChargeTextField.setVisible(true);
            dielectricConstantPanel.setVisible(true);
            dielectricConstantTextField.setVisible(true);
            orb1HeightLabel.setVisible(true);
            orb2HeightLabel.setVisible(true);
            orb1HeightTextField.setVisible(true);
            orb2HeightTextField.setVisible(true);
            separationDistanceLabel.setVisible(true);
            separationDistanceTextField.setVisible(true);
            dragCoefficientLabel.setVisible(true);
            dragCoefficientTextField.setVisible(true);
            orb1RadiusLabel.setVisible(true);
            orb2RadiusLabel.setVisible(true);
            orb1RadiusTextField.setVisible(true);
            orb2RadiusTextField.setVisible(true);
        }
        else
        {
            orb1ChargeLabel.setVisible(false);
            orb1ChargeTextField.setVisible(false);
            orb2ChargeLabel.setVisible(false);
            orb2ChargeTextField.setVisible(false);
            dielectricConstantPanel.setVisible(false);
            dielectricConstantTextField.setVisible(false);
            separationDistanceLabel.setVisible(false);
            separationDistanceTextField.setVisible(false);
            dragCoefficientLabel.setVisible(false);
            dragCoefficientTextField.setVisible(false);
            orb1RadiusLabel.setVisible(false);
            orb2RadiusLabel.setVisible(false);
            orb1RadiusTextField.setVisible(false);
            orb2RadiusTextField.setVisible(false);
        }
        if(considerGravity.isSelected())
        {
            gravityConstantLabel.setVisible(true);
            gravityConstantTextField.setVisible(true);
            planetaryRadiusLabel.setVisible(true);
            planetaryRadiusTextField.setVisible(true);
            planetaryMassLabel.setVisible(true);
            planetaryMassTextField.setVisible(true);
            orb1HeightLabel.setVisible(true);
            orb1HeightTextField.setVisible(true);
            orb2HeightLabel.setVisible(true);
            orb2HeightTextField.setVisible(true);
        }
        else
        {
            gravityConstantLabel.setVisible(false);
            gravityConstantTextField.setVisible(false);
            planetaryRadiusLabel.setVisible(false);
            planetaryRadiusTextField.setVisible(false);
            planetaryMassLabel.setVisible(false);
            planetaryMassTextField.setVisible(false);
            orb1HeightLabel.setVisible(false);
            orb1HeightTextField.setVisible(false);
            orb2HeightLabel.setVisible(false);
            orb2HeightTextField.setVisible(false);
        }
//        buttonsPanel.add(orb1ChargeDensityTextField); // don't remember what I have this for or if it's a mistake
//        buttonsPanel.add(orb2ChargeDensityTextField); // don't remember what I have this for or if it's a mistake
//        frame.pack();
        buttonsPanel.validate(); // THIS SEEMS TO NOT BE NEEDED BUT KEEP IT UNTIL I LOOK FURTHER INTO THIS!!!
        buttonsPanel.setVisible(true);

//        System.out.println("The width is: " + buttonsPanel.getWidth()); // here for testing purposes
    }

    public void setRadioButtonProperties()
    {
        inVacuumRadioButton = new JRadioButton("Vacuum");
        inAirRadioButton = new JRadioButton("Air");
        inOtherMediumRadioButton = new JRadioButton("Other");
        inVacuumRadioButton.setSelected(true);

        ButtonGroup group = new ButtonGroup();
        group.add(inVacuumRadioButton);
        group.add(inAirRadioButton);
        group.add(inOtherMediumRadioButton);
    }

    public void setRegularButtonProperties()
    {
        simulateButton = new JButton("Simulate");

        simulateButton.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                // The following is test code and is not the real deal type of simulation
                orb1.setX(0); simulationStarted = true;
//                Timer timer = new Timer(100, new Repaint());
            }
        });
    }

//    public class Repaint implements ActionListener
//    {
//        public void actionPerformed(ActionEvent e)
//        {
//            repaint();
//        }
//    }

    public void createPanels()
    {
        buttonsPanel = new JPanel();
    }

    public void createOrbs()
    {
        orb1 = new Orb();
        orb2 = new Orb();
    }

    protected void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        drawTitle(g);
        // THE FOLLOWING IS DATA CALCULATED AND SHOVED INTO THE ORB CLASS BEING USED
        g.setColor(Color.RED);
        orb1.setX(0.03F); orb1.setY(0.1F); // temporary for testing purposes
        if(orb1RadiusTextField.getText() != null)
            orb1.setRadius(Float.parseFloat(orb1RadiusTextField.getText()));
        else
            orb1.setRadius(0.3F);
        System.out.println("The nummber is this: " + Float.parseFloat(orb1RadiusTextField.getText()));
        g.fillOval(getPixelXCoordinate(orb1.getX()), getPixelYCoordinate(orb1.getY()), convertMetresToPixels(orb1.getRadius()), convertMetresToPixels(orb1.getRadius()));
    }

    public int convertMetresToPixels(double metres)
    {// This method only converts metres to pixels and does not take into account where the pixels are drawn
        int pixels = -1;
        int scalar = 3000;
        pixels = (int) (scalar*metres);
        return pixels;
    }

    public int getPixelXCoordinate(double metresXCoordinate)
    {
        return convertMetresToPixels(metresXCoordinate);
    }

    public int getPixelYCoordinate(double metresYCoordinate)
    {
        return (int) (frame.getHeight() - convertMetresToPixels(metresYCoordinate));
    }

    public void drawTitle(Graphics g) // There's an issue with the delay from normal/unformatted text to special/formatted text
    {
        String title = "Welcome to the orb program!";
        FontMetrics fontMetrics = g.getFontMetrics();
        graphicsPanel.setFont(new Font("Times", Font.BOLD, 20));

        // Get the position of the leftmost character in the baseline
        int x = fontMetrics.stringWidth(title);
        int y = fontMetrics.getAscent();

        //
        g.drawString(title, x, y);

        // Nullify unused references for garbage collector
        fontMetrics = null;
        title = null;
    }

    public void setFrameProperties()
    {
        frame = new JFrame();
        frame.setTitle("Orb program");
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(1100, 800); // change resolution in conjunction with FontMetrics title placement
        frame.setLocationRelativeTo(null);
        frame.setLayout(new BorderLayout());
//        frame.add(buttonsPanel); // uncomment this later
        frame.add(graphicsPanel);
        frame.add(buttonsPanel, BorderLayout.EAST);
    }

    public void setCheckBoxProperties()
    {
        considerGravity = new JCheckBox("Enable gravity", false);
        considerGravity.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                setPanelProperties();
            }
        });

        considerElectricity = new JCheckBox("Enable electrical forces", true);
        considerElectricity.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                setPanelProperties();
            }
        });
    }

    public void setTextFieldProperties()
    {
        float tempElementaryCharge = common.getElementaryCharge();
        gravityConstantTextField = new JTextField("9.79205");
        orb1ChargeTextField = new JTextField(String.valueOf(tempElementaryCharge));
        orb2ChargeTextField = new JTextField(String.valueOf(-1 * tempElementaryCharge));
        orb1InitialVelocityTextField = new JTextField("0");
        orb2InitialVelocityTextField = new JTextField("0");
        planetaryRadiusTextField = new JTextField("6.3685E6");
        planetaryMassTextField = new JTextField("5.9721986E24");
        dielectricConstantTextField = new JTextField("1.00058986");
        orb1HeightTextField = new JTextField("1");
        orb2HeightTextField = new JTextField("1");
        separationDistanceTextField = new JTextField("1");
        dragCoefficientTextField = new JTextField("0.47");
        orb1RadiusTextField = new JTextField("0.03");
        orb2RadiusTextField = new JTextField("CACA2");

//        orb1ChargeDensityTextField = new JTextField(""); // don't remember what I have this for or if it's a mistake
//        orb2ChargeDensityTextField = new JTextField(""); // don't remember what I have this for or if it's a mistake
    }

//    public String getOrb1Initial // I WAS HERE LAST!!!!

    public static void main(String[] args) // main() will be removed later
    {
        UserInterface userInterface = new UserInterface(); // this will later be called via the main() of the launcher program
    }
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package project;

/**
 *
 * @author Deniz
 */

public class Common
{
    private float coulombConstant = (float) 8.9875517873681764E9; // Nm^2/C^2
    private float newtonGravitationalConstant = (float) 6.67428E-11; // Nm^2/kg^2
    private float planetaryMass = (float) 5.9721986E24; // (in kg) defaults to Earth's mass
    private float dielectricConstant = (float) 1.00058986; // dimensionless
    private float planetaryRadius;
    private float height;
    private float systemImpulse;
    private final float airDensityEarth = (float) 1.29; // in kg/m^3 // THIS NUMBER COULD BE WRONG
    private float mediumDragForce;
    private final float airDensityMars = (float) 2.30446139E-5; // g/(cm^3)
    private float gravityConstant; // = (float) 9.80665; // in m/s^2 // set it via text field instead of here by default
    private float mediumDensity; // also called fluid density
    private float separationDistance; // m
    private float electricalPotentialEnergy;
    private double electricField;
    private double gravitationalPotentialEnergy;
    private double totalKineticEnergy;
    private double totalPotentialEnergy;
    private boolean inVacuum = true; // should make it get from text field - check my logic again jic
//    private float potentialDifference; // I'M PRETTY SURE THIS IS FOR V = ED AND V = ED IS FOR UNIFORM ELECTRIC FIELDS AND THIS PROGRAM DOESN'T SIMULATE SOMETHING WITH A UNIFORM ELECTRIC FIELD
    private boolean inAir = false; // should make it get from text field - check my logic again jic
    private boolean inOtherMedium = false; // neglect any additional electrical properties that MIGHT exist(depending on the fluid in question)
    private final float elementaryCharge = (float) 1.6E-19;

    public Common()
    {

    }

    public float getElementaryCharge()
    {
        return elementaryCharge;
    }

    public double getSeparationDistance()
    {
        return separationDistance;
    }

    public float getSystemImpulse()
    {
        return systemImpulse;
    }

    public float getElectricalPotentialEnergy()
    {
        return electricalPotentialEnergy;
    }

    public double getElectricField()
    {
        return electricField;
    }

    public float getMediumDragForce()
    {
        if(inVacuum)
        {
            return 0;
        }
        else
        {
            return mediumDragForce;
        }
    }

    public void setSeparationDistance(Orb orb1, Orb orb2, float surfaceSeparation)
    {
        separationDistance = surfaceSeparation + orb1.getRadius() + orb2.getRadius();
    }

    public void setMediumDragForce(float mediumDragForce)
    {
        this.mediumDragForce = mediumDragForce;
    }

    public void setMediumDragForce(float mediumDensity, double velocity, float referenceArea, float dragCoefficient)
    {
        mediumDragForce = (float) (-0.5 * mediumDensity * referenceArea * dragCoefficient * Math.pow(velocity, 2)); // haven't paid too much attention to direction of the vector yet
    }

    public void setMediumDensity(float mediumDensity)
    {
        this.mediumDensity = mediumDensity;
    }

//    public void setSeparationDistance(Point point)
//    {
//
//    }

    public void setSystemImpulse(float systemImpulse)
    {
        this.systemImpulse = systemImpulse;
    }

    public float getGravityConstant()
    {
        if(gravityConstant > 9.7 && gravityConstant < 9.9)
        {
            return gravityConstant;
        }
        else
        {
            gravityConstant = (float) (newtonGravitationalConstant * planetaryMass/Math.pow((planetaryRadius + height),2));
            return gravityConstant;
        }
    }

    public double getGravitationalPotentialEnergy()
    {
       return gravitationalPotentialEnergy;
    }

    public double getTotalKineticEnergy()
    {
        return totalKineticEnergy;
    }

    public double getTotalPotentialEnergy()
    {
        return totalPotentialEnergy;
    }

//    public float getPotentialDifference()
//    {
//        return potentialDifference;
//    }

    public void setGravityConstant(float gravityConstant)
    {
        this.gravityConstant = gravityConstant;
    }
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package project;

import java.awt.Point;

/**
 *
 * @author Deniz
 */
public class Orb
{
    private boolean fixedOrbPosition = false;
    private float currentVelocity;
    private float currentSpeed;
    private float orbArea;
    private double charge;
    private double mass;
    private Point position;
    private float x;
    private float y;
    private double initialVelocity;
    private double intialSpeed;
    private float chargeDensity;
    private float potential;
    private float gamma; // in order to implement relativistic linear momentum
    private float initialMomentum;
    private float finalMomentum;
    private float impulse;
    private float radius;
    private final float sphereDragCoefficient = 0.47F;
    private float weight;

    public Orb()
    {

    }

    public float getWeight()
    {
        return weight;
    }

    public float getRadius()
    {
        return radius;
    }

    public void setRadius(float radius)
    {
        this.radius = radius;
    }

    public double getSpeed()
    {
        return currentSpeed;
    }

    public double getVelocity()
    {
        return currentVelocity;
    }

    public double getPotential()
    {
        return potential;
    }

    public double getCharge()
    {
        return charge;
    }

    public float getChargeDensity()
    {
        return chargeDensity;
    }

    public float getInitialMomentum()
    {
        return initialMomentum;
    }

    public float getFinalMomentum()
    {
        return finalMomentum;
    }

    public float getImpulse()
    {
        return impulse;
    }

    public double getMass()
    {
        return mass;
    }

    public Point getPosition()
    {
        return position;
    }

    public float getX()
    {
        return x;
    }

    public float getY()
    {
        return y;
    }

    public void setInitialVelocity(double initialVelocity)
    {
        this.initialVelocity = initialVelocity;
    }

    public void setImpulse(float impulse)
    {
        this.impulse = impulse;
    }

    public void setInitialMomentum(float initialMomentum)
    {
        this.initialMomentum = initialMomentum;
    }

    public void setVelocity(float currentVelocity)
    {
        this.currentVelocity = currentVelocity;
    }

    public void setSpeed(float currentSpeed)
    {
        this.currentSpeed = currentSpeed;
    }

    public void setFinalMomentum(float finalMomentum)
    {
        this.finalMomentum = finalMomentum;
    }

    public void setX()
    {
        // THIS ONE SHOULD OBTAIN ITS DATA FROM A JTEXTFIELD!!!
    }

    public void setX(float currentX)
    {
        this.x = currentX;
    }

    public void setY()
    {
        // THIS ONE SHOULD OBTAIN ITS DATA FROM A JTEXTFIELD!!!
    }

    public void setY(float currentY)
    {
        this.y = currentY;
    }

    public void setCharge(double charge)
    {
        this.charge = charge;
    }

    public void setChargeDensity(float chargeDensity)
    {
        this.chargeDensity = chargeDensity;
    }

    public void setMass(float mass)
    {
        this.mass = mass;
    }

    public void setPosition(Point position)
    {
        this.position = position;
    }

    public void setPosition(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}

        // Nullify unused references for garbage collector
        fontMetrics = null;
        title = null;