GUI Ladestatus + Thread

[tom g.]

Hallo Forum,

vorweg, ich habe schon hier gesucht, komme aber irgendwie nicht klar.

Ich möchte den Ladestatus meiner GUI im SplashScreen darstellen.

Hier mal der Code der Main Klasse:

package sys;

import java.io.File;
import sys.cls.IniRecource;
import sys.frm.TransparentWindow;
import sys.frm.MainFrame;
import javax.swing.*;


public class Main {
    /* Konstanten definition */
    public static boolean DEBUG_STATE = true;
    public static String PATH_TO_INI = System.getProperty("user.dir") + File.separator + "ini.xml";
    public static IniRecource INI_RESOURCE = new IniRecource(PATH_TO_INI);
    /*variablen deklarieren */
    
    private Thread tIni,tSplash,tMainFrame;
    private TransparentWindow tw;
    private MainFrame mf;
    /** Creates a new instance of Main */
    public Main() {
       System.out.println("Starte CP JImageResizer");
        
        //Splashscreen öffnen
        tw = new TransparentWindow();// Initialisieren des Fensters
        tSplash = new Thread(tw); 
        tSplash.run(); //anzeigen des Fensters this.setVisible(true);
        
        
        //Ini.xml lesen
        tIni = new Thread(INI_RESOURCE);
        tIni.run();
        
        // GUI erzeugen
        mf = new MainFrame(); //Initialisieren des Fensters
        tMainFrame = new Thread(mf); //Initialisieren des Threads
        tMainFrame.run(); //Fenster anzeigen this.setVisible(true);
        tw.stop(); //ausblenden des SplashScreens this.setVisible(false);
        tSplash.interrupt(); // beenden des tSplash Threads
       
    }
    
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        new Main();
    }
    
}

Jetzt meine Fragen

In

 //Splashscreen öffnen
        tw = new TransparentWindow();// Initialisieren des Fensters
        tsplash = new Thread(tw); 
        tsplash.run(); //anzeigen des Fensters this.setVisible(true);

wird das Fenster ja schon bei tw = new TransparentWindow() initialisiert und dann nur bei tsplash.run angezeigt.

Sollte ich lieber das Initialisieren durch die tsplash.run() - Methode aufrufen und am Ende this.setVisible(true) setzen.

Wie bekomme ich heraus, wie lange der Thread zum Initialisieren des MainFrames brauch, und wie setze ich dann das Value der JProgressbar im Splashscreen.

Damit meine ich nicht tw.setValue(int i); sondern was in int i reinkommt.

Ich hoffe ich habe mich halbwegs verständlich ausgedrückt.

Danke

Tom

 

[André Uhres]

Wie lange eine Startup dauern wird lässt sich (mit und ohne Kristallkugel) wohl schwer voraussagen,
daher bietet JProgressBar die Methode "setIndeterminate" an:

package splash;
/*
 * Main.java
 */
import java.io.File;
import javax.swing.*;
public class Main {
    /* Konstanten definition */
    final private static boolean DEBUG_STATE = true;
    final private static String PATH_TO_INI = System.getProperty("user.dir") + File.separator + "ini.xml";
    final private static IniRecource INI_RESOURCE = new IniRecource(PATH_TO_INI);
    /*variablen deklarieren */
    private Thread tIni,tSplash,tMainFrame;
    private TransparentWindow tw;
    private MainFrame mf;
    public Main() {
        System.out.println("Starte CP JImageResizer");

        //Splashscreen öffnen:
        tw = new TransparentWindow();
        tw.setVisible(true);

        //Ini.xml lesen:
        tIni = new Thread(INI_RESOURCE);
        tIni.start();//<------------------ein Thread wird mit start() getstartet!!!
        // GUI erzeugen:
        mf = new MainFrame(); //Fenster erzeugen
        tMainFrame = new Thread(mf); //Initialisieren des Threads
        tMainFrame.start();//<------------ein Thread wird mit start() getstartet!!!

        try {
            //Warten bis alle Threads fertig sind:
            tIni.join();
            tMainFrame.join();
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }

        //Ausblenden des SplashScreens:
        tw.dispose();
    }
    public static void main(final String[] args) {new Main();}
}
class IniRecource implements Runnable{
    private String str;
    public IniRecource(final String str){
        this.str = str;
    }
    public void run() {
        try {Thread.sleep(3000);} catch (InterruptedException ex) {}
    }
}
class TransparentWindow extends JWindow {
    public TransparentWindow(){
        setSize(400,20);
        setLocationRelativeTo(null);
        JProgressBar progress = new JProgressBar();
        progress.setIndeterminate(true);
        progress.setString("Starte CP JImageResizer...");
        progress.setStringPainted(true);
        add(progress);
    }
}
class MainFrame extends JFrame implements Runnable{
    public void run() {
        setSize(400,300);
        setLocationRelativeTo(null);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setTitle("MainFrame");
        try {Thread.sleep(4000);} catch (InterruptedException ex) {}
        setVisible(true);
    }
}

 

