Attachment #143932 for bug #281909

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




                          "org.eclipse.ui.forms.widgets.Hyperlink.onClick", //$NON-NLS-1$
                          JSListenerType.ACTION );

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }

  public void readData( final Widget widget ) {
    ControlLCAUtil.processSelection( widget, null, false );
    WidgetLCAUtil.processHelp( widget );




    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }

  ////////////////
  // Write changes





    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }

  ////////////////
  // Write changes





    String expected
      =   "var wm = org.eclipse.swt.WidgetManager.getInstance();"
        + "var w = wm.newWidget( \"w2\", \"w3\", true, "
        + "\"qx.ui.form.Button\" );";
        + ", \"qx.ui.form.Button\" );";
    assertEquals( expected, Fixture.getAllMarkup() );
    // ensure that the WidgetManager, once initialized, is not initialized
    // twice
    writer = JSWriter.getWriterFor( shell.button );
    writer.newWidget( "qx.ui.form.Button" );
    expected +=   "var w = wm.newWidget( \"w2\", \"w3\", true, "
                +  "\"qx.ui.form.Button\" );";
                +  ", \"qx.ui.form.Button\" );";
    assertEquals( expected, Fixture.getAllMarkup() );
    // ensure that obtaining the widget reference (var w =) is only rendered
    // once

    display.dispose();
  }

  private String getTypePoolId( final Widget widget ) {
    AbstractWidgetLCA lca = WidgetUtil.getLCA( widget );
    return lca.getTypePoolId( widget );
  }

  public void testNewWidget() throws Exception {
    Display display = new Display();
    TestShell shell = new TestShell( display );

    String expected
      =   "var wm = org.eclipse.swt.WidgetManager.getInstance();"
        + "var w = wm.newWidget( \"w2\", \"w3\", true, "
        + "\"qx.ui.form.Button\" );";
        + ", \"qx.ui.form.Button\" );";
    assertEquals( expected, Fixture.getAllMarkup() );
    // Ensures that the "widget reference is set"-flag is set
    Fixture.fakeResponseWriter();

    assertEquals( expected, Fixture.getAllMarkup() );
    display.dispose();
  }
  
  public void testNewWidgetWithTypePoolId() throws IOException {
    Display display = new Display();
    TestShell shell = new TestShell( display );
    Widget widget = new Widget( shell, SWT.NONE ) {
      public Object getAdapter( final Class adapter ) {
        Object result;
        if( adapter == ILifeCycleAdapter.class ) {
          result = new AbstractWidgetLCA() {

            public void preserveValues( Widget widget ) {
            }

            public void renderChanges( Widget widget ) throws IOException {
            }

            public void renderDispose( Widget widget ) throws IOException {
            }

            public void renderInitialization( Widget widget )
              throws IOException
            {
            }

            public void readData( Widget widget ) {
            }
            public String getTypePoolId( Widget widget ) {
              return "myWidgetPoolId";
            }
            
          }; 
        } else {
          result = super.getAdapter( adapter );
        }
        return result;
      }
    };
    JSWriter writer = JSWriter.getWriterFor( widget );
    writer.newWidget( "qx.ui.widget" );
    String expected
      =   "var wm = org.eclipse.swt.WidgetManager.getInstance();"
        + "var w = wm.newWidget( \"w2\", \"\", false, 767544711, "
        + "\"qx.ui.widget\" );";
    assertEquals( expected, Fixture.getAllMarkup() );
  }

  private String getTypePoolIdHash( final Widget widget ) {
    String id = getTypePoolId( widget );
    return id == null ? null : String.valueOf( id.hashCode() );
  }

  public void testNewWidgetWithParams() throws Exception {
    Display display = new Display();

    String expected
      =   "var wm = org.eclipse.swt.WidgetManager.getInstance();"
        + "var w = wm.newWidget( \"w2\", \"w3\", true, "
        + "\"qx.ui.form.Button\", '\"abc\", [\"#ff0000\" ]' );";
        + ", \"qx.ui.form.Button\", '\"abc\", [\"#ff0000\" ]' );";
    assertEquals( expected, Fixture.getAllMarkup() );
    // Ensures that the "widget reference is set"-flag is set
    Fixture.fakeResponseWriter();

    writer.newWidget( "TreeItem", null );
    expected
      =   "var w = wm.newWidget( \"w4\", \"\", false, "
        + "\"TreeItem\" );";
        + ", \"TreeItem\" );";
    assertEquals( expected, Fixture.getAllMarkup() );
  }

  public void testResetJSProperty() throws IOException {
    Display display = new Display();
    Shell shell = new Shell( display );
    JSWriter writer = JSWriter.getWriterFor( shell );
    Fixture.fakeResponseWriter();
    writer.reset( "testProperty" );
    String expected = "var wm = org.eclipse.swt.WidgetManager.getInstance();"
                      + "var w = wm.findWidgetById( \""
                      + WidgetUtil.getId( shell )
                      + "\" );w.resetTestProperty();";
    assertEquals( expected, Fixture.getAllMarkup() );
  }

  public void testResetJSPropertyChain() throws IOException {
    Display display = new Display();
    Shell shell = new Shell( display );
    JSWriter writer = JSWriter.getWriterFor( shell );
    Fixture.fakeResponseWriter();
    writer.reset( new String[] { "labelObject", "testProperty" } );
    String expected = "var wm = org.eclipse.swt.WidgetManager.getInstance();"
                      + "var w = wm.findWidgetById( \""
                      + WidgetUtil.getId( shell )
                      + "\" );w.getLabelObject().resetTestProperty();";
    assertEquals( expected, Fixture.getAllMarkup() );
  }





    assertFalse( WidgetLCAUtil.equals( new Date[] { new Date( 3 ) }, null ) );
  }

  public void testEscapeText() {
    // Empty Parameter
    try {
      WidgetLCAUtil.escapeText( null, true );

    assertEquals( expected, WidgetLCAUtil.escapeText( "Test\\", false ) );
  }

  public void testTruncateZeros() {
    assertEquals( ( char )0, "\000".charAt( 0 ) );
    assertEquals( "foo ", WidgetLCAUtil.escapeText( "foo \000 bar", false ) );
    assertEquals( "foo", WidgetLCAUtil.escapeText( "foo\000", false ) );

    WidgetLCAUtil.writeBackground( control, red );
    assertEquals( "", Fixture.getAllMarkup() );
  }
  
  public void testResetCalls() throws IOException {
    Fixture.fakeResponseWriter();
    WidgetLCAUtil.resetBounds();
    String expected 
      = "w.resetClipWidth();w.resetClipHeight();w.setSpace( 0, 0, 0, 0 );";
    assertEquals( expected, Fixture.getAllMarkup() );

    Fixture.fakeResponseWriter();
    WidgetLCAUtil.resetMenu();
    expected 
      =   "w.resetContextMenu();w.removeEventListener( \"contextmenu\", "
        + "org.eclipse.swt.MenuUtil.contextMenu );";
    assertEquals( expected, Fixture.getAllMarkup() );

    Fixture.fakeResponseWriter();
    WidgetLCAUtil.resetToolTip();
    expected = "wm.setToolTip( w );";
    assertEquals( expected, Fixture.getAllMarkup() );
    
    Fixture.fakeResponseWriter();
    WidgetLCAUtil.resetFont();
    expected = "w.resetFont();";
    assertEquals( expected, Fixture.getAllMarkup() );
    
    Fixture.fakeResponseWriter();
    WidgetLCAUtil.resetForeground();
    expected 
      =   "w.resetTextColor();w.removeEventListener( \"appear\", "
        + "org.eclipse.swt.WidgetManager._onAppearSetForeground );";
    assertEquals( expected, Fixture.getAllMarkup() );
    
    Fixture.fakeResponseWriter();
    WidgetLCAUtil.resetBackground();
    expected = "w.resetBackgroundColor();";
    assertEquals( expected, Fixture.getAllMarkup() );

    Fixture.fakeResponseWriter();
    WidgetLCAUtil.resetEnabled();
    expected = "w.setEnabled( true );";
    assertEquals( expected, Fixture.getAllMarkup() );
  }
  
  public void testWriteMenu() throws IOException {
    Display display = new Display();
    Composite shell = new Shell( display , SWT.NONE );




    Fixture.removeContext();
  }

  public void testExecutionOrder() {
    // Build test environment:
    final StringBuffer log = new StringBuffer();
    Fixture.fakeResponseWriter();

            public void renderDispose( final Widget widget ) throws IOException
            {
            }
            public void createResetHandlerCalls( final String typePoolId ) 
              throws IOException
            {
            }
            public String getTypePoolId( final Widget widget ) {
              return null;
            }
          };
        }
        return result;




          }
          public void renderDispose( final Widget widget ) throws IOException {
          }
          public void createResetHandlerCalls( final String typePoolId )
            throws IOException
          {
          }
          public String getTypePoolId( final Widget widget ) {
            return null;
          }
          public void renderInitialization( final Widget widget )
            throws IOException
          {




  private final List renderInitLog = new ArrayList();
  private final List renderChangesLog = new ArrayList();
  private final List renderDisposeLog = new ArrayList();
  private final List renderDisposeHandlerRegistration = new ArrayList();

  private final class DisposeTestButton extends Button {


    assertEquals( new Rectangle( 0, 0, 30, 70 ), display.getBounds() );
  }
  
  public void testRenderChangedButDisposed() {
    Display display = new Display();
    Shell shell = new Shell( display, SWT.NONE );
    final Button button = new DisposeTestButton( shell, SWT.PUSH );

    } );
    RWTFixture.fakeNewRequest();
    Fixture.fakeRequestParam( RequestParams.UIROOT, displayId );
    Fixture.fakeRequestParam( RequestParams.UIROOT, displayId );
    Fixture.fakeRequestParam( JSConst.EVENT_WIDGET_SELECTED, buttonId );
    RWTFixture.executeLifeCycleFromServerThread( );
    
    assertEquals( 0, renderInitLog.size() );
    assertFalse( renderChangesLog.contains( button ) );
    assertTrue( renderDisposeLog.contains( button ) );
    assertFalse( renderDisposeHandlerRegistration.isEmpty() );

    clearLogs();
    button2.addSelectionListener( new SelectionAdapter() {

    assertEquals( 0, renderInitLog.size() );
    assertFalse( renderChangesLog.contains( button2 ) );
    assertTrue( renderDisposeLog.contains( button2 ) );
    assertFalse( renderDisposeHandlerRegistration.contains( button2 ) );

    clearLogs();
    button3.addSelectionListener( new SelectionAdapter() {

    assertEquals( 0, renderInitLog.size() );
    assertFalse( renderChangesLog.contains( button3 ) );
    assertTrue( renderDisposeLog.contains( button3 ) );
    assertFalse( renderDisposeHandlerRegistration.isEmpty() );
  }

  public void testIsInitializedState() throws IOException {

            }


            public String getTypePoolId( final Widget widget ) {
              return getClass().getName() + "_" + widget.getStyle();
            }

            public void createResetHandlerCalls( final String typePoolId )
              throws IOException
            {
              renderDisposeHandlerRegistration.add( typePoolId );
            }

            public void renderDispose( final Widget widget ) throws IOException
            {
              renderDisposeLog.add( widget );

    renderInitLog.clear();
    renderChangesLog.clear();
    renderDisposeLog.clear();
    renderDisposeHandlerRegistration.clear();
  }
}

Lines 1892-1901 Link Here

(-)src/org/eclipse/swt/custom/CTabFolder.java (-4 / +5 lines)
1892		1892
1893	void onDispose() {	1893	void onDispose() {
1894	/*	1894	/*
1895	* Usually when an item is disposed, destroyItem will change the size of the items array,	1895	* Usually when an item is disposed of, destroyItem will change the size of
1896	* reset the bounds of all the tabs and manage the widget associated with the tab.	1896	* the items array, reset the bounds of all the tabs and manage the widget
1897	* Since the whole folder is being disposed, this is not necessary. For speed	1897	* associated with the tab. Since the whole folder is being disposed, this
1898	* the inDispose flag is used to skip over this part of the item dispose.	1898	* is not necessary. For speed the inDispose flag is used to skip over this
		1899	* part of the item dispose.
1899	*/	1900	*/
1900	inDispose = true;	1901	inDispose = true;
1901	removeControlListener( resizeListener );	1902	removeControlListener( resizeListener );




   * code has been processed the client-side widget should be in a state that is
   * equivalent to a newly created widget.
   * </p>
   *
   * <p>
   * Subclasses should override this method if pooling is supported by the
   * widget type this LCA belongs to. To activate pooling override
   * {@link #getTypePoolId(Widget)}.
   * </p>
   * 
   * @see #getTypePoolId(Widget)
   *
   * @param typePoolId the type pool id of the widget to reset
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method is not called anymore.
   */
  public void createResetHandlerCalls( final String typePoolId )
    throws IOException

   * suffix. If this method returns <code>null</code>, the widget will not be
   * stored in the widget pool and cannot be reused.
   * </p>
   *
   * <p>
   * Subclasses may override to activate pooling. In case pooling is activated
   * the method {@link #createResetHandlerCalls(String)} should also be
   * overridden.
   * </p>
   * 
   * @see #createResetHandlerCalls(String)
   *
   * @param widget the widget to store in the pool
   * @return the type pool id or <code>null</code> if the widget should not be
   *         pooled
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method is not called anymore.
   */
  public String getTypePoolId( final Widget widget ) {
    return null;




  public ToolBar( final Composite parent, final int style ) {
    super( parent, checkStyle( style ) );
    /*
     * Ensure that either of HORIZONTAL or VERTICAL is set. NOTE: HORIZONTAL and
     * VERTICAL have the same values as H_SCROLL and V_SCROLL so it is necessary
     * to first clear these bits to avoid scroll bars and then reset the bits
     * using the original style supplied by the programmer.
     */
    * programmer.
    */
    if( ( style & SWT.VERTICAL ) != 0 ) {
      this.style |= SWT.VERTICAL;
    } else {




package org.eclipse.swt.internal.widgets.labelkit;

import java.io.IOException;
import java.text.MessageFormat;

import org.eclipse.rwt.lifecycle.AbstractWidgetLCA;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Widget;


public class LabelLCA extends AbstractWidgetLCA {

    getDelegate( widget ).renderDispose( ( Label )widget );
  }

  public void createResetHandlerCalls( final String typePoolId ) throws IOException {
    getDelegate( typePoolId ).createResetHandlerCalls( typePoolId );
  }

  public String getTypePoolId( final Widget widget ) {
    // TODO [rh] disabled pooling, see bugs prefixed with [pooling]
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=204107
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=199142
//    return getDelegate( widget ).getTypePoolId( ( Label )widget );
    return null;
  }

  private static AbstractLabelLCADelegate getDelegate( final String tpId ) {
    AbstractLabelLCADelegate result;
    if( tpId.startsWith( SeparatorLabelLCA.TYPE_POOL_ID) ) {
      result = SEPARATOR_LCA;
    } else if( tpId.startsWith( StandardLabelLCA.TYPE_POOL_ID ) ) {
      result = LABEL_LCA;
    } else {
      String txt= "The typePoolId ''{0}'' is not supported.";
      String msg = MessageFormat.format( txt, new Object[] { tpId } );
      throw new IllegalArgumentException( msg );
    }
    return result;
  }

  private static AbstractLabelLCADelegate getDelegate( final Widget widget ) {
    AbstractLabelLCADelegate result;
    if( ( widget.getStyle() & SWT.SEPARATOR ) != 0 ) {

Lines 22-27 Link Here

(-)src/org/eclipse/swt/internal/widgets/labelkit/AbstractLabelLCADelegate.java (-2 lines)
22	abstract void renderInitialization( Label label ) throws IOException;	22	abstract void renderInitialization( Label label ) throws IOException;
23	abstract void renderChanges( Label label ) throws IOException;	23	abstract void renderChanges( Label label ) throws IOException;
24	abstract void renderDispose( Label label ) throws IOException;	24	abstract void renderDispose( Label label ) throws IOException;
25	abstract void createResetHandlerCalls( String typePoolId ) throws IOException;
26	abstract String getTypePoolId( Label label );
27	}	25	}





  private static final String QX_TYPE = "org.eclipse.swt.widgets.Separator";
  private static final String JS_FUNC_ADD_LINE_STYLE = "addLineStyle";
  private static final String JS_FUNC_REMOVE_LINE_STYLE = "removeLineStyle";
  private static final String JS_FIELD_LINE_ORIENTATION = "lineOrientation";
  private static final Object[] PARAM_SHADOW_IN
    = new Object[] { JSConst.JS_STYLE_FLAG_SHADOW_IN };
  private static final Object[] PARAM_SHADOW_OUT
    = new Object[] { JSConst.JS_STYLE_FLAG_SHADOW_OUT };
  static final String TYPE_POOL_ID = SeparatorLabelLCA.class.getName();

  void preserveValues( final Label label ) {
    ControlLCAUtil.preserveValues( label );

    writer.dispose();
  }

  void createResetHandlerCalls( final String typePoolId ) throws IOException {
    ControlLCAUtil.resetChanges();
    ControlLCAUtil.resetStyleFlags();
    resetStyle();
  }

  String getTypePoolId( final Label label ) {
    return TYPE_POOL_ID;
  }

  private static void writeStyle( final Label label ) throws IOException {
    JSWriter writer = JSWriter.getWriterFor( label );
    int style = label.getStyle();

      writer.call( JS_FUNC_ADD_LINE_STYLE, PARAM_SHADOW_OUT );
    }
  }

  private static void resetStyle() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.call( JS_FUNC_REMOVE_LINE_STYLE, PARAM_SHADOW_IN );
    writer.call( JS_FUNC_REMOVE_LINE_STYLE, PARAM_SHADOW_OUT );
    writer.reset( JS_FIELD_LINE_ORIENTATION );
  }
}




public class StandardLabelLCA extends AbstractLabelLCADelegate {

  private static final String QX_TYPE = "qx.ui.basic.Atom";
  static final String TYPE_POOL_ID = StandardLabelLCA.class.getName();

  private static final String PROP_TEXT = "text";
  private static final String PROP_ALIGNMENT = "alignment";

    writer.dispose();
  }

  void createResetHandlerCalls( final String typePoolId ) throws IOException {
    resetAlignment();
    resetText();
    resetImage();
    ControlLCAUtil.resetChanges();
    ControlLCAUtil.resetStyleFlags();
  }

  String getTypePoolId( final Label label ) {
    return TYPE_POOL_ID;
  }

  //////////////////////////////////////
  // Helping methods to write JavaScript


    }
  }

  private static void resetText() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    Object[] args = new Object[]{ JSWriter.WIDGET_REF, null };
    writer.callStatic( JS_FUNC_LABEL_UTIL_SET_TEXT, args );
  }

  private static void writeImage( final Label label ) throws IOException {
    Image image = label.getImage();
    if( WidgetLCAUtil.hasChanged( label, Props.IMAGE, image, null ) )

    }
  }

  private static void resetImage() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    Object[] args = new Object[]{ JSWriter.WIDGET_REF, null };
    writer.callStatic( JS_FUNC_LABEL_UTIL_SET_IMAGE, args );
  }

  private static void writeAlignment( final Label label ) throws IOException {
    Integer alignment = new Integer( label.getAlignment() );
    Integer defValue = DEFAULT_ALIGNMENT;

    }
  }

  private static void resetAlignment() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( "horizontalChildrenAlign" );
    writer.reset( new String[] { "labelObject", "textAlign" } );
  }

  private static String getAlignment( final int alignment ) {
    String result;
    if( ( alignment & SWT.LEFT ) != 0 ) {





  private static final String JS_PROP_HEIGHT = "height";
  private static final String JS_PROP_WIDTH = "width";
  private static final String JS_PROP_CLIP_WIDTH = "clipWidth";
  private static final String JS_PROP_CLIP_HEIGHT = "clipHeight";
  private static final String PARAM_X = "bounds.x";
  private static final String PARAM_Y = "bounds.y";
  private static final String PARAM_WIDTH = "bounds.width";

  }

  /**
   * Writes JavaScript code to the response that resets the bounds of a widget.
   * This method is intended to be used by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetBounds() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( JS_PROP_CLIP_WIDTH );
    writer.reset( JS_PROP_CLIP_HEIGHT );
    writer.set( JS_PROP_SPACE, new int[] { 0, 0, 0, 0 } );
  }


  /**
   * Determines whether the property <code>menu</code> of the given widget has
   * changed during the processing of the current request and if so, writes
   * JavaScript code to the response that updates the client-side menu property

  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>menu</code> of a widget. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetMenu() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( JS_PROP_CONTEXT_MENU );
    writer.removeListener( JSConst.QX_EVENT_CONTEXTMENU,
                           JSConst.JS_CONTEXT_MENU );
  }

  /**
   * Determines whether the property <code>toolTip</code> of the given widget
   * has changed during the processing of the current request and if so, writes
   * JavaScript code to the response that updates the client-side toolTip

  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>toolTip</code> of a widget. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetToolTip() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.call( JSWriter.WIDGET_MANAGER_REF,
                 JS_FUNC_SET_TOOL_TIP,
                 new Object[] { JSWriter.WIDGET_REF } );
  }


  /////////////////////////////////////////////////
  // write-methods used by other ...LCAUtil classes

  /**
   * Determines whether the property <code>image</code> of the given widget
   * has changed during the processing of the current request and if so, writes
   * JavaScript code to the response that updates the client-side image property

  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>font</code> of a widget. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetFont() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( JSConst.QX_FIELD_FONT );
  }

  /**
   * Determines whether the property <code>foreground</code> of the given
   * widget has changed during the processing of the current request and if so,
   * writes JavaScript code to the response that updates the client-side

  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>foreground</code> of a widget. This method is intended to be used
   * by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetForeground() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( "textColor" );
    String listener = "org.eclipse.swt.WidgetManager._onAppearSetForeground";
    writer.removeListener( "appear", listener );
  }

  /**
   * Determines whether the property <code>background</code> of the given
   * widget has changed during the processing of the current request and if so,
   * writes JavaScript code to the response that updates the client-side

  }

  /**
   * Writes JavaScript code to the response that reset the property
   * <code>background</code> of a widget. This method is intended to be used
   * by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetBackground() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( JSConst.QX_FIELD_BG_COLOR );
  }

  /**
   * Determines whether the background gradient properties of the
   * given widget has changed during the processing of the current request and
   * if so, writes JavaScript code to the response that updates the client-side



  /**
   * Writes JavaScript code to the response that resets the property
   * <code>enabled</code> of a widget. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetEnabled() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    // TODO [fappel]: check whether to use reset
    writer.set( JSConst.QX_FIELD_ENABLED, true );
  }

  /**
   * Replaces all newline characters in the specified input string with the
   * given replacement string.
   *

    }
    return result;
  }


  /////////////////////////////////////
  // deprecated pooling-related methods

  /**
   * Writes JavaScript code to the response that resets the bounds of a widget.
   * This method is intended to be used by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetBounds() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>menu</code> of a widget. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetMenu() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>toolTip</code> of a widget. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   * 
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetToolTip() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>font</code> of a widget. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetFont() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>foreground</code> of a widget. This method is intended to be used
   * by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetForeground() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that reset the property
   * <code>background</code> of a widget. This method is intended to be used
   * by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetBackground() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>enabled</code> of a widget. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetEnabled() throws IOException {
  }
}




  }

  /**
   * Returns the {@link JSWriter} instance used to reset a widgets attributes in
   * order to take part in the pooling mechanism.
   * 
   *
   * @return the {@link JSWriter} instance
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method should not be used anymore.
   */
  public static JSWriter getWriterForResetHandler() {
    return new JSWriter( null );

    throws IOException
  {
    ensureWidgetManager();
    String typePoolId = getTypePoolId( widget );
    StringBuffer buffer = new StringBuffer();
    buffer.append( "var w = wm.newWidget( \"" );
    buffer.append( WidgetUtil.getId( widget ) );

    buffer.append( getJSParentId( widget ) );
    buffer.append( "\", " );
    buffer.append( useSetParent() );
    buffer.append( ", " );
    Integer poolIdHashCode
      = typePoolId == null ? null : new Integer( typePoolId.hashCode() );
    buffer.append( poolIdHashCode );
    buffer.append( ", \"" );
    buffer.append( className );
    buffer.append( "\"" );


  /**
   * Dispose is used to dispose of the widget of this {@link JSWriter} on the
   * client side.
   * dispose of the widget if there are no pooling informations available.
   *
   * @throws IOException if an I/O error occurs
   *
   * @see AbstractWidgetLCA#getTypePoolId(Widget)
   * @see AbstractWidgetLCA#createResetHandlerCalls(String)
   */
  public void dispose() throws IOException {
    ensureWidgetManager();

           : Boolean.FALSE;
  }

  private String getTypePoolId( final Widget widget ) {
    AbstractWidgetLCA lca = WidgetUtil.getLCA( widget );
    return lca.getTypePoolId( widget );
  }

  private String getJSParentId( final Widget widget ) {
    String result = "";
    if( !( widget instanceof Shell ) && widget instanceof Control ) {




 */
public class ControlLCAUtil {

  private static final Object[] PARAM_STYLE_BORDER
    = new Object[] { JSConst.JS_STYLE_FLAG_BORDER };

  private static final Object[] PARAM_STYLE_FLAT
    = new Object[] { JSConst.JS_STYLE_FLAG_FLAT };

  private static final JSListenerInfo FOCUS_GAINED_LISTENER_INFO
    = new JSListenerInfo( "focusin",
                          "org.eclipse.swt.EventUtil.focusGained",

  }

  /**
   * Writes JavaScript code to the response that resets the bounds of a control.
   * This method is intended to be used by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetBounds() throws IOException {
    WidgetLCAUtil.resetBounds();
  }

  /**
   * Determines whether the z-index of the given control has changed during the
   * processing of the current request and if so, writes JavaScript code to the
   * response that updates the client-side z-index.

  }

  /**
   * Writes JavaScript code to the response that resets the z-index property of
   * a control. This method is intended to be used by implementations of the
   * method {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetZIndex() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( JSConst.QX_FIELD_Z_INDEX );
  }

  /**
   * Determines whether the visibility of the given control has changed during
   * the processing of the current request and if so, writes JavaScript code to
   * the response that updates the client-side visibility.

  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>visible</code> of a control. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetVisible() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    // TODO [fappel]: check whether to use reset
    writer.set( JSConst.QX_FIELD_VISIBLE, true );
  }

  /**
   * Determines whether the property <code>enabled</code> of the given control
   * has changed during the processing of the current request and if so, writes
   * JavaScript code to the response that updates the client-side enabled

  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>enabled</code> of a control. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetEnabled() throws IOException {
    WidgetLCAUtil.resetEnabled();
  }

  /**
   * Determines for all of the following properties of the specified control
   * whether the property has changed during the processing of the current
   * request and if so, writes JavaScript code to the response that updates the

  }

  /**
   * Writes JavaScript code to the response that resets the following properties
   * of a control.
   * <ul>
   * <li>bounds</li>
   * <li>z-index (except for Shells)</li>
   * <li>tab index</li>
   * <li>tool tip text</li>
   * <li>menu</li>
   * <li>visible</li>
   * <li>enabled</li>
   * <li>foreground</li>
   * <li>background</li>
   * <li>font</li>
   * <!--li>whether ControlListeners are registered</li>
   * <li>whether ActivateListeners are registered</li>
   * <li>whether FocusListeners are registered</li-->
   * </ul>
   * This method is intended to be used by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetChanges() throws IOException {
    resetFocusListener();
    // resetting Activation Listener is automatically done by JSWriter#dispose
    // TODO [rst] What about resetting Control- and FocusListener? document this
    resetMenu();
    resetToolTip();
    resetFont();
    resetBackground();
    resetForeground();
    resetEnabled();
    resetVisible();
    resetTabIndex();
    resetZIndex();
    resetBounds();
  }

  /**
   * Writes JavaScript code to the response that adds client-side resize
   * listeners to a control. These listeners send notifications when the control
   * is resized.

  }

  /**
   * Writes JavaScript code to the response that removes the client-side resize
   * notification listeners from a control.
   *
   * @throws IOException
   */
  public static void resetResizeNotificator()
    throws IOException
  {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.removeListener( JSConst.QX_EVENT_CHANGE_WIDTH,
                           JSConst.JS_WIDGET_RESIZED );
    writer.removeListener( JSConst.QX_EVENT_CHANGE_HEIGHT,
                           JSConst.JS_WIDGET_RESIZED );
  }

  /**
   * Writes JavaScript code to the response that adds client-side move listeners
   * to a control. These listeners send notifications when the control is moved.
   * @param control the control to add move notification listeners to

  }

  /**
   * Writes JavaScript code to the response that removes the client-side move
   * notification listeners from a control.
   *
   * @throws IOException
   */
  public static void resetMoveNotificator()
    throws IOException
  {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.removeListener( JSConst.QX_EVENT_CHANGE_LOCATION_X,
                           JSConst.JS_WIDGET_MOVED );
    writer.removeListener( JSConst.QX_EVENT_CHANGE_LOCATION_Y,
                           JSConst.JS_WIDGET_MOVED );
  }

  /**
   * Determines whether the property <code>menu</code> of the given control
   * has changed during the processing of the current request and if so, writes
   * JavaScript code to the response that updates the client-side menu

  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>menu</code> of a control. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetMenu() throws IOException {
    WidgetLCAUtil.resetMenu();
  }

  /**
   * Determines whether the tool tip of the given control has changed during the
   * processing of the current request and if so, writes JavaScript code to the
   * response that updates the client-side tool tip.

  }

  /**
   * Writes JavaScript code to the response that resets the tool tip of a
   * control. This method is intended to be used by implementations of the
   * method {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetToolTip() throws IOException {
    WidgetLCAUtil.resetToolTip();
  }

  /**
   * Determines whether the property <code>foreground</code> of the given
   * control has changed during the processing of the current request and if so,
   * writes JavaScript code to the response that updates the client-side

  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>foreground</code> of a control. This method is intended to be used
   * by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetForeground() throws IOException {
    WidgetLCAUtil.resetForeground();
  }

  /**
   * Determines whether the property <code>background</code> of the given
   * control has changed during the processing of the current request and if so,
   * writes JavaScript code to the response that updates the client-side

  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>background</code> of a control. This method is intended to be used
   * by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetBackground() throws IOException {
    WidgetLCAUtil.resetBackground();
  }

  /**
   * Checks the given control for common SWT style flags (e.g.
   * <code>SWT.BORDER</code>) and if present, writes code to pass the according
   * states to the client.

  }

  /**
   * Writes JavaScript code to the response that resets the style flags.
   * <p>This method is intended to be used by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.</p>
   *
   * @throws IOException
   */
  public static void resetStyleFlags() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.call( JSConst.QX_FUNC_REMOVE_STATE, PARAM_STYLE_BORDER );
    writer.call( JSConst.QX_FUNC_REMOVE_STATE, PARAM_STYLE_FLAT );
  }

  /**
   * Determines whether the property <code>font</code> of the given control
   * has changed during the processing of the current request and if so, writes
   * JavaScript code to the response that updates the client-side font property.

    WidgetLCAUtil.writeFont( control, newValue );
  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>font</code> of a control. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   */
  public static void resetFont() throws IOException {
    WidgetLCAUtil.resetFont();
  }

  static void writeCursor( final Control control ) throws IOException {
    Cursor newValue = control.getCursor();
    if( WidgetLCAUtil.hasChanged( control, PROP_CURSOR, newValue, null ) ) {

    }
  }

  static void resetCursor() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( JSConst.QX_FIELD_CURSOR );
  }

  public static void writeActivateListener( final Control control )
    throws IOException
  {

    }
  }

  private static void resetFocusListener() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.removeListener( FOCUS_GAINED_LISTENER_INFO.getEventType(),
                           FOCUS_GAINED_LISTENER_INFO.getJSListener() );
    writer.removeListener( FOCUS_LOST_LISTENER_INFO.getEventType(),
                           FOCUS_LOST_LISTENER_INFO.getJSListener() );
  }

  private static void writeMouseListener( final Control control )
    throws IOException
  {

    }
  }

  private static void resetTabIndex() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( JSConst.QX_FIELD_TAB_INDEX );
  }

  /**
   * Recursively computes the tab indices for all child controls of a given
   * composite and stores the resulting values in the control adapters.

    }
    return result;
  }


  /////////////////////////////////////
  // deprecated pooling-related methods

  /**
   * Writes JavaScript code to the response that resets the bounds of a control.
   * This method is intended to be used by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetBounds() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that resets the z-index property of
   * a control. This method is intended to be used by implementations of the
   * method {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetZIndex() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>visible</code> of a control. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetVisible() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>enabled</code> of a control. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetEnabled() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that resets the following properties
   * of a control.
   * <ul>
   * <li>bounds</li>
   * <li>z-index (except for Shells)</li>
   * <li>tab index</li>
   * <li>tool tip text</li>
   * <li>menu</li>
   * <li>visible</li>
   * <li>enabled</li>
   * <li>foreground</li>
   * <li>background</li>
   * <li>font</li>
   * <!--li>whether ControlListeners are registered</li>
   * <li>whether ActivateListeners are registered</li>
   * <li>whether FocusListeners are registered</li-->
   * </ul>
   * This method is intended to be used by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetChanges() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that removes the client-side resize
   * notification listeners from a control.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetResizeNotificator()
    throws IOException
  {
  }

  /**
   * Writes JavaScript code to the response that removes the client-side move
   * notification listeners from a control.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetMoveNotificator()
    throws IOException
  {
  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>menu</code> of a control. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetMenu() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that resets the tool tip of a
   * control. This method is intended to be used by implementations of the
   * method {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetToolTip() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>foreground</code> of a control. This method is intended to be used
   * by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetForeground() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>background</code> of a control. This method is intended to be used
   * by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetBackground() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that resets the style flags.
   * <p>This method is intended to be used by implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.</p>
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetStyleFlags() throws IOException {
  }

  /**
   * Writes JavaScript code to the response that resets the property
   * <code>font</code> of a control. This method is intended to be used by
   * implementations of the method
   * {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
   *
   * @throws IOException
   * @deprecated As of 1.3, server-side widget pooling is no longer required.
   *             This method does nothing.
   */
  public static void resetFont() throws IOException {
  }
}





