Attachment #147290 for bug #283596

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2007, 2009 Innoopract Informationssysteme GmbH.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *
 * Contributors:
 *     Innoopract Informationssysteme GmbH - initial API and implementation
 *     EclipseSource - ongoing development
 ******************************************************************************/
package org.eclipse.rap.ui.internal.progress;


import org.eclipse.rwt.service.ISessionStore;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.internal.progress.ProgressManager;
import org.eclipse.ui.progress.UIJob;

// RAP [fappel]:
public class JobManagerAdapter
  extends ProgressProvider
  implements IJobChangeListener
{

  private static JobManagerAdapter _instance;
  private final Map jobs;
  private final ProgressManager defaultProgressManager;

    }
    return _instance;
  }


  private JobManagerAdapter() {
    // To avoid deadlocks we have to use the same synchronisation lock.
    // If anyone has a better idea - you're welcome.

    Job.getJobManager().setProgressProvider( this );
    Job.getJobManager().addJobChangeListener( this );
  }


  ///////////////////////////////
  // ProgressProvider

  public IProgressMonitor createMonitor( final Job job ) {
    ProgressManager manager = findProgressManager( job );
    return manager.createMonitor( job );
  }

  public IProgressMonitor createMonitor( final Job job,
                                         final IProgressMonitor group,
                                         final int ticks )

    ProgressManager manager = findProgressManager( job );
    return manager.createMonitor( job, group, ticks );
  }

  public IProgressMonitor createProgressGroup() {
    return defaultProgressManager.createProgressGroup();
  }


  ///////////////////////////////
  // interface IJobChangeListener

  public void aboutToRun( final IJobChangeEvent event ) {
    ProgressManager manager = findProgressManager( event.getJob() );
    manager.changeListener.aboutToRun( event );

    } else {
      // RAP [rh] fixes bug 283595
      event.getJob().cancel();
      manager[ 0 ].changeListener.done( event );
    }
  }



  public void scheduled( final IJobChangeEvent event ) {
    ProgressManager manager;
    Display display = findDisplay( event.getJob() );
    synchronized( lock ) {
      if( display != null ) {
        jobs.put( event.getJob(), display );
        Runnable runnable = new Runnable() {
          public void run() {
            bindToSession( event.getJob() );
            String id = String.valueOf( event.getJob().hashCode() );
            UICallBack.activate( id );
          }
        };
        UICallBack.runNonUIThreadWithFakeContext( display, runnable );
      }
      manager = findProgressManager( event.getJob() );
    }
    manager.changeListener.scheduled( event );
  }


  public void sleeping( final IJobChangeEvent event ) {
    ProgressManager manager = findProgressManager( event.getJob() );
    manager.changeListener.sleeping( event );
  }

  
  //////////////////
  // helping methods

  private ProgressManager findProgressManager( final Job job ) {
    synchronized( lock ) {
      final ProgressManager result[] = new ProgressManager[ 1 ];

      return result[ 0 ];
    }
  }

  private static Display findDisplay( final Job job ) {
    Display result = null;
    if( ContextProvider.hasContext() ) {
      result = RWTLifeCycle.getSessionDisplay();
    } else {
      if( job instanceof UIJob ) {
        UIJob uiJob = ( UIJob )job;
        result = uiJob.getDisplay();
        if( result == null ) {
          throw new IllegalStateException( "" );
        }
      }
    }
    return result;
  }

  private void bindToSession( final Object keyToRemove ) {
    ISessionStore session = RWT.getSessionStore();
    HttpSessionBindingListener watchDog = new HttpSessionBindingListener() {

Return to bug 283596

Lines 1-5 Link Here

(-)Eclipse UI/org/eclipse/rap/ui/internal/progress/JobManagerAdapter.java (-21 / +45 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2008 Innoopract Informationssysteme GmbH.	2	* Copyright (c) 2007, 2009 Innoopract Informationssysteme GmbH.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 7-12 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Innoopract Informationssysteme GmbH - initial API and implementation	9	* Innoopract Informationssysteme GmbH - initial API and implementation
		10	* EclipseSource - ongoing development
10	******************************************************************************/	11	******************************************************************************/
11	package org.eclipse.rap.ui.internal.progress;	12	package org.eclipse.rap.ui.internal.progress;
12		13
Lines 25-37 Link Here
25	import org.eclipse.rwt.service.ISessionStore;	26	import org.eclipse.rwt.service.ISessionStore;
26	import org.eclipse.swt.widgets.Display;	27	import org.eclipse.swt.widgets.Display;
27	import org.eclipse.ui.internal.progress.ProgressManager;	28	import org.eclipse.ui.internal.progress.ProgressManager;
		29	import org.eclipse.ui.progress.UIJob;
28		30
29	// RAP [fappel]:	31	// RAP [fappel]:
30	public class JobManagerAdapter	32	public class JobManagerAdapter
31	extends ProgressProvider	33	extends ProgressProvider
32	implements IJobChangeListener	34	implements IJobChangeListener
33	{	35	{
34		36
35	private static JobManagerAdapter _instance;	37	private static JobManagerAdapter _instance;
36	private final Map jobs;	38	private final Map jobs;
37	private final ProgressManager defaultProgressManager;	39	private final ProgressManager defaultProgressManager;
Lines 43-50 Link Here
43	}	45	}
44	return _instance;	46	return _instance;
45	}	47	}
46		48
47		49
48	private JobManagerAdapter() {	50	private JobManagerAdapter() {
49	// To avoid deadlocks we have to use the same synchronisation lock.	51	// To avoid deadlocks we have to use the same synchronisation lock.
50	// If anyone has a better idea - you're welcome.	52	// If anyone has a better idea - you're welcome.
Lines 63-78 Link Here
63	Job.getJobManager().setProgressProvider( this );	65	Job.getJobManager().setProgressProvider( this );
64	Job.getJobManager().addJobChangeListener( this );	66	Job.getJobManager().addJobChangeListener( this );
65	}	67	}
66		68
67		69
68	///////////////////////////////	70	///////////////////////////////
69	// ProgressProvider	71	// ProgressProvider
70		72
71	public IProgressMonitor createMonitor( final Job job ) {	73	public IProgressMonitor createMonitor( final Job job ) {
72	ProgressManager manager = findProgressManager( job );	74	ProgressManager manager = findProgressManager( job );
73	return manager.createMonitor( job );	75	return manager.createMonitor( job );
74	}	76	}
75		77
76	public IProgressMonitor createMonitor( final Job job,	78	public IProgressMonitor createMonitor( final Job job,
77	final IProgressMonitor group,	79	final IProgressMonitor group,
78	final int ticks )	80	final int ticks )
Lines 80-94 Link Here
80	ProgressManager manager = findProgressManager( job );	82	ProgressManager manager = findProgressManager( job );
81	return manager.createMonitor( job, group, ticks );	83	return manager.createMonitor( job, group, ticks );
82	}	84	}
83		85
84	public IProgressMonitor createProgressGroup() {	86	public IProgressMonitor createProgressGroup() {
85	return defaultProgressManager.createProgressGroup();	87	return defaultProgressManager.createProgressGroup();
86	}	88	}
87		89
88		90
89	///////////////////////////////	91	///////////////////////////////
90	// interface IJobChangeListener	92	// interface IJobChangeListener
91		93
92	public void aboutToRun( final IJobChangeEvent event ) {	94	public void aboutToRun( final IJobChangeEvent event ) {
93	ProgressManager manager = findProgressManager( event.getJob() );	95	ProgressManager manager = findProgressManager( event.getJob() );
94	manager.changeListener.aboutToRun( event );	96	manager.changeListener.aboutToRun( event );
Lines 128-134 Link Here
128	} else {	130	} else {
129	// RAP [rh] fixes bug 283595	131	// RAP [rh] fixes bug 283595
130	event.getJob().cancel();	132	event.getJob().cancel();
131	manager[ 0 ].changeListener.done( event );	133	manager[ 0 ].changeListener.done( event );
132	}	134	}
133	}	135	}
134		136
Lines 139-165 Link Here
139		141
140	public void scheduled( final IJobChangeEvent event ) {	142	public void scheduled( final IJobChangeEvent event ) {
141	ProgressManager manager;	143	ProgressManager manager;
		144	Display display = findDisplay( event.getJob() );
142	synchronized( lock ) {	145	synchronized( lock ) {
143	if( ContextProvider.hasContext() ) {	146	if( display != null ) {
144	jobs.put( event.getJob(), RWTLifeCycle.getSessionDisplay() );	147	jobs.put( event.getJob(), display );
145	bindToSession( event.getJob() );	148	Runnable runnable = new Runnable() {
146	String id = String.valueOf( event.getJob().hashCode() );	149	public void run() {
147	UICallBack.activate( id );	150	bindToSession( event.getJob() );
		151	String id = String.valueOf( event.getJob().hashCode() );
		152	UICallBack.activate( id );
		153	}
		154	};
		155	UICallBack.runNonUIThreadWithFakeContext( display, runnable );
148	}	156	}
149	manager = findProgressManager( event.getJob() );	157	manager = findProgressManager( event.getJob() );
150	}	158	}
151	manager.changeListener.scheduled( event );	159	manager.changeListener.scheduled( event );
152	}	160	}
153		161
		162
154	public void sleeping( final IJobChangeEvent event ) {	163	public void sleeping( final IJobChangeEvent event ) {
155	ProgressManager manager = findProgressManager( event.getJob() );	164	ProgressManager manager = findProgressManager( event.getJob() );
156	manager.changeListener.sleeping( event );	165	manager.changeListener.sleeping( event );
157	}	166	}
158		167
159
160	//////////////////	168	//////////////////
161	// helping methods	169	// helping methods
162		170
163	private ProgressManager findProgressManager( final Job job ) {	171	private ProgressManager findProgressManager( final Job job ) {
164	synchronized( lock ) {	172	synchronized( lock ) {
165	final ProgressManager result[] = new ProgressManager[ 1 ];	173	final ProgressManager result[] = new ProgressManager[ 1 ];
Lines 180-186 Link Here
180	return result[ 0 ];	188	return result[ 0 ];
181	}	189	}
182	}	190	}
183		191
		192	private static Display findDisplay( final Job job ) {
		193	Display result = null;
		194	if( ContextProvider.hasContext() ) {
		195	result = RWTLifeCycle.getSessionDisplay();
		196	} else {
		197	if( job instanceof UIJob ) {
		198	UIJob uiJob = ( UIJob )job;
		199	result = uiJob.getDisplay();
		200	if( result == null ) {
		201	throw new IllegalStateException( "" );
		202	}
		203	}
		204	}
		205	return result;
		206	}
		207
184	private void bindToSession( final Object keyToRemove ) {	208	private void bindToSession( final Object keyToRemove ) {
185	ISessionStore session = RWT.getSessionStore();	209	ISessionStore session = RWT.getSessionStore();
186	HttpSessionBindingListener watchDog = new HttpSessionBindingListener() {	210	HttpSessionBindingListener watchDog = new HttpSessionBindingListener() {