GUI friert ein! (Thread,GUI,EDT,GLASSPANE)

[benhaze]

Hallo liebe Entwicklergemeinde!
Ich habe folgendes Problem:

In meiner Anwendung *passieren* ServiceCalls.
Ich quatsche quasi WebServices an.
Diese ServiceCalls werden in einem separaten Thread aufgerufen.
Nun wollte ich, während so ein ServiceCall-Thread läuft, eine Art Progressbar in der Ui anzeigen und alles andere solange deaktivieren.

Was habe ich bisher getan:
1. ServiceCall-Thread gestartet
2. warten solange Thread läuft
3. solange Thread läuft, *modalen Dialog* mit Progressbar anzeigen.

Das klappt wunderbar.
Wegen dem modalen Dialog. Während dieser angezeigt wird, werden die UI-events weiter gepumpt.
Nun wollte ich aber den Dialog durch ein Glasspane mit Progressbar ersetzen.

Wie könnte ich es nun hinbekommen aus meiner while-schleife heraus (im EDT)
die progressbar im auf dem GlassPane anzuzeigen?

quasi brauche ich nen modales glasspane (oder so)

Danke!

 

[Leetus]

Hallo benhaze,
die Frag habe ich mir auch gestellt.
Ich habe eine RCP Anwendung. Dort kannst du den neuen Thread deine Display aus der Anwendung übergeben und asynchron laufen lassen. Wenn du die ProgressBar füllst ist es auch sichtbar.

public class ServiceCaller extends Thread {
   private Display display
   private ProgressBar progressBar;
   public ServiceCaller(final Display display, final ProgressBar progressBar) {
	this.display = display;
	this.progressBar = progressBar;

   }
   public final void run() {
           display.asyncExec(new Runnable() {
                   public void run() {
   
                 	//Dein Service-Call
	   		progessBar <--füllen
                   
               });
   }
}

Bei Swing solltest nach der Swingworker Klasse und den einen invokelater Aufruf googlen.

Gruß
Leetus

 

[benhaze]

Danke für deine Hilfe, aber das klappt so nicht.
Ich kann nicht den ServiceCall und das Zeichnen der Progressbar in einem Thread starten.
der EDT wird dadurch sofort geblockt.

Hier habe ich mal den konkreten (etwas angepassten) Code:

@Override
    public Object invoke(Object p_proxy, Method p_method, Object[] p_args)
    {
        Object ret = null;
        final Object proxy = p_proxy;
        final Method method = p_method;
        final Object[] args = p_args;
        final WebserviceInvocationHandler handler = this;
        StackTraceElement[] stack = Thread.currentThread().getStackTrace();
        
        try 
        {
            m_threadIsRunning = true;
            //Thread für ServiceCall
            MyRequesetThread myInvocationThread = new MyRequesetThread() {
                
                @Override
                public void run() 
                {
                    try 
                    {
                        Object result = handler.doIt(proxy, method, args);
                        super.setResult(result);
                    }
                    catch (SfxException p_ex) 
                    {
 
                        Object result = (SfxException)p_ex;
                        super.setResult(result);
                    }
                    finally
                    {
                        m_threadIsRunning = false;
                    }
                }
            };
            myInvocationThread.start(); //ServiceCall Thread starten
            
           //so: hier jetzt darauf warten, bis der Thread beendet ist 
           //und dann das Ergebnis holen, DABEI WIRD ABER DER EDT blockiert!
          //jetzt (während des wartens) würde ich gerne ein glasspane anzeigen.
            while (true)
            {
                if (m_threadIsRunning)
                {
                    //do nothing....just wait...
                    if (!m_waitingDialog.isVisible() && m_threadIsRunning)
                    {
                            if (m_threadIsRunning)
                            {
                                Class c = method.getReturnType();
                                String s = getStringRepForClass(c);
                                m_waitingDialog.setText(s);
                                //modalen dialog anzeigen klappt wunderbar,
                                //da die events weiter gepumpt werden
                                m_waitingDialog.setDialogVisible(true);
                            }
                    }
                }
                else
                {
                    if (m_waitingDialog.isVisible())
                        m_waitingDialog.setDialogVisible(false);
                    break;
                }
            }

            //hier das Ergebnis vom ServiceCall holen:
            ret = myInvocationThread.getInvocationReturnValue();

            if (ret instanceof SfxException)
                throw (SfxException)ret;
        }
        catch(SfxException p_ex)
        {
            SimpleErrorViewer v = new SimpleErrorViewer(null,true,p_ex);
            v.setVisible(true);
            ret = null; //must return null to avoid any class cast exception!
        }

        return ret;
    }