final class PushButtonDelegateLCA extends ButtonDelegateLCA {

  static final String TYPE_POOL_ID
    = PushButtonDelegateLCA.class.getName();
  private static final String QX_TYPE = "org.eclipse.rwt.widgets.Button";

  private static final Object[] PARAM_PUSH = new Object[] { "push" };

    JSWriter writer = JSWriter.getWriterFor( button );
    writer.dispose();
  }

  String getTypePoolId( final Button button ) {
    return null;
  }

  void createResetHandlerCalls( final String typePoolId ) throws IOException {
  }
}

Lines 20-25 Link Here

(-)src/org/eclipse/swt/internal/widgets/buttonkit/ButtonDelegateLCA.java (-2 lines)
20	abstract void renderInitialization( Button button ) throws IOException;	20	abstract void renderInitialization( Button button ) throws IOException;
21	abstract void renderChanges( Button button ) throws IOException;	21	abstract void renderChanges( Button button ) throws IOException;
22	abstract void renderDispose( Button button ) throws IOException;	22	abstract void renderDispose( Button button ) throws IOException;
23	abstract void createResetHandlerCalls( String typePoolId ) throws IOException;
24	abstract String getTypePoolId( Button widget );
25	}	23	}




package org.eclipse.swt.internal.widgets.buttonkit;

import java.io.IOException;
import java.text.MessageFormat;

