Attachment #193574 for bug #341760

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

View | Details | Raw Unified | Return to bug 341760
Collapse All | Expand All

Lines 289-295 Link Here

(-)src/org/eclipse/rwt/internal/engine/RWTServletContextListener.java (-1 lines)
289	}	289	}
290	}	290	}
291	} else {	291	} else {
292	phaseListeners.add( new PreserveWidgetsPhaseListener() );
293	phaseListeners.add( new CurrentPhase.Listener() );	292	phaseListeners.add( new CurrentPhase.Listener() );
294	}	293	}
295	PhaseListenerRegistry phaseListenerRegistry = RWTFactory.getPhaseListenerRegistry();	294	PhaseListenerRegistry phaseListenerRegistry = RWTFactory.getPhaseListenerRegistry();

Lines 18-24 Link Here

(-)src/org/eclipse/rwt/internal/lifecycle/IDisplayLifeCycleAdapter.java (-1 / +2 lines)
18		18
19		19
20	public interface IDisplayLifeCycleAdapter extends ILifeCycleAdapter {	20	public interface IDisplayLifeCycleAdapter extends ILifeCycleAdapter {
21	void preserveValues( Display display );
22	void readData( Display display );	21	void readData( Display display );
		22	void preserveValues( Display display );
23	void render( Display display ) throws IOException;	23	void render( Display display ) throws IOException;
		24	void clearPreserved( Display display );
24	}	25	}




/*******************************************************************************
 * Copyright (c) 2002, 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Innoopract Informationssysteme GmbH - initial API and implementation
 *     EclipseSource - ongoing development
 ******************************************************************************/
package org.eclipse.rwt.internal.lifecycle;

import org.eclipse.rwt.lifecycle.*;
import org.eclipse.swt.internal.widgets.*;
import org.eclipse.swt.internal.widgets.WidgetTreeVisitor.AllWidgetTreeVisitor;
import org.eclipse.swt.widgets.*;

public final class PreserveWidgetsPhaseListener implements PhaseListener {

  private static final long serialVersionUID = 1L;

  public void beforePhase( final PhaseEvent event ) {
  }

  public void afterPhase( final PhaseEvent event ) {
    if( PhaseId.READ_DATA.equals( event.getPhaseId() ) ) {
      Display display = RWTLifeCycle.getSessionDisplay();
      if( display != null ) {
        preserve( display );
      }
    } else if( PhaseId.RENDER.equals( event.getPhaseId() ) ) {
      Display display = RWTLifeCycle.getSessionDisplay();
      if( display != null ) {
        clearPreserved( display );
      }
    }
  }
  
  public PhaseId getPhaseId() {
    return PhaseId.ANY;
  }
  
  /////////////////////////////////////////////////////
  // Helping methods to preserve widget property values

  private static void preserve( final Display display ) {
    IDisplayLifeCycleAdapter displayLCA = DisplayUtil.getLCA( display );
    IWidgetAdapter adapter = DisplayUtil.getAdapter( display );
    if( adapter.isInitialized() ) {
      displayLCA.preserveValues( display );
      IDisplayAdapter displayAdapter
        = ( IDisplayAdapter )display.getAdapter( IDisplayAdapter.class );
      Composite[] shells = displayAdapter.getShells();
      for( int i = 0; i < shells.length; i++ ) {
        WidgetTreeVisitor.accept( shells[ i ], new AllWidgetTreeVisitor() {
          public boolean doVisit( final Widget widget ) {
            AbstractWidgetLCA widgetLCA = WidgetUtil.getLCA( widget );
            widgetLCA.preserveValues( widget );
            return true;
          }
        } );
      }
    }
  }
  
  static void clearPreserved( final Display display ) {
    WidgetAdapter widgetAdapter 
      = ( WidgetAdapter )DisplayUtil.getAdapter( display );
    widgetAdapter.clearPreserved();
    IDisplayAdapter displayAdapter
      = ( IDisplayAdapter )display.getAdapter( IDisplayAdapter.class );
    Composite[] shells = displayAdapter.getShells();
    for( int i = 0; i < shells.length; i++ ) {
      WidgetTreeVisitor.accept( shells[ i ], new AllWidgetTreeVisitor() {
        public boolean doVisit( final Widget widget ) {
          WidgetAdapter widgetAdapter 
            = ( WidgetAdapter )WidgetUtil.getAdapter( widget );
          widgetAdapter.clearPreserved();
          return true;
        }
      } );
    }
  }
}

Lines 23-29 Link Here

(-)src/org/eclipse/rwt/internal/lifecycle/ReadData.java (-1 / +3 lines)
23		23
24	public PhaseId execute() {	24	public PhaseId execute() {
25	Display display = RWTLifeCycle.getSessionDisplay();	25	Display display = RWTLifeCycle.getSessionDisplay();
26	DisplayUtil.getLCA( display ).readData( display );	26	IDisplayLifeCycleAdapter displayLCA = DisplayUtil.getLCA( display );
		27	displayLCA.readData( display );
		28	displayLCA.preserveValues( display );
27	return PhaseId.PROCESS_ACTION;	29	return PhaseId.PROCESS_ACTION;
28	}	30	}
29	}	31	}

Lines 25-31 Link Here

