Thread: I'm new to JFrame and need some help

Basically, to familiarize myself with this class I'm doing my first project, which is drawing the Mendelbrot Set, but before that I have to handle much simpler things;

If I have a the class
public class Canvas extends JFrame

and the functions

    public static void main(String args[])
    {
 
        System.out.println("Running Canvas.java");
        Canvas canvas = new Canvas();
 
    }
 
    public Canvas()
    {
        setSize(width, height);
        setVisible(true);
    }
 
    public void paint(Graphics g)
    {
        g.setColor(Color.yellow);
        g.fillRect(0,0, width, height);
    }

Who calls the function paint() when I run Canvas.java? Is it re-called every time that it finishes? Because that's what seems to be happening with my code.

Thank you in advance for your help

I'm fresh out of highschool in terms of my java knowledge, so I don't know much yet

In your post I don't know what these terms are:

GUI class
JVM
Java SE
swing class


Also, which name should I give it? I'm used to Canvas because of the project I made in highschool

I might as well post all the code I have so far

package Mendelbrot;
 
 
import java.awt.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JFrame;
 
/**
 *
 * @author 
 */
public class Canvas extends JFrame
{
    int width=200;
    int height=200;
    int iterations=4;
 
    Thread thread=new Thread();
 
 
    public static void main(String args[])
    {
 
        System.out.println("Running Canvas.java");
        Canvas canvas = new Canvas();
 
 
    }
 
    public Canvas()
    {
        setSize(width, height);
        setVisible(true);
    }
 
 
    public void paint(Graphics g)
    {
        g.setColor(Color.yellow);
        g.fillRect(0,0, width, height);
 
 
        int[][] grid=render(width, height);
 
        for(int i=0;i<width;i++)
        {
            for(int j=0;j<height;j++)
            {
                if(grid[i][j]==0)
                {
                    g.setColor(Color.WHITE);
                }
                if(grid[i][j]==1)
                {
                    g.setColor(Color.BLACK);
                }
                g.fillRect(i,j,1,1); //fills a single pixel
            }
        }
 
 
    }
 
 
    /**
     * 
     * @param c complex number
     * @param n how many iterations are used to find the answer
     * @return true if c is part of the mendelbrot set
     */
    public boolean isMend(Z c,int n)
    {
        return isMend(c,n,c);
    }
 
 
    public boolean isMend(Z zn, int n, Z c)
    {
//        System.out.println(n);
        if(n==0)
        {
            if(zn.getSize()<=2)
                return true;
            else
                return false;
        }
 
        Z zn1=Z.sum(Z.multiply(zn,zn),c);
        return isMend(zn1,n-1,c);
    }
 
 
    /**
     * 
     * @param w width
     * @param h height
     * @return an image to be painted
     */
    public int[][] render(int w, int h)
    {
        System.out.println("Render "+w+","+h);
        int[][] grid=new int[w][h];
 
        //Initialization of the grid
        for(int i=0;i<w;i++)
        {
            for(int j=0;j<h;j++)
            {
                grid[i][j]=0;
            }
        }
 
 
        //Give values
        for(int i=0;i<w;i++)
        {
            for(int j=0;j<h;j++)
            {
                // -1<x<1  -1<y<1
                int x=i/100-1;
                int y=j/100-1;
                Z c=new Z(x,y);
                if(isMend(c,iterations))
                {
                    grid[i][j]=1;
                }
                System.out.println("Finished rendering pixel ["+i+","+j+"]");
            }
        }
 
        return grid;
    }
 
//    public void run()
//    {
//        while(true)
//        {
//            repaint();
//            System.out.println("Repainting");
//
//
//            try
//            {
//                thread.sleep(2000);
//            }
//            catch (InterruptedException ex)
//            {
//                Logger.getLogger(Canvas.class.getName()).log(Level.SEVERE, null, ex);
//            }
//        }
//    }
 
 
 
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
 
package Mendelbrot;
 
/**
 *
 * @author Alon Eitan
 */
public class Z //Imaginary Number
{
    /**
     * Real component
     */
    public double re;
    /**
     * Imaginary component
     */
    public double im;
 
 
 
    /**
     *
     * @param a real component
     * @param b imaginary component
     */
    public Z(double a, double b)
    {
        re=a;
        im=b;
    }
 
 
 
 
    public double getSize()
    {
        return re*re+im*im;
    }
 
    public double getAngle()
    {
        return Math.atan(im/re);
    }
 
 
    public static Z sum(Z a, Z b)
    {
        double re=a.re+b.re;
        double im=a.im+b.im;
        return new Z(re,im);
    }
 
 
    public static Z multiply(Z a,Z b)
    {
        double re=a.re*b.re-(a.im*b.im);
        double im=a.re*b.im+a.im*b.re;
        return new Z(re,im);
    }
 
 
    public double getReal()
    {
        return re;
    }
 
    public double getImaginary()
    {
        return im;
    }
 
    public void setReal(double re)
    {
        this.re = re;
    }
 
    public void setImaginary(double im)
    {
        this.im = im;
    }
 
}

Then it's in a GUI class because I can see it on my screen. (which is the entire point of this program)
How does the JVM determine when the GUI needs to be drawn?

For some reason the paint() function is being called multiple times.
It also isn't drawing correctly, but that's a different issue (I think).

My question is why my code calls the paint() function multiple times

Right... never mind, I managed to solve my problem.

But I have a new one now regarding threads; I'm trying to activate two threads at the same time, one that repaints every half second and another that renders the image (so that I can see the image progressively getting rendered)

But for some reason, the moment I activate one thread, it stays in the thread's loop and doesn't do anything else.


Here are the threads' run() functions:

    public void run()
    {
        while(true) //infinite loop
        {
            repaint();
 
 
            try
            {
                repainter.sleep(500);
            }
            catch (InterruptedException ex)
            {
                Logger.getLogger(Canvas.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

   public void run()
    {
        render();
    }

These are the relevant functions

    public MyCanvas()
    {
        setSize(width, height);
        setVisible(true);
        ren.setWindow(-2.2,1.3,3.4,2.6);
 
        ren.startRendering();
        run();
    }

Inside MyCanvas:

    public void run()
    {
        while(true)
        {
            repaint();
 
 
            try
            {
                repainter.sleep(500);
            }
            catch (InterruptedException ex)
            {
                Logger.getLogger(Canvas.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

Inside Renderer:

    public void run()
    {
        render();
    }

Here:

import java.util.logging.Level;
import java.util.logging.Logger;
 
public class ThreadProblem
{
 
 
    public static void main(String[]args)
    {
        ThreadProblem tp=new ThreadProblem();
    }
 
    public ThreadProblem()
    {
        Apples a=new Apples();
        Oranges b=new Oranges();
    }
 
 
 
 
    public class Apples implements Runnable
    {
 
        Thread applesThread=new Thread();
 
        public Apples()
        {
            run();
        }
        public void run()
        {
            while(true)
            {
                System.out.println("Apples");
                try
                {
                    applesThread.sleep(1000);
                }
                catch (InterruptedException ex)
                {
                    Logger.getLogger(ThreadProblem.class.getName()).log(Level.SEVERE, null, ex);
                }
 
            }
        }
 
    }
 
    public class Oranges implements Runnable
    {
        Thread orangesThread=new Thread();
 
        public Oranges()
        {
            run();
        }
        public void run()
        {
            while(true)
            {
                System.out.println("Oranges");
                try
                {
                    orangesThread.sleep(2000);
                }
                catch (InterruptedException ex)
                {
                    Logger.getLogger(ThreadProblem.class.getName()).log(Level.SEVERE, null, ex);
                }
 
            }
        }
    }
 
}

I want it to print "Apples" every second and "Oranges" every two seconds, but instead it only prints "Apples" every second.

Unrelated problem:
Assuming I have a variable that goes from 0 to 1, how do I use it and the class Color to get a rainbow spectrum? (0=red, 1=violet)

Actually what you have done is a wrong appreach. this ll help u i guess

public class ThreadProblem
{

public static void main(String[] arg)
{
new ThreadProblem();
}

public ThreadProblem()
{
Apples a=new Apples();
Oranges b=new Oranges();
}

public class Apples extends Thread
{

public Apples()
{
start();
}
public void run()
{
while(true)
{
System.out.println("Apples");
try
{
this.sleep(1000);
}
catch (InterruptedException ex)
{
System.out.println("into catch");
}

}
}

}

public class Oranges extends Thread
{
public Oranges()
{
start();
}
public void run()
{
while(true)
{
System.out.println("Oranges");
try
{
this.sleep(2000);
}
catch (InterruptedException ex)
{
System.out.println("into orange catch");
}

}
}
}

}

I used your method and now I'm getting "java.lang.IllegalMonitorStateException"

I managed to find how to make rainbow colors from
Create a rainbow with GD

But now I have two new problems (because of the exception I posted above)
1. My repainter thread doesn't work
2. I tried adding a MouseListener and a MouseMotionListener to (as of now) draw rectangles, and it isn't working properly either. It's drawing the rectangles too large:


This is the MouseListener and MouseMotionListener I used

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
 
package Mendelbrot;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.*;
 
/**
 *
 * @author Alon Eitan
 */
public class Zoomer implements MouseListener, MouseMotionListener
{
    int sx,sy; //starting x y
    int cx,cy; //current x y
    Graphics g;
 
    boolean dragging=false;
 
    public Zoomer(Graphics g)
    {
        this.g=g;
    }
 
    public void mouseClicked(MouseEvent me)
    {
    }
 
    public void mousePressed(MouseEvent me)
    {
        if(dragging)
            return;
        sx=me.getX();
        sy=me.getY();
        dragging=true;
    }
 
    public void mouseReleased(MouseEvent me)
    {
        dragging=false;
 
    }
 
    public void mouseEntered(MouseEvent me)
    {
    }
 
    public void mouseExited(MouseEvent me)
    {
    }
 
    public void mouseDragged(MouseEvent me)
    {
        if(!dragging)
            return;
        cx=me.getX();
        cy=me.getY(); 
        g.setColor(Color.white);
        g.drawRect(sx, sy, cx, cy);
    }
 
    public void mouseMoved(MouseEvent me)
    {
    }
 
}

It's creating rectangles but not according to the true position of the mouse, but further right and downwards.

    public class Repainter extends Thread
    {
 
        public void run()
        {
            while (true)
            {
                repaint();
                try
                {
                    this.wait(150);  //<--- exception here
                }
                catch (InterruptedException ex)
                {
                    Logger.getLogger(MyCanvas.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }
 
    }

Exception in thread "Thread-2" java.lang.IllegalMonitorStateException
        at java.lang.Object.wait(Native Method)
        at Mendelbrot.MyCanvas$Repainter.run(MyCanvas.java:83)