import org.eclipse.rwt.lifecycle.AbstractWidgetLCA;
import org.eclipse.rwt.lifecycle.JSWriter;

    getLCADelegate( widget ).renderDispose( ( Button )widget );
  }

  public void createResetHandlerCalls( final String typePoolId ) 
    throws IOException 
  {
    getLCADelegate( typePoolId ).createResetHandlerCalls( typePoolId );
  }

  public String getTypePoolId( final Widget widget ) {
    return getLCADelegate( widget ).getTypePoolId( ( Button )widget );
  }

  private static ButtonDelegateLCA getLCADelegate( final String tpId ) {
    ButtonDelegateLCA result;
    if( tpId.startsWith( CheckButtonDelegateLCA.TYPE_POOL_ID ) ) {
      result = CHECK;
    } else if( tpId.startsWith( PushButtonDelegateLCA.TYPE_POOL_ID ) ) {
      result = PUSH;
    } else if( tpId.startsWith( RadioButtonDelegateLCA.TYPE_POOL_ID ) ) {
      result = RADIO;
    } else {
      String txt= "The typePoolId ''{0}'' is not supported.";
      String msg = MessageFormat.format( txt, new Object[] { tpId } );
      throw new IllegalArgumentException( msg );
    }
    return result;
  }

  private static ButtonDelegateLCA getLCADelegate( final Widget widget ) {
    ButtonDelegateLCA result;
    int style = ( ( Button )widget ).getStyle();





final class CheckButtonDelegateLCA extends ButtonDelegateLCA {

  static final String TYPE_POOL_ID
    = CheckButtonDelegateLCA.class.getName();
  private static final String QX_TYPE = "org.eclipse.rwt.widgets.Button";
  private static final Object[] PARAM_CHECK = new Object[] { "check" };


    writer.dispose();
  }

  String getTypePoolId( final Button button ) {
    // Disabled pooling, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=226099
//    return TYPE_POOL_ID;
    return null;
  }

  void createResetHandlerCalls( final String typePoolId ) throws IOException {
    ButtonLCAUtil.resetAlignment();
    ButtonLCAUtil.resetText();
    ButtonLCAUtil.resetSelection();
    ControlLCAUtil.resetChanges();
    ControlLCAUtil.resetStyleFlags();
  }

  private static void writeGrayed( final Button button ) throws IOException {
    Boolean newValue = Boolean.valueOf( button.getGrayed() );
    String prop = PROP_GRAYED;





final class RadioButtonDelegateLCA extends ButtonDelegateLCA {

  static final String TYPE_POOL_ID
    = RadioButtonDelegateLCA.class.getName();
  private static final String QX_TYPE = "org.eclipse.rwt.widgets.Button";  
  private static final Object[] PARAM_RADIO = new Object[] { "radio" };


    writer.dispose();
  }
     
  String getTypePoolId( final Button button ) {
//    return TYPE_POOL_ID;
    return null;
  }

  void createResetHandlerCalls( final String typePoolId ) throws IOException {
// TODO [fappel]: check why removal of listener doesn't work. Seems as if
//                manager is removed already (maybe dispose call?)...
//    JSWriter writer = JSWriter.getWriterForResetHandler();
//    writer.removeListener( JS_PROP_MANAGER,
//                           JS_LISTENER_INFO.getEventType(),
//                           JS_LISTENER_INFO.getJSListener() );
    ButtonLCAUtil.resetAlignment();
    ButtonLCAUtil.resetText();
    ButtonLCAUtil.resetSelection();
    ControlLCAUtil.resetChanges();
    ControlLCAUtil.resetStyleFlags();
  }

  private static void processSelectionEvent( final Button button ) {
    if( SelectionEvent.hasListener( button ) ) {
      int type = SelectionEvent.WIDGET_SELECTED;




    }
  }

  static void resetText() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    // Note [fappel]: reset doesn't work, so use setting to empty string
    writer.set( "text", new Object[]{ null } );
  }

  static void writeImage( final Button button ) throws IOException {
    Image image = button.getImage();
    if( WidgetLCAUtil.hasChanged( button, Props.IMAGE, image, null ) ) {

    }
  }

  static void resetImage() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.set( "image", new Object[]{ null } );
  }

  static void writeAlignment( final Button button ) throws IOException {
    if( ( button.getStyle() & SWT.ARROW ) == 0 ) {
      Integer newValue = new Integer( button.getAlignment() );

    }
  }

  static void resetAlignment() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( JS_PROP_HORIZONTAL_CHILDREN_ALIGN );
  }

  static void writeSelection( final Button button ) throws IOException {
    Boolean newValue = Boolean.valueOf( button.getSelection() );
    JSWriter writer = JSWriter.getWriterFor( button );
    writer.set( PROP_SELECTION, JS_PROP_SELECTION, newValue, Boolean.FALSE );
  }

  static void resetSelection() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.set( JS_PROP_SELECTION, Boolean.FALSE );
  }

  // TODO [rst] Can this be moved to ShellLCA ?
  static void writeDefault( final Button button ) throws IOException {
    boolean isDefault = isDefaultButton( button );




    initialize : function( widget ) {

      widget.setHorizontalChildrenAlign( qx.constant.Layout.ALIGN_LEFT );
      widget.setVerticalChildrenAlign( qx.constant.Layout.ALIGN_TOP );
      widget.setAppearance( org.eclipse.swt.LabelUtil.APPEARANCE );
      widget.setOverflow( qx.constant.Style.OVERFLOW_HIDDEN );
      // TODO [rh] workaround for weird getLabelObject behaviour
      widget.setLabel( "(empty)" );
      // end workaround
      var labelObject = widget.getLabelObject();
      labelObject.setMode( qx.constant.Style.LABEL_MODE_HTML );
      labelObject.setTextOverflow( false );
      labelObject.setAppearance( "label-graytext" );
      // TODO [rh] workaround for weird getLabelObject behaviour
      widget.setLabel( "" );
      // end workaround
      widget.setHideFocus( true );
      // track DOM insertion state
      widget.addEventListener( "beforeRemoveDom",
                               org.eclipse.swt.LabelUtil._onRemoveDom );
      widget.addEventListener( "insertDom",
                               org.eclipse.swt.LabelUtil._onInsertDom );
      widget.addEventListener( "mouseover",
                               org.eclipse.swt.LabelUtil._onMouseOver );
      widget.addEventListener( "mouseout",
                               org.eclipse.swt.LabelUtil._onMouseOut );
                                 org.eclipse.swt.LabelUtil._onMouseOut );
      }
    },
    
    _onRemoveDom : function( evt ) {

        widget.setUserData( "setText", text );
        widget.addEventListener( "appear",
                                 org.eclipse.swt.LabelUtil._setTextDelayed );
      }
      // workaround for pooling problems
      else if( !widget._isInDOM && widget.getUserData( "pooled" ) ) {
        widget.setUserData( "setText", text );
        widget.addEventListener( "insertDom",
                                 org.eclipse.swt.LabelUtil._setTextDelayed );
      } else {
        org.eclipse.swt.LabelUtil._doSetText( widget, text );
      }

        widget.setUserData( "setImage", imagePath );
        widget.addEventListener( "appear",
                                 org.eclipse.swt.LabelUtil._setImageDelayed );
      } else if( !widget._isInDOM && widget.getUserData( "pooled" ) ) {
        widget.setUserData( "setImage", imagePath );
        widget.addEventListener( "insertDom",
                                 org.eclipse.swt.LabelUtil._setImageDelayed );
      } else {
        org.eclipse.swt.LabelUtil._doSetImage( widget, imagePath );
      }




    // Key: id (string), value: widget instanace (qx.ui.core.Widget)
    this._map = {};
    
    // initialize widget pool
    this._widgetPool = new Object();
    // this field is needed as Opera has some problems with
    // accessing local variables in eval expressions.
    this._current = null;

     * removed from this WidgetManager (see remove).
     * No action is taken if there is no widget registered for the given id or 
     * the widget was already disposed of.
     * In case of a widget type that supports pooling the widget is disconnected
     * from its parent, its 'disposeHandler' that reinitializes the widget is
     * called and it's added to the pool to be ready for reuse.
     */
    dispose : function( id ) {
      var widget = this.findWidgetById( id );

          if( parent && parent.getChildren() ) {
            widget.setParent( null );
          }
          // [if] Replace dispose() with destroy()
          widget.destroy();
          if( typePoolId != null ) {
            var typePool = this._widgetPool[ typePoolId ];
            typePool.resetHandler( widget );
            widget.setUserData( "pooled", true );
            // EXPERIMENTAL: If the widget has a reset method, call it
            if( widget.rap_reset ) {
              widget.rap_reset();
            }
            typePool.elements.push( widget );
          // dispose of widgets that cannot be pooled
          } else {
            // [if] Replace dispose() with destroy()
          	widget.destroy();
          }
        }
      }
    },

    registerResetHandler : function( typePoolId, resetHandler ) {
      this._createWidgetPool( typePoolId, resetHandler );
    },
    
    newWidget : function( widgetId, parentId, isControl, type, paramList ) {
                          parentId,
                          isControl,
                          typePoolId,
                          type,
                          paramList )
    {
      // Note [fappel]: Do not remove the 'wm' declaration. This is needed
      //                for IE if the 'newExpression' has a reference to
      //                the variable defined in the script from the server.
      // TODO [fappel]: Think about improvement of the hardcoded expression... 
      var wm = this;
      
      var newExpression;
      if( paramList != null ) {
        newExpression = "new " + type + "(" + paramList + ");";
      } else {
        newExpression = "new " + type + "();";
        result = typePool.elements.pop();
        if( result ) {
          if( paramList != null ) {
            // If paramList isn't empty we have to reinitialize the widget.
            // Luckily only our own js widgets use this...
            var expression =   "org.eclipse.swt.WidgetManager.getInstance()."
                             + "_current.reInit("
                             + paramList
                             + ");";
            // Assignment of the field _current is needed as Opera has some 
            // problems with accessing local variables in eval expressions.
            this._current = result;
            window.eval( expression );
            this._current = null;
          }
          // EXPERIMENTAL: If the widget has an init method, call it
          if( result.rap_init ) {
            result.rap_init();
          }
        }
//        this.debug( "_____ recycled: " + result );
      }
      
      // ... otherwise create a new one
      if( result == null ) {
        var newExpression;
        if( paramList != null ) {
          newExpression = "new " + type + "(" + paramList + ");";
        } else {
          newExpression = "new " + type + "();";
        }
        result = window.eval( newExpression );
        result.setUserData( "typePoolId", typePoolId );
        result.setUserData( "pooled", false );
//        this.debug( "_____ created: " + result );
      }
      var result = window.eval( newExpression );
      
      // map the widget to the server side widgetId
      if( result.classname == "org.eclipse.swt.widgets.Shell" ) {

      }
    },

    /**
     * Creates a new caching pool for widgets with the given pooling id.
     */
    _createWidgetPool : function( typePoolId, resetHandler ) {
      var typePool = new Object();
      typePool.elements = new Array();
      typePool.resetHandler = resetHandler;
      this._widgetPool[ typePoolId ] = typePool;        
    },

    ////////////////
    // Font handling


Lines 76-82 Link Here

(-)js/org/eclipse/swt/TextUtil.js (-1 / +1 lines)
76	* Sets the selected text range of the given text widget.	76	* Sets the selected text range of the given text widget.
77	*/	77	*/
78	setSelection : function( text, start, length ) {	78	setSelection : function( text, start, length ) {
79	if( text.isCreated() && !text.getUserData( "pooled" ) ) {	79	if( text.isCreated() ) {
80	org.eclipse.swt.TextUtil._doSetSelection( text, start, length );	80	org.eclipse.swt.TextUtil._doSetSelection( text, start, length );
81	} else {	81	} else {
82	text.setUserData( "onAppear.selectionStart", start );	82	text.setUserData( "onAppear.selectionStart", start );




    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId ) throws IOException {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }


  //////////////////////////////////////////
  // Helping method to write JavaScript code





    }
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }


  //////////////////
  // ReadData helper





    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }

  public void doRedrawFake( final Control control ) {
    int evtId = ControlEvent.CONTROL_RESIZED;
    ControlEvent evt = new ControlEvent( control, evtId );




    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId ) throws IOException {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }


  //////////////////
  // Helping methods





    }
  }

  static void resetText() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( JS_PROP_VALUE );
  }

  static void writeReadOnly( final Text text ) throws IOException {
    JSWriter writer = JSWriter.getWriterFor( text );
    Boolean newValue = Boolean.valueOf( !text.getEditable() );
    writer.set( PROP_READONLY, JS_PROP_READ_ONLY, newValue, Boolean.FALSE );
  }

  static void resetReadOnly() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( JS_PROP_READ_ONLY );
  }

  static void writeTextLimit( final Text text ) throws IOException {
    JSWriter writer = JSWriter.getWriterFor( text );
    Integer newValue = new Integer( text.getTextLimit() );

    }
  }

  static void resetTextLimit() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( JS_PROP_MAX_LENGTH );
  }

  static void writeWrap( final Text text ) throws IOException {
    JSWriter writer = JSWriter.getWriterFor( text );
    Boolean value = Boolean.valueOf( ( text.getStyle() & SWT.WRAP ) != 0 );

    }
  }

  static void resetSelection() {
    // POOLING Implement if pooling is reactivated
  }

  static void writeAlignment( final Text text ) throws IOException {
    int style = text.getStyle();
    if( ( style & SWT.RIGHT ) != 0 ) {

    }
  }

  static void resetSelectionListener() {
    // POOLING Implement if pooling is reactivated
  }

  static void preserveVerifyAndModifyListener( final Text text ) {
    IWidgetAdapter adapter = WidgetUtil.getAdapter( text );
    adapter.preserve( PROP_VERIFY_MODIFY_LISTENER,

    }
  }

  static void resetVerifyAndModifyListener() {
    // POOLING Implement if pooling is reactivated
  }

  private static boolean hasSelectionListener( final Text text ) {
    // Emulate SWT (on Windows) where a default button takes precedence over
    // a SelectionListener on a text field when both are on the same shell.




package org.eclipse.swt.internal.widgets.textkit;

import java.io.IOException;
import java.text.MessageFormat;

import org.eclipse.rwt.lifecycle.AbstractWidgetLCA;
import org.eclipse.rwt.lifecycle.JSWriter;

    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId ) throws IOException {
    getLCADelegate( typePoolId ).createResetHandlerCalls( typePoolId );
  }

  public String getTypePoolId( final Widget widget ) {
//    return getLCADelegate( widget ).getTypePoolId( ( Text )widget );
    // Disabled pooling, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=218466
    // [Pooling] Text widgets occasionally don't accept keyboard entries
    return null;
  }

  private static AbstractTextDelegateLCA getLCADelegate( final String tpId ) {
    AbstractTextDelegateLCA result;
    if( PasswordTextLCA.TYPE_POOL_ID.equals( tpId ) ) {
      result = PASSWORD;
    } else if( SingleTextLCA.TYPE_POOL_ID.equals( tpId ) ) {
      result = SINGLE;
    } else if( MultiTextLCA.TYPE_POOL_ID.equals( tpId ) ) {
      result = MULTI;
    } else {
      String txt= "The typePoolId ''{0}'' is not supported.";
      String msg = MessageFormat.format( txt, new Object[] { tpId } );
      throw new IllegalArgumentException( msg );
    }
    return result;
  }

  private static AbstractTextDelegateLCA getLCADelegate( final Widget widget ) {
    AbstractTextDelegateLCA result;
    int style = ( ( Text )widget ).getStyle();

Lines 20-25 Link Here

(-)src/org/eclipse/swt/internal/widgets/textkit/AbstractTextDelegateLCA.java (-2 lines)
20	abstract void renderInitialization( Text text ) throws IOException;	20	abstract void renderInitialization( Text text ) throws IOException;
21	abstract void renderChanges( Text text ) throws IOException;	21	abstract void renderChanges( Text text ) throws IOException;
22	abstract void renderDispose( Text text ) throws IOException;	22	abstract void renderDispose( Text text ) throws IOException;
23	abstract void createResetHandlerCalls( String typePoolId ) throws IOException;
24	abstract String getTypePoolId( Text text );
25	}	23	}





final class SingleTextLCA extends AbstractTextDelegateLCA {

  static final String TYPE_POOL_ID = SingleTextLCA.class.getName();

  void preserveValues( final Text text ) {
    ControlLCAUtil.preserveValues( text );
    TextLCAUtil.preserveValues( text );

    writer.dispose();
  }

  String getTypePoolId( final Text text ) {
    return TYPE_POOL_ID;
  }

  void createResetHandlerCalls( final String typePoolId ) throws IOException {
    TextLCAUtil.resetSelection();
    TextLCAUtil.resetVerifyAndModifyListener();
    TextLCAUtil.resetSelectionListener();
    TextLCAUtil.resetTextLimit();
    TextLCAUtil.resetReadOnly();
    TextLCAUtil.resetText();
    ControlLCAUtil.resetChanges();
    ControlLCAUtil.resetStyleFlags();
  }
}





final class MultiTextLCA extends AbstractTextDelegateLCA {

  static final String TYPE_POOL_ID = MultiTextLCA.class.getName();

  void preserveValues( final Text text ) {
    ControlLCAUtil.preserveValues( text );
    TextLCAUtil.preserveValues( text );

    writer.dispose();
  }

  String getTypePoolId( final Text text ) {
    return TYPE_POOL_ID;
  }

  void createResetHandlerCalls( final String typePoolId ) throws IOException {
    TextLCAUtil.resetVerifyAndModifyListener();
    TextLCAUtil.resetTextLimit();
    TextLCAUtil.resetReadOnly();
    TextLCAUtil.resetText();
    ControlLCAUtil.resetChanges();
    ControlLCAUtil.resetStyleFlags();
  }
}





final class PasswordTextLCA extends AbstractTextDelegateLCA {

  static final String TYPE_POOL_ID = PasswordTextLCA.class.getName();

  void preserveValues( final Text text ) {
    ControlLCAUtil.preserveValues( text );
    TextLCAUtil.preserveValues( text );

    writer.dispose();
  }

  String getTypePoolId( final Text text ) {
    return TYPE_POOL_ID;
  }

  void createResetHandlerCalls( final String typePoolId ) throws IOException {
    TextLCAUtil.resetVerifyAndModifyListener();
    TextLCAUtil.resetSelectionListener();
    TextLCAUtil.resetSelection();
    TextLCAUtil.resetTextLimit();
    TextLCAUtil.resetReadOnly();
    TextLCAUtil.resetText();
    ControlLCAUtil.resetChanges();
    ControlLCAUtil.resetStyleFlags();
  }
}




    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId ) throws IOException {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }

  public Rectangle adjustCoordinates( final Widget widget,
                                      final Rectangle bounds )
  {

    return result;
  }

//  public Rectangle adjustCoordinates( final Rectangle bounds ) {
//    int border = 1;
//    int hTabBar = 23;
//    return new Rectangle( bounds.x - border - 10,
//                          bounds.y - hTabBar - border -10,
//                          bounds.width,
//                          bounds.height );
//  }


  //////////////////////////////////////
  // Helping methods to write properties





public final class ShellLCA extends AbstractWidgetLCA {

  private static final String QX_TYPE = "org.eclipse.swt.widgets.Shell";
//  private static final String TYPE_POOL_ID = ShellLCA.class.getName();

  private static final String PROP_TEXT = "text";
  private static final String PROP_IMAGE = "image";

    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.call( "removeState", new Object[]{ "rwt_TITLE" } );
    // TODO [rst] If this is ever being reactivated, all Shell style-flag states
    //            must be removed
    writer.set( "parentShell", ( Object )null );
    ControlLCAUtil.resetStyleFlags();
    ControlLCAUtil.resetResizeNotificator();
    ControlLCAUtil.resetMoveNotificator();
    // TODO [rh] reset close listener when shell pooling is activated
    ControlLCAUtil.resetBounds();
    ControlLCAUtil.resetZIndex();
    ControlLCAUtil.resetToolTip();
  }

  public String getTypePoolId( final Widget widget ) {
//    return TYPE_POOL_ID;
    return null;
  }

  //////////////////
  // Helping methods





    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
    ControlLCAUtil.resetStyleFlags();
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }


  ////////////////////////////////////
  // Helping methods to preserve state





public class CompositeLCA extends AbstractWidgetLCA {

  private static final String QX_TYPE = "qx.ui.layout.CanvasLayout";
//  private static final String TYPE_POOL_ID = CompositeLCA.class.getName();

  public void preserveValues( final Widget widget ) {
    ControlLCAUtil.preserveValues( ( Control )widget );

    JSWriter writer = JSWriter.getWriterFor( widget );
    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
    ControlLCAUtil.resetChanges();
    ControlLCAUtil.resetStyleFlags();
  }