[tom g.]

Hallo André,

Wie lange eine Startup dauern wird lässt sich (mit und ohne Kristallkugel) wohl schwer voraussagen,
daher bietet JProgressBar die Methode "setIndeterminate" an:

soweit so gut. Das habe ich verstanden. Wie aber stelle ich es an, das es
so wie bei Netbeans ist.

Ist dort die Anzeige der JProgessBar in etwa so geplant worden?

JProgressbar

max = 100

Threads z.B. 5

pro Thread = 20

Wenn Thread fertig, dann current = current + 20.

Frage((n)zeichen) über Fragen((n)zeichen).

Danke schon mal.

Tom

 

[André Uhres]

Eine Progressbar zeichnet naturgemäss nur einen einzigen Thread.
Um mehreren Threads zu zeichnen, müsste man mehrere Progessbars haben, was wohl selten jemand so macht.
Man zeichnet also nur den Hauptthread, also den, welcher voraussichtlich am längsten läuft.
Du Kannst z.B. dem MainFrame die Referenz "tw" im Konstruktor mitgeben und beim Laden der GUI
an passenden Stellen eine Methode aus TransparentWindow aufrufen,
die die Progressbar auf einen geschätzten Wert setzt.

EDIT: Ich bin mir jetzt aber nicht sicher, ob du den Sinn von Threads erfasst hast:
Threads macht man, um mehrere Prozesse parallel, also quasi gleichzeitig laufen zu lassen.
Wenn man das Resultat von einem Thread braucht, muss man natürlich warten, bis er fertig ist (join).

 

[tom g.]

Hallo,

hab's schon verstanden. Ist bei mir aber eine Mischung.

Thread 1 ruft den SplashScreen auf.
Thread 2 läd die ini-Datei.
Thread 3 wartet auf 2 und schreibt werte in die ini.
Thread 4 wartet auf 3 und läd das Hauptfenster.
HauptFenster fertig Thread 4 bleibt bestehen und Thread1 wird geschlossen.

Habe mir jetzt eine Klasse GUIThread extends Thread geschrieben. Der wird eine Instans des Objectes, ein String
und eine Instans des TransparentWindow-Objektes übergeben. Ich hole mir die Millisekunden des Threads und
übergebe diese an die JProgressBar.

Funzt alles so weit.

Nur wie kann ich in der übergebenen Objekt Instans die run() - Methode aufrufen? object.start() geht nicht.

Hier mal der Code der Klasse. (nicht erschlagen falls es Quatch ist ;-) )

package sys.cls;

/**
 * GUIThread.java
 * @author cttogo
 * Created on 22. März 2007, 20:25
 */
import java.util.*;
import sys.frm.TransparentWindow;

public class GUIThread extends Thread{
    private long mmSecStart;
    private long mmSecStop;
    private long mmTemp;
    private String infoText = "";
    private TransparentWindow tw;
    private Object object = null;
    /** Creates a new instance of GUIThread */
    public GUIThread(Object o,String s,TransparentWindow itw) {
        tw = itw;
        infoText = s;
        object = o;
    }
    
    public void stoppe() {
        System.out.println("Stoppe Thread " + infoText);
        mmSecStop = System.currentTimeMillis();
        tw.setLabel("Programm wird gestartet");
        try {Thread.sleep(3000);} catch (InterruptedException ex) {}
        tw.setPCurrent(tw.getPMax());
    }
    public void starte() {
        tw.setLabel(infoText);
        System.out.println("Starte Thread " + infoText);
        mmSecStart = System.currentTimeMillis() + tw.getPCurrent();
    }
    private void setProgressBar(){
        if((System.currentTimeMillis() - mmSecStart) > mmTemp){
            mmTemp = System.currentTimeMillis()- mmSecStart;
            tw.setPCurrent( (int) Math.round(System.currentTimeMillis() - mmSecStart) ) ;
            System.out.println((int) Math.round(System.currentTimeMillis() - mmSecStart) + " : " 
+ (int) Math.round(mmTemp) );
        }
    }
    public void run(){
        object.run();
        starte();
        while (this.isAlive() ){
            setProgressBar();
        }
        stoppe();
    }
}

object.run kann Netbeans nicht parsen.

Tom

 

[André Uhres]

Am besten, du übergibst nicht den Runnable, sondern gleich den Thread:
((Thread)object).start();
oder object gleich als Thread deklarieren :wink:

 

[tom g.]

Hi André,

das probiere Morgen aus, muss gleich auf Hochzeit :ROST::

Tom

 

[André Uhres]

Hi André,

das probiere Morgen aus, muss gleich auf Hochzeit :ROST::

Tom

Aha, du heiratest

 

[tom g.]

Hi André,

das probiere Morgen aus, muss gleich auf Hochzeit :ROST::

Tom

Aha, du heiratest

Neeeee, habe das schon Jahre hinter mir. :roll:

Meine kleine Schwester. :lol: :applaus:

Tom

 

[André Uhres]

war nur'n Scherz, sonst hättest du ja morgen auch was anderes zu tun als als gerade Java programmieren :wink:

 

[tom g.]

Ich habe das Problem gelöst.

Die Klasse GUIThread

import java.util.*;
import sys.frm.TransparentWindow;
import sys.Main;


public class GUIThread extends Thread{
    private long mmSecStart;
    private long mmSecStop;
    private long mmTemp;
    private String infoText = "";
    private TransparentWindow tw;
    private boolean bLast;
    private Thread tTemp;
    private Main main;
    
    
    /** 
     * Instanziert ein neues Objekt von GUIThread 
     **/
    public GUIThread(TransparentWindow itw){ //der SplashScreen
     
        tw = itw;
    }
    
    //Stop die Anzeige für das Modul.
    //Wenn bLast == true wird die Stopvariable in der Mainklasse gestzt.
    public void stoppe() {
        mmSecStop = System.currentTimeMillis();
        if(bLast){
            tw.setPCurrent(tw.getPMax());
            tw.setLabel("Programm wird gestartet");
            try {Thread.sleep(1800);} catch (InterruptedException ex) {} //Splash noch 1.8 Secunden anzeigen
            main.WAIT_OF_MAINFRAME = false;
        }
        
    }
    
    //Startet die Anzeige für das Modul
    public void starte() {
        tw.setLabel(infoText);
        mmSecStart = System.currentTimeMillis() + tw.getPCurrent();
        while(tTemp.isAlive() && main.MAINFRAME_READY == false){
            setProgressBar();
        }
        stoppe();
        
    }
    
    //Übergibt der Progressbar das Value
    private void setProgressBar(){
        if((System.currentTimeMillis() - mmSecStart) > mmTemp){
            mmTemp = System.currentTimeMillis()- mmSecStart;
            tw.setPCurrent( (int) Math.round(System.currentTimeMillis() - mmSecStart) ) ;
            System.out.println((int) Math.round(System.currentTimeMillis() - mmSecStart) + " : " + (int) Math.round(mmTemp) );
        }
    }
    
    //Setzt den laufenden Thread
    public void setThread(Thread t){
        tTemp = t;
    }
    
    //Übergibt ob das aufrufende Modul das letzte Modul ist
    public void setLast(boolean b){
        bLast = b;
    }
    
    //Setzt den angezeigten Info String
    public void setString(String s){
        infoText = s;
    }
    
    //Startet GUIThread
    public void run(){
        
    }
    
}

@André

THX

Hast mir sehr geholfen.

Tom