(-)src/org/eclipse/rwt/internal/lifecycle/Render.java (-1 / +3 lines)
25		25
26	public PhaseId execute() throws IOException {	26	public PhaseId execute() throws IOException {
27	Display display = RWTLifeCycle.getSessionDisplay();	27	Display display = RWTLifeCycle.getSessionDisplay();
28	DisplayUtil.getLCA( display ).render( display );	28	IDisplayLifeCycleAdapter displayLCA = DisplayUtil.getLCA( display );
		29	displayLCA.render( display );
		30	displayLCA.clearPreserved( display );
29	return null;	31	return null;
30	}	32	}
31	}	33	}





  private static final String WRITER_MAP
    = JSWriter.class.getName() + "#map";
  private static final String HAS_WIDGET_MANAGER
    = JSWriter.class.getName() + "#hasWidgetManager";
  private static final String CURRENT_WIDGET_REF
    = JSWriter.class.getName() + "#currentWidgetRef";


    IServiceStateInfo stateInfo = ContextProvider.getStateInfo();
    if(    currentPhaseIsRender()
        && widget != null
        && stateInfo.getAttribute( HAS_WIDGET_MANAGER ) == null )
    {
      writeVarAssignment( WIDGET_MANAGER_REF,
                          "org.eclipse.swt.WidgetManager.getInstance()" );
      stateInfo.setAttribute( HAS_WIDGET_MANAGER, Boolean.TRUE );
    }
  }





  ////////////////////////////////////////////////////////
  // interface implementation of IDisplayLifeCycleAdapter

  public void readData( Display display ) {
    readBounds( display );
    readCursorLocation( display );
    readFocusControl( display );
    KeyBindingUtil.readKeyBindingEvents( display );
    WidgetTreeVisitor visitor = new AllWidgetTreeVisitor() {
      public boolean doVisit( final Widget widget ) {
        IWidgetLifeCycleAdapter adapter = WidgetUtil.getLCA( widget );
        adapter.readData( widget );
        return true;
      }
    };
    Shell[] shells = getShells( display );
    for( int i = 0; i < shells.length; i++ ) {
      Composite shell = shells[ i ];
      WidgetTreeVisitor.accept( shell, visitor );
    }
    for( int i = 0; i < shells.length; i++ ) {
      if( shells[ i ].getMaximized() || shells[ i ].getFullScreen() ) {
        Object adapter = shells[ i ].getAdapter( IShellAdapter.class );
        IShellAdapter shellAdapter = ( IShellAdapter )adapter;
        shellAdapter.setBounds( display.getBounds() );
      }
    }
    DNDSupport.processEvents();
  }

  public void preserveValues( final Display display ) {
    IWidgetAdapter adapter = DisplayUtil.getAdapter( display );
    adapter.preserve( PROP_FOCUS_CONTROL, display.getFocusControl() );

    adapter.preserve( PROP_TIMEOUT_PAGE, getTimeoutPage() );
    adapter.preserve( PROP_EXIT_CONFIRMATION, getExitConfirmation() );
    KeyBindingUtil.preserveKeyBindings( display );
    if( adapter.isInitialized() ) {
      Shell[] shells = getShells( display );
      for( int i = 0; i < shells.length; i++ ) {
        WidgetTreeVisitor.accept( shells[ i ], new AllWidgetTreeVisitor() {
          public boolean doVisit( final Widget widget ) {
            AbstractWidgetLCA widgetLCA = WidgetUtil.getLCA( widget );
            widgetLCA.preserveValues( widget );
            return true;
          }
        } );
      }
    }
  }

  public void render( final Display display ) throws IOException {

      KeyBindingUtil.writeKeyBindings( display );
    }
  }
  
  public void clearPreserved( Display display ) {
    WidgetAdapter widgetAdapter = ( WidgetAdapter )DisplayUtil.getAdapter( display );
    widgetAdapter.clearPreserved();
    Composite[] shells = getShells( display );
    for( int i = 0; i < shells.length; i++ ) {
      WidgetTreeVisitor.accept( shells[ i ], new AllWidgetTreeVisitor() {
        public boolean doVisit( final Widget widget ) {
          WidgetAdapter widgetAdapter = ( WidgetAdapter )WidgetUtil.getAdapter( widget );
          widgetAdapter.clearPreserved();
          return true;
        }
      } );
    }
  }

  private static void renderShells( Display display ) throws IOException {
    RenderVisitor visitor = new RenderVisitor();

    IWidgetAdapter adapter = DisplayUtil.getAdapter( display );
    Object oldTimeoutPage = adapter.getPreserved( PROP_TIMEOUT_PAGE );
    if( !timeoutPage.equals( oldTimeoutPage ) ) {
      String pattern = "org.eclipse.swt.Request.getInstance().setTimeoutPage( \"{0}\" );";
        = "org.eclipse.swt.Request.getInstance().setTimeoutPage( \"{0}\" );";
      Object[] param = new Object[] { timeoutPage };
      String jsCode = MessageFormat.format( pattern, param );
      IServiceStateInfo stateInfo = ContextProvider.getStateInfo();

  }

  private static String getTimeoutPage() {
    String timeoutTitle = RWTMessages.getMessage( "RWT_SessionTimeoutPageTitle" );
    String timeoutHeadline = RWTMessages.getMessage( "RWT_SessionTimeoutPageHeadline" );
    String timeoutHeadline
      = RWTMessages.getMessage( "RWT_SessionTimeoutPageHeadline" );
    String pattern = RWTMessages.getMessage( "RWT_SessionTimeoutPageMessage" );
    Object[] arguments = new Object[]{ "<a {HREF_URL}>", "</a>" };
    String timeoutMessage = MessageFormat.format( pattern, arguments );

    ThemeManager.getInstance().registerResources();
  }

  public void readData( Display display ) {
    readBounds( display );
    readCursorLocation( display );
    readFocusControl( display );
    KeyBindingUtil.readKeyBindingEvents( display );
    WidgetTreeVisitor visitor = new AllWidgetTreeVisitor() {
      public boolean doVisit( final Widget widget ) {
        IWidgetLifeCycleAdapter adapter = WidgetUtil.getLCA( widget );
        adapter.readData( widget );
        return true;
      }
    };
    Shell[] shells = getShells( display );
    for( int i = 0; i < shells.length; i++ ) {
      Composite shell = shells[ i ];
      WidgetTreeVisitor.accept( shell, visitor );
    }
    for( int i = 0; i < shells.length; i++ ) {
      if( shells[ i ].getMaximized() || shells[ i ].getFullScreen() ) {
        Object adapter = shells[ i ].getAdapter( IShellAdapter.class );
        IShellAdapter shellAdapter = ( IShellAdapter )adapter;
        shellAdapter.setBounds( display.getBounds() );
      }
    }
    DNDSupport.processEvents();
  }

  /////////////////////////////
  // Helping methods for render


Lines 75-81 Link Here

(-)src/org/eclipse/RWTQ07TestSuite.java (-1 / +1 lines)
75	// RWT core tests, but there is still some refactoring	75	// RWT core tests, but there is still some refactoring
76	// necessary to achieve this, so they've been moved	76	// necessary to achieve this, so they've been moved
77	// temporarily to the q07 fragment tests..	77	// temporarily to the q07 fragment tests..
78	suite.addTestSuite( PreserveWidgetsPhaseListener_Test.class );	78	suite.addTestSuite( PreserveWidgets_Test.class );
79	suite.addTestSuite( WidgetAdapter_Test.class );	79	suite.addTestSuite( WidgetAdapter_Test.class );
80	suite.addTestSuite( DuplicateRequest_Test.class );	80	suite.addTestSuite( DuplicateRequest_Test.class );
81	suite.addTestSuite( MouseEvent_Test.class );	81	suite.addTestSuite( MouseEvent_Test.class );




/*******************************************************************************
 * Copyright (c) 2002, 2011 Innoopract Informationssysteme GmbH and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Innoopract Informationssysteme GmbH - initial API and implementation
 *    EclipseSource - ongoing development
 *    Frank Appel - replaced singletons and static fields (Bug 337787)
 ******************************************************************************/
package org.eclipse.rwt.internal.lifecycle;

import java.io.IOException;

import junit.framework.TestCase;

import org.eclipse.rwt.AdapterFactory;
import org.eclipse.rwt.Fixture;
import org.eclipse.rwt.internal.AdapterManager;
import org.eclipse.rwt.internal.AdapterManagerImpl;
import org.eclipse.rwt.internal.engine.RWTFactory;
import org.eclipse.rwt.internal.service.RequestParams;
import org.eclipse.rwt.lifecycle.*;
import org.eclipse.swt.SWT;
import org.eclipse.swt.internal.widgets.Props;
import org.eclipse.swt.widgets.*;

public class PreserveWidgetsPhaseListener_Test extends TestCase {

  public static final class TestEntryPointWithShell implements IEntryPoint {
    public int createUI() {
      Display display = new Display();
      new Shell( display, SWT.NONE );
      int count = 0;
      while( count < 1 ) {
        if( !display.readAndDispatch() ) {
          display.sleep();
        }
        count++;
      }
      return 0;
    }
  }
  
  protected void setUp() throws Exception {
    Fixture.setUp();
    Fixture.fakeNewRequest();
    RWTFactory.getPhaseListenerRegistry().add( new PreserveWidgetsPhaseListener() );
  }

  protected void tearDown() throws Exception {
    Fixture.tearDown();
  }

  public void testInitialization() throws Exception {
    // ensures that the default WidgetCopyPhaseListener is registered
    // and executes at the designated phases
    Display display = new Display();
    Composite shell = new Shell( display , SWT.NONE );
    final Text text = new Text( shell, SWT.NONE );
    text.setText( "hello" );
    Fixture.markInitialized( display );
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    final StringBuffer log = new StringBuffer();
    lifeCycle.addPhaseListener( new PhaseListener() {

      private static final long serialVersionUID = 1L;

      public void beforePhase( final PhaseEvent event ) {
        if( PhaseId.PROCESS_ACTION.equals( event.getPhaseId() ) ) {
          IWidgetAdapter adapter = WidgetUtil.getAdapter( text );
          if( "hello".equals( adapter.getPreserved( Props.TEXT ) ) ) {
            log.append( "copy created" );
          }
        }
      }

      public void afterPhase( final PhaseEvent event ) {
      }

      public PhaseId getPhaseId() {
        return PhaseId.ANY;
      }
    } );
    Fixture.executeLifeCycleFromServerThread( );
    assertEquals( "copy created", log.toString() );
  }

  public void testExecutionOrder() {
    final StringBuffer log = new StringBuffer();
    Fixture.fakeResponseWriter();
    AdapterFactory lifeCycleAdapterFactory = new AdapterFactory() {

      private AdapterFactory factory = new LifeCycleAdapterFactory();

      public Object getAdapter( final Object adaptable, final Class adapter ) {
        Object result = null;
        if( adaptable instanceof Display && adapter == ILifeCycleAdapter.class )
        {
          result = new IDisplayLifeCycleAdapter() {
            public void preserveValues( final Display display ) {
              log.append( display.getClass().getName() );
            }
            public void readData( Display display ) {
            }
            public void render( Display display ) throws IOException {
            }
          };
        } else {
          result = new AbstractWidgetLCA() {
            public void preserveValues( final Widget widget ) {
              log.append( widget.getClass().getName() );
            }
            public void readData( final Widget widget ) {
            }
            public void renderInitialization( final Widget widget ) throws IOException {
            }
            public void renderChanges( final Widget widget ) throws IOException
            {
            }
            public void renderDispose( final Widget widget ) throws IOException {
            }
          };
        }
        return result;
      }

      public Class[] getAdapterList() {
        return factory.getAdapterList();
      }
    };
    Fixture.disposeOfServiceContext();
    Fixture.createServiceContext();
    AdapterManager manager = AdapterManagerImpl.getInstance();
    manager.registerAdapters( lifeCycleAdapterFactory, Display.class );
    manager.registerAdapters( lifeCycleAdapterFactory, Widget.class );

    // Create test widget hierarchy
    Display display = new Display();
    Composite shell = new Shell( display , SWT.NONE );
    new Text( shell, SWT.NONE );
    // Execute life cycle
    Fixture.markInitialized( display );
    Fixture.executeLifeCycleFromServerThread( );
    String expected = Display.class.getName()
                    + Shell.class.getName()
                    + Text.class.getName();
    assertEquals( expected, log.toString() );
  }

  public void testStartup() throws Exception {
    // Simulate startup with no startup entry point set
    // First request: (renders html skeletion that contains 'application')
    RWTFactory.getEntryPointManager().register( EntryPointManager.DEFAULT, TestEntryPointWithShell.class );
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
    lifeCycle.execute();
    // Second request: first 'real' one that writes JavaScript to create display
    Fixture.fakeResponseWriter();
    fakeUIRootRequestParam( RWTLifeCycle.getSessionDisplay() );
    lifeCycle.execute();
    assertTrue( Fixture.getAllMarkup().indexOf( "setSpace" ) != -1 );
  }
  
  public void testClearPreservedWithDisposedDisplay() {
    Fixture.fakePhase( PhaseId.RENDER );
    Display display = new Display();
    display.dispose();
    try {
      PreserveWidgetsPhaseListener.clearPreserved( display );
    } catch( Exception e ) {
      fail( "Preserve-phase-listener must succeed even with disposed display" );
    }
  }

  private static void fakeUIRootRequestParam( final Display display ) {
    Object adapter = display.getAdapter( IWidgetAdapter.class );
    IWidgetAdapter displayAdapter = ( IWidgetAdapter )adapter;
    Fixture.fakeRequestParam( RequestParams.UIROOT, displayAdapter.getId() );
  }
}




/*******************************************************************************
 * Copyright (c) 2002, 2011 Innoopract Informationssysteme GmbH and others.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Innoopract Informationssysteme GmbH - initial API and implementation
 *    EclipseSource - ongoing development
 *    Frank Appel - replaced singletons and static fields (Bug 337787)
 ******************************************************************************/
package org.eclipse.rwt.internal.lifecycle;

import java.io.IOException;

import junit.framework.TestCase;

import org.eclipse.rwt.AdapterFactory;
import org.eclipse.rwt.Fixture;
import org.eclipse.rwt.internal.AdapterManager;
import org.eclipse.rwt.internal.AdapterManagerImpl;
import org.eclipse.rwt.internal.engine.RWTFactory;
import org.eclipse.rwt.lifecycle.*;
import org.eclipse.swt.SWT;
import org.eclipse.swt.internal.widgets.Props;
import org.eclipse.swt.internal.widgets.displaykit.DisplayLCA;
import org.eclipse.swt.widgets.*;

public class PreserveWidgets_Test extends TestCase {

  public static final class TestEntryPointWithShell implements IEntryPoint {
    public int createUI() {
      Display display = new Display();
      new Shell( display, SWT.NONE );
      int count = 0;
      while( count < 1 ) {
        if( !display.readAndDispatch() ) {
          display.sleep();
        }
        count++;
      }
      return 0;
    }
  }

  private static class LoggingLifeCycleAdapterFactory implements AdapterFactory {

    private final StringBuffer log;

    private LoggingLifeCycleAdapterFactory( StringBuffer log ) {
      this.log = log;
    }

    public Object getAdapter( final Object adaptable, final Class adapter ) {
      Object result = null;
      if( adaptable instanceof Display && adapter == ILifeCycleAdapter.class ) {
        result = new IDisplayLifeCycleAdapter() {
          public void preserveValues( final Display display ) {
            log.append( display.getClass().getName() );
          }
          public void readData( Display display ) {
          }
          public void render( Display display ) throws IOException {
          }
          public void clearPreserved( Display display ) {
          }
        };
      } else {
        result = new AbstractWidgetLCA() {
          public void preserveValues( final Widget widget ) {
            log.append( widget.getClass().getName() );
          }
          public void readData( final Widget widget ) {
          }
          public void renderInitialization( final Widget widget ) throws IOException {
          }
          public void renderChanges( final Widget widget ) throws IOException
          {
          }
          public void renderDispose( final Widget widget ) throws IOException {
          }
        };
      }
      return result;
    }

    public Class[] getAdapterList() {
      return new LifeCycleAdapterFactory().getAdapterList();
    }
  }

  protected void setUp() throws Exception {
    Fixture.setUp();
    Fixture.fakeNewRequest();
  }

  protected void tearDown() throws Exception {
    Fixture.tearDown();
  }

  public void testInitialization() throws Exception {
    // ensures that the default WidgetCopyPhaseListener is registered
    // and executes at the designated phases
    Display display = new Display();
    Composite shell = new Shell( display , SWT.NONE );
    final Text text = new Text( shell, SWT.NONE );
    text.setText( "hello" );
    Fixture.markInitialized( display );
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    final StringBuffer log = new StringBuffer();
    lifeCycle.addPhaseListener( new PhaseListener() {
      private static final long serialVersionUID = 1L;
      public void beforePhase( final PhaseEvent event ) {
        if( PhaseId.PROCESS_ACTION.equals( event.getPhaseId() ) ) {
          IWidgetAdapter adapter = WidgetUtil.getAdapter( text );
          if( "hello".equals( adapter.getPreserved( Props.TEXT ) ) ) {
            log.append( "copy created" );
          }
        }
      }
      public void afterPhase( final PhaseEvent event ) {
      }
      public PhaseId getPhaseId() {
        return PhaseId.ANY;
      }
    } );
    Fixture.executeLifeCycleFromServerThread( );
    assertEquals( "copy created", log.toString() );
  }

  public void testExecutionOrder() {
    StringBuffer log = new StringBuffer();
    installLoggingLifeCycleAdapterFactory( log );
    Display display = new Display();
    Composite shell = new Shell( display );
    new Text( shell, SWT.NONE );
    Fixture.markInitialized( display );
    new DisplayLCA().preserveValues( display );
    String expected = Shell.class.getName() + Text.class.getName();
    assertEquals( expected, log.toString() );
  }

  public void testPreserveValuesWhenDisplayIsUninitialized() {
    StringBuffer log = new StringBuffer();
    installLoggingLifeCycleAdapterFactory( log );
    Display display = new Display();
    Composite shell = new Shell( display );
    new Text( shell, SWT.NONE );
    new DisplayLCA().preserveValues( display );
    assertEquals( "", log.toString() );
  }

  public void testStartup() throws Exception {
    // Simulate startup with no startup entry point set
    // First request: (renders html skeletion that contains 'application')
    RWTFactory.getEntryPointManager().register( EntryPointManager.DEFAULT, 
                                                TestEntryPointWithShell.class );
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.execute();
    // Second request: first 'real' one that writes JavaScript to create display
    Fixture.fakeResponseWriter();
    Fixture.fakeNewRequest( RWTLifeCycle.getSessionDisplay() );
    lifeCycle.execute();
    assertTrue( Fixture.getAllMarkup().indexOf( "setSpace" ) != -1 );
  }
  
  public void testClearPreservedWithDisposedDisplay() {
    Display display = new Display();
    display.dispose();
    Fixture.fakePhase( PhaseId.RENDER );
    try {
      new DisplayLCA().clearPreserved( display );
    } catch( Exception e ) {
      fail( "Preserve-phase-listener must succeed even with disposed display" );
    }
  }

  private static void installLoggingLifeCycleAdapterFactory( StringBuffer log ) {
    AdapterFactory lifeCycleAdapterFactory = new LoggingLifeCycleAdapterFactory( log );
    Fixture.disposeOfServiceContext();
    Fixture.createServiceContext();
    AdapterManager manager = AdapterManagerImpl.getInstance();
    manager.registerAdapters( lifeCycleAdapterFactory, Display.class );
    manager.registerAdapters( lifeCycleAdapterFactory, Widget.class );
  }
}





public class RenderDispose_Test extends TestCase {

  private final PreserveWidgetsPhaseListener preserveWidgetsPhaseListener
    = new PreserveWidgetsPhaseListener();

  public void testDisposeNotYetInitialized() {
    // set up the test widget hierarchy
    Display display = new Display();

  protected void setUp() throws Exception {
    Fixture.setUp();
    Fixture.fakeResponseWriter();
    RWTFactory.getPhaseListenerRegistry().add( preserveWidgetsPhaseListener );
  }

  protected void tearDown() throws Exception {

Lines 31-37 Link Here

(-)src/org/eclipse/rwt/internal/textsize/MeasurementHandler_Test.java (-1 lines)
31		31
32	// Let pass one startup request to init the 'system'	32	// Let pass one startup request to init the 'system'
33	Fixture.fakeNewRequest( display );	33	Fixture.fakeNewRequest( display );
34	RWTFactory.getPhaseListenerRegistry().add( new PreserveWidgetsPhaseListener() );
35	RWTFactory.getPhaseListenerRegistry().add( new CurrentPhase.Listener() );	34	RWTFactory.getPhaseListenerRegistry().add( new CurrentPhase.Listener() );
36	RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();	35	RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
37	ISessionStore session = ContextProvider.getSession();	36	ISessionStore session = ContextProvider.getSession();




  }

  public void testProcessKeyEventsWithDoItFlag() {
    RWTFactory.getPhaseListenerRegistry().add( new PreserveWidgetsPhaseListener() );
    RWTFactory.getPhaseListenerRegistry().add( new CurrentPhase.Listener() );
    final java.util.List eventLog = new ArrayList();
    Listener doitTrueListener = new Listener() {

  }

  public void testProcessTraverseEventsWithDoItFlag() {
    RWTFactory.getPhaseListenerRegistry().add( new PreserveWidgetsPhaseListener() );
    RWTFactory.getPhaseListenerRegistry().add( new CurrentPhase.Listener() );
    final java.util.List eventLog = new ArrayList();
    Listener doitTrueListener = new Listener() {

  }

  public void testKeyAndTraverseEvents() {
    RWTFactory.getPhaseListenerRegistry().add( new PreserveWidgetsPhaseListener() );
    RWTFactory.getPhaseListenerRegistry().add( new CurrentPhase.Listener() );
    final java.util.List eventLog = new ArrayList();
    Display display = new Display();





import org.eclipse.rwt.Fixture;
import org.eclipse.rwt.graphics.Graphics;
import org.eclipse.rwt.internal.lifecycle.JSConst;
import org.eclipse.rwt.internal.lifecycle.*;
import org.eclipse.rwt.lifecycle.*;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CCombo;

  }

  public void testReadText() {
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
    Display display = new Display();
    Shell shell = new Shell( display, SWT.NONE );
    final CCombo ccombo = new CCombo( shell, SWT.NONE );


  public void testTextSelectionWithVerifyEvent() {
    final java.util.List log = new ArrayList();
    // register preserve-values phase-listener
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
    Display display = new Display();
    Shell shell = new Shell( display, SWT.NONE );
    final CCombo ccombo = new CCombo( shell, SWT.NONE );

    } );

    String buttonId = WidgetUtil.getId( button );
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );

    // Execute life cycle once to simulate startup request
    Fixture.fakeNewRequest( display );

Lines 359-365 Link Here

(-)src/org/eclipse/swt/internal/custom/ctabfolderkit/CTabFolderLCA_Test.java (-1 lines)
359		359
360	// Let pass one startup request to init the 'system'	360	// Let pass one startup request to init the 'system'
361	Fixture.fakeNewRequest( display );	361	Fixture.fakeNewRequest( display );
362	RWTFactory.getPhaseListenerRegistry().add( new PreserveWidgetsPhaseListener() );
363	RWTFactory.getPhaseListenerRegistry().add( new CurrentPhase.Listener() );	362	RWTFactory.getPhaseListenerRegistry().add( new CurrentPhase.Listener() );
364	Fixture.executeLifeCycleFromServerThread( );	363	Fixture.executeLifeCycleFromServerThread( );
365		364

Lines 12-19 Link Here

(-)src/org/eclipse/swt/internal/dnd/dragsourcekit/DragSourceLCA_Test.java (-3 lines)
12	import junit.framework.TestCase;	12	import junit.framework.TestCase;
13		13
14	import org.eclipse.rwt.Fixture;	14	import org.eclipse.rwt.Fixture;
15	import org.eclipse.rwt.internal.engine.RWTFactory;
16	import org.eclipse.rwt.internal.lifecycle.PreserveWidgetsPhaseListener;
17	import org.eclipse.rwt.lifecycle.PhaseId;	15	import org.eclipse.rwt.lifecycle.PhaseId;
18	import org.eclipse.swt.SWT;	16	import org.eclipse.swt.SWT;
19	import org.eclipse.swt.dnd.DND;	17	import org.eclipse.swt.dnd.DND;
Lines 25-31 Link Here
25		23
26	protected void setUp() throws Exception {	24	protected void setUp() throws Exception {
27	Fixture.setUp();	25	Fixture.setUp();
28	RWTFactory.getPhaseListenerRegistry().add( new PreserveWidgetsPhaseListener() );
29	}	26	}
30		27
31	protected void tearDown() throws Exception {	28	protected void tearDown() throws Exception {





import org.eclipse.rwt.Fixture;
import org.eclipse.rwt.graphics.Graphics;
import org.eclipse.rwt.internal.engine.RWTFactory;
import org.eclipse.rwt.internal.lifecycle.*;
import org.eclipse.rwt.lifecycle.*;
import org.eclipse.swt.SWT;

  }

  public void testReadText() {
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
    Display display = new Display();
    Shell shell = new Shell( display, SWT.NONE );
    final Combo combo = new Combo( shell, SWT.BORDER );


  public void testTextSelectionWithVerifyEvent() {
    final java.util.List log = new ArrayList();
    // register preserve-values phase-listener
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
    Display display = new Display();
    Shell shell = new Shell( display, SWT.NONE );
    final Combo combo = new Combo( shell, SWT.NONE );

    } );

    String buttonId = WidgetUtil.getId( button );
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );

    // Execute life cycle once to simulate startup request
    Fixture.fakeNewRequest( display );

Lines 15-22 Link Here

(-)src/org/eclipse/swt/internal/widgets/displaykit/DNDSupport_Test.java (-3 lines)
15	import junit.framework.TestCase;	15	import junit.framework.TestCase;
16		16
17	import org.eclipse.rwt.Fixture;	17	import org.eclipse.rwt.Fixture;
18	import org.eclipse.rwt.internal.engine.RWTFactory;
19	import org.eclipse.rwt.internal.lifecycle.PreserveWidgetsPhaseListener;
20	import org.eclipse.rwt.lifecycle.PhaseId;	18	import org.eclipse.rwt.lifecycle.PhaseId;
21	import org.eclipse.rwt.lifecycle.WidgetUtil;	19	import org.eclipse.rwt.lifecycle.WidgetUtil;
22	import org.eclipse.swt.SWT;	20	import org.eclipse.swt.SWT;
Lines 63-69 Link Here
63		61
64	protected void setUp() throws Exception {	62	protected void setUp() throws Exception {
65	Fixture.setUp();	63	Fixture.setUp();
66	RWTFactory.getPhaseListenerRegistry().add( new PreserveWidgetsPhaseListener() );
67	Fixture.fakePhase( PhaseId.PROCESS_ACTION );	64	Fixture.fakePhase( PhaseId.PROCESS_ACTION );
68	display = new Display();	65	display = new Display();
69	shell = new Shell( display );	66	shell = new Shell( display );




import junit.framework.TestCase;

import org.eclipse.rwt.Fixture;
import org.eclipse.rwt.internal.engine.RWTFactory;
import org.eclipse.rwt.internal.lifecycle.*;
import org.eclipse.rwt.lifecycle.WidgetUtil;
import org.eclipse.swt.SWT;

    shell.layout();
    shell.open();
    
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
    String button1Id = WidgetUtil.getId( button1 );

    // Simulate initial request that constructs UI

    shell.layout();
    shell.open();
    
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
    String buttonId = WidgetUtil.getId( button );

    // Simulate initial request that constructs UI




import junit.framework.TestCase;

import org.eclipse.rwt.Fixture;
import org.eclipse.rwt.internal.engine.RWTFactory;
import org.eclipse.rwt.internal.lifecycle.PreserveWidgetsPhaseListener;
import org.eclipse.rwt.internal.lifecycle.RWTLifeCycle;
import org.eclipse.rwt.lifecycle.IWidgetAdapter;
import org.eclipse.rwt.lifecycle.WidgetUtil;
import org.eclipse.swt.SWT;

    assertTrue( Fixture.getAllMarkup().indexOf( "setSpace" ) == -1 );
    // Simulate client-side size-change of shell: menuBar must render new size
    Fixture.clearPreserved();
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    PreserveWidgetsPhaseListener preserveListener
      = new PreserveWidgetsPhaseListener();
    lifeCycle.addPhaseListener( preserveListener );
    shell.setMenuBar( menuBar );
    String shellId = WidgetUtil.getId( shell );
    String menuId = WidgetUtil.getId( menuBar );

    Fixture.executeLifeCycleFromServerThread( );
    String expected = "wm.findWidgetById( \"" + menuId + "\" );w.setSpace";
    assertTrue( Fixture.getAllMarkup().indexOf( expected ) != -1 );
    lifeCycle.removePhaseListener( preserveListener );
  }

  private void testPreserveMenuListener( final Menu menu ) {

Lines 11-23 Link Here

(-)src/org/eclipse/swt/internal/widgets/shellkit/ShellLCA_Test.java (-7 / +5 lines)
11	******************************************************************************/	11	******************************************************************************/
12	package org.eclipse.swt.internal.widgets.shellkit;	12	package org.eclipse.swt.internal.widgets.shellkit;
13		13
		14	import java.io.IOException;
		15
14	import junit.framework.TestCase;	16	import junit.framework.TestCase;
15		17
16	import org.eclipse.rwt.Fixture;	18	import org.eclipse.rwt.Fixture;
17	import org.eclipse.rwt.graphics.Graphics;	19	import org.eclipse.rwt.graphics.Graphics;
18	import org.eclipse.rwt.internal.engine.RWTFactory;
19	import org.eclipse.rwt.internal.lifecycle.JSConst;	20	import org.eclipse.rwt.internal.lifecycle.JSConst;
20	import org.eclipse.rwt.internal.lifecycle.PreserveWidgetsPhaseListener;
21	import org.eclipse.rwt.lifecycle.*;	21	import org.eclipse.rwt.lifecycle.*;
22	import org.eclipse.swt.SWT;	22	import org.eclipse.swt.SWT;
23	import org.eclipse.swt.events.*;	23	import org.eclipse.swt.events.*;
Lines 25-30 Link Here
25	import org.eclipse.swt.internal.events.*;	25	import org.eclipse.swt.internal.events.*;
26	import org.eclipse.swt.internal.graphics.ImageFactory;	26	import org.eclipse.swt.internal.graphics.ImageFactory;
27	import org.eclipse.swt.internal.widgets.*;	27	import org.eclipse.swt.internal.widgets.*;
		28	import org.eclipse.swt.internal.widgets.displaykit.DisplayLCA;
28	import org.eclipse.swt.widgets.*;	29	import org.eclipse.swt.widgets.*;
29		30
30		31
Lines 287-293 Link Here
287	activeShell.open();	288	activeShell.open();
288	String shellToActivateId = WidgetUtil.getId( shellToActivate );	289	String shellToActivateId = WidgetUtil.getId( shellToActivate );
289	// Set precondition and assert it	290	// Set precondition and assert it
290	RWTFactory.getPhaseListenerRegistry().add( new PreserveWidgetsPhaseListener() );
291	activeShell.setActive();	291	activeShell.setActive();
292	assertSame( activeShell, display.getActiveShell() );	292	assertSame( activeShell, display.getActiveShell() );
293	// Simulate shell activation without event listeners	293	// Simulate shell activation without event listeners
Lines 447-463 Link Here
447	}	447	}
448		448
449	// see bug 223879	449	// see bug 223879
450	public void testRenderPopupMenu() {	450	public void testRenderPopupMenu() throws IOException {
451	Fixture.markInitialized( display );	451	Fixture.markInitialized( display );
452	Shell shell = new Shell( display , SWT.NONE );	452	Shell shell = new Shell( display , SWT.NONE );
453	shell.setMinimumSize( 100, 100 );	453	shell.setMinimumSize( 100, 100 );
454	Menu menu = new Menu( shell, SWT.POP_UP );	454	Menu menu = new Menu( shell, SWT.POP_UP );
455	MenuItem item = new MenuItem( menu, SWT.PUSH );
456	item.setText( "Popup" );
457	shell.setMenu( menu );	455	shell.setMenu( menu );
458	Fixture.fakeResponseWriter();	456	Fixture.fakeResponseWriter();
459	Fixture.fakeNewRequest( display );	457	Fixture.fakeNewRequest( display );
460	Fixture.executeLifeCycleFromServerThread();	458	new DisplayLCA().render( display );
461	String markup = Fixture.getAllMarkup();	459	String markup = Fixture.getAllMarkup();
462	String createMenuScript	460	String createMenuScript
463	= "var w = new org.eclipse.rwt.widgets.Menu();"	461	= "var w = new org.eclipse.rwt.widgets.Menu();"





import org.eclipse.rwt.Fixture;
import org.eclipse.rwt.graphics.Graphics;
import org.eclipse.rwt.internal.engine.RWTFactory;
import org.eclipse.rwt.internal.lifecycle.*;
import org.eclipse.rwt.internal.service.RequestParams;
import org.eclipse.rwt.lifecycle.IWidgetAdapter;

    item1.setControl( control1 );
    shell.open();

    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
    String displayId = DisplayUtil.getAdapter( display ).getId();
    String folderId = WidgetUtil.getId( folder );
    String item1Id = WidgetUtil.getId( item1 );

    Fixture.fakeNewRequest( display );
    Fixture.fakeRequestParam( RequestParams.UIROOT, displayId );
    Fixture.fakeRequestParam( JSConst.EVENT_WIDGET_SELECTED, folderId );
    Fixture.fakeRequestParam( JSConst.EVENT_WIDGET_SELECTED_ITEM, item1Id );
    Fixture.readDataAndProcessAction( display );

      }
    } );

    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
    String displayId = DisplayUtil.getAdapter( display ).getId();
    String item1Id = WidgetUtil.getId( item1 );
    String folderId = WidgetUtil.getId( folder );





import org.eclipse.rwt.Fixture;
import org.eclipse.rwt.graphics.Graphics;
import org.eclipse.rwt.internal.engine.RWTFactory;
import org.eclipse.rwt.internal.lifecycle.PreserveWidgetsPhaseListener;
import org.eclipse.rwt.internal.lifecycle.RWTLifeCycle;
import org.eclipse.rwt.lifecycle.IWidgetAdapter;
import org.eclipse.rwt.lifecycle.WidgetUtil;
import org.eclipse.swt.SWT;

      }
    } );
    String columnId = WidgetUtil.getId( column );
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
    //
    Fixture.fakeNewRequest( display );
    Fixture.executeLifeCycleFromServerThread( );

Lines 502-508 Link Here

(-)src/org/eclipse/swt/internal/widgets/tablekit/TableLCA_Test.java (-1 lines)
502	public void testClearVirtual() {	502	public void testClearVirtual() {
503	Fixture.fakePhase( PhaseId.PROCESS_ACTION );	503	Fixture.fakePhase( PhaseId.PROCESS_ACTION );
504	RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();	504	RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
505	lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
506	shell.setSize( 100, 100 );	505	shell.setSize( 100, 100 );
507	shell.setLayout( new FillLayout() );	506	shell.setLayout( new FillLayout() );
508	final Table table = new Table( shell, SWT.VIRTUAL );	507	final Table table = new Table( shell, SWT.VIRTUAL );




import junit.framework.TestCase;

import org.eclipse.rwt.Fixture;
import org.eclipse.rwt.internal.lifecycle.JSConst;
import org.eclipse.rwt.internal.lifecycle.*;
import org.eclipse.rwt.lifecycle.*;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;

  
  private Display display;
  private Shell shell;
  private TextLCA textLCA;

  protected void setUp() throws Exception {
    Fixture.setUp();
    Fixture.fakePhase( PhaseId.PROCESS_ACTION );
    Fixture.fakeResponseWriter();
    textLCA = new TextLCA();
    display = new Display();
    shell = new Shell( display );
  }

    Fixture.markInitialized( text );
    Fixture.clearPreserved();
    Fixture.preserveWidgets();
    TextLCA textLCA = new TextLCA();
    text.setText( "hello" );
    textLCA.renderChanges( text );
    assertTrue( Fixture.getAllMarkup().endsWith( "setValue( \"hello\" );" ) );

    Fixture.markInitialized( text );
    Fixture.clearPreserved();
    Fixture.preserveWidgets();
    TextLCA textLCA = new TextLCA();
    char[] value = new char[] { 'h', 'e', 'l', 0, 'l', 'o' };
    text.setText( String.valueOf( value ) );
    textLCA.renderChanges( text );

  public void testSelectionWithVerifyEvent() {
    final java.util.List log = new ArrayList();
    // register preserve-values phase-listener
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
    final Text text = new Text( shell, SWT.NONE );
    shell.open();
    String textId = WidgetUtil.getId( text );

  }

  public void testPreserveText() {
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
    Text text = new Text( shell, SWT.SINGLE );
    shell.open();
    Fixture.markInitialized( display );


  public void testVerifyAndModifyEvent() {
    final java.util.List log = new ArrayList();
    // register preserve-values phase-listener
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
    // set up widgets to be tested
    final Text text = new Text( shell, SWT.NONE );
    shell.open();


  public void testTextLimit() throws IOException {
    Text text = new Text( shell, SWT.NONE );
    TextLCA lca = new TextLCA();
    // run LCA one to dump the here uninteresting prolog
    textLCA.renderChanges( text );
    // Initially no textLimit must be rendered if the initial value is untouched
    Fixture.fakeResponseWriter();
    textLCA.renderChanges( text );
    assertEquals( -1, Fixture.getAllMarkup().indexOf( "setMaxLength" ) );
    // Positive textLimit is written as setMaxLength( ... )
    Fixture.fakeResponseWriter();

    Fixture.clearPreserved();
    Fixture.preserveWidgets();
    text.setTextLimit( 12 );
    textLCA.renderChanges( text );
    String expected = "setMaxLength( 12 );";
    assertTrue( Fixture.getAllMarkup().indexOf( expected ) != -1 );
    // Negative textLimit is tread as 'no limit'

    Fixture.clearPreserved();
    Fixture.preserveWidgets();
    text.setTextLimit( -50 );
    textLCA.renderChanges( text );
    expected = "setMaxLength( null );";
    assertTrue( Fixture.getAllMarkup().indexOf( expected ) != -1 );
  }
  
  public void testEchoCharMultiLine() throws IOException {
    Fixture.fakeNewRequest( display );
    Text text = new Text( shell, SWT.MULTI );
    textLCA.render( text );
    String markup = Fixture.getAllMarkup();
    assertTrue( markup.indexOf( "setPasswordMode" ) == -1 );
    
    Fixture.preserveWidgets();
    text.setEchoChar( ( char )27 );
    textLCA.render( text );
    assertTrue( markup.indexOf( "setPasswordMode" ) == -1 );
  }

  public void testEchoCharSingleLine() throws IOException {
    Text text = new Text( shell, SWT.SINGLE );
    textLCA.render( text );
    Fixture.fakeNewRequest( display );
    Fixture.executeLifeCycleFromServerThread();
    String markup = Fixture.getAllMarkup();
    assertTrue( markup.indexOf( "setPasswordMode" ) == -1 );

    Fixture.preserveWidgets();
    text.setEchoChar( ( char )27 );
    textLCA.render( text );
    Fixture.executeLifeCycleFromServerThread();
    markup = Fixture.getAllMarkup();
    assertTrue( markup.indexOf( "setPasswordMode( true )" ) != -1 );
    
    Fixture.preserveWidgets();
    text.setEchoChar( ( char )0 );
    textLCA.render( text );
    Fixture.executeLifeCycleFromServerThread();
    markup = Fixture.getAllMarkup();
    assertTrue( markup.indexOf( "setPasswordMode( false )" ) != -1 );
  }
  
  public void testEchoCharPassword() throws IOException {
    Text text = new Text( shell, SWT.PASSWORD );
    textLCA.render( text );
    Fixture.fakeNewRequest( display );
    Fixture.executeLifeCycleFromServerThread();
    String markup = Fixture.getAllMarkup();
    assertTrue( markup.indexOf( "setPasswordMode( true )" ) != -1 );

    Fixture.preserveWidgets();
    text.setEchoChar( ( char )0 );
    textLCA.render( text );
    Fixture.executeLifeCycleFromServerThread();
    markup = Fixture.getAllMarkup();
    assertTrue( markup.indexOf( "setPasswordMode( false )" ) != -1 );

    Fixture.preserveWidgets();
    text.setEchoChar( ( char )27 );
    textLCA.render( text );
    Fixture.executeLifeCycleFromServerThread();
    markup = Fixture.getAllMarkup();
    assertTrue( markup.indexOf( "setPasswordMode( true )" ) != -1 );
  }

      = "org.eclipse.swt.TextUtil.setHasVerifyOrModifyListener( w, true )";
    Text text = new Text( shell, SWT.READ_ONLY );
    text.addModifyListener( createModifyListener() );
    textLCA.renderChanges( text );
    assertTrue( Fixture.getAllMarkup().indexOf( setHasModifyListener ) != -1 );
  }
  

    Fixture.markInitialized( text );
    Fixture.preserveWidgets();
    text.setEditable( true );
    textLCA.renderChanges( text );
    assertTrue( Fixture.getAllMarkup().indexOf( setHasModifyListener ) != -1 );
  }


    Fixture.markInitialized( text );
    Fixture.preserveWidgets();
    text.setText( "abc\u2028abc\u2029abc" );
    textLCA.renderChanges( text );
    String expected = "w.setValue( \"abcabcabc\" );";
    assertTrue( Fixture.getAllMarkup().indexOf( expected ) != -1 );
  }

    Fixture.markInitialized( text );
    Fixture.preserveWidgets();
    text.setText( "abc\u2028abc\u2029abc" );
    textLCA.renderChanges( text );
    String expected = "w.setValue( \"abcabcabc\" );";
    assertTrue( Fixture.getAllMarkup().indexOf( expected ) != -1 );
  }

    Fixture.markInitialized( text );
    Fixture.preserveWidgets();
    text.setText( "abc\u2028abc\u2029abc" );
    textLCA.renderChanges( text );
    String expected = "w.setValue( \"abcabcabc\" );";
    assertTrue( Fixture.getAllMarkup().indexOf( expected ) != -1 );
  }