  public String getTypePoolId( final Widget widget ) {
    // TODO [rh] disabled pooling, see
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=203499
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=204107
//    return TYPE_POOL_ID;
    return null;
  }
}




    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }

  public Rectangle adjustCoordinates( final Widget widget,
                                      final Rectangle newBounds )
  {




    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }

  //////////////////
  // Helping methods





    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {    
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }

  //////////////////
  // Helping methods
  private void writeMaximum( final Slider slider ) throws IOException {





import java.io.IOException;
import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;

import javax.servlet.http.HttpServletRequest;

import org.eclipse.rwt.internal.util.HTML;
import org.eclipse.rwt.lifecycle.*;
import org.eclipse.rwt.resources.IResource;
import org.eclipse.rwt.service.ISessionStore;
import org.eclipse.swt.events.TypedEvent;
import org.eclipse.swt.graphics.Device;
import org.eclipse.swt.graphics.Rectangle;

  private final static String PATTERN_REQUEST_COUNTER
    =   "var req = org.eclipse.swt.Request.getInstance();"
      + "req.setRequestCounter( \"{0,number,#}\" );";
  private static final String DISPOSE_HANDLER_REGISTRY
    = "org.eclipse.rap.disposeHandlerRegistry";
  private static final JSVar DISPOSE_HANDLER_START
    = new JSVar( "function( " + JSWriter.WIDGET_REF + " ) {" );

  private static final String CLIENT_LOG_LEVEL
    = "org.eclipse.rwt.clientLogLevel";


  private static void disposeWidgets() throws IOException {
    Widget[] disposedWidgets = DisposedWidgets.getAll();
    // TODO [rst] since widget pooling is removed, the loop should be reverted
    //            again
    // [fappel]: client side disposal order is crucial for the widget
    //           caching mechanism - we need to dispose of children first. This
    //           is reverse to the server side mechanism (which is analog to

    for( int i = disposedWidgets.length - 1; i >= 0; i-- ) {
      Widget toDispose = disposedWidgets[ i ];
      AbstractWidgetLCA lca = WidgetUtil.getLCA( toDispose );

      Set disposeHandler = getAlreadyRegisteredHandlers();
      String key = lca.getTypePoolId( toDispose );
      if( key != null && !disposeHandler.contains( key ) ) {
        JSWriter writer = JSWriter.getWriterFor( toDispose );
        Object[] params = new Object[] {
          new Integer( key.hashCode() ),
          DISPOSE_HANDLER_START
        };
        writer.startCall( JSWriter.WIDGET_MANAGER_REF,
                          "registerResetHandler",
                          params );
        try {
          lca.createResetHandlerCalls( key );
        } finally {
          writer.endCall( new Object[] { new JSVar( "}" ) } );
          disposeHandler.add( key );
        }
      }

      lca.renderDispose( toDispose );
    }
  }

  private static Set getAlreadyRegisteredHandlers() {
    ISessionStore session = ContextProvider.getSession();
    Set result = ( Set )session.getAttribute( DISPOSE_HANDLER_REGISTRY );
    if( result == null ) {
      result = new HashSet();
      session.setAttribute( DISPOSE_HANDLER_REGISTRY, result );
    }
    return result;
  }

  private static void writeScriptTag( final HtmlResponseWriter out,
                                      final String library )
    throws IOException




    writer.dispose();
  }

  ////////////////////////////////////
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }

  // /////////////////////////////////
  // Helping methods to write changes
  private void writeShowItem( final TreeItem item ) throws IOException {
    Tree tree = item.getParent();




    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }

  private static void writeText( final CLabel label ) throws IOException {
    String text = label.getText();
    if( WidgetLCAUtil.hasChanged( label, PROP_TEXT, text, "" ) ) {




    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId ) 
    throws IOException 
  {
  }
  
  public String getTypePoolId( final Widget widget ) {
    return null;
  }
  
  private static MenuDelegateLCA getDelegateLCA( final Widget widget ) {
    MenuDelegateLCA result;
    Menu menu = ( Menu )widget;




  private static final String QX_TYPE
    = "org.eclipse.swt.custom.ScrolledComposite";

//  private static final String TYPE_POOL_ID
//    = ScrolledCompositeLCA.class.getName();

  private static final Integer ZERO = new Integer( 0 );

  // Request parameter names

    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException 
  {
    ControlLCAUtil.resetChanges();
    resetClipBounds();
    resetScrollBars();
    resetBarSelection();
    ControlLCAUtil.resetStyleFlags();
  }

  public String getTypePoolId( final Widget widget ) {
    // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=226651
//  return TYPE_POOL_ID;
  return null;
  }


  ///////////////////////////////////
  // Helping methods to write changes


    writer.set( PROP_OVERFLOW, "overflow", overflow, null );
  }

  private static void resetScrollBars() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( "overflow" );
  }

  private static void writeBarSelection( final ScrolledComposite composite )
    throws IOException
  {

    }
  }

  private static void resetBarSelection() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.set( "hBarSelection", 0 );
    writer.set( "vBarSelection", 0 );
  }

  private static void writeClipBounds( final ScrolledComposite composite )
    throws IOException
  {

    }
  }

  private static void resetClipBounds() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( "clipWidth" );
    writer.reset( "clipHeight" );
  }

  private static String getOverflow( final ScrolledComposite composite ) {
    String result;
    ScrollBar horizontalBar = composite.getHorizontalBar();




    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.call( "removeAll", null );
  }

  public String getTypePoolId( final Widget widget ) {
//    TODO [rst] Enable pooling when re-parenting problems with
//               qx.ui.form.ComboBox are solved
//    return TYPE_POOL_ID;
    return null;
  }

  ///////////////////////////////////////
  // Helping methods to read client state





    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }

  public static IExpandBarAdapter getExpandBarAdapter( final ExpandBar bar ) {
    return ( IExpandBarAdapter )bar.getAdapter( IExpandBarAdapter.class );
  }

Lines 55-65 Link Here

(-)src/org/eclipse/swt/internal/widgets/coolbarkit/CoolBarLCA.java (-7 lines)
55	JSWriter writer = JSWriter.getWriterFor( widget );	55	JSWriter writer = JSWriter.getWriterFor( widget );
56	writer.dispose();	56	writer.dispose();
57	}	57	}
58
59	public void createResetHandlerCalls( final String typePoolId ) throws IOException {
60	}
61
62	public String getTypePoolId( final Widget widget ) {
63	return null;
64	}
65	}	58	}




    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }

  ////////////////
  // Event helper





    writer.dispose();
  }
  
  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }

  private static void writeState( final ProgressBar progressBar )
    throws IOException
  {




    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }


  //////////////////////////////////////////
  // Helping method to write JavaScript code





    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }


  ////////////////////////////////////////////
  // Helping methods to render JavaScript code





    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId ) 
    throws IOException 
  {
  }
  
  public String getTypePoolId( final Widget widget ) {
    return null;
  }
  

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




    writer.dispose();
  }
  
  public void createResetHandlerCalls( final String typePoolId ) 
    throws IOException 
  {
  }
  
  public String getTypePoolId( final Widget widget ) {
    return null;
  }
}




    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }

  public void doRedrawFake( final Control control ) {
    Table table = ( Table )control;
    Object adapter = table.getAdapter( ITableAdapter.class );




    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId ) throws IOException {
  }
  
  public String getTypePoolId( final Widget widget ) {
    return null;
  }
  
  private static ToolItemDelegateLCA getLCADelegate( final Widget widget ) {
    ToolItemDelegateLCA result;
    int style = ( ( ToolItem )widget ).getStyle();




    getDelegateLCA( menuItem ).renderDispose( menuItem );
  }
  
  public void createResetHandlerCalls( final String typePoolId ) 
    throws IOException 
  {
  }
  
  public String getTypePoolId( final Widget widget ) {
    return null;
  }
  
  private static boolean isTopLevelMenuBarItem( final MenuItem menuItem ) {
    return ( menuItem.getParent().getStyle() & SWT.BAR ) != 0;
  }




  public void renderDispose( final Widget widget ) throws IOException {
    // do nothing
  }
  
  public void createResetHandlerCalls( final String typePoolId ) throws IOException {
    // do nothing
  }
  
  public String getTypePoolId( final Widget widget ) {
    // do nothing
    return null;
  }
}





  private static final String QX_TYPE = "org.eclipse.swt.widgets.Sash";

//  private static final String TYPE_POOL_ID = SashLCA.class.getName();

  public void preserveValues( final Widget widget ) {
    ControlLCAUtil.preserveValues( ( Control )widget );
    IWidgetAdapter adapter = WidgetUtil.getAdapter( widget );

    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
    ControlLCAUtil.resetChanges();
    ControlLCAUtil.resetStyleFlags();
  }

  public String getTypePoolId( final Widget widget ) {
//    return TYPE_POOL_ID;
    // TODO [bm] disabled due to cursor problems
    return null;
  }
}




    JSWriter writer = JSWriter.getWriterFor( widget );
    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId ) throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( "legend" );
    ControlLCAUtil.resetStyleFlags();
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }
}




    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.call( "removeAll", null );
  }

  public String getTypePoolId( final Widget widget ) {
    return null;
  }

  ///////////////////////////////////////
  // Helping methods to read client state





    getDelegate( widget ).renderDispose( ( DateTime )widget );
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
  }

  public String getTypePoolId( final Widget widget ) {
    // TODO [rh] disabled pooling, see bugs prefixed with [pooling]
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=204107
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=199142
    // return getDelegate( widget ).getTypePoolId( ( DateTime )widget );
    return null;
  }

  private static AbstractDateTimeLCADelegate getDelegate( final Widget widget )
  {
    AbstractDateTimeLCADelegate result;




public final class SpinnerLCA extends AbstractWidgetLCA {

  private static final String QX_TYPE = "org.eclipse.swt.widgets.Spinner";
//  private static final String TYPE_POOL_ID = SpinnerLCA.class.getName();

  private static final Integer DEFAULT_TEXT_LIMIT
    = new Integer( Spinner.LIMIT );

    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
    ControlLCAUtil.resetStyleFlags();
    resetReadOnly();
    resetValues();
  }

  public String getTypePoolId( final Widget widget ) {
    // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=226651
//  return TYPE_POOL_ID;
    return null;
  }

  //////////////////////////////////////
  // Helping methods to write JavaScript


    }
  }

  private static void resetValues() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
//    TODO [rst] Missing resetters in QX_TYPE, discuss with qooxdoo
//    writer.reset( "min" );
//    writer.reset( "max" );
    writer.reset( "incrementAmount" );
    writer.reset( "pageIncrementAmount" );
    writer.reset( "value" );
  }

  private static void writeSetInt( final JSWriter writer,
                                   final String javaProperty,
                                   final String jsProperty,

    writer.set( JSConst.QX_FIELD_EDITABLE, !readOnly );
  }

  private static void resetReadOnly() throws IOException {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( JSConst.QX_FIELD_EDITABLE );
  }

  private static void writeWrap( final Spinner spinner ) throws IOException {
    if( ( spinner.getStyle() & SWT.WRAP ) != 0 ) {
      JSWriter writer = JSWriter.getWriterFor( spinner );




  construct : function() {
    this.base( arguments );
    this.setMarkLeadingItem( true );
    // Should changeSelection events passed to the server-side?
    // state == no, action == yes
    this._changeSelectionNotification = "state";
    this._topIndex = 0;
    var selMgr = this.getManager();
    selMgr.addEventListener( "changeLeadItem", this._onChangeLeadItem, this );
    selMgr.addEventListener( "changeSelection", this._onSelectionChange, this );
    this.addEventListener( "focus", this._onFocusIn, this );
    this.addEventListener( "blur", this._onFocusOut, this );
    this.addEventListener( "click", this._onClick, this );
    this.addEventListener( "dblclick", this._onDblClick, this );
    this.addEventListener( "appear", this._onAppear, this );
    // Listen to send event of request to report topIndex
    var req = org.eclipse.swt.Request.getInstance();
    req.addEventListener( "send", this._onSendRequest, this );
  },
  
  destruct : function() {
    var req = org.eclipse.swt.Request.getInstance();
    req.removeEventListener( "send", this._onSendRequest, this );
    var selMgr = this.getManager();
    selMgr.removeEventListener( "changeLeadItem", this._onChangeLeadItem, this );
    selMgr.removeEventListener( "changeSelection", this._onSelectionChange, this );
    this.removeEventListener( "focus", this._onFocusIn, this );
    this.removeEventListener( "blur", this._onFocusOut, this );
    this.removeEventListener( "click", this._onClick, this );
    this.removeEventListener( "dblclick", this._onDblClick, this );
    this.removeEventListener( "appear", this._onAppear, this );
  },

  members : {
    
    // TODO [rst] Move parameter to constructor and delete this method
    init : function( multiSelection ) {
      var manager = this.getManager();
      manager.setMultiSelection( multiSelection );
    },
    
    rap_init : function( multiSelection ) {
      // Should changeSelection events passed to the server-side?
      // state == no, action == yes
      this._changeSelectionNotification = "state";
      this._topIndex = 0;
      var selMgr = this.getManager();
      selMgr.addEventListener( "changeLeadItem", this._onChangeLeadItem, this );
      selMgr.addEventListener( "changeSelection", this._onSelectionChange, this );
      this.addEventListener( "focus", this._onFocusIn, this );
      this.addEventListener( "blur", this._onFocusOut, this );
      this.addEventListener( "click", this._onClick, this );
      this.addEventListener( "dblclick", this._onDblClick, this );
      this.addEventListener( "appear", this._onAppear, this );
      // Listen to send event of request to report topIndex
      var req = org.eclipse.swt.Request.getInstance();
      req.addEventListener( "send", this._onSendRequest, this );
    },
    
    rap_reset : function() {
      var req = org.eclipse.swt.Request.getInstance();
      req.removeEventListener( "send", this._onSendRequest, this );
      var selMgr = this.getManager();
      selMgr.removeEventListener( "changeLeadItem", this._onChangeLeadItem, this );
      selMgr.removeEventListener( "changeSelection", this._onSelectionChange, this );
      this.removeEventListener( "focus", this._onFocusIn, this );
      this.removeEventListener( "blur", this._onFocusOut, this );
      this.removeEventListener( "click", this._onClick, this );
      this.removeEventListener( "dblclick", this._onDblClick, this );
      this.removeEventListener( "appear", this._onAppear, this );
    },
    
    /** Sets the given array of items. */
    setItems : function( items ) {
      // preserve selection and focused item




    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
    ControlLCAUtil.resetStyleFlags();
  }

  public String getTypePoolId( final Widget widget ) {
    // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=226651
//    return TYPE_POOL_ID;
    return null;
  }

  private static void writeSelectionListener( final Link link )
    throws IOException
  {





  private static final String PARAM_EXECUTE_RESULT = "executeResult";

//  private static final String TYPE_POOL_ID = BrowserLCA.class.getName();

  private static final String PROP_URL = "url";
  private static final String PROP_TEXT = "text";


    writer.dispose();
  }

  public void createResetHandlerCalls( final String typePoolId )
    throws IOException
  {
    JSWriter writer = JSWriter.getWriterForResetHandler();
    writer.reset( QX_FIELD_SOURCE );
    ControlLCAUtil.resetStyleFlags();
  }

  public String getTypePoolId( final Widget widget ) {
    // TODO [rh] Disabled pooling. In IE7, using Browser#setText() does not 
    //      work when widget was pooled. The previous content is displayed.
//    return TYPE_POOL_ID;
    return null;
  }

  private static void writeUrl( final Browser browser ) 
    throws IOException 
  {

Return to bug 281909

Lines 102-117 Link Here

(-)src/org/eclipse/rwt/lifecycle/JSWriter_Test.java (-69 / +20 lines)
102	String expected	102	String expected
103	= "var wm = org.eclipse.swt.WidgetManager.getInstance();"	103	= "var wm = org.eclipse.swt.WidgetManager.getInstance();"
104	+ "var w = wm.newWidget( \"w2\", \"w3\", true, "	104	+ "var w = wm.newWidget( \"w2\", \"w3\", true, "
105	+ getTypePoolIdHash( shell.button )	105	+ "\"qx.ui.form.Button\" );";
106	+ ", \"qx.ui.form.Button\" );";
107	assertEquals( expected, Fixture.getAllMarkup() );	106	assertEquals( expected, Fixture.getAllMarkup() );
108	// ensure that the WidgetManager, once initialized, is not initialized	107	// ensure that the WidgetManager, once initialized, is not initialized
109	// twice	108	// twice
110	writer = JSWriter.getWriterFor( shell.button );	109	writer = JSWriter.getWriterFor( shell.button );
111	writer.newWidget( "qx.ui.form.Button" );	110	writer.newWidget( "qx.ui.form.Button" );
112	expected += "var w = wm.newWidget( \"w2\", \"w3\", true, "	111	expected += "var w = wm.newWidget( \"w2\", \"w3\", true, "
113	+ getTypePoolIdHash( shell.button )	112	+ "\"qx.ui.form.Button\" );";
114	+ ", \"qx.ui.form.Button\" );";
115	assertEquals( expected, Fixture.getAllMarkup() );	113	assertEquals( expected, Fixture.getAllMarkup() );
116	// ensure that obtaining the widget reference (var w =) is only rendered	114	// ensure that obtaining the widget reference (var w =) is only rendered
117	// once	115	// once
Lines 121-131 Link Here
121	display.dispose();	119	display.dispose();
122	}	120	}
123		121
124	private String getTypePoolId( final Widget widget ) {
125	AbstractWidgetLCA lca = WidgetUtil.getLCA( widget );
126	return lca.getTypePoolId( widget );
127	}
128
129	public void testNewWidget() throws Exception {	122	public void testNewWidget() throws Exception {
130	Display display = new Display();	123	Display display = new Display();
131	TestShell shell = new TestShell( display );	124	TestShell shell = new TestShell( display );
Lines 134-141 Link Here
134	String expected	127	String expected
135	= "var wm = org.eclipse.swt.WidgetManager.getInstance();"	128	= "var wm = org.eclipse.swt.WidgetManager.getInstance();"
136	+ "var w = wm.newWidget( \"w2\", \"w3\", true, "	129	+ "var w = wm.newWidget( \"w2\", \"w3\", true, "
137	+ getTypePoolIdHash( shell.button )	130	+ "\"qx.ui.form.Button\" );";
138	+ ", \"qx.ui.form.Button\" );";
139	assertEquals( expected, Fixture.getAllMarkup() );	131	assertEquals( expected, Fixture.getAllMarkup() );
140	// Ensures that the "widget reference is set"-flag is set	132	// Ensures that the "widget reference is set"-flag is set
141	Fixture.fakeResponseWriter();	133	Fixture.fakeResponseWriter();
Lines 144-199 Link Here
144	assertEquals( expected, Fixture.getAllMarkup() );	136	assertEquals( expected, Fixture.getAllMarkup() );
145	display.dispose();	137	display.dispose();
146	}	138	}
147
148	public void testNewWidgetWithTypePoolId() throws IOException {
149	Display display = new Display();
150	TestShell shell = new TestShell( display );
151	Widget widget = new Widget( shell, SWT.NONE ) {
152	public Object getAdapter( final Class adapter ) {
153	Object result;
154	if( adapter == ILifeCycleAdapter.class ) {
155	result = new AbstractWidgetLCA() {
156
157	public void preserveValues( Widget widget ) {
158	}
159
160	public void renderChanges( Widget widget ) throws IOException {
161	}
162
163	public void renderDispose( Widget widget ) throws IOException {
164	}
165
166	public void renderInitialization( Widget widget )
167	throws IOException
168	{
169	}
170
171	public void readData( Widget widget ) {
172	}
173	public String getTypePoolId( Widget widget ) {
174	return "myWidgetPoolId";
175	}
176
177	};
178	} else {
179	result = super.getAdapter( adapter );
180	}
181	return result;
182	}
183	};
184	JSWriter writer = JSWriter.getWriterFor( widget );
185	writer.newWidget( "qx.ui.widget" );
186	String expected
187	= "var wm = org.eclipse.swt.WidgetManager.getInstance();"
188	+ "var w = wm.newWidget( \"w2\", \"\", false, 767544711, "
189	+ "\"qx.ui.widget\" );";
190	assertEquals( expected, Fixture.getAllMarkup() );
191	}
192
193	private String getTypePoolIdHash( final Widget widget ) {
194	String id = getTypePoolId( widget );
195	return id == null ? null : String.valueOf( id.hashCode() );
196	}
197		139
198	public void testNewWidgetWithParams() throws Exception {	140	public void testNewWidgetWithParams() throws Exception {
199	Display display = new Display();	141	Display display = new Display();
Lines 207-214 Link Here
207	String expected	149	String expected
208	= "var wm = org.eclipse.swt.WidgetManager.getInstance();"	150	= "var wm = org.eclipse.swt.WidgetManager.getInstance();"
209	+ "var w = wm.newWidget( \"w2\", \"w3\", true, "	151	+ "var w = wm.newWidget( \"w2\", \"w3\", true, "
210	+ getTypePoolIdHash( shell.button )	152	+ "\"qx.ui.form.Button\", '\"abc\", [\"#ff0000\" ]' );";
211	+ ", \"qx.ui.form.Button\", '\"abc\", [\"#ff0000\" ]' );";
212	assertEquals( expected, Fixture.getAllMarkup() );	153	assertEquals( expected, Fixture.getAllMarkup() );
213	// Ensures that the "widget reference is set"-flag is set	154	// Ensures that the "widget reference is set"-flag is set
214	Fixture.fakeResponseWriter();	155	Fixture.fakeResponseWriter();
Lines 222-244 Link Here
222	writer.newWidget( "TreeItem", null );	163	writer.newWidget( "TreeItem", null );
223	expected	164	expected
224	= "var w = wm.newWidget( \"w4\", \"\", false, "	165	= "var w = wm.newWidget( \"w4\", \"\", false, "
225	+ getTypePoolIdHash( item )	166	+ "\"TreeItem\" );";
226	+ ", \"TreeItem\" );";
227	assertEquals( expected, Fixture.getAllMarkup() );	167	assertEquals( expected, Fixture.getAllMarkup() );
228	}	168	}
229		169
230	public void testResetJSProperty() throws IOException {	170	public void testResetJSProperty() throws IOException {
231	JSWriter writer = JSWriter.getWriterForResetHandler();	171	Display display = new Display();
		172	Shell shell = new Shell( display );
		173	JSWriter writer = JSWriter.getWriterFor( shell );
232	Fixture.fakeResponseWriter();	174	Fixture.fakeResponseWriter();
233	writer.reset( "testProperty" );	175	writer.reset( "testProperty" );
234	assertEquals( "w.resetTestProperty();", Fixture.getAllMarkup() );	176	String expected = "var wm = org.eclipse.swt.WidgetManager.getInstance();"
		177	+ "var w = wm.findWidgetById( \""
		178	+ WidgetUtil.getId( shell )
		179	+ "\" );w.resetTestProperty();";
		180	assertEquals( expected, Fixture.getAllMarkup() );
235	}	181	}
236		182
237	public void testResetJSPropertyChain() throws IOException {	183	public void testResetJSPropertyChain() throws IOException {
238	JSWriter writer = JSWriter.getWriterForResetHandler();	184	Display display = new Display();
		185	Shell shell = new Shell( display );
		186	JSWriter writer = JSWriter.getWriterFor( shell );
239	Fixture.fakeResponseWriter();	187	Fixture.fakeResponseWriter();
240	writer.reset( new String[] { "labelObject", "testProperty" } );	188	writer.reset( new String[] { "labelObject", "testProperty" } );
241	String expected = "w.getLabelObject().resetTestProperty();";	189	String expected = "var wm = org.eclipse.swt.WidgetManager.getInstance();"
		190	+ "var w = wm.findWidgetById( \""
		191	+ WidgetUtil.getId( shell )
		192	+ "\" );w.getLabelObject().resetTestProperty();";
242	assertEquals( expected, Fixture.getAllMarkup() );	193	assertEquals( expected, Fixture.getAllMarkup() );
243	}	194	}
244		195

Lines 129-135 Link Here

(-)src/org/eclipse/rwt/lifecycle/WidgetLCAUtil_Test.java (-44 / +2 lines)
129	assertFalse( WidgetLCAUtil.equals( new Date[] { new Date( 3 ) }, null ) );	129	assertFalse( WidgetLCAUtil.equals( new Date[] { new Date( 3 ) }, null ) );
130	}	130	}
131		131
132	public void testEscapeText() throws Exception {	132	public void testEscapeText() {
133	// Empty Parameter	133	// Empty Parameter
134	try {	134	try {
135	WidgetLCAUtil.escapeText( null, true );	135	WidgetLCAUtil.escapeText( null, true );
Lines 177-183 Link Here
177	assertEquals( expected, WidgetLCAUtil.escapeText( "Test\\", false ) );	177	assertEquals( expected, WidgetLCAUtil.escapeText( "Test\\", false ) );
178	}	178	}
179		179
180	public void testTruncateZeros() throws Exception {	180	public void testTruncateZeros() {
181	assertEquals( ( char )0, "\000".charAt( 0 ) );	181	assertEquals( ( char )0, "\000".charAt( 0 ) );
182	assertEquals( "foo ", WidgetLCAUtil.escapeText( "foo \000 bar", false ) );	182	assertEquals( "foo ", WidgetLCAUtil.escapeText( "foo \000 bar", false ) );
183	assertEquals( "foo", WidgetLCAUtil.escapeText( "foo\000", false ) );	183	assertEquals( "foo", WidgetLCAUtil.escapeText( "foo\000", false ) );
Lines 429-477 Link Here
429	WidgetLCAUtil.writeBackground( control, red );	429	WidgetLCAUtil.writeBackground( control, red );
430	assertEquals( "", Fixture.getAllMarkup() );	430	assertEquals( "", Fixture.getAllMarkup() );
431	}	431	}
432
433	public void testResetCalls() throws IOException {
434	Fixture.fakeResponseWriter();
435	WidgetLCAUtil.resetBounds();
436	String expected
437	= "w.resetClipWidth();w.resetClipHeight();w.setSpace( 0, 0, 0, 0 );";
438	assertEquals( expected, Fixture.getAllMarkup() );
439
440	Fixture.fakeResponseWriter();
441	WidgetLCAUtil.resetMenu();
442	expected
443	= "w.resetContextMenu();w.removeEventListener( \"contextmenu\", "
444	+ "org.eclipse.swt.MenuUtil.contextMenu );";
445	assertEquals( expected, Fixture.getAllMarkup() );
446		432
447	Fixture.fakeResponseWriter();
448	WidgetLCAUtil.resetToolTip();
449	expected = "wm.setToolTip( w );";
450	assertEquals( expected, Fixture.getAllMarkup() );
451
452	Fixture.fakeResponseWriter();
453	WidgetLCAUtil.resetFont();
454	expected = "w.resetFont();";
455	assertEquals( expected, Fixture.getAllMarkup() );
456
457	Fixture.fakeResponseWriter();
458	WidgetLCAUtil.resetForeground();
459	expected
460	= "w.resetTextColor();w.removeEventListener( \"appear\", "
461	+ "org.eclipse.swt.WidgetManager._onAppearSetForeground );";
462	assertEquals( expected, Fixture.getAllMarkup() );
463
464	Fixture.fakeResponseWriter();
465	WidgetLCAUtil.resetBackground();
466	expected = "w.resetBackgroundColor();";
467	assertEquals( expected, Fixture.getAllMarkup() );
468
469	Fixture.fakeResponseWriter();
470	WidgetLCAUtil.resetEnabled();
471	expected = "w.setEnabled( true );";
472	assertEquals( expected, Fixture.getAllMarkup() );
473	}
474
475	public void testWriteMenu() throws IOException {	433	public void testWriteMenu() throws IOException {
476	Display display = new Display();	434	Display display = new Display();
477	Composite shell = new Shell( display , SWT.NONE );	435	Composite shell = new Shell( display , SWT.NONE );

Lines 116-122 Link Here

(-)src/org/eclipse/rwt/internal/lifecycle/PreserveWidgetsPhaseListener_Test.java (-8 / +1 lines)
116	Fixture.removeContext();	116	Fixture.removeContext();
117	}	117	}
118		118
119	public void testExecutionOrder() throws Exception {	119	public void testExecutionOrder() {
120	// Build test environment:	120	// Build test environment:
121	final StringBuffer log = new StringBuffer();	121	final StringBuffer log = new StringBuffer();
122	Fixture.fakeResponseWriter();	122	Fixture.fakeResponseWriter();
Lines 167-179 Link Here
167	public void renderDispose( final Widget widget ) throws IOException	167	public void renderDispose( final Widget widget ) throws IOException
168	{	168	{
169	}	169	}
170	public void createResetHandlerCalls( final String typePoolId )
171	throws IOException
172	{
173	}
174	public String getTypePoolId( final Widget widget ) {
175	return null;
176	}
177	};	170	};
178	}	171	}
179	return result;	172	return result;

Lines 43-49 Link Here

(-)src/org/eclipse/swt/internal/widgets/displaykit/DisplayLCA_Test.java (-17 / +1 lines)
43	private final List renderInitLog = new ArrayList();	43	private final List renderInitLog = new ArrayList();
44	private final List renderChangesLog = new ArrayList();	44	private final List renderChangesLog = new ArrayList();
45	private final List renderDisposeLog = new ArrayList();	45	private final List renderDisposeLog = new ArrayList();
46	private final List renderDisposeHandlerRegistration = new ArrayList();
47		46
48	private final class DisposeTestButton extends Button {	47	private final class DisposeTestButton extends Button {
49		48
Lines 145-151 Link Here
145	assertEquals( new Rectangle( 0, 0, 30, 70 ), display.getBounds() );	144	assertEquals( new Rectangle( 0, 0, 30, 70 ), display.getBounds() );
146	}	145	}
147		146
148	public void testRrenderChangedButDisposed() {	147	public void testRenderChangedButDisposed() {
149	Display display = new Display();	148	Display display = new Display();
150	Shell shell = new Shell( display, SWT.NONE );	149	Shell shell = new Shell( display, SWT.NONE );
151	final Button button = new DisposeTestButton( shell, SWT.PUSH );	150	final Button button = new DisposeTestButton( shell, SWT.PUSH );
Lines 173-186 Link Here
173	} );	172	} );
174	RWTFixture.fakeNewRequest();	173	RWTFixture.fakeNewRequest();
175	Fixture.fakeRequestParam( RequestParams.UIROOT, displayId );	174	Fixture.fakeRequestParam( RequestParams.UIROOT, displayId );
176	Fixture.fakeRequestParam( RequestParams.UIROOT, displayId );
177	Fixture.fakeRequestParam( JSConst.EVENT_WIDGET_SELECTED, buttonId );	175	Fixture.fakeRequestParam( JSConst.EVENT_WIDGET_SELECTED, buttonId );
178	RWTFixture.executeLifeCycleFromServerThread( );	176	RWTFixture.executeLifeCycleFromServerThread( );
179		177
180	assertEquals( 0, renderInitLog.size() );	178	assertEquals( 0, renderInitLog.size() );
181	assertFalse( renderChangesLog.contains( button ) );	179	assertFalse( renderChangesLog.contains( button ) );
182	assertTrue( renderDisposeLog.contains( button ) );	180	assertTrue( renderDisposeLog.contains( button ) );
183	assertFalse( renderDisposeHandlerRegistration.isEmpty() );
184		181
185	clearLogs();	182	clearLogs();
186	button2.addSelectionListener( new SelectionAdapter() {	183	button2.addSelectionListener( new SelectionAdapter() {
Lines 198-204 Link Here
198	assertEquals( 0, renderInitLog.size() );	195	assertEquals( 0, renderInitLog.size() );
199	assertFalse( renderChangesLog.contains( button2 ) );	196	assertFalse( renderChangesLog.contains( button2 ) );
200	assertTrue( renderDisposeLog.contains( button2 ) );	197	assertTrue( renderDisposeLog.contains( button2 ) );
201	assertFalse( renderDisposeHandlerRegistration.contains( button2 ) );
202		198
203	clearLogs();	199	clearLogs();
204	button3.addSelectionListener( new SelectionAdapter() {	200	button3.addSelectionListener( new SelectionAdapter() {
Lines 216-222 Link Here
216	assertEquals( 0, renderInitLog.size() );	212	assertEquals( 0, renderInitLog.size() );
217	assertFalse( renderChangesLog.contains( button3 ) );	213	assertFalse( renderChangesLog.contains( button3 ) );
218	assertTrue( renderDisposeLog.contains( button3 ) );	214	assertTrue( renderDisposeLog.contains( button3 ) );
219	assertFalse( renderDisposeHandlerRegistration.isEmpty() );
220	}	215	}
221		216
222	public void testIsInitializedState() throws IOException {	217	public void testIsInitializedState() throws IOException {
Lines 341-356 Link Here
341	}	336	}
342		337
343		338
344	public String getTypePoolId( final Widget widget ) {
345	return getClass().getName() + "_" + widget.getStyle();
346	}
347
348	public void createResetHandlerCalls( final String typePoolId )
349	throws IOException
350	{
351	renderDisposeHandlerRegistration.add( typePoolId );
352	}
353
354	public void renderDispose( final Widget widget ) throws IOException	339	public void renderDispose( final Widget widget ) throws IOException
355	{	340	{
356	renderDisposeLog.add( widget );	341	renderDisposeLog.add( widget );
Lines 392-397 Link Here
392	renderInitLog.clear();	377	renderInitLog.clear();
393	renderChangesLog.clear();	378	renderChangesLog.clear();
394	renderDisposeLog.clear();	379	renderDisposeLog.clear();
395	renderDisposeHandlerRegistration.clear();
396	}	380	}
397	}	381	}

Lines 103-113 Link Here

(-)src/org/eclipse/rwt/lifecycle/JSWriter.java (-19 / +6 lines)
103	}	103	}
104		104
105	/**	105	/**
106	* Returns the {@link JSWriter} instance used to reset	106	* Returns the {@link JSWriter} instance used to reset a widgets attributes in
107	* a widgets attributes in order to take part in the	107	* order to take part in the pooling mechanism.
108	* pooling mechanism.	108	*
109	*
110	* @return the {@link JSWriter} instance	109	* @return the {@link JSWriter} instance
		110	* @deprecated As of 1.3, server-side widget pooling is no longer required.
		111	* This method should not be used anymore.
111	*/	112	*/
112	public static JSWriter getWriterForResetHandler() {	113	public static JSWriter getWriterForResetHandler() {
113	return new JSWriter( null );	114	return new JSWriter( null );
Lines 148-154 Link Here
148	throws IOException	149	throws IOException
149	{	150	{
150	ensureWidgetManager();	151	ensureWidgetManager();
151	String typePoolId = getTypePoolId( widget );
152	StringBuffer buffer = new StringBuffer();	152	StringBuffer buffer = new StringBuffer();
153	buffer.append( "var w = wm.newWidget( \"" );	153	buffer.append( "var w = wm.newWidget( \"" );
154	buffer.append( WidgetUtil.getId( widget ) );	154	buffer.append( WidgetUtil.getId( widget ) );
Lines 156-165 Link Here
156	buffer.append( getJSParentId( widget ) );	156	buffer.append( getJSParentId( widget ) );
157	buffer.append( "\", " );	157	buffer.append( "\", " );
158	buffer.append( useSetParent() );	158	buffer.append( useSetParent() );
159	buffer.append( ", " );
160	Integer poolIdHashCode
161	= typePoolId == null ? null : new Integer( typePoolId.hashCode() );
162	buffer.append( poolIdHashCode );
163	buffer.append( ", \"" );	159	buffer.append( ", \"" );
164	buffer.append( className );	160	buffer.append( className );
165	buffer.append( "\"" );	161	buffer.append( "\"" );
Lines 656-668 Link Here
656		652
657	/**	653	/**
658	* Dispose is used to dispose of the widget of this {@link JSWriter} on the	654	* Dispose is used to dispose of the widget of this {@link JSWriter} on the
659	* client side. As todays browser have several memory issues this will only	655	* client side.
660	* dispose of the widget if there are no pooling informations available.
661	*	656	*
662	* @throws IOException if an I/O error occurs	657	* @throws IOException if an I/O error occurs
663	*
664	* @see AbstractWidgetLCA#getTypePoolId(Widget)
665	* @see AbstractWidgetLCA#createResetHandlerCalls(String)
666	*/	658	*/
667	public void dispose() throws IOException {	659	public void dispose() throws IOException {
668	ensureWidgetManager();	660	ensureWidgetManager();
Lines 753-763 Link Here
753	: Boolean.FALSE;	745	: Boolean.FALSE;
754	}	746	}
755		747
756	private String getTypePoolId( final Widget widget ) {
757	AbstractWidgetLCA lca = WidgetUtil.getLCA( widget );
758	return lca.getTypePoolId( widget );
759	}
760
761	private String getJSParentId( final Widget widget ) {	748	private String getJSParentId( final Widget widget ) {
762	String result = "";	749	String result = "";
763	if( !( widget instanceof Shell ) && widget instanceof Control ) {	750	if( !( widget instanceof Shell ) && widget instanceof Control ) {

Lines 50-64 Link Here

(-)rap/org/eclipse/ui/forms/internal/widgets/hyperlinkkit/HyperlinkLCA.java (-9 lines)
50	"org.eclipse.ui.forms.widgets.Hyperlink.onClick", //$NON-NLS-1$	50	"org.eclipse.ui.forms.widgets.Hyperlink.onClick", //$NON-NLS-1$
51	JSListenerType.ACTION );	51	JSListenerType.ACTION );
52		52
53	public void createResetHandlerCalls( final String typePoolId )
54	throws IOException
55	{
56	}
57
58	public String getTypePoolId( final Widget widget ) {
59	return null;
60	}
61
62	public void readData( final Widget widget ) {	53	public void readData( final Widget widget ) {
63	ControlLCAUtil.processSelection( widget, null, false );	54	ControlLCAUtil.processSelection( widget, null, false );
64	WidgetLCAUtil.processHelp( widget );	55	WidgetLCAUtil.processHelp( widget );

Lines 65-77 Link Here

(-)src/org/eclipse/swt/internal/custom/ctabfolderkit/CTabFolderLCA_Test.java (-7 lines)
65	}	65	}
66	public void renderDispose( final Widget widget ) throws IOException {	66	public void renderDispose( final Widget widget ) throws IOException {
67	}	67	}
68	public void createResetHandlerCalls( final String typePoolId )
69	throws IOException
70	{
71	}
72	public String getTypePoolId( final Widget widget ) {
73	return null;
74	}
75	public void renderInitialization( final Widget widget )	68	public void renderInitialization( final Widget widget )
76	throws IOException	69	throws IOException
77	{	70	{

Lines 91-107 Link Here

(-)src/org/eclipse/rwt/lifecycle/AbstractWidgetLCA.java (-6 / +6 lines)
91	* code has been processed the client-side widget should be in a state that is	91	* code has been processed the client-side widget should be in a state that is
92	* equivalent to a newly created widget.	92	* equivalent to a newly created widget.
93	* </p>	93	* </p>
94	*
95	* <p>	94	* <p>
96	* Subclasses should override this method if pooling is supported by the	95	* Subclasses should override this method if pooling is supported by the
97	* widget type this LCA belongs to. To activate pooling override	96	* widget type this LCA belongs to. To activate pooling override
98	* {@link #getTypePoolId(Widget)}.	97	* {@link #getTypePoolId(Widget)}.
99	* </p>	98	* </p>
100	*	99	*
101	* @see #getTypePoolId(Widget)	100	* @see #getTypePoolId(Widget)
102	*
103	* @param typePoolId the type pool id of the widget to reset	101	* @param typePoolId the type pool id of the widget to reset
104	* @throws IOException	102	* @throws IOException
		103	* @deprecated As of 1.3, server-side widget pooling is no longer required.
		104	* This method is not called anymore.
105	*/	105	*/
106	public void createResetHandlerCalls( final String typePoolId )	106	public void createResetHandlerCalls( final String typePoolId )
107	throws IOException	107	throws IOException
Lines 123-140 Link Here
123	* suffix. If this method returns <code>null</code>, the widget will not be	123	* suffix. If this method returns <code>null</code>, the widget will not be
124	* stored in the widget pool and cannot be reused.	124	* stored in the widget pool and cannot be reused.
125	* </p>	125	* </p>
126	*
127	* <p>	126	* <p>
128	* Subclasses may override to activate pooling. In case pooling is activated	127	* Subclasses may override to activate pooling. In case pooling is activated
129	* the method {@link #createResetHandlerCalls(String)} should also be	128	* the method {@link #createResetHandlerCalls(String)} should also be
130	* overridden.	129	* overridden.
131	* </p>	130	* </p>
132	*	131	*
133	* @see #createResetHandlerCalls(String)	132	* @see #createResetHandlerCalls(String)
134	*
135	* @param widget the widget to store in the pool	133	* @param widget the widget to store in the pool
136	* @return the type pool id or <code>null</code> if the widget should not be	134	* @return the type pool id or <code>null</code> if the widget should not be
137	* pooled	135	* pooled
		136	* @deprecated As of 1.3, server-side widget pooling is no longer required.
		137	* This method is not called anymore.
138	*/	138	*/
139	public String getTypePoolId( final Widget widget ) {	139	public String getTypePoolId( final Widget widget ) {
140	return null;	140	return null;

Lines 84-96 Link Here

(-)src/org/eclipse/swt/widgets/ToolBar.java (-7 / +5 lines)
84	public ToolBar( final Composite parent, final int style ) {	84	public ToolBar( final Composite parent, final int style ) {
85	super( parent, checkStyle( style ) );	85	super( parent, checkStyle( style ) );
86	/*	86	/*
87	* Ensure that either of HORIZONTAL or VERTICAL is set.	87	* Ensure that either of HORIZONTAL or VERTICAL is set. NOTE: HORIZONTAL and
88	* NOTE: HORIZONTAL and VERTICAL have the same values	88	* VERTICAL have the same values as H_SCROLL and V_SCROLL so it is necessary
89	* as H_SCROLL and V_SCROLL so it is necessary to first	89	* to first clear these bits to avoid scroll bars and then reset the bits
90	* clear these bits to avoid scroll bars and then reset	90	* using the original style supplied by the programmer.
91	* the bits using the original style supplied by the	91	*/
92	* programmer.
93	*/
94	if( ( style & SWT.VERTICAL ) != 0 ) {	92	if( ( style & SWT.VERTICAL ) != 0 ) {
95	this.style \|= SWT.VERTICAL;	93	this.style \|= SWT.VERTICAL;
96	} else {	94	} else {

Lines 11-21 Link Here

(-)src/org/eclipse/swt/internal/widgets/labelkit/LabelLCA.java (-28 / +2 lines)
11	package org.eclipse.swt.internal.widgets.labelkit;	11	package org.eclipse.swt.internal.widgets.labelkit;
12		12
13	import java.io.IOException;	13	import java.io.IOException;
14	import java.text.MessageFormat;
15		14
16	import org.eclipse.rwt.lifecycle.AbstractWidgetLCA;	15	import org.eclipse.rwt.lifecycle.AbstractWidgetLCA;
17	import org.eclipse.swt.SWT;	16	import org.eclipse.swt.SWT;
18	import org.eclipse.swt.widgets.*;	17	import org.eclipse.swt.widgets.Label;
		18	import org.eclipse.swt.widgets.Widget;
19		19
20		20
21	public class LabelLCA extends AbstractWidgetLCA {	21	public class LabelLCA extends AbstractWidgetLCA {
Lines 45-76 Link Here
45	getDelegate( widget ).renderDispose( ( Label )widget );	45	getDelegate( widget ).renderDispose( ( Label )widget );
46	}	46	}
47		47
48	public void createResetHandlerCalls( final String typePoolId ) throws IOException {
49	getDelegate( typePoolId ).createResetHandlerCalls( typePoolId );
50	}
51
52	public String getTypePoolId( final Widget widget ) {
53	// TODO [rh] disabled pooling, see bugs prefixed with [pooling]
54	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=204107
55	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=199142
56	// return getDelegate( widget ).getTypePoolId( ( Label )widget );
57	return null;
58	}
59
60	private static AbstractLabelLCADelegate getDelegate( final String tpId ) {
61	AbstractLabelLCADelegate result;
62	if( tpId.startsWith( SeparatorLabelLCA.TYPE_POOL_ID) ) {
63	result = SEPARATOR_LCA;
64	} else if( tpId.startsWith( StandardLabelLCA.TYPE_POOL_ID ) ) {
65	result = LABEL_LCA;
66	} else {
67	String txt= "The typePoolId ''{0}'' is not supported.";
68	String msg = MessageFormat.format( txt, new Object[] { tpId } );
69	throw new IllegalArgumentException( msg );
70	}
71	return result;
72	}
73
74	private static AbstractLabelLCADelegate getDelegate( final Widget widget ) {	48	private static AbstractLabelLCADelegate getDelegate( final Widget widget ) {
75	AbstractLabelLCADelegate result;	49	AbstractLabelLCADelegate result;
76	if( ( widget.getStyle() & SWT.SEPARATOR ) != 0 ) {	50	if( ( widget.getStyle() & SWT.SEPARATOR ) != 0 ) {

Lines 23-35 Link Here

(-)src/org/eclipse/swt/internal/widgets/labelkit/SeparatorLabelLCA.java (-19 lines)
23		23
24	private static final String QX_TYPE = "org.eclipse.swt.widgets.Separator";	24	private static final String QX_TYPE = "org.eclipse.swt.widgets.Separator";
25	private static final String JS_FUNC_ADD_LINE_STYLE = "addLineStyle";	25	private static final String JS_FUNC_ADD_LINE_STYLE = "addLineStyle";
26	private static final String JS_FUNC_REMOVE_LINE_STYLE = "removeLineStyle";
27	private static final String JS_FIELD_LINE_ORIENTATION = "lineOrientation";	26	private static final String JS_FIELD_LINE_ORIENTATION = "lineOrientation";
28	private static final Object[] PARAM_SHADOW_IN	27	private static final Object[] PARAM_SHADOW_IN
29	= new Object[] { JSConst.JS_STYLE_FLAG_SHADOW_IN };	28	= new Object[] { JSConst.JS_STYLE_FLAG_SHADOW_IN };
30	private static final Object[] PARAM_SHADOW_OUT	29	private static final Object[] PARAM_SHADOW_OUT
31	= new Object[] { JSConst.JS_STYLE_FLAG_SHADOW_OUT };	30	= new Object[] { JSConst.JS_STYLE_FLAG_SHADOW_OUT };
32	static final String TYPE_POOL_ID = SeparatorLabelLCA.class.getName();
33		31
34	void preserveValues( final Label label ) {	32	void preserveValues( final Label label ) {
35	ControlLCAUtil.preserveValues( label );	33	ControlLCAUtil.preserveValues( label );
Lines 59-74 Link Here
59	writer.dispose();	57	writer.dispose();
60	}	58	}
61		59
62	void createResetHandlerCalls( final String typePoolId ) throws IOException {
63	ControlLCAUtil.resetChanges();
64	ControlLCAUtil.resetStyleFlags();
65	resetStyle();
66	}
67
68	String getTypePoolId( final Label label ) {
69	return TYPE_POOL_ID;
70	}
71
72	private static void writeStyle( final Label label ) throws IOException {	60	private static void writeStyle( final Label label ) throws IOException {
73	JSWriter writer = JSWriter.getWriterFor( label );	61	JSWriter writer = JSWriter.getWriterFor( label );
74	int style = label.getStyle();	62	int style = label.getStyle();
Lines 80-90 Link Here
80	writer.call( JS_FUNC_ADD_LINE_STYLE, PARAM_SHADOW_OUT );	68	writer.call( JS_FUNC_ADD_LINE_STYLE, PARAM_SHADOW_OUT );
81	}	69	}
82	}	70	}
83
84	private static void resetStyle() throws IOException {
85	JSWriter writer = JSWriter.getWriterForResetHandler();
86	writer.call( JS_FUNC_REMOVE_LINE_STYLE, PARAM_SHADOW_IN );
87	writer.call( JS_FUNC_REMOVE_LINE_STYLE, PARAM_SHADOW_OUT );
88	writer.reset( JS_FIELD_LINE_ORIENTATION );
89	}
90	}	71	}

Lines 23-29 Link Here

(-)src/org/eclipse/swt/internal/widgets/labelkit/StandardLabelLCA.java (-31 lines)
23	public class StandardLabelLCA extends AbstractLabelLCADelegate {	23	public class StandardLabelLCA extends AbstractLabelLCADelegate {
24		24
25	private static final String QX_TYPE = "qx.ui.basic.Atom";	25	private static final String QX_TYPE = "qx.ui.basic.Atom";
26	static final String TYPE_POOL_ID = StandardLabelLCA.class.getName();
27		26
28	private static final String PROP_TEXT = "text";	27	private static final String PROP_TEXT = "text";
29	private static final String PROP_ALIGNMENT = "alignment";	28	private static final String PROP_ALIGNMENT = "alignment";
Lines 77-94 Link Here
77	writer.dispose();	76	writer.dispose();
78	}	77	}
79		78
80	void createResetHandlerCalls( final String typePoolId ) throws IOException {
81	resetAlignment();
82	resetText();
83	resetImage();
84	ControlLCAUtil.resetChanges();
85	ControlLCAUtil.resetStyleFlags();
86	}
87
88	String getTypePoolId( final Label label ) {
89	return TYPE_POOL_ID;
90	}
91
92	//////////////////////////////////////	79	//////////////////////////////////////
93	// Helping methods to write JavaScript	80	// Helping methods to write JavaScript
94		81
Lines 103-114 Link Here
103	}	90	}
104	}	91	}
105		92
106	private static void resetText() throws IOException {
107	JSWriter writer = JSWriter.getWriterForResetHandler();
108	Object[] args = new Object[]{ JSWriter.WIDGET_REF, null };
109	writer.callStatic( JS_FUNC_LABEL_UTIL_SET_TEXT, args );
110	}
111
112	private static void writeImage( final Label label ) throws IOException {	93	private static void writeImage( final Label label ) throws IOException {
113	Image image = label.getImage();	94	Image image = label.getImage();
114	if( WidgetLCAUtil.hasChanged( label, Props.IMAGE, image, null ) )	95	if( WidgetLCAUtil.hasChanged( label, Props.IMAGE, image, null ) )
Lines 126-137 Link Here
126	}	107	}
127	}	108	}
128		109
129	private static void resetImage() throws IOException {
130	JSWriter writer = JSWriter.getWriterForResetHandler();
131	Object[] args = new Object[]{ JSWriter.WIDGET_REF, null };
132	writer.callStatic( JS_FUNC_LABEL_UTIL_SET_IMAGE, args );
133	}
134
135	private static void writeAlignment( final Label label ) throws IOException {	110	private static void writeAlignment( final Label label ) throws IOException {
136	Integer alignment = new Integer( label.getAlignment() );	111	Integer alignment = new Integer( label.getAlignment() );
137	Integer defValue = DEFAULT_ALIGNMENT;	112	Integer defValue = DEFAULT_ALIGNMENT;
Lines 145-156 Link Here
145	}	120	}
146	}	121	}
147		122
148	private static void resetAlignment() throws IOException {
149	JSWriter writer = JSWriter.getWriterForResetHandler();
150	writer.reset( "horizontalChildrenAlign" );
151	writer.reset( new String[] { "labelObject", "textAlign" } );
152	}
153
154	private static String getAlignment( final int alignment ) {	123	private static String getAlignment( final int alignment ) {
155	String result;	124	String result;
156	if( ( alignment & SWT.LEFT ) != 0 ) {	125	if( ( alignment & SWT.LEFT ) != 0 ) {

Lines 41-48 Link Here

(-)src/org/eclipse/rwt/lifecycle/WidgetLCAUtil.java (-106 / +94 lines)
41		41
42	private static final String JS_PROP_HEIGHT = "height";	42	private static final String JS_PROP_HEIGHT = "height";
43	private static final String JS_PROP_WIDTH = "width";	43	private static final String JS_PROP_WIDTH = "width";
44	private static final String JS_PROP_CLIP_WIDTH = "clipWidth";
45	private static final String JS_PROP_CLIP_HEIGHT = "clipHeight";
46	private static final String PARAM_X = "bounds.x";	44	private static final String PARAM_X = "bounds.x";
47	private static final String PARAM_Y = "bounds.y";	45	private static final String PARAM_Y = "bounds.y";
48	private static final String PARAM_WIDTH = "bounds.width";	46	private static final String PARAM_WIDTH = "bounds.width";
Lines 446-466 Link Here
446	}	444	}
447		445
448	/**	446	/**
449	* Writes JavaScript code to the response that resets the bounds of a widget.
450	* This method is intended to be used by implementations of the method
451	* {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
452	*
453	* @throws IOException
454	*/
455	public static void resetBounds() throws IOException {
456	JSWriter writer = JSWriter.getWriterForResetHandler();
457	writer.reset( JS_PROP_CLIP_WIDTH );
458	writer.reset( JS_PROP_CLIP_HEIGHT );
459	writer.set( JS_PROP_SPACE, new int[] { 0, 0, 0, 0 } );
460	}
461
462
463	/**
464	* Determines whether the property <code>menu</code> of the given widget has	447	* Determines whether the property <code>menu</code> of the given widget has
465	* changed during the processing of the current request and if so, writes	448	* changed during the processing of the current request and if so, writes
466	* JavaScript code to the response that updates the client-side menu property	449	* JavaScript code to the response that updates the client-side menu property
Lines 488-508 Link Here
488	}	471	}
489		472
490	/**	473	/**
491	* Writes JavaScript code to the response that resets the property
492	* <code>menu</code> of a widget. This method is intended to be used by
493	* implementations of the method
494	* {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
495	*
496	* @throws IOException
497	*/
498	public static void resetMenu() throws IOException {
499	JSWriter writer = JSWriter.getWriterForResetHandler();
500	writer.reset( JS_PROP_CONTEXT_MENU );
501	writer.removeListener( JSConst.QX_EVENT_CONTEXTMENU,
502	JSConst.JS_CONTEXT_MENU );
503	}
504
505	/**
506	* Determines whether the property <code>toolTip</code> of the given widget	474	* Determines whether the property <code>toolTip</code> of the given widget
507	* has changed during the processing of the current request and if so, writes	475	* has changed during the processing of the current request and if so, writes
508	* JavaScript code to the response that updates the client-side toolTip	476	* JavaScript code to the response that updates the client-side toolTip
Lines 531-555 Link Here
531	}	499	}
532		500
533	/**	501	/**
534	* Writes JavaScript code to the response that resets the property
535	* <code>toolTip</code> of a widget. This method is intended to be used by
536	* implementations of the method
537	* {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
538	*
539	* @throws IOException
540	*/
541	public static void resetToolTip() throws IOException {
542	JSWriter writer = JSWriter.getWriterForResetHandler();
543	writer.call( JSWriter.WIDGET_MANAGER_REF,
544	JS_FUNC_SET_TOOL_TIP,
545	new Object[] { JSWriter.WIDGET_REF } );
546	}
547
548
549	/////////////////////////////////////////////////
550	// write-methods used by other ...LCAUtil classes
551
552	/**
553	* Determines whether the property <code>image</code> of the given widget	502	* Determines whether the property <code>image</code> of the given widget
554	* has changed during the processing of the current request and if so, writes	503	* has changed during the processing of the current request and if so, writes
555	* JavaScript code to the response that updates the client-side image property	504	* JavaScript code to the response that updates the client-side image property
Lines 659-677 Link Here
659	}	608	}
660		609
661	/**	610	/**
662	* Writes JavaScript code to the response that resets the property
663	* <code>font</code> of a widget. This method is intended to be used by
664	* implementations of the method
665	* {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
666	*
667	* @throws IOException
668	*/
669	public static void resetFont() throws IOException {
670	JSWriter writer = JSWriter.getWriterForResetHandler();
671	writer.reset( JSConst.QX_FIELD_FONT );
672	}
673
674	/**
675	* Determines whether the property <code>foreground</code> of the given	611	* Determines whether the property <code>foreground</code> of the given
676	* widget has changed during the processing of the current request and if so,	612	* widget has changed during the processing of the current request and if so,
677	* writes JavaScript code to the response that updates the client-side	613	* writes JavaScript code to the response that updates the client-side
Lines 699-719 Link Here
699	}	635	}
700		636
701	/**	637	/**
702	* Writes JavaScript code to the response that resets the property
703	* <code>foreground</code> of a widget. This method is intended to be used
704	* by implementations of the method
705	* {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
706	*
707	* @throws IOException
708	*/
709	public static void resetForeground() throws IOException {
710	JSWriter writer = JSWriter.getWriterForResetHandler();
711	writer.reset( "textColor" );
712	String listener = "org.eclipse.swt.WidgetManager._onAppearSetForeground";
713	writer.removeListener( "appear", listener );
714	}
715
716	/**
717	* Determines whether the property <code>background</code> of the given	638	* Determines whether the property <code>background</code> of the given
718	* widget has changed during the processing of the current request and if so,	639	* widget has changed during the processing of the current request and if so,
719	* writes JavaScript code to the response that updates the client-side	640	* writes JavaScript code to the response that updates the client-side
Lines 774-792 Link Here
774	}	695	}
775		696
776	/**	697	/**
777	* Writes JavaScript code to the response that reset the property
778	* <code>background</code> of a widget. This method is intended to be used
779	* by implementations of the method
780	* {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
781	*
782	* @throws IOException
783	*/
784	public static void resetBackground() throws IOException {
785	JSWriter writer = JSWriter.getWriterForResetHandler();
786	writer.reset( JSConst.QX_FIELD_BG_COLOR );
787	}
788
789	/**
790	* Determines whether the background gradient properties of the	698	* Determines whether the background gradient properties of the
791	* given widget has changed during the processing of the current request and	699	* given widget has changed during the processing of the current request and
792	* if so, writes JavaScript code to the response that updates the client-side	700	* if so, writes JavaScript code to the response that updates the client-side
Lines 908-927 Link Here
908		816
909		817
910	/**	818	/**
911	* Writes JavaScript code to the response that resets the property
912	* <code>enabled</code> of a widget. This method is intended to be used by
913	* implementations of the method
914	* {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
915	*
916	* @throws IOException
917	*/
918	public static void resetEnabled() throws IOException {
919	JSWriter writer = JSWriter.getWriterForResetHandler();
920	// TODO [fappel]: check whether to use reset
921	writer.set( JSConst.QX_FIELD_ENABLED, true );
922	}
923
924	/**
925	* Replaces all newline characters in the specified input string with the	819	* Replaces all newline characters in the specified input string with the
926	* given replacement string.	820	* given replacement string.
927	*	821	*
Lines 1178-1181 Link Here
1178	}	1072	}
1179	return result;	1073	return result;
1180	}	1074	}
		1075
		1076
		1077	/////////////////////////////////////
		1078	// deprecated pooling-related methods
		1079
		1080	/**
		1081	* Writes JavaScript code to the response that resets the bounds of a widget.
		1082	* This method is intended to be used by implementations of the method
		1083	* {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
		1084	*
		1085	* @throws IOException
		1086	* @deprecated As of 1.3, server-side widget pooling is no longer required.
		1087	* This method does nothing.
		1088	*/
		1089	public static void resetBounds() throws IOException {
		1090	}
		1091
		1092	/**
		1093	* Writes JavaScript code to the response that resets the property
		1094	* <code>menu</code> of a widget. This method is intended to be used by
		1095	* implementations of the method
		1096	* {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
		1097	*
		1098	* @throws IOException
		1099	* @deprecated As of 1.3, server-side widget pooling is no longer required.
		1100	* This method does nothing.
		1101	*/
		1102	public static void resetMenu() throws IOException {
		1103	}
		1104
		1105	/**
		1106	* Writes JavaScript code to the response that resets the property
		1107	* <code>toolTip</code> of a widget. This method is intended to be used by
		1108	* implementations of the method
		1109	* {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
		1110	*
		1111	* @throws IOException
		1112	* @deprecated As of 1.3, server-side widget pooling is no longer required.
		1113	* This method does nothing.
		1114	*/
		1115	public static void resetToolTip() throws IOException {
		1116	}
		1117
		1118	/**
		1119	* Writes JavaScript code to the response that resets the property
		1120	* <code>font</code> of a widget. This method is intended to be used by
		1121	* implementations of the method
		1122	* {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
		1123	*
		1124	* @throws IOException
		1125	* @deprecated As of 1.3, server-side widget pooling is no longer required.
		1126	* This method does nothing.
		1127	*/
		1128	public static void resetFont() throws IOException {
		1129	}
		1130
		1131	/**
		1132	* Writes JavaScript code to the response that resets the property
		1133	* <code>foreground</code> of a widget. This method is intended to be used
		1134	* by implementations of the method
		1135	* {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
		1136	*
		1137	* @throws IOException
		1138	* @deprecated As of 1.3, server-side widget pooling is no longer required.
1139	* This method does nothing.
1140	*/
1141	public static void resetForeground() throws IOException {
1142	}
1143
1144	/**
1145	* Writes JavaScript code to the response that reset the property
1146	* <code>background</code> of a widget. This method is intended to be used
1147	* by implementations of the method
1148	* {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
1149	*
1150	* @throws IOException
1151	* @deprecated As of 1.3, server-side widget pooling is no longer required.
1152	* This method does nothing.
1153	*/
1154	public static void resetBackground() throws IOException {
1155	}
1156
1157	/**
1158	* Writes JavaScript code to the response that resets the property
1159	* <code>enabled</code> of a widget. This method is intended to be used by
1160	* implementations of the method
1161	* {@link AbstractWidgetLCA#createResetHandlerCalls(String)}.
1162	*
1163	* @throws IOException
1164	* @deprecated As of 1.3, server-side widget pooling is no longer required.
1165	* This method does nothing.
1166	*/
1167	public static void resetEnabled() throws IOException {
1168	}
1181	}	1169	}

Lines 20-27 Link Here

(-)src/org/eclipse/swt/internal/widgets/buttonkit/PushButtonDelegateLCA.java (-9 lines)
20		20
21	final class PushButtonDelegateLCA extends ButtonDelegateLCA {	21	final class PushButtonDelegateLCA extends ButtonDelegateLCA {
22		22
23	static final String TYPE_POOL_ID
24	= PushButtonDelegateLCA.class.getName();
25	private static final String QX_TYPE = "org.eclipse.rwt.widgets.Button";	23	private static final String QX_TYPE = "org.eclipse.rwt.widgets.Button";
26		24
27	private static final Object[] PARAM_PUSH = new Object[] { "push" };	25	private static final Object[] PARAM_PUSH = new Object[] { "push" };
Lines 59-69 Link Here
59	JSWriter writer = JSWriter.getWriterFor( button );	57	JSWriter writer = JSWriter.getWriterFor( button );
60	writer.dispose();	58	writer.dispose();
61	}	59	}
62
63	String getTypePoolId( final Button button ) {
64	return null;
65	}
66
67	void createResetHandlerCalls( final String typePoolId ) throws IOException {
68	}
69	}	60	}

Lines 20-27 Link Here

(-)src/org/eclipse/swt/internal/widgets/buttonkit/CheckButtonDelegateLCA.java (-16 lines)
20		20
21	final class CheckButtonDelegateLCA extends ButtonDelegateLCA {	21	final class CheckButtonDelegateLCA extends ButtonDelegateLCA {
22		22
23	static final String TYPE_POOL_ID
24	= CheckButtonDelegateLCA.class.getName();
25	private static final String QX_TYPE = "org.eclipse.rwt.widgets.Button";	23	private static final String QX_TYPE = "org.eclipse.rwt.widgets.Button";
26	private static final Object[] PARAM_CHECK = new Object[] { "check" };	24	private static final Object[] PARAM_CHECK = new Object[] { "check" };
27		25
Lines 63-82 Link Here
63	writer.dispose();	61	writer.dispose();
64	}	62	}
65		63
66	String getTypePoolId( final Button button ) {
67	// Disabled pooling, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=226099
68	// return TYPE_POOL_ID;
69	return null;
70	}
71
72	void createResetHandlerCalls( final String typePoolId ) throws IOException {
73	ButtonLCAUtil.resetAlignment();
74	ButtonLCAUtil.resetText();
75	ButtonLCAUtil.resetSelection();
76	ControlLCAUtil.resetChanges();
77	ControlLCAUtil.resetStyleFlags();
78	}
79
80	private static void writeGrayed( final Button button ) throws IOException {	64	private static void writeGrayed( final Button button ) throws IOException {
81	Boolean newValue = Boolean.valueOf( button.getGrayed() );	65	Boolean newValue = Boolean.valueOf( button.getGrayed() );
82	String prop = PROP_GRAYED;	66	String prop = PROP_GRAYED;

Lines 22-29 Link Here

(-)src/org/eclipse/swt/internal/widgets/buttonkit/RadioButtonDelegateLCA.java (-21 lines)
22		22
23	final class RadioButtonDelegateLCA extends ButtonDelegateLCA {	23	final class RadioButtonDelegateLCA extends ButtonDelegateLCA {
24		24
25	static final String TYPE_POOL_ID
26	= RadioButtonDelegateLCA.class.getName();
27	private static final String QX_TYPE = "org.eclipse.rwt.widgets.Button";	25	private static final String QX_TYPE = "org.eclipse.rwt.widgets.Button";
28	private static final Object[] PARAM_RADIO = new Object[] { "radio" };	26	private static final Object[] PARAM_RADIO = new Object[] { "radio" };
29		27
Lines 60-84 Link Here
60	writer.dispose();	58	writer.dispose();
61	}	59	}
62		60
63	String getTypePoolId( final Button button ) {
64	// return TYPE_POOL_ID;
65	return null;
66	}
67
68	void createResetHandlerCalls( final String typePoolId ) throws IOException {
69	// TODO [fappel]: check why removal of listener doesn't work. Seems as if
70	// manager is removed already (maybe dispose call?)...
71	// JSWriter writer = JSWriter.getWriterForResetHandler();
72	// writer.removeListener( JS_PROP_MANAGER,
73	// JS_LISTENER_INFO.getEventType(),
74	// JS_LISTENER_INFO.getJSListener() );
75	ButtonLCAUtil.resetAlignment();
76	ButtonLCAUtil.resetText();
77	ButtonLCAUtil.resetSelection();
78	ControlLCAUtil.resetChanges();
79	ControlLCAUtil.resetStyleFlags();
80	}
81
82	private static void processSelectionEvent( final Button button ) {	61	private static void processSelectionEvent( final Button button ) {
83	if( SelectionEvent.hasListener( button ) ) {	62	if( SelectionEvent.hasListener( button ) ) {
84	int type = SelectionEvent.WIDGET_SELECTED;	63	int type = SelectionEvent.WIDGET_SELECTED;

Lines 76-87 Link Here

(-)src/org/eclipse/swt/internal/widgets/buttonkit/ButtonLCAUtil.java (-21 lines)
76	}	76	}
77	}	77	}
78		78
79	static void resetText() throws IOException {
80	JSWriter writer = JSWriter.getWriterForResetHandler();
81	// Note [fappel]: reset doesn't work, so use setting to empty string
82	writer.set( "text", new Object[]{ null } );
83	}
84
85	static void writeImage( final Button button ) throws IOException {	79	static void writeImage( final Button button ) throws IOException {
86	Image image = button.getImage();	80	Image image = button.getImage();
87	if( WidgetLCAUtil.hasChanged( button, Props.IMAGE, image, null ) ) {	81	if( WidgetLCAUtil.hasChanged( button, Props.IMAGE, image, null ) ) {
Lines 97-107 Link Here
97	}	91	}
98	}	92	}
99		93
100	static void resetImage() throws IOException {
101	JSWriter writer = JSWriter.getWriterForResetHandler();
102	writer.set( "image", new Object[]{ null } );
103	}
104
105	static void writeAlignment( final Button button ) throws IOException {	94	static void writeAlignment( final Button button ) throws IOException {
106	if( ( button.getStyle() & SWT.ARROW ) == 0 ) {	95	if( ( button.getStyle() & SWT.ARROW ) == 0 ) {
107	Integer newValue = new Integer( button.getAlignment() );	96	Integer newValue = new Integer( button.getAlignment() );
Lines 129-150 Link Here
129	}	118	}
130	}	119	}
131		120
132	static void resetAlignment() throws IOException {
133	JSWriter writer = JSWriter.getWriterForResetHandler();
134	writer.reset( JS_PROP_HORIZONTAL_CHILDREN_ALIGN );
135	}
136
137	static void writeSelection( final Button button ) throws IOException {	121	static void writeSelection( final Button button ) throws IOException {
138	Boolean newValue = Boolean.valueOf( button.getSelection() );	122	Boolean newValue = Boolean.valueOf( button.getSelection() );
139	JSWriter writer = JSWriter.getWriterFor( button );	123	JSWriter writer = JSWriter.getWriterFor( button );
140	writer.set( PROP_SELECTION, JS_PROP_SELECTION, newValue, Boolean.FALSE );	124	writer.set( PROP_SELECTION, JS_PROP_SELECTION, newValue, Boolean.FALSE );
141	}	125	}
142		126
143	static void resetSelection() throws IOException {
144	JSWriter writer = JSWriter.getWriterForResetHandler();
145	writer.set( JS_PROP_SELECTION, Boolean.FALSE );
146	}
147
148	// TODO [rst] Can this be moved to ShellLCA ?	127	// TODO [rst] Can this be moved to ShellLCA ?
149	static void writeDefault( final Button button ) throws IOException {	128	static void writeDefault( final Button button ) throws IOException {
150	boolean isDefault = isDefaultButton( button );	129	boolean isDefault = isDefaultButton( button );

Lines 24-54 Link Here

(-)js/org/eclipse/swt/LabelUtil.js (-35 / +23 lines)
24	initialize : function( widget ) {	24	initialize : function( widget ) {
25		25
26	widget.setHorizontalChildrenAlign( qx.constant.Layout.ALIGN_LEFT );	26	widget.setHorizontalChildrenAlign( qx.constant.Layout.ALIGN_LEFT );
27	if( !widget.getUserData( "pooled" ) ) {	27	widget.setVerticalChildrenAlign( qx.constant.Layout.ALIGN_TOP );
28	widget.setVerticalChildrenAlign( qx.constant.Layout.ALIGN_TOP );	28	widget.setAppearance( org.eclipse.swt.LabelUtil.APPEARANCE );
29	widget.setAppearance( org.eclipse.swt.LabelUtil.APPEARANCE );	29	widget.setOverflow( qx.constant.Style.OVERFLOW_HIDDEN );
30	widget.setOverflow( qx.constant.Style.OVERFLOW_HIDDEN );	30	// TODO [rh] workaround for weird getLabelObject behaviour
31	// TODO [rh] workaround for weird getLabelObject behaviour	31	widget.setLabel( "(empty)" );
32	widget.setLabel( "(empty)" );	32	// end workaround
33	// end workaround	33	var labelObject = widget.getLabelObject();
34	var labelObject = widget.getLabelObject();	34	labelObject.setMode( qx.constant.Style.LABEL_MODE_HTML );
35	labelObject.setMode( qx.constant.Style.LABEL_MODE_HTML );	35	labelObject.setTextOverflow( false );
36	labelObject.setTextOverflow( false );	36	labelObject.setAppearance( "label-graytext" );
37	labelObject.setAppearance( "label-graytext" );	37	// TODO [rh] workaround for weird getLabelObject behaviour
38	// TODO [rh] workaround for weird getLabelObject behaviour	38	widget.setLabel( "" );
39	widget.setLabel( "" );	39	// end workaround
40	// end workaround	40	widget.setHideFocus( true );
41	widget.setHideFocus( true );	41	// track DOM insertion state
42	// track DOM insertion state	42	widget.addEventListener( "beforeRemoveDom",
43	widget.addEventListener( "beforeRemoveDom",	43	org.eclipse.swt.LabelUtil._onRemoveDom );
44	org.eclipse.swt.LabelUtil._onRemoveDom );	44	widget.addEventListener( "insertDom",
45	widget.addEventListener( "insertDom",	45	org.eclipse.swt.LabelUtil._onInsertDom );
46	org.eclipse.swt.LabelUtil._onInsertDom );	46	widget.addEventListener( "mouseover",
47	widget.addEventListener( "mouseover",	47	org.eclipse.swt.LabelUtil._onMouseOver );
48	org.eclipse.swt.LabelUtil._onMouseOver );	48	widget.addEventListener( "mouseout",
49	widget.addEventListener( "mouseout",	49	org.eclipse.swt.LabelUtil._onMouseOut );
50	org.eclipse.swt.LabelUtil._onMouseOut );
51	}
52	},	50	},
53		51
54	_onRemoveDom : function( evt ) {	52	_onRemoveDom : function( evt ) {
Lines 75-86 Link Here
75	widget.setUserData( "setText", text );	73	widget.setUserData( "setText", text );
76	widget.addEventListener( "appear",	74	widget.addEventListener( "appear",
77	org.eclipse.swt.LabelUtil._setTextDelayed );	75	org.eclipse.swt.LabelUtil._setTextDelayed );
78	}
79	// workaround for pooling problems
80	else if( !widget._isInDOM && widget.getUserData( "pooled" ) ) {
81	widget.setUserData( "setText", text );
82	widget.addEventListener( "insertDom",
83	org.eclipse.swt.LabelUtil._setTextDelayed );
84	} else {	76	} else {
85	org.eclipse.swt.LabelUtil._doSetText( widget, text );	77	org.eclipse.swt.LabelUtil._doSetText( widget, text );
86	}	78	}
Lines 91-100 Link Here
91	widget.setUserData( "setImage", imagePath );	83	widget.setUserData( "setImage", imagePath );
92	widget.addEventListener( "appear",	84	widget.addEventListener( "appear",
93	org.eclipse.swt.LabelUtil._setImageDelayed );	85	org.eclipse.swt.LabelUtil._setImageDelayed );
94	} else if( !widget._isInDOM && widget.getUserData( "pooled" ) ) {
95	widget.setUserData( "setImage", imagePath );
96	widget.addEventListener( "insertDom",
97	org.eclipse.swt.LabelUtil._setImageDelayed );
98	} else {	86	} else {
99	org.eclipse.swt.LabelUtil._doSetImage( widget, imagePath );	87	org.eclipse.swt.LabelUtil._doSetImage( widget, imagePath );
100	}	88	}

Lines 24-31 Link Here

(-)js/org/eclipse/swt/WidgetManager.js (-82 / +9 lines)
24	// Key: id (string), value: widget instanace (qx.ui.core.Widget)	24	// Key: id (string), value: widget instanace (qx.ui.core.Widget)
25	this._map = {};	25	this._map = {};
26		26
27	// initialize widget pool
28	this._widgetPool = new Object();
29	// this field is needed as Opera has some problems with	27	// this field is needed as Opera has some problems with
30	// accessing local variables in eval expressions.	28	// accessing local variables in eval expressions.
31	this._current = null;	29	this._current = null;
Lines 52-60 Link Here
52	* removed from this WidgetManager (see remove).	50	* removed from this WidgetManager (see remove).
53	* No action is taken if there is no widget registered for the given id or	51	* No action is taken if there is no widget registered for the given id or
54	* the widget was already disposed of.	52	* the widget was already disposed of.
55	* In case of a widget type that supports pooling the widget is disconnected
56	* from its parent, its 'disposeHandler' that reinitializes the widget is
57	* called and it's added to the pool to be ready for reuse.
58	*/	53	*/
59	dispose : function( id ) {	54	dispose : function( id ) {
60	var widget = this.findWidgetById( id );	55	var widget = this.findWidgetById( id );
Lines 67-150 Link Here
67	if( parent && parent.getChildren() ) {	62	if( parent && parent.getChildren() ) {
68	widget.setParent( null );	63	widget.setParent( null );
69	}	64	}
70	// handle widgets that can be pooled	65	// [if] Replace dispose() with destroy()
71	var typePoolId = widget.getUserData( "typePoolId" );	66	widget.destroy();
72	if( typePoolId != null ) {
73	var typePool = this._widgetPool[ typePoolId ];
74	typePool.resetHandler( widget );
75	widget.setUserData( "pooled", true );
76	// EXPERIMENTAL: If the widget has a reset method, call it
77	if( widget.rap_reset ) {
78	widget.rap_reset();
79	}
80	typePool.elements.push( widget );
81	// dispose of widgets that cannot be pooled
82	} else {
83	// [if] Replace dispose() with destroy()
84	widget.destroy();
85	}
86	}	67	}
87	}	68	}
88	},	69	},
89
90	registerResetHandler : function( typePoolId, resetHandler ) {
91	this._createWidgetPool( typePoolId, resetHandler );
92	},
93		70
94	newWidget : function( widgetId,	71	newWidget : function( widgetId, parentId, isControl, type, paramList ) {
95	parentId,
96	isControl,
97	typePoolId,
98	type,
99	paramList )
100	{
101	// Note [fappel]: Do not remove the 'wm' declaration. This is needed	72	// Note [fappel]: Do not remove the 'wm' declaration. This is needed
102	// for IE if the 'newExpression' has a reference to	73	// for IE if the 'newExpression' has a reference to
103	// the variable defined in the script from the server.	74	// the variable defined in the script from the server.
104	// TODO [fappel]: Think about improvement of the hardcoded expression...	75	// TODO [fappel]: Think about improvement of the hardcoded expression...
105	var wm = this;	76	var wm = this;
106		77
107	var result = null;	78	var newExpression;
108	// if the widget type supports pooling get a widget from the pool -	79	if( paramList != null ) {
109	// if available...	80	newExpression = "new " + type + "(" + paramList + ");";
110	if( typePoolId != null && this._widgetPool[ typePoolId ] ) {	81	} else {
111	var typePool = this._widgetPool[ typePoolId ];	82	newExpression = "new " + type + "();";
112	result = typePool.elements.pop();
113	if( result ) {
114	if( paramList != null ) {
115	// If paramList isn't empty we have to reinitialize the widget.
116	// Luckily only our own js widgets use this...
117	var expression = "org.eclipse.swt.WidgetManager.getInstance()."
118	+ "_current.reInit("
119	+ paramList
120	+ ");";
121	// Assignment of the field _current is needed as Opera has some
122	// problems with accessing local variables in eval expressions.
123	this._current = result;
124	window.eval( expression );
125	this._current = null;
126	}
127	// EXPERIMENTAL: If the widget has an init method, call it
128	if( result.rap_init ) {
129	result.rap_init();
130	}
131	}
132	// this.debug( "_____ recycled: " + result );
133	}
134
135	// ... otherwise create a new one
136	if( result == null ) {
137	var newExpression;
138	if( paramList != null ) {
139	newExpression = "new " + type + "(" + paramList + ");";
140	} else {
141	newExpression = "new " + type + "();";
142	}
143	result = window.eval( newExpression );
144	result.setUserData( "typePoolId", typePoolId );
145	result.setUserData( "pooled", false );
146	// this.debug( "_____ created: " + result );
147	}	83	}
		84	var result = window.eval( newExpression );
148		85
149	// map the widget to the server side widgetId	86	// map the widget to the server side widgetId
150	if( result.classname == "org.eclipse.swt.widgets.Shell" ) {	87	if( result.classname == "org.eclipse.swt.widgets.Shell" ) {
Lines 249-264 Link Here
249	}	186	}
250	},	187	},
251		188
252	/**
253	* Creates a new caching pool for widgets with the given pooling id.
254	*/
255	_createWidgetPool : function( typePoolId, resetHandler ) {
256	var typePool = new Object();
257	typePool.elements = new Array();
258	typePool.resetHandler = resetHandler;
259	this._widgetPool[ typePoolId ] = typePool;
260	},
261
262	////////////////	189	////////////////
263	// Font handling	190	// Font handling
264		191

Lines 18-25 Link Here

(-)src/org/eclipse/swt/internal/widgets/textkit/SingleTextLCA.java (-16 lines)
18		18
19	final class SingleTextLCA extends AbstractTextDelegateLCA {	19	final class SingleTextLCA extends AbstractTextDelegateLCA {
20		20
21	static final String TYPE_POOL_ID = SingleTextLCA.class.getName();
22
23	void preserveValues( final Text text ) {	21	void preserveValues( final Text text ) {
24	ControlLCAUtil.preserveValues( text );	22	ControlLCAUtil.preserveValues( text );
25	TextLCAUtil.preserveValues( text );	23	TextLCAUtil.preserveValues( text );
Lines 65-82 Link Here
65	writer.dispose();	63	writer.dispose();
66	}	64	}
67		65
68	String getTypePoolId( final Text text ) {
69	return TYPE_POOL_ID;
70	}
71
72	void createResetHandlerCalls( final String typePoolId ) throws IOException {
73	TextLCAUtil.resetSelection();
74	TextLCAUtil.resetVerifyAndModifyListener();
75	TextLCAUtil.resetSelectionListener();
76	TextLCAUtil.resetTextLimit();
77	TextLCAUtil.resetReadOnly();
78	TextLCAUtil.resetText();
79	ControlLCAUtil.resetChanges();
80	ControlLCAUtil.resetStyleFlags();
81	}
82	}	66	}

Lines 19-26 Link Here

(-)src/org/eclipse/swt/internal/widgets/textkit/MultiTextLCA.java (-14 lines)
19		19
20	final class MultiTextLCA extends AbstractTextDelegateLCA {	20	final class MultiTextLCA extends AbstractTextDelegateLCA {
21		21
22	static final String TYPE_POOL_ID = MultiTextLCA.class.getName();
23
24	void preserveValues( final Text text ) {	22	void preserveValues( final Text text ) {
25	ControlLCAUtil.preserveValues( text );	23	ControlLCAUtil.preserveValues( text );
26	TextLCAUtil.preserveValues( text );	24	TextLCAUtil.preserveValues( text );
Lines 65-80 Link Here
65	writer.dispose();	63	writer.dispose();
66	}	64	}
67		65
68	String getTypePoolId( final Text text ) {
69	return TYPE_POOL_ID;
70	}
71
72	void createResetHandlerCalls( final String typePoolId ) throws IOException {
73	TextLCAUtil.resetVerifyAndModifyListener();
74	TextLCAUtil.resetTextLimit();
75	TextLCAUtil.resetReadOnly();
76	TextLCAUtil.resetText();
77	ControlLCAUtil.resetChanges();
78	ControlLCAUtil.resetStyleFlags();
79	}
80	}	66	}

Lines 17-24 Link Here

(-)src/org/eclipse/swt/internal/widgets/textkit/PasswordTextLCA.java (-16 lines)
17		17
18	final class PasswordTextLCA extends AbstractTextDelegateLCA {	18	final class PasswordTextLCA extends AbstractTextDelegateLCA {
19		19
20	static final String TYPE_POOL_ID = PasswordTextLCA.class.getName();
21
22	void preserveValues( final Text text ) {	20	void preserveValues( final Text text ) {
23	ControlLCAUtil.preserveValues( text );	21	ControlLCAUtil.preserveValues( text );
24	TextLCAUtil.preserveValues( text );	22	TextLCAUtil.preserveValues( text );
Lines 62-79 Link Here
62	writer.dispose();	60	writer.dispose();
63	}	61	}
64		62
65	String getTypePoolId( final Text text ) {
66	return TYPE_POOL_ID;
67	}
68
69	void createResetHandlerCalls( final String typePoolId ) throws IOException {
70	TextLCAUtil.resetVerifyAndModifyListener();
71	TextLCAUtil.resetSelectionListener();
72	TextLCAUtil.resetSelection();
73	TextLCAUtil.resetTextLimit();
74	TextLCAUtil.resetReadOnly();
75	TextLCAUtil.resetText();
76	ControlLCAUtil.resetChanges();
77	ControlLCAUtil.resetStyleFlags();
78	}
79	}	63	}

Lines 32-38 Link Here

(-)src/org/eclipse/swt/internal/widgets/shellkit/ShellLCA.java (-23 lines)
32	public final class ShellLCA extends AbstractWidgetLCA {	32	public final class ShellLCA extends AbstractWidgetLCA {
33		33
34	private static final String QX_TYPE = "org.eclipse.swt.widgets.Shell";	34	private static final String QX_TYPE = "org.eclipse.swt.widgets.Shell";
35	// private static final String TYPE_POOL_ID = ShellLCA.class.getName();
36		35
37	private static final String PROP_TEXT = "text";	36	private static final String PROP_TEXT = "text";
38	private static final String PROP_IMAGE = "image";	37	private static final String PROP_IMAGE = "image";
Lines 134-161 Link Here
134	writer.dispose();	133	writer.dispose();
135	}	134	}
136		135
137	public void createResetHandlerCalls( final String typePoolId )
138	throws IOException
139	{
140	JSWriter writer = JSWriter.getWriterForResetHandler();
141	writer.call( "removeState", new Object[]{ "rwt_TITLE" } );
142	// TODO [rst] If this is ever being reactivated, all Shell style-flag states
143	// must be removed
144	writer.set( "parentShell", ( Object )null );
145	ControlLCAUtil.resetStyleFlags();
146	ControlLCAUtil.resetResizeNotificator();
147	ControlLCAUtil.resetMoveNotificator();
148	// TODO [rh] reset close listener when shell pooling is activated
149	ControlLCAUtil.resetBounds();
150	ControlLCAUtil.resetZIndex();
151	ControlLCAUtil.resetToolTip();
152	}
153
154	public String getTypePoolId( final Widget widget ) {
155	// return TYPE_POOL_ID;
156	return null;
157	}
158
159	//////////////////	136	//////////////////
160	// Helping methods	137	// Helping methods
161		138

Lines 21-27 Link Here

(-)src/org/eclipse/swt/internal/widgets/compositekit/CompositeLCA.java (-16 lines)
21	public class CompositeLCA extends AbstractWidgetLCA {	21	public class CompositeLCA extends AbstractWidgetLCA {
22		22
23	private static final String QX_TYPE = "qx.ui.layout.CanvasLayout";	23	private static final String QX_TYPE = "qx.ui.layout.CanvasLayout";
24	// private static final String TYPE_POOL_ID = CompositeLCA.class.getName();
25		24
26	public void preserveValues( final Widget widget ) {	25	public void preserveValues( final Widget widget ) {
27	ControlLCAUtil.preserveValues( ( Control )widget );	26	ControlLCAUtil.preserveValues( ( Control )widget );
Lines 52-70 Link Here
52	JSWriter writer = JSWriter.getWriterFor( widget );	51	JSWriter writer = JSWriter.getWriterFor( widget );
53	writer.dispose();	52	writer.dispose();
54	}	53	}
55
56	public void createResetHandlerCalls( final String typePoolId )
57	throws IOException
58	{
59	ControlLCAUtil.resetChanges();
60	ControlLCAUtil.resetStyleFlags();
61	}
62
63	public String getTypePoolId( final Widget widget ) {
64	// TODO [rh] disabled pooling, see
65	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=203499
66	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=204107
67	// return TYPE_POOL_ID;
68	return null;
69	}
70	}	54	}

Lines 25-33 Link Here

(-)src/org/eclipse/swt/internal/custom/scrolledcompositekit/ScrolledCompositeLCA.java (-37 lines)
25	private static final String QX_TYPE	25	private static final String QX_TYPE
26	= "org.eclipse.swt.custom.ScrolledComposite";	26	= "org.eclipse.swt.custom.ScrolledComposite";
27		27
28	// private static final String TYPE_POOL_ID
29	// = ScrolledCompositeLCA.class.getName();
30
31	private static final Integer ZERO = new Integer( 0 );	28	private static final Integer ZERO = new Integer( 0 );
32		29
33	// Request parameter names	30	// Request parameter names
Lines 95-117 Link Here
95	writer.dispose();	92	writer.dispose();
96	}	93	}
97		94
98	public void createResetHandlerCalls( final String typePoolId )
99	throws IOException
100	{
101	ControlLCAUtil.resetChanges();
102	resetClipBounds();
103	resetScrollBars();
104	resetBarSelection();
105	ControlLCAUtil.resetStyleFlags();
106	}
107
108	public String getTypePoolId( final Widget widget ) {
109	// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=226651
110	// return TYPE_POOL_ID;
111	return null;
112	}
113
114
115	///////////////////////////////////	95	///////////////////////////////////
116	// Helping methods to write changes	96	// Helping methods to write changes
117		97
Lines 123-133 Link Here
123	writer.set( PROP_OVERFLOW, "overflow", overflow, null );	103	writer.set( PROP_OVERFLOW, "overflow", overflow, null );
124	}	104	}
125		105
126	private static void resetScrollBars() throws IOException {
127	JSWriter writer = JSWriter.getWriterForResetHandler();
128	writer.reset( "overflow" );
129	}
130
131	private static void writeBarSelection( final ScrolledComposite composite )	106	private static void writeBarSelection( final ScrolledComposite composite )
132	throws IOException	107	throws IOException
133	{	108	{
Lines 142-153 Link Here
142	}	117	}
143	}	118	}
144		119
145	private static void resetBarSelection() throws IOException {
146	JSWriter writer = JSWriter.getWriterForResetHandler();
147	writer.set( "hBarSelection", 0 );
148	writer.set( "vBarSelection", 0 );
149	}
150
151	private static void writeClipBounds( final ScrolledComposite composite )	120	private static void writeClipBounds( final ScrolledComposite composite )
152	throws IOException	121	throws IOException
153	{	122	{
Lines 159-170 Link Here
159	}	128	}
160	}	129	}
161		130
162	private static void resetClipBounds() throws IOException {
163	JSWriter writer = JSWriter.getWriterForResetHandler();
164	writer.reset( "clipWidth" );
165	writer.reset( "clipHeight" );
166	}
167
168	private static String getOverflow( final ScrolledComposite composite ) {	131	private static String getOverflow( final ScrolledComposite composite ) {
169	String result;	132	String result;
170	ScrollBar horizontalBar = composite.getHorizontalBar();	133	ScrollBar horizontalBar = composite.getHorizontalBar();

Lines 59-73 Link Here

(-)src/org/eclipse/swt/internal/widgets/menuitemkit/MenuItemLCA.java (-9 lines)
59	getDelegateLCA( menuItem ).renderDispose( menuItem );	59	getDelegateLCA( menuItem ).renderDispose( menuItem );
60	}	60	}
61		61
62	public void createResetHandlerCalls( final String typePoolId )
63	throws IOException
64	{
65	}
66
67	public String getTypePoolId( final Widget widget ) {
68	return null;
69	}
70
71	private static boolean isTopLevelMenuBarItem( final MenuItem menuItem ) {	62	private static boolean isTopLevelMenuBarItem( final MenuItem menuItem ) {
72	return ( menuItem.getParent().getStyle() & SWT.BAR ) != 0;	63	return ( menuItem.getParent().getStyle() & SWT.BAR ) != 0;
73	}	64	}

Lines 46-64 Link Here

(-)src/org/eclipse/swt/internal/widgets/datetimekit/DateTimeLCA.java (-13 lines)
46	getDelegate( widget ).renderDispose( ( DateTime )widget );	46	getDelegate( widget ).renderDispose( ( DateTime )widget );
47	}	47	}
48		48
49	public void createResetHandlerCalls( final String typePoolId )
50	throws IOException
51	{
52	}
53
54	public String getTypePoolId( final Widget widget ) {
55	// TODO [rh] disabled pooling, see bugs prefixed with [pooling]
56	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=204107
57	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=199142
58	// return getDelegate( widget ).getTypePoolId( ( DateTime )widget );
59	return null;
60	}
61
62	private static AbstractDateTimeLCADelegate getDelegate( final Widget widget )	49	private static AbstractDateTimeLCADelegate getDelegate( final Widget widget )
63	{	50	{
64	AbstractDateTimeLCADelegate result;	51	AbstractDateTimeLCADelegate result;

Lines 23-29 Link Here

(-)src/org/eclipse/swt/internal/widgets/spinnerkit/SpinnerLCA.java (-30 lines)
23	public final class SpinnerLCA extends AbstractWidgetLCA {	23	public final class SpinnerLCA extends AbstractWidgetLCA {
24		24
25	private static final String QX_TYPE = "org.eclipse.swt.widgets.Spinner";	25	private static final String QX_TYPE = "org.eclipse.swt.widgets.Spinner";
26	// private static final String TYPE_POOL_ID = SpinnerLCA.class.getName();
27		26
28	private static final Integer DEFAULT_TEXT_LIMIT	27	private static final Integer DEFAULT_TEXT_LIMIT
29	= new Integer( Spinner.LIMIT );	28	= new Integer( Spinner.LIMIT );
Lines 95-114 Link Here
95	writer.dispose();	94	writer.dispose();
96	}	95	}
97		96
98	public void createResetHandlerCalls( final String typePoolId )
99	throws IOException
100	{
101	ControlLCAUtil.resetStyleFlags();
102	resetReadOnly();
103	resetValues();
104	}
105
106	public String getTypePoolId( final Widget widget ) {
107	// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=226651
108	// return TYPE_POOL_ID;
109	return null;
110	}
111
112	//////////////////////////////////////	97	//////////////////////////////////////
113	// Helping methods to write JavaScript	98	// Helping methods to write JavaScript
114		99
Lines 146-161 Link Here
146	}	131	}
147	}	132	}
148		133
149	private static void resetValues() throws IOException {
150	JSWriter writer = JSWriter.getWriterForResetHandler();
151	// TODO [rst] Missing resetters in QX_TYPE, discuss with qooxdoo
152	// writer.reset( "min" );
153	// writer.reset( "max" );
154	writer.reset( "incrementAmount" );
155	writer.reset( "pageIncrementAmount" );
156	writer.reset( "value" );
157	}
158
159	private static void writeSetInt( final JSWriter writer,	134	private static void writeSetInt( final JSWriter writer,
160	final String javaProperty,	135	final String javaProperty,
161	final String jsProperty,	136	final String jsProperty,
Lines 176-186 Link Here
176	writer.set( JSConst.QX_FIELD_EDITABLE, !readOnly );	151	writer.set( JSConst.QX_FIELD_EDITABLE, !readOnly );
177	}	152	}
178		153
179	private static void resetReadOnly() throws IOException {
180	JSWriter writer = JSWriter.getWriterForResetHandler();
181	writer.reset( JSConst.QX_FIELD_EDITABLE );
182	}
183
184	private static void writeWrap( final Spinner spinner ) throws IOException {	154	private static void writeWrap( final Spinner spinner ) throws IOException {
185	if( ( spinner.getStyle() & SWT.WRAP ) != 0 ) {	155	if( ( spinner.getStyle() & SWT.WRAP ) != 0 ) {
186	JSWriter writer = JSWriter.getWriterFor( spinner );	156	JSWriter writer = JSWriter.getWriterFor( spinner );

Lines 19-69 Link Here

(-)js/org/eclipse/swt/widgets/List.js (-33 / +26 lines)
19	construct : function() {	19	construct : function() {
20	this.base( arguments );	20	this.base( arguments );
21	this.setMarkLeadingItem( true );	21	this.setMarkLeadingItem( true );
22	this.rap_init();	22	// Should changeSelection events passed to the server-side?
		23	// state == no, action == yes
		24	this._changeSelectionNotification = "state";
		25	this._topIndex = 0;
		26	var selMgr = this.getManager();
		27	selMgr.addEventListener( "changeLeadItem", this._onChangeLeadItem, this );
		28	selMgr.addEventListener( "changeSelection", this._onSelectionChange, this );
		29	this.addEventListener( "focus", this._onFocusIn, this );
		30	this.addEventListener( "blur", this._onFocusOut, this );
		31	this.addEventListener( "click", this._onClick, this );
		32	this.addEventListener( "dblclick", this._onDblClick, this );
		33	this.addEventListener( "appear", this._onAppear, this );
		34	// Listen to send event of request to report topIndex
		35	var req = org.eclipse.swt.Request.getInstance();
		36	req.addEventListener( "send", this._onSendRequest, this );
23	},	37	},
24		38
25	destruct : function() {	39	destruct : function() {
26	this.rap_reset();	40	var req = org.eclipse.swt.Request.getInstance();
		41	req.removeEventListener( "send", this._onSendRequest, this );
		42	var selMgr = this.getManager();
		43	selMgr.removeEventListener( "changeLeadItem", this._onChangeLeadItem, this );
		44	selMgr.removeEventListener( "changeSelection", this._onSelectionChange, this );
		45	this.removeEventListener( "focus", this._onFocusIn, this );
		46	this.removeEventListener( "blur", this._onFocusOut, this );
		47	this.removeEventListener( "click", this._onClick, this );
		48	this.removeEventListener( "dblclick", this._onDblClick, this );
		49	this.removeEventListener( "appear", this._onAppear, this );
27	},	50	},
28		51
29	members : {	52	members : {
30		53
		54	// TODO [rst] Move parameter to constructor and delete this method
31	init : function( multiSelection ) {	55	init : function( multiSelection ) {
32	var manager = this.getManager();	56	var manager = this.getManager();
33	manager.setMultiSelection( multiSelection );	57	manager.setMultiSelection( multiSelection );
34	},	58	},
35		59
36	rap_init : function( multiSelection ) {
37	// Should changeSelection events passed to the server-side?
38	// state == no, action == yes
39	this._changeSelectionNotification = "state";
40	this._topIndex = 0;
41	var selMgr = this.getManager();
42	selMgr.addEventListener( "changeLeadItem", this._onChangeLeadItem, this );
43	selMgr.addEventListener( "changeSelection", this._onSelectionChange, this );
44	this.addEventListener( "focus", this._onFocusIn, this );
45	this.addEventListener( "blur", this._onFocusOut, this );
46	this.addEventListener( "click", this._onClick, this );
47	this.addEventListener( "dblclick", this._onDblClick, this );
48	this.addEventListener( "appear", this._onAppear, this );
49	// Listen to send event of request to report topIndex
50	var req = org.eclipse.swt.Request.getInstance();
51	req.addEventListener( "send", this._onSendRequest, this );
52	},
53
54	rap_reset : function() {
55	var req = org.eclipse.swt.Request.getInstance();
56	req.removeEventListener( "send", this._onSendRequest, this );
57	var selMgr = this.getManager();
58	selMgr.removeEventListener( "changeLeadItem", this._onChangeLeadItem, this );
59	selMgr.removeEventListener( "changeSelection", this._onSelectionChange, this );
60	this.removeEventListener( "focus", this._onFocusIn, this );
61	this.removeEventListener( "blur", this._onFocusOut, this );
62	this.removeEventListener( "click", this._onClick, this );
63	this.removeEventListener( "dblclick", this._onDblClick, this );
64	this.removeEventListener( "appear", this._onAppear, this );
65	},
66
67	/** Sets the given array of items. */	60	/** Sets the given array of items. */
68	setItems : function( items ) {	61	setItems : function( items ) {
69	// preserve selection and focused item	62	// preserve selection and focused item

Lines 28-35 Link Here

(-)src/org/eclipse/swt/internal/browser/browserkit/BrowserLCA.java (-17 lines)
28		28
29	private static final String PARAM_EXECUTE_RESULT = "executeResult";	29	private static final String PARAM_EXECUTE_RESULT = "executeResult";
30		30
31	// private static final String TYPE_POOL_ID = BrowserLCA.class.getName();
32
33	private static final String PROP_URL = "url";	31	private static final String PROP_URL = "url";
34	private static final String PROP_TEXT = "text";	32	private static final String PROP_TEXT = "text";
35		33
Lines 75-95 Link Here
75	writer.dispose();	73	writer.dispose();
76	}	74	}
77		75
78	public void createResetHandlerCalls( final String typePoolId )
79	throws IOException
80	{
81	JSWriter writer = JSWriter.getWriterForResetHandler();
82	writer.reset( QX_FIELD_SOURCE );
83	ControlLCAUtil.resetStyleFlags();
84	}
85
86	public String getTypePoolId( final Widget widget ) {
87	// TODO [rh] Disabled pooling. In IE7, using Browser#setText() does not
88	// work when widget was pooled. The previous content is displayed.
89	// return TYPE_POOL_ID;
90	return null;
91	}
92
93	private static void writeUrl( final Browser browser )	76	private static void writeUrl( final Browser browser )
94	throws IOException	77	throws IOException
95	{	78	{