# Modifizierter Ladebalken?



## Guest (8. Jul 2008)

Hi,

ich brauche sowas wie einen 3 farbigen Ladebalken für folgendes vorhaben:

Ladebalken:

=======25%============50%===========75%==========100%

0 - 25% rot
25 - 75% orange
75 - 100% grün

Das Laden ist bei mir geteilt in Pflicht Daten (ohne Läuft es nicht), empfohlener Datensatz (verkürzt die Ladezeit, wenn einmalig geladen) und komplett geladen.

Bis 25% kann der Nutzer den Ladevorgang nicht abbrechen, nach 25% kann er abbrechen oder sagen brich bei 75% (empfohlen) bzw. 100% (alles) ab. Mir geht es jetzt hier um die Visualisierung des Vorganges.

Gibt es eine Möglichkeit einen Ladebalken (oder etwas anderes was so ähnlich aussieht? z.B. quer liegendes Balkendiagramm?) so zu modifizieren?

Ich könnte ja theoretisch auch 3 JPG-Bilder nehmen und die übereinander anzeigen. Nur weiß ich nicht wie ich die Bilder dann passend schneide um z.B. bei jedem 1% ein Pixel von dem Bild mehr zu zeigen und wie lege ich drei Bilder übereinander? Leider habe ich mit sowas noch nicht gearbeitet und bräuchte hier etwas Hilfe.

Jemand eine Idee?

Danke

Tommy


----------



## Coldplay (8. Jul 2008)

Wieso willst du einen Balken so modifizieren? Nimm doch einfach 4 Balken mit jeweils verschiedenen farben und plaziere dazwischen deine Prozentzahlen einfach mit Labels.


----------



## Gast (8. Jul 2008)

Das Problem was ich habe ist das die Prozentwerte eben nicht fix sind sondern abhängig davon was der Nutzer schon geladen hat bzw. sich der Prozentwert während des Ladevorgangs ändern kann.

Die Prozentwerte brauchen auch nicht dazwischen war nur zur Darstellung, das der Ladeprozess bis 25% eben in rot dargestellt werden soll, danach Orange etc.

Ich müsste eigentlich nur 3 Balken übereinanderlegen und den ersten bei z.B. 25% stehen lassen. Geht das?


----------



## SlaterB (8. Jul 2008)

du denkst immer noch dass du dafür eine bestimmte Komponente brauchst, aber du kannst das selber kontrollieren,

irgendwo hast du ja
double percent = getPercentFromAnywhere()
progressBar.setValue(percent);

und nun schreibst du
double percent = getPercentFromAnywhere()
if (percent > 0.25) {
percent = 0.25;
}
progressBar.setValue(percent);

fertig, Problem gelöst,
wenn du willst kannst du ja eine spezielle SubKlasse bauen und da setValue entspechend überschreiben/ modifizieren


----------



## Coldplay (8. Jul 2008)

Mein Vorschlag wäre nicht übereinander sondern nebeneinander 3 Balken. Und die Prozentzahlen kannst du ganz rechts in einem Label oder Textfeld ausgeben. Diesen Wert kannst du an der Stelle aktualisieren, wo du deinen Balken aktualisierst. Du kennst ja deine Datenmenge, Balken 1 musst du so programmieren dass er bei 25% Datenmenge voll ist, Balken 2, dass er bei 25% anfängt sich zu ändern und bei 75% voll ist usw.


----------



## Gast (8. Jul 2008)

Danke für den Tip.

Was ich nur noch nicht verstanden habe ist jetzt die nächste(zweite) Progressbar die Quasi dann loslaufen müsste, wenn die erste gestoppt wurde (hier 25%). Nur wie platziere ich die so aneinander das es reibungslos einhergeht?

Das ganze sollte dann so aussehen: 

= = rot
- = orange
. = grün

=====---------------........

Mein Idee war hier halt 3 Stück übereinander zu paltzieren und immer eine so wie du es geschrieben hast auslaufen zu lassen. Nur wie platziere ich drei übereinander und wie sage ich welche oben liegt?


----------



## Guest (8. Jul 2008)

Damit wir nicht aneinander vorbeisprechen. Ich habe folgendes Layout auf meiner JToolBar:


```
setLayout(new FormLayout(
					new ColumnSpec[] {
						FormFactory.DEFAULT_COLSPEC,
						FormFactory.DEFAULT_COLSPEC,
						FormFactory.DEFAULT_COLSPEC,
						new ColumnSpec(ColumnSpec.FILL, Sizes.DEFAULT, FormSpec.DEFAULT_GROW),
						FormFactory.DEFAULT_COLSPEC,
						FormFactory.DEFAULT_COLSPEC,
						FormFactory.DEFAULT_COLSPEC,
						FormFactory.DEFAULT_COLSPEC,
						FormFactory.LABEL_COMPONENT_GAP_COLSPEC,
						new ColumnSpec(ColumnSpec.FILL, Sizes.DEFAULT, FormSpec.DEFAULT_GROW),
						FormFactory.LABEL_COMPONENT_GAP_COLSPEC,
						FormFactory.DEFAULT_COLSPEC,
						FormFactory.DEFAULT_COLSPEC,
											FormFactory.DEFAULT_COLSPEC,
					},
					new RowSpec[] {
							FormFactory.DEFAULT_ROWSPEC
						}));
```

Meine Progressbar setze ich wie folgt:


```
add(pBar, cc.xy(10, 1));
```

Wenn ich jetzt drei Stück nebeneinander setze, habe ich doch immer eine Lücke zwischen der ersten und der zweiten Progressbar die beiden liegen nicht nahtlos aneinander. Das stört mich derzeit nur noch.


----------



## Coldplay (8. Jul 2008)

Dies wäre dann eine Frage des Layouts. Ich bin mir nicht sicher aber die Balken exakt nebeneinander zu plazieren müsste mit GridLayout (oder GridBagLayout) problemlos gehen. Wenn du schon ein anderes Layout benutzt kannst du alle 3 auf einem Panel packen, und dessen Layout mit GridLayoutsetzen, sodass du ein 1x3 Gitternetz hast.


----------



## Coldplay (8. Jul 2008)

Bitte gib uns Feedback, wenn du Erfolg hast. Das würde auch mich interessieren.


----------



## Guest (8. Jul 2008)

Das klappt so leider nicht. 

Das Problem ist, dass die Ladebalken bereits im Leerzustand (0%) einen Rahmen aufweisen. Anhand des Rahmen und der Füllung kann der Nutzer die Prozente abschätzen. Jetzt habe ich den Ladebalken in 3 Teile aufgeteilt und damit 3 Rahmen geschaffen. Es dürfte jedoch nur einen Gesamtrahmen geben. Die Rahmen auszublenden ist auch nicht der Hit, dann fehlt irgendwie was, nur die Rahmen links/rechts rauszunehmen geht glaub ich nicht.

Anbei mal der Code:

Noch jemand eine Idee?


```
private void initComponents(){
		setLayout(new FormLayout(
				new ColumnSpec[] {
					new ColumnSpec(ColumnSpec.FILL, Sizes.DEFAULT, FormSpec.DEFAULT_GROW),
					new ColumnSpec(ColumnSpec.FILL, Sizes.DEFAULT, FormSpec.DEFAULT_GROW),
					new ColumnSpec(ColumnSpec.FILL, Sizes.DEFAULT, FormSpec.DEFAULT_GROW),
				},
				new RowSpec[] {
						FormFactory.DEFAULT_ROWSPEC
					}));
		CellConstraints cc = new CellConstraints();
		
		jpb1 = new JProgressBar();
		jpb2 = new JProgressBar();
		jpb3 = new JProgressBar();
		
		
		
		add(jpb1,cc.xy(1, 1));
		add(jpb2,cc.xy(2, 1));
		add(jpb3,cc.xy(3, 1));
	}
```


----------



## Tom299 (9. Jul 2008)

ich hab das mit den farben mal in einen test-code von mir eingebaut, vielleicht hilft dir das ja weiter.


```
package de.thomas.thread;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JProgressBar;


public class ThreadApp extends JFrame implements ActionListener, Runnable {

    private static final long serialVersionUID = 1L;
    private JButton btnStartProgress;
    private JButton btnPauseProgress;
    private JButton btnStopProgress;
    private JProgressBar barProgress;
    private JLabel lblProgress;    
    private int iCount = 0;
    private final int maxCount = 100;
    private final String AC_START_PROGRESS = "startProgress";
    private final String AC_PAUSE_PROGRESS = "pauseProgress";
    private final String AC_STOP_PROGRESS = "stopProgress";
    Thread t;
    private boolean suspend = false;
    private boolean stop = false;    
    
    
    public ThreadApp()
    {
        initComponents ();
        setLocationRelativeTo( null );
    }
    
    
    public static void main (String[] args) 
    {
        java.awt.EventQueue.invokeLater(new Runnable() 
        {
            public void run() 
            {
                new ThreadApp().setVisible(true);
            }
        });    
    }

    private void initComponents()
    {
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); 
        btnStartProgress = new JButton("Start");
        btnStartProgress.addActionListener (this);
        btnStartProgress.setActionCommand (AC_START_PROGRESS);
         
        btnPauseProgress = new JButton("Pause");
        btnPauseProgress.addActionListener (this);
        btnPauseProgress.setActionCommand (AC_PAUSE_PROGRESS);
        btnPauseProgress.setEnabled (false);
        
        btnStopProgress = new JButton("Stop");
        btnStopProgress.addActionListener (this);
        btnStopProgress.setActionCommand (AC_STOP_PROGRESS);
        btnStopProgress.setEnabled (false);
                
        barProgress = new JProgressBar();
        barProgress.setMinimum (0);
        barProgress.setMaximum (maxCount);
        barProgress.setValue (iCount);
        barProgress.setBorderPainted (false);
        barProgress.setForeground (Color.RED);
        
        lblProgress = new JLabel(Integer.toString (barProgress.getValue ()) + "%");
        lblProgress.setPreferredSize (new Dimension (32, 16));        
        
        this.getContentPane().setLayout (new FlowLayout());
        this.getContentPane().add (btnStartProgress);
        this.getContentPane().add (btnPauseProgress);
        this.getContentPane().add (btnStopProgress);
        this.getContentPane().add (barProgress);
        this.getContentPane().add (lblProgress);
        this.pack ();        
    }        
    
    public void actionPerformed (ActionEvent ae) 
    {
        if ( ae.getActionCommand () == AC_START_PROGRESS) {            
            iCount = 0;
            btnStartProgress.setEnabled (false);
            btnPauseProgress.setEnabled (true);
            btnStopProgress.setEnabled (true);
            t = new Thread(this);
            t.start ();            
        }
        else if ( ae.getActionCommand () == AC_PAUSE_PROGRESS) {            
            if (suspend) {
                //System.out.println ("isNotPause");
                resumeThread ();
            }
            else {
                //System.out.println ("isPause");
                suspendThread ();
            }
        }
        else if ( ae.getActionCommand () == AC_STOP_PROGRESS) {
            stopThread ();
            btnPauseProgress.setEnabled (false);
            btnStopProgress.setEnabled (false);
        }
    }

    public void run () {
        
        while (!t.isInterrupted () && iCount <= maxCount) {
            try {
                waitForResumeOrStop ();                            
                barProgress.setValue (iCount);
                if (iCount >= 75) {
                    barProgress.setForeground (Color.GREEN);
                }                
                else if (iCount >= 25) {
                    barProgress.setForeground (Color.ORANGE);
                }
                else {
                    barProgress.setForeground (Color.RED);
                }
                lblProgress.setText (Integer.toString (barProgress.getValue ()) + "%");
                iCount ++;
                Thread.sleep(100);
            }
            catch (InterruptedException e) {                
                t.interrupt ();
            }
        }
        btnStartProgress.setEnabled (true);
        btnPauseProgress.setEnabled (false);
        btnStopProgress.setEnabled (false);
        stop = false;
        suspend = false;
    }
    
    public void suspendThread () {
        suspend = true;
    }

    public void resumeThread () {
        suspend = false;
        synchronized (this) {
            this.notifyAll ();
        }
    }
    
    public void stopThread () {
        stop = true;
        t.interrupt ();
    }
    
    public final void waitForResumeOrStop () throws InterruptedException {
        synchronized (this) {
            while (suspend) {
                this.wait ();
                if (stop)
                    throw new InterruptedException ();
            }
            if (stop)
                throw new InterruptedException ();
        }
    }    
}
```


----------



## Tom299 (9. Jul 2008)

und hier noch ne version mit 3 progress bars, kann man sicher noch besser machen, aber funktioniert ...


```
package de.thomas.thread;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;


public class ThreadApp2 extends JFrame implements ActionListener, Runnable {

    private static final long serialVersionUID = 1L;
    private JButton btnStartProgress;
    private JButton btnPauseProgress;
    private JButton btnStopProgress;
    private JProgressBar barProgressRed;
    private JProgressBar barProgressOrange;
    private JProgressBar barProgressGreen;
    private JLabel lblProgress;
    private int iCount = 0;
    private final int maxCount = 100;
    private final String AC_START_PROGRESS = "startProgress";
    private final String AC_PAUSE_PROGRESS = "pauseProgress";
    private final String AC_STOP_PROGRESS = "stopProgress";
    Thread t;
    private boolean suspend = false;
    private boolean stop = false;    
    
    
    public ThreadApp2()
    {
        initComponents ();
        setLocationRelativeTo( null );
    }
    
    
    public static void main (String[] args) 
    {
        java.awt.EventQueue.invokeLater(new Runnable() 
        {
            public void run() 
            {
                new ThreadApp2().setVisible(true);
            }
        });    
    }

    private void initComponents()
    {
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); 
        btnStartProgress = new JButton("Start");
        btnStartProgress.addActionListener (this);
        btnStartProgress.setActionCommand (AC_START_PROGRESS);
         
        btnPauseProgress = new JButton("Pause");
        btnPauseProgress.addActionListener (this);
        btnPauseProgress.setActionCommand (AC_PAUSE_PROGRESS);
        btnPauseProgress.setEnabled (false);
        
        btnStopProgress = new JButton("Stop");
        btnStopProgress.addActionListener (this);
        btnStopProgress.setActionCommand (AC_STOP_PROGRESS);
        btnStopProgress.setEnabled (false);
                        
        barProgressRed = new JProgressBar();
        barProgressRed.setMinimum (0);
        barProgressRed.setMaximum (24);
        barProgressRed.setValue (0);
        barProgressRed.setBorderPainted (false);
        barProgressRed.setForeground (Color.RED);
        barProgressRed.setPreferredSize (new Dimension (100, 15));

        barProgressOrange = new JProgressBar();
        barProgressOrange.setMinimum (25);
        barProgressOrange.setMaximum (74);
        barProgressOrange.setValue (25);
        barProgressOrange.setBorderPainted (false);
        barProgressOrange.setForeground (Color.ORANGE);
        barProgressOrange.setPreferredSize (new Dimension (200, 15));
        
        barProgressGreen = new JProgressBar();
        barProgressGreen.setMinimum (75);
        barProgressGreen.setMaximum (100);
        barProgressGreen.setValue (75);
        barProgressGreen.setBorderPainted (false);
        barProgressGreen.setForeground (Color.GREEN);        
        barProgressGreen.setPreferredSize (new Dimension (100, 15));
        
        lblProgress = new JLabel(Integer.toString (barProgressRed.getValue ()) + "%");
        lblProgress.setPreferredSize (new Dimension (32, 16));        
        
        this.getContentPane().setLayout (new FlowLayout());
        this.getContentPane().add (btnStartProgress);
        this.getContentPane().add (btnPauseProgress);
        this.getContentPane().add (btnStopProgress);
        
        JPanel panProgress = new JPanel (new GridBagLayout ());
        panProgress.add (barProgressRed, new GridBagConstraints (1,0,1,1,0.0,0.0,GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL,new Insets (0,0,0,0), 0,0));
        panProgress.add (barProgressOrange, new GridBagConstraints (2,0,1,1,0.0,0.0,GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL,new Insets (0,0,0,0), 0,0));
        panProgress.add (barProgressGreen, new GridBagConstraints (3,0,1,1,0.0,0.0,GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL,new Insets (0,0,0,0), 0,0));
        
        this.getContentPane().add (panProgress);
        this.getContentPane().add (lblProgress);
        this.pack ();        
    }
    
    public void actionPerformed (ActionEvent ae) 
    {
        if ( ae.getActionCommand () == AC_START_PROGRESS) {            
            iCount = 0;
            btnStartProgress.setEnabled (false);
            btnPauseProgress.setEnabled (true);
            btnStopProgress.setEnabled (true);
            t = new Thread(this);
            t.start ();            
        }
        else if ( ae.getActionCommand () == AC_PAUSE_PROGRESS) {            
            if (suspend) {
                //System.out.println ("isNotPause");
                resumeThread ();
            }
            else {
                //System.out.println ("isPause");
                suspendThread ();
            }
        }
        else if ( ae.getActionCommand () == AC_STOP_PROGRESS) {
            stopThread ();
            btnPauseProgress.setEnabled (false);
            btnStopProgress.setEnabled (false);
        }
    }

    public void run () {
        while (!t.isInterrupted () && iCount <= maxCount) {
            try {
                waitForResumeOrStop ();
                barProgressRed.setValue (iCount);
                barProgressOrange.setValue (iCount);
                barProgressGreen.setValue (iCount);
                if (iCount >= 75) {
                    lblProgress.setText (Integer.toString (barProgressGreen.getValue ()) + "%");
                }
                else if (iCount >= 25) {
                    lblProgress.setText (Integer.toString (barProgressOrange.getValue ()) + "%");
                }
                else {
                    lblProgress.setText (Integer.toString (barProgressRed.getValue ()) + "%");
                }
                iCount ++;
                Thread.sleep(100);
            }
            catch (InterruptedException e) {                
                t.interrupt ();
            }
        }
        btnStartProgress.setEnabled (true);
        btnPauseProgress.setEnabled (false);
        btnStopProgress.setEnabled (false);
        stop = false;
        suspend = false;
    }
    
    public void suspendThread () {
        suspend = true;
    }

    public void resumeThread () {
        suspend = false;
        synchronized (this) {
            this.notifyAll ();
        }
    }
    
    public void stopThread () {
        stop = true;
        t.interrupt ();
    }
    
    public final void waitForResumeOrStop () throws InterruptedException {
        synchronized (this) {
            while (suspend) {
                this.wait ();
                if (stop)
                    throw new InterruptedException ();
            }
            if (stop)
                throw new InterruptedException ();
        }
    }    
}
```


----------



## Quaxli (9. Jul 2008)

Ich würde mir so'n Ding einfach selbst schreiben. Woran machst Du denn den Fortschritt fest?


----------



## Coldplay (9. Jul 2008)

Wenn die obigen Beispiele von Tim dich auch nicht weiterbringen, würde ich dir empfehlen, deinen eigenen Balken als Notlösung mit Rechtecken zu programmieren. Du könntest auf ein Canvas deine Rechtecke zeichnen und mit repaint() Methode aktualisieren. Dann hättest du weder störende Rahmen noch Probleme mit verschiedenen Farben, du solltest bloß die Geometrie der Rechecke zu jedem Zeitpunkt richtig berechnen.


----------



## Tom299 (9. Jul 2008)

ich heisse aber Tom *hust* ;-)

den fortschritt mach ich bei mir im test-code ja einfach am iCount fest (zählt einfach von 0-100). aber wie genau der TE den fortschritt berechnet muß er ja selbst wissen und entsprechend setzen. dient ja lediglich nur als kleines beispiel wie man es machen könnte.

evlt. kann man ja auch die JProgressBar ableiten und die paint () - methode überschreiben und da halt entsprechend die farben setzen. hab ich nicht versucht, aber könnt auch klappen.


----------



## Tom299 (9. Jul 2008)

da ich grad spaß an dem thema hatte, hab ich es nochmal verbessert, diesmal einfach die UI überschrieben, so gehts meiner meinung am einfachsten ;-)


```
package de.thomas.thread;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JProgressBar;
import javax.swing.plaf.basic.BasicProgressBarUI;


public class ThreadApp3 extends JFrame implements ActionListener, Runnable {

    private static final long serialVersionUID = 1L;
    private JButton btnStartProgress;
    private JButton btnPauseProgress;
    private JButton btnStopProgress;
    private JProgressBar barProgress;
    private JLabel lblProgress;    
    private int iCount = 0;
    private final int maxCount = 100;
    private final String AC_START_PROGRESS = "startProgress";
    private final String AC_PAUSE_PROGRESS = "pauseProgress";
    private final String AC_STOP_PROGRESS = "stopProgress";
    Thread t;
    private boolean suspend = false;
    private boolean stop = false;    
    
    
    public ThreadApp3()
    {
        initComponents ();
        setLocationRelativeTo( null );
    }
    
    
    public static void main (String[] args) 
    {
        java.awt.EventQueue.invokeLater(new Runnable() 
        {
            public void run() 
            {
                new ThreadApp3().setVisible(true);
            }
        });    
    }

    private void initComponents()
    {
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); 
        btnStartProgress = new JButton("Start");
        btnStartProgress.addActionListener (this);
        btnStartProgress.setActionCommand (AC_START_PROGRESS);
         
        btnPauseProgress = new JButton("Pause");
        btnPauseProgress.addActionListener (this);
        btnPauseProgress.setActionCommand (AC_PAUSE_PROGRESS);
        btnPauseProgress.setEnabled (false);
        
        btnStopProgress = new JButton("Stop");
        btnStopProgress.addActionListener (this);
        btnStopProgress.setActionCommand (AC_STOP_PROGRESS);
        btnStopProgress.setEnabled (false);
                
        barProgress = new JProgressBar ();
        barProgress.setMinimum (0);
        barProgress.setMaximum (maxCount);
        barProgress.setValue (iCount);
        barProgress.setBorderPainted (false);
        barProgress.setUI (new ColoredProgressBarUI ());
        
        lblProgress = new JLabel(Integer.toString (barProgress.getValue ()) + "%");
        lblProgress.setPreferredSize (new Dimension (32, 16));        
        
        this.getContentPane().setLayout (new FlowLayout());
        this.getContentPane().add (btnStartProgress);
        this.getContentPane().add (btnPauseProgress);
        this.getContentPane().add (btnStopProgress);
        this.getContentPane().add (barProgress);
        this.getContentPane().add (lblProgress);
        this.pack ();        
    }        
    
    public void actionPerformed (ActionEvent ae) 
    {
        if ( ae.getActionCommand () == AC_START_PROGRESS) {            
            iCount = 0;
            btnStartProgress.setEnabled (false);
            btnPauseProgress.setEnabled (true);
            btnStopProgress.setEnabled (true);
            t = new Thread(this);
            t.start ();            
        }
        else if ( ae.getActionCommand () == AC_PAUSE_PROGRESS) {            
            if (suspend) {
                //System.out.println ("isNotPause");
                resumeThread ();
            }
            else {
                //System.out.println ("isPause");
                suspendThread ();
            }
        }
        else if ( ae.getActionCommand () == AC_STOP_PROGRESS) {
            stopThread ();
            btnPauseProgress.setEnabled (false);
            btnStopProgress.setEnabled (false);
        }
    }

    public void run () {
        while (!t.isInterrupted () && iCount <= maxCount) {
            try {
                waitForResumeOrStop ();                            
                barProgress.setValue (iCount);
                lblProgress.setText (Integer.toString (barProgress.getValue ()) + "%");
                iCount ++;
                Thread.sleep(100);
            }
            catch (InterruptedException e) {                
                t.interrupt ();
            }
        }
        btnStartProgress.setEnabled (true);
        btnPauseProgress.setEnabled (false);
        btnStopProgress.setEnabled (false);
        stop = false;
        suspend = false;
    }
    
    public void suspendThread () {
        suspend = true;
    }

    public void resumeThread () {
        suspend = false;
        synchronized (this) {
            this.notifyAll ();
        }
    }
    
    public void stopThread () {
        stop = true;
        t.interrupt ();
    }
    
    public final void waitForResumeOrStop () throws InterruptedException {
        synchronized (this) {
            while (suspend) {
                this.wait ();
                if (stop)
                    throw new InterruptedException ();
            }
            if (stop)
                throw new InterruptedException ();
        }
    }    
}

class ColoredProgressBarUI extends BasicProgressBarUI {
    
    public ColoredProgressBarUI () {
        super ();
    }
    
    @Override
    public void paint (Graphics g, JComponent c) {        
        int maxWidth = c.getWidth ();
        int singleQuarter = maxWidth / 4;
        int tripleQuarter = singleQuarter * 3;
        
        int amountFull = getAmountFull (c.getInsets (), c.getWidth (), c.getHeight ());
        if (amountFull >= tripleQuarter) {
            g.setColor (Color.RED);
            g.fillRect (0, 0, singleQuarter - 1, c.getHeight ());
            g.setColor (Color.ORANGE);
            g.fillRect (singleQuarter, 0, amountFull - singleQuarter, c.getHeight ());
            g.setColor (Color.GREEN);
            g.fillRect (tripleQuarter, 0, amountFull - tripleQuarter, c.getHeight ());
        }
        else if (amountFull >= singleQuarter) {
            g.setColor (Color.RED);
            g.fillRect (0, 0, singleQuarter - 1, c.getHeight ());
            g.setColor (Color.ORANGE);
            g.fillRect (singleQuarter, 0, amountFull - singleQuarter, c.getHeight ());
        }
        else {
            g.setColor (Color.RED);
            g.fillRect (0, 0, amountFull, c.getHeight ());
        }
    }
}
```


----------