import org.eclipse.rwt.Fixture;
import org.eclipse.rwt.graphics.Graphics;
import org.eclipse.rwt.internal.engine.RWTFactory;
import org.eclipse.rwt.internal.lifecycle.PreserveWidgetsPhaseListener;
import org.eclipse.rwt.internal.lifecycle.RWTLifeCycle;
import org.eclipse.rwt.lifecycle.IWidgetAdapter;
import org.eclipse.rwt.lifecycle.WidgetUtil;
import org.eclipse.swt.SWT;

      }
    } );
    String columnId = WidgetUtil.getId( column );
    RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
    lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
    //
    Fixture.fakeNewRequest( display );
    Fixture.executeLifeCycleFromServerThread();

Lines 51-57 Link Here

(-)src/org/eclipse/rwt/internal/engine/PhaseListenerRegistry_Test.java (-1 lines)
51	Fixture.createServiceContext();	51	Fixture.createServiceContext();
52		52
53	assertEquals( true, findPhaseListener( CurrentPhase.Listener.class ) );	53	assertEquals( true, findPhaseListener( CurrentPhase.Listener.class ) );
54	assertEquals( true, findPhaseListener( PreserveWidgetsPhaseListener.class ) );
55	}	54	}
56		55
57	public void testAdd() {	56	public void testAdd() {

Lines 35-40 Link Here

(-)src/org/eclipse/swt/internal/widgets/displaykit/DisplayLCAFacadeImpl.java (+2 lines)
35	JavaScriptResponseWriter responseWriter = stateInfo.getResponseWriter();	35	JavaScriptResponseWriter responseWriter = stateInfo.getResponseWriter();
36	responseWriter.write( "Render Fake" );	36	responseWriter.write( "Render Fake" );
37	}	37	}
		38	public void clearPreserved( Display display ) {
		39	}
38	};	40	};
39	}	41	}
40		42

Lines 260-276 Link Here

(-)src/org/eclipse/rwt/Fixture.java (-8 / +12 lines)
260	}	260	}
261		261
262	public static void preserveWidgets() {	262	public static void preserveWidgets() {
263	PreserveWidgetsPhaseListener listener = new PreserveWidgetsPhaseListener();	263	Display display = RWTLifeCycle.getSessionDisplay();
264	RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();	264	IDisplayLifeCycleAdapter displayLCA = DisplayUtil.getLCA( display );
265	PhaseEvent event = new PhaseEvent( lifeCycle, PhaseId.READ_DATA );	265	PhaseId bufferedPhaseId = CurrentPhase.get();
266	listener.afterPhase( event );	266	fakePhase( PhaseId.READ_DATA );
		267	displayLCA.preserveValues( display );
		268	fakePhase( bufferedPhaseId );
267	}	269	}
268		270
269	public static void clearPreserved() {	271	public static void clearPreserved() {
270	PreserveWidgetsPhaseListener listener = new PreserveWidgetsPhaseListener();	272	Display display = RWTLifeCycle.getSessionDisplay();
271	ILifeCycle lifeCycle = RWTFactory.getLifeCycleFactory().getLifeCycle();	273	IDisplayLifeCycleAdapter displayLCA = DisplayUtil.getLCA( display );
272	PhaseEvent event = new PhaseEvent( lifeCycle, PhaseId.RENDER );	274	PhaseId bufferedPhaseId = CurrentPhase.get();
273	listener.afterPhase( event );	275	fakePhase( PhaseId.RENDER );
		276	displayLCA.clearPreserved( display );
		277	fakePhase( bufferedPhaseId );
274	}	278	}
275		279
276	public static String getAllMarkup() {	280	public static String getAllMarkup() {




  </extension>

  <extension
        id="org.eclipse.ui.workbench.preserveWidgetValues"
        point="org.eclipse.rap.ui.phaselistener">
     <listener class="org.eclipse.rwt.internal.lifecycle.PreserveWidgetsPhaseListener"/>
  </extension>

  <extension
        id="org.eclipse.ui.workbench.currentPhase"
        point="org.eclipse.rap.ui.phaselistener">
     <listener class="org.eclipse.rwt.internal.lifecycle.CurrentPhase$Listener"/>

Return to bug 341760

Lines 2394-2405 Link Here

(-)plugin.xml (-6 lines)
2394	</extension>	2394	</extension>
2395		2395
2396	<extension	2396	<extension
2397	id="org.eclipse.ui.workbench.preserveWidgetValues"
2398	point="org.eclipse.rap.ui.phaselistener">
2399	<listener class="org.eclipse.rwt.internal.lifecycle.PreserveWidgetsPhaseListener"/>
2400	</extension>
2401
2402	<extension
2403	id="org.eclipse.ui.workbench.currentPhase"	2397	id="org.eclipse.ui.workbench.currentPhase"
2404	point="org.eclipse.rap.ui.phaselistener">	2398	point="org.eclipse.rap.ui.phaselistener">
2405	<listener class="org.eclipse.rwt.internal.lifecycle.CurrentPhase$Listener"/>	2399	<listener class="org.eclipse.rwt.internal.lifecycle.CurrentPhase$Listener"/>

Removed Link Here

(-)src/org/eclipse/rwt/internal/lifecycle/PreserveWidgetsPhaseListener.java (-85 lines)
1	/*******************************************************************************
2	* Copyright (c) 2002, 2009 Innoopract Informationssysteme GmbH.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Innoopract Informationssysteme GmbH - initial API and implementation
10	* EclipseSource - ongoing development
11	******************************************************************************/
12	package org.eclipse.rwt.internal.lifecycle;
13
14	import org.eclipse.rwt.lifecycle.*;
15	import org.eclipse.swt.internal.widgets.*;
16	import org.eclipse.swt.internal.widgets.WidgetTreeVisitor.AllWidgetTreeVisitor;
17	import org.eclipse.swt.widgets.*;
18
19	public final class PreserveWidgetsPhaseListener implements PhaseListener {
20
21	private static final long serialVersionUID = 1L;
22
23	public void beforePhase( final PhaseEvent event ) {
24	}
25
26	public void afterPhase( final PhaseEvent event ) {
27	if( PhaseId.READ_DATA.equals( event.getPhaseId() ) ) {
28	Display display = RWTLifeCycle.getSessionDisplay();
29	if( display != null ) {
30	preserve( display );
31	}
32	} else if( PhaseId.RENDER.equals( event.getPhaseId() ) ) {
33	Display display = RWTLifeCycle.getSessionDisplay();
34	if( display != null ) {
35	clearPreserved( display );
36	}
37	}
38	}
39
40	public PhaseId getPhaseId() {
41	return PhaseId.ANY;
42	}
43
44	/////////////////////////////////////////////////////
45	// Helping methods to preserve widget property values
46
47	private static void preserve( final Display display ) {
48	IDisplayLifeCycleAdapter displayLCA = DisplayUtil.getLCA( display );
49	IWidgetAdapter adapter = DisplayUtil.getAdapter( display );
50	if( adapter.isInitialized() ) {
51	displayLCA.preserveValues( display );
52	IDisplayAdapter displayAdapter
53	= ( IDisplayAdapter )display.getAdapter( IDisplayAdapter.class );
54	Composite[] shells = displayAdapter.getShells();
55	for( int i = 0; i < shells.length; i++ ) {
56	WidgetTreeVisitor.accept( shells[ i ], new AllWidgetTreeVisitor() {
57	public boolean doVisit( final Widget widget ) {
58	AbstractWidgetLCA widgetLCA = WidgetUtil.getLCA( widget );
59	widgetLCA.preserveValues( widget );
60	return true;
61	}
62	} );
63	}
64	}
65	}
66
67	static void clearPreserved( final Display display ) {
68	WidgetAdapter widgetAdapter
69	= ( WidgetAdapter )DisplayUtil.getAdapter( display );
70	widgetAdapter.clearPreserved();
71	IDisplayAdapter displayAdapter
72	= ( IDisplayAdapter )display.getAdapter( IDisplayAdapter.class );
73	Composite[] shells = displayAdapter.getShells();
74	for( int i = 0; i < shells.length; i++ ) {
75	WidgetTreeVisitor.accept( shells[ i ], new AllWidgetTreeVisitor() {
76	public boolean doVisit( final Widget widget ) {
77	WidgetAdapter widgetAdapter
78	= ( WidgetAdapter )WidgetUtil.getAdapter( widget );
79	widgetAdapter.clearPreserved();
80	return true;
81	}
82	} );
83	}
84	}
85	}

Lines 66-73 Link Here

(-)src/org/eclipse/rwt/lifecycle/JSWriter.java (-4 / +4 lines)
66		66
67	private static final String WRITER_MAP	67	private static final String WRITER_MAP
68	= JSWriter.class.getName() + "#map";	68	= JSWriter.class.getName() + "#map";
69	private static final String HAS_WINDOW_MANAGER	69	private static final String HAS_WIDGET_MANAGER
70	= JSWriter.class.getName() + "#hasWindowManager";	70	= JSWriter.class.getName() + "#hasWidgetManager";
71	private static final String CURRENT_WIDGET_REF	71	private static final String CURRENT_WIDGET_REF
72	= JSWriter.class.getName() + "#currentWidgetRef";	72	= JSWriter.class.getName() + "#currentWidgetRef";
73		73
Lines 749-759 Link Here
749	IServiceStateInfo stateInfo = ContextProvider.getStateInfo();	749	IServiceStateInfo stateInfo = ContextProvider.getStateInfo();
750	if( currentPhaseIsRender()	750	if( currentPhaseIsRender()
751	&& widget != null	751	&& widget != null
752	&& stateInfo.getAttribute( HAS_WINDOW_MANAGER ) == null )	752	&& stateInfo.getAttribute( HAS_WIDGET_MANAGER ) == null )
753	{	753	{
754	writeVarAssignment( WIDGET_MANAGER_REF,	754	writeVarAssignment( WIDGET_MANAGER_REF,
755	"org.eclipse.swt.WidgetManager.getInstance()" );	755	"org.eclipse.swt.WidgetManager.getInstance()" );
756	stateInfo.setAttribute( HAS_WINDOW_MANAGER, Boolean.TRUE );	756	stateInfo.setAttribute( HAS_WIDGET_MANAGER, Boolean.TRUE );
757	}	757	}
758	}	758	}
759		759

Removed Link Here

(-)src/org/eclipse/rwt/internal/lifecycle/PreserveWidgetsPhaseListener_Test.java (-183 lines)
1	/*******************************************************************************
2	* Copyright (c) 2002, 2011 Innoopract Informationssysteme GmbH and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Innoopract Informationssysteme GmbH - initial API and implementation
10	* EclipseSource - ongoing development
11	* Frank Appel - replaced singletons and static fields (Bug 337787)
12	******************************************************************************/
13	package org.eclipse.rwt.internal.lifecycle;
14
15	import java.io.IOException;
16
17	import junit.framework.TestCase;
18
19	import org.eclipse.rwt.AdapterFactory;
20	import org.eclipse.rwt.Fixture;
21	import org.eclipse.rwt.internal.AdapterManager;
22	import org.eclipse.rwt.internal.AdapterManagerImpl;
23	import org.eclipse.rwt.internal.engine.RWTFactory;
24	import org.eclipse.rwt.internal.service.RequestParams;
25	import org.eclipse.rwt.lifecycle.*;
26	import org.eclipse.swt.SWT;
27	import org.eclipse.swt.internal.widgets.Props;
28	import org.eclipse.swt.widgets.*;
29
30	public class PreserveWidgetsPhaseListener_Test extends TestCase {
31
32	public static final class TestEntryPointWithShell implements IEntryPoint {
33	public int createUI() {
34	Display display = new Display();
35	new Shell( display, SWT.NONE );
36	int count = 0;
37	while( count < 1 ) {
38	if( !display.readAndDispatch() ) {
39	display.sleep();
40	}
41	count++;
42	}
43	return 0;
44	}
45	}
46
47	protected void setUp() throws Exception {
48	Fixture.setUp();
49	Fixture.fakeNewRequest();
50	RWTFactory.getPhaseListenerRegistry().add( new PreserveWidgetsPhaseListener() );
51	}
52
53	protected void tearDown() throws Exception {
54	Fixture.tearDown();
55	}
56
57	public void testInitialization() throws Exception {
58	// ensures that the default WidgetCopyPhaseListener is registered
59	// and executes at the designated phases
60	Display display = new Display();
61	Composite shell = new Shell( display , SWT.NONE );
62	final Text text = new Text( shell, SWT.NONE );
63	text.setText( "hello" );
64	Fixture.markInitialized( display );
65	RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
66	final StringBuffer log = new StringBuffer();
67	lifeCycle.addPhaseListener( new PhaseListener() {
68
69	private static final long serialVersionUID = 1L;
70
71	public void beforePhase( final PhaseEvent event ) {
72	if( PhaseId.PROCESS_ACTION.equals( event.getPhaseId() ) ) {
73	IWidgetAdapter adapter = WidgetUtil.getAdapter( text );
74	if( "hello".equals( adapter.getPreserved( Props.TEXT ) ) ) {
75	log.append( "copy created" );
76	}
77	}
78	}
79
80	public void afterPhase( final PhaseEvent event ) {
81	}
82
83	public PhaseId getPhaseId() {
84	return PhaseId.ANY;
85	}
86	} );
87	Fixture.executeLifeCycleFromServerThread( );
88	assertEquals( "copy created", log.toString() );
89	}
90
91	public void testExecutionOrder() {
92	final StringBuffer log = new StringBuffer();
93	Fixture.fakeResponseWriter();
94	AdapterFactory lifeCycleAdapterFactory = new AdapterFactory() {
95
96	private AdapterFactory factory = new LifeCycleAdapterFactory();
97
98	public Object getAdapter( final Object adaptable, final Class adapter ) {
99	Object result = null;
100	if( adaptable instanceof Display && adapter == ILifeCycleAdapter.class )
101	{
102	result = new IDisplayLifeCycleAdapter() {
103	public void preserveValues( final Display display ) {
104	log.append( display.getClass().getName() );
105	}
106	public void readData( Display display ) {
107	}
108	public void render( Display display ) throws IOException {
109	}
110	};
111	} else {
112	result = new AbstractWidgetLCA() {
113	public void preserveValues( final Widget widget ) {
114	log.append( widget.getClass().getName() );
115	}
116	public void readData( final Widget widget ) {
117	}
118	public void renderInitialization( final Widget widget ) throws IOException {
119	}
120	public void renderChanges( final Widget widget ) throws IOException
121	{
122	}
123	public void renderDispose( final Widget widget ) throws IOException {
124	}
125	};
126	}
127	return result;
128	}
129
130	public Class[] getAdapterList() {
131	return factory.getAdapterList();
132	}
133	};
134	Fixture.disposeOfServiceContext();
135	Fixture.createServiceContext();
136	AdapterManager manager = AdapterManagerImpl.getInstance();
137	manager.registerAdapters( lifeCycleAdapterFactory, Display.class );
138	manager.registerAdapters( lifeCycleAdapterFactory, Widget.class );
139
140	// Create test widget hierarchy
141	Display display = new Display();
142	Composite shell = new Shell( display , SWT.NONE );
143	new Text( shell, SWT.NONE );
144	// Execute life cycle
145	Fixture.markInitialized( display );
146	Fixture.executeLifeCycleFromServerThread( );
147	String expected = Display.class.getName()
148	+ Shell.class.getName()
149	+ Text.class.getName();
150	assertEquals( expected, log.toString() );
151	}
152
153	public void testStartup() throws Exception {
154	// Simulate startup with no startup entry point set
155	// First request: (renders html skeletion that contains 'application')
156	RWTFactory.getEntryPointManager().register( EntryPointManager.DEFAULT, TestEntryPointWithShell.class );
157	RWTLifeCycle lifeCycle = ( RWTLifeCycle )RWTFactory.getLifeCycleFactory().getLifeCycle();
158	lifeCycle.addPhaseListener( new PreserveWidgetsPhaseListener() );
159	lifeCycle.execute();
160	// Second request: first 'real' one that writes JavaScript to create display
161	Fixture.fakeResponseWriter();
162	fakeUIRootRequestParam( RWTLifeCycle.getSessionDisplay() );
163	lifeCycle.execute();
164	assertTrue( Fixture.getAllMarkup().indexOf( "setSpace" ) != -1 );
165	}
166
167	public void testClearPreservedWithDisposedDisplay() {
168	Fixture.fakePhase( PhaseId.RENDER );
169	Display display = new Display();
170	display.dispose();
171	try {
172	PreserveWidgetsPhaseListener.clearPreserved( display );
173	} catch( Exception e ) {
174	fail( "Preserve-phase-listener must succeed even with disposed display" );
175	}
176	}
177
178	private static void fakeUIRootRequestParam( final Display display ) {
179	Object adapter = display.getAdapter( IWidgetAdapter.class );
180	IWidgetAdapter displayAdapter = ( IWidgetAdapter )adapter;
181	Fixture.fakeRequestParam( RequestParams.UIROOT, displayAdapter.getId() );
182	}
183	}

Lines 22-30 Link Here

(-)src/org/eclipse/rwt/internal/lifecycle/RenderDispose_Test.java (-4 lines)
22		22
23	public class RenderDispose_Test extends TestCase {	23	public class RenderDispose_Test extends TestCase {
24		24
25	private final PreserveWidgetsPhaseListener preserveWidgetsPhaseListener
26	= new PreserveWidgetsPhaseListener();
27
28	public void testDisposeNotYetInitialized() {	25	public void testDisposeNotYetInitialized() {
29	// set up the test widget hierarchy	26	// set up the test widget hierarchy
30	Display display = new Display();	27	Display display = new Display();
Lines 68-74 Link Here
68	protected void setUp() throws Exception {	65	protected void setUp() throws Exception {
69	Fixture.setUp();	66	Fixture.setUp();
70	Fixture.fakeResponseWriter();	67	Fixture.fakeResponseWriter();
71	RWTFactory.getPhaseListenerRegistry().add( preserveWidgetsPhaseListener );
72	}	68	}
73		69
74	protected void tearDown() throws Exception {	70	protected void tearDown() throws Exception {

Lines 348-354 Link Here

(-)src/org/eclipse/rwt/lifecycle/ControlLCAUtil_Test.java (-3 lines)
348	}	348	}
349		349
350	public void testProcessKeyEventsWithDoItFlag() {	350	public void testProcessKeyEventsWithDoItFlag() {
351	RWTFactory.getPhaseListenerRegistry().add( new PreserveWidgetsPhaseListener() );
352	RWTFactory.getPhaseListenerRegistry().add( new CurrentPhase.Listener() );	351	RWTFactory.getPhaseListenerRegistry().add( new CurrentPhase.Listener() );
353	final java.util.List eventLog = new ArrayList();	352	final java.util.List eventLog = new ArrayList();
354	Listener doitTrueListener = new Listener() {	353	Listener doitTrueListener = new Listener() {
Lines 409-415 Link Here
409	}	408	}
410		409
411	public void testProcessTraverseEventsWithDoItFlag() {	410	public void testProcessTraverseEventsWithDoItFlag() {
412	RWTFactory.getPhaseListenerRegistry().add( new PreserveWidgetsPhaseListener() );
413	RWTFactory.getPhaseListenerRegistry().add( new CurrentPhase.Listener() );	411	RWTFactory.getPhaseListenerRegistry().add( new CurrentPhase.Listener() );
414	final java.util.List eventLog = new ArrayList();	412	final java.util.List eventLog = new ArrayList();
415	Listener doitTrueListener = new Listener() {	413	Listener doitTrueListener = new Listener() {
Lines 461-467 Link Here
461	}	459	}
462		460
463	public void testKeyAndTraverseEvents() {	461	public void testKeyAndTraverseEvents() {
464	RWTFactory.getPhaseListenerRegistry().add( new PreserveWidgetsPhaseListener() );
465	RWTFactory.getPhaseListenerRegistry().add( new CurrentPhase.Listener() );	462	RWTFactory.getPhaseListenerRegistry().add( new CurrentPhase.Listener() );
466	final java.util.List eventLog = new ArrayList();	463	final java.util.List eventLog = new ArrayList();
467	Display display = new Display();	464	Display display = new Display();