Resize JPanel after setting color

Question

To make the long story short, I have two JPanel objects in my JFrame , one of them is adjustment panel, and the other one is graphic panel. When I resize the window, the graphic panels does not resize accordingly.

I have two classes, one of them is GUImodel class and the other one is ModelSim (model simulation) class, in which GUImodel class visualize the simulation parts in ModelSim .

Where i,j indices in draw method cover (770,460) pixels in my graphic JPanel . fillRect colours each pixel of 770x460 pixels based on my definition in above code. How can I resize the graphic JPanel by expanding the window. Logically, by resizing the graphic Panel, the coloured pixels are not going to have square shape any more, which is fine in my case.

Please help me how can I do that? Let me know, If you need any other information

---

Here is the runnable code; the first class is GUICA and the other one is ModelSim.

GUICA:

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;

import javax.swing.*;

/**
 * Cellular Automata Graphical User Interface
 * @author Mahdi
 * @version 1.0
 */
// This code provide a simple GUI for Cellular Automata 
// Notice that we are going to extend our super class JFrame which is the main window of our simulation
// Inside this JFrame, we are going to add two subframes, which are called JPanels.
public class GUICA extends JFrame {

    // We need to make to Jpanels inside the main Jframe

    // First Jpanel is adjustPanel
    private JPanel adjustPanel;
    // Second Jpanel is graphicPanel
    private JPanel graphicPanel;

    // Now it is the time to create buttons
    private JButton startButton;
    private JButton resetButton;
    private JButton stopButton;

    // We need to make an object from our model to implement that one in GUI part
     private ModelSim model;

    // We need also timer to re-implement (update) our simulation
     private Timer timer;

    // Detrmining the initial values of Windows panel main size
     static int widthPixel = 766;
     static int heightPixel = 468;
     Rectangle bounds;
    // Now, that's the time to create our constructor
    public GUICA(){
        // Here super is our JFrame and the string defines the name of our Frame.
        super("Cellular Automata Evacuation");
        // The below code will close the window(JFrame), once we have click on window exit
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        //lets define the default size of our window page(main JFrame), where the first value is the x and second one is y;
        setSize(widthPixel,heightPixel);


        // First let's define the role of our timer in our future simulation. We first have to initialize our object in
        // the constructor, then with an actionlistener, we will define the role of timerlistener with a nested class.
        timer = new Timer(1,new TimerListener());

        // We need to initialize our buttons right now.
        // The important factor here is the actionlistener, we need to addactionlistener to each button to define their duties.
        // Their duties can be defined by a nested class (which is defined inside our main class)
        startButton = new JButton("Start");
        startButton.addActionListener(new StartListener());

        resetButton = new JButton("Reset");
        resetButton.addActionListener(new ResetListener());

        stopButton = new JButton("Stop");
        stopButton.addActionListener(new StopListener());

        // There are many options to put the buttons in different part of the JPanel, I am going to use not the easiest one
        // but the handiest one. We want to accommodate our buttons inside adjustPanel
        adjustPanel = new JPanel(new GridBagLayout());
        // The below code is for determining the position of our buttons
        GridBagConstraints grid = new GridBagConstraints();

        grid.insets = new Insets(10,10,10,10);
        // For start button
        grid.gridx = 0;
        grid.gridy = 1;
        adjustPanel.add(startButton, grid);
        // For stop button
        grid.gridx = 0;
        grid.gridy = 2;
        adjustPanel.add(resetButton,grid);
        //Let's Separate the buttons from each other with the below tricky method
        grid.insets = new Insets(20,20,20,20);
        JLabel white = new JLabel();
        grid.gridx = 0;
        grid.gridy = 3;
        adjustPanel.add(white,grid);
        // For stop button
        grid.gridx = 0;
        grid.gridy = 4;
        adjustPanel.add(stopButton,grid);

        // We can determine that how much of the space is going to be belonged to adjustPanel
        adjustPanel.setPreferredSize(new Dimension(100,heightPixel));
        // We need to add this panel to our main JFrame panel; also we can determine where we want to place this panel
        // I won't use grid method to place this panel. However,instead, I use the simplest way to determine the position of panels
        setLayout(new BorderLayout());
        add(adjustPanel,BorderLayout.WEST);

        // What about the other panel (graphicPanel) we need to initialize again, but we do not need to determine the exact position
        // of this panle, because it will cover the whole remainder JFrame as its own property
        graphicPanel = new JPanel();
        graphicPanel = new GraphicPanel();
        graphicPanel.setPreferredSize(new Dimension(widthPixel-100,heightPixel));
        //graphicPanel.setBackground(Color.white);
        add(graphicPanel,BorderLayout.CENTER);
        bounds = new Rectangle(widthPixel-100,heightPixel);
        model = new ModelSim(bounds);
    }
    // Start button action listener
    private class StartListener implements ActionListener{
        public void actionPerformed(ActionEvent e) {
            timer.start();

        }
    }

    // Reset button action listener
    private class ResetListener implements ActionListener{
        public void actionPerformed(ActionEvent e) {
             model = new ModelSim(bounds);

        }
    }

    // Stop button action listener
    private class StopListener implements ActionListener{
        public void actionPerformed(ActionEvent e) {
            timer.stop();

        }
    }
    // Stop button action listener
    private class TimerListener implements ActionListener{
        public void actionPerformed(ActionEvent e) {

            model.update();

        }
    }

    private class GraphicPanel extends JPanel{
        public GraphicPanel(){
            setPreferredSize(new Dimension(widthPixel-100,heightPixel));
            //super.revalidate();
            //super.repaint();
            //System.out.println(widthPixel);
        }
        public void paintComponent(Graphics g){
            super.paintComponent(g);
            g.setColor(Color.WHITE);
            g.fillRect(0, 0, widthPixel-100,heightPixel);
            model.draw(g);

        }

    }

    // To make the code runnable, we need provide static main class
    public static void main(String[] args){
        JFrame gui = new GUICA();
        gui.pack();
        gui.setVisible(true);


    }
}

---

ModelSim code:

import java.awt.*;
import java.util.ArrayList;

public class ModelSim {
    private Rectangle bounds;
    private Color color;

    public ModelSim(Rectangle bounds){
        // Properties
        this.bounds = bounds;
    }

    public void update(){

    }
        // Defining the static values together with walls and prohibited places.
    public void draw(Graphics g){
        // Pixel Grow
        int pgw = 1;
        int pgh = 1;
        for(int j = 0; j < bounds.getHeight(); j++){
            for(int i = 0; i < bounds.getWidth(); i++){
                if (i<100){
                    g.setColor(color.RED);
                    g.fillRect(i,j,pgw,pgh);

                }else if(i>100){
                    g.setColor(color.GREEN);
                    g.fillRect(i,j,pgw,pgh);
                }`enter code here`
          }
        }
    }
}

Answer 1

Edit:

I suppose your panel IS resizing, but you can't see it as you have hard-coded background coloring. To avoid this I suggest that you use something like

g.fillRect(0, 0, this.getWidth(), this.getHeight());

Also, cast Graphics object g to Graphics2D class. Then you can use the scale method in it. The scaling factors are doubles and separate for both x and y axes.

In your case, the scaling factors should be

double scaleX = this.getWidth() / 770.0;
double scaleY = this.getHeight() / 460.0;

// Now simply call scale
((Graphics2D) g).scale(scaleX, scaleY);

Put this before drawing anything.

Hope this helps.

---

You need to use a proper layout manager to place your panels in your JFrame.

If you have only two panels, I'd suggest using BorderLayout. It is quite simple to use and would probably serve your purpose.

This way your panels would resize when you resize your window.

Good luck.