Attachment #202075 for bug #355612

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

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




 *
 * Contributors:
 *    Frank Appel - initial API and implementation
 *    EclipseSource - ongoing development
 ******************************************************************************/
package org.eclipse.rwt.internal.textsize;


import org.eclipse.swt.internal.SerializableCompatibility;

class MeasurementOperator implements SerializableCompatibility {

  private final Set<Probe> probes;
  private final Set<MeasurementItem> items;
  private boolean isStartupProbeMeasurementPerformed;

  static MeasurementOperator getInstance() {
    return ( MeasurementOperator )SessionSingletonBase.getInstance( MeasurementOperator.class );

    readMeasuredFontProbeSizes();
    return readMeasuredTextSizes();
  }

  void handleStartupProbeMeasurementResults() {
    if( !isStartupProbeMeasurementPerformed ) {
      readMeasuredFontProbeSizes();
      isStartupProbeMeasurementPerformed = true;
    }
  }

  int getProbeCount() {
    return probes.size();
  }

  void addProbeToMeasure( FontData fontData ) {
    Probe probe = RWTFactory.getProbeStore().getProbe( fontData );
    if( probe == null ) {

    }
    probes.add( probe );
  }

  Probe[] getProbes() {
    return probes.toArray( new Probe[ probes.size() ] );
  }

  void addItemToMeasure( MeasurementItem newItem ) {
    if( !requestContainsMeasurementResult( newItem ) ) {
      items.add( newItem );
    }
  }

  int getItemCount() {
    return items.size();
  }

  MeasurementItem[] getItems() {
    return items.toArray( new MeasurementItem[ items.size() ] );
  }

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

  private boolean hasProbesToMeasure() {
    return !probes.isEmpty();
  }

  private void writeFontProbingStatement() {
    TextSizeUtilFacade.writeFontProbing();
  }

  private void readMeasuredFontProbeSizes() {
    HttpServletRequest request = ContextProvider.getRequest();
    Iterator probeList = probes.iterator();

      }
    }
  }

  private void createProbeResult( Probe probe, String value ) {
    Point size = getSize( value );
    ProbeResultStore.getInstance().createProbeResult( probe, size );
  }

  private void addStartupProbesToBuffer() {
    Probe[] probeList = RWTFactory.getProbeStore().getProbes();
    probes.addAll( Arrays.asList( probeList ) );




 *
 * Contributors:
 *    Frank Appel - initial API and implementation
 *    EclipseSource - ongoing development
 ******************************************************************************/
package org.eclipse.rwt.internal.textsize;


  public void testHandleMeasurementRequest() {
    requestProbingOfFont1();
    requestMeasurementOfItem1();

    operator.handleMeasurementRequests();

    assertEquals( 1, operator.getProbeCount() );
    assertEquals( 1, operator.getItemCount() );
  }

    operator.handleMeasurementRequests();
    requestProbingOfFont2();
    requestMeasurementOfItem2();

    operator.handleMeasurementRequests();

    assertEquals( 2, operator.getProbeCount() );
    assertEquals( 2, operator.getItemCount() );
  }

  public void testSubsequentCallsToHandleMeasurementRequestAreIdempotent() {
    requestProbingOfFont1();
    requestMeasurementOfItem1();
    operator.handleMeasurementRequests();
    requestProbingOfFont1();
    requestMeasurementOfItem1();

    operator.handleMeasurementRequests();

    assertEquals( 1, operator.getProbeCount() );
    assertEquals( 1, operator.getItemCount() );
  }

  public void testHandleMeasurementResults() {
    requestProbingOfFont1();
    requestMeasurementOfItem1();

    requestProbingOfFont1();
    fakeRequestParamWithMeasurementResultOfItem( MEASUREMENT_ITEM_1 );
    requestMeasurementOfItem1();

    operator.handleMeasurementRequests();

    assertEquals( 0, operator.getItemCount() );
  }

  public void testInitStartupProbes() {
    createProbeOfFont1();

    MeasurementOperator measurementOperator = new MeasurementOperator();

    assertEquals( 1, measurementOperator.getProbeCount() );
  }

  public void testHandleStartupProbeMeasurementResults() {
    createProbeOfFont1();
    fakeRequestParamWithMeasurementResultOfProbe( FONT_DATA_1 );
    MeasurementOperator measurementOperator = new MeasurementOperator();

    measurementOperator.handleStartupProbeMeasurementResults();

    assertEquals( 0, measurementOperator.getProbeCount() );
  }

  public void testHandleStartupProbeMeasurementResultsExecutedOnce() {
    requestProbing( FONT_DATA_1 );
    fakeRequestParamWithMeasurementResultOfProbe( FONT_DATA_1 );
    operator.handleStartupProbeMeasurementResults();
    requestProbing( FONT_DATA_2 );
    fakeRequestParamWithMeasurementResultOfProbe( FONT_DATA_2 );

    operator.handleStartupProbeMeasurementResults();

    assertEquals( 1, operator.getProbeCount() );
  }

  public void testAddItemToMeasure() {
    initializeSessionWithDisplay();
    MeasurementItem item = createItem();

    operator.addItemToMeasure( item );

    checkMeasurementItemBuffering( item );


  public void testAddItemToMeasureIsIdempotent() {
    MeasurementItem item = createItem();

    operator.addItemToMeasure( item );
    operator.addItemToMeasure( item );

    checkMeasurementItemBuffering( item );
  }

  public void testGetItemsToMeasureWithEmptyResult() {
    MeasurementItem[] items = MeasurementOperator.getInstance().getItems();

    assertEquals( 0, items.length );
  }

  protected void setUp() throws Exception {
    Fixture.setUp();
    operator = MeasurementOperator.getInstance();
  }

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

  private void requestMeasurementOfItem1() {
    MeasurementOperator.getInstance().addItemToMeasure( MEASUREMENT_ITEM_1 );
  }

  private void requestMeasurementOfItem2() {
    MeasurementOperator.getInstance().addItemToMeasure( MEASUREMENT_ITEM_2 );
  }

  private void requestProbingOfFont2() {
    requestProbing( FONT_DATA_2 );
  }

  private void requestProbing( FontData fontData1 ) {
    Fixture.fakeNewRequest();
    operator.addProbeToMeasure( fontData1 );
  }

  private MeasurementItem createItem() {
    FontData fontData = new FontData( "arial", 13, SWT.BOLD );
    String textToMeasure = "textToMeasure";

  private MeasurementItem createItem( FontData fontData, String textToMeasure, int wrapWidth ) {
    return new MeasurementItem( textToMeasure, fontData, wrapWidth );
  }

  private Display initializeSessionWithDisplay() {
    return new Display();
  }

  private void checkMeasurementItemBuffering( MeasurementItem item ) {
    assertEquals( 1, MeasurementOperator.getInstance().getItems().length );
    assertSame( item, MeasurementOperator.getInstance().getItems() [ 0 ] );

Return to bug 355612

Lines 7-13 Link Here

(-)src/org/eclipse/rwt/internal/textsize/MeasurementOperator.java (-16 / +20 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Frank Appel - initial API and implementation	9	* Frank Appel - initial API and implementation
10	* EclipseSource - bug 348056: Eliminate compiler warnings	10	* EclipseSource - ongoing development
11	******************************************************************************/	11	******************************************************************************/
12	package org.eclipse.rwt.internal.textsize;	12	package org.eclipse.rwt.internal.textsize;
13		13
Lines 23-31 Link Here
23	import org.eclipse.swt.internal.SerializableCompatibility;	23	import org.eclipse.swt.internal.SerializableCompatibility;
24		24
25	class MeasurementOperator implements SerializableCompatibility {	25	class MeasurementOperator implements SerializableCompatibility {
26		26
27	private final Set<Probe> probes;	27	private final Set<Probe> probes;
28	private final Set<MeasurementItem> items;	28	private final Set<MeasurementItem> items;
		29	private boolean isStartupProbeMeasurementPerformed;
29		30
30	static MeasurementOperator getInstance() {	31	static MeasurementOperator getInstance() {
31	return ( MeasurementOperator )SessionSingletonBase.getInstance( MeasurementOperator.class );	32	return ( MeasurementOperator )SessionSingletonBase.getInstance( MeasurementOperator.class );
Lines 50-64 Link Here
50	readMeasuredFontProbeSizes();	51	readMeasuredFontProbeSizes();
51	return readMeasuredTextSizes();	52	return readMeasuredTextSizes();
52	}	53	}
53		54
54	void handleStartupProbeMeasurementResults() {	55	void handleStartupProbeMeasurementResults() {
55	readMeasuredFontProbeSizes();	56	if( !isStartupProbeMeasurementPerformed ) {
		57	readMeasuredFontProbeSizes();
		58	isStartupProbeMeasurementPerformed = true;
		59	}
56	}	60	}
57		61
58	int getProbeCount() {	62	int getProbeCount() {
59	return probes.size();	63	return probes.size();
60	}	64	}
61		65
62	void addProbeToMeasure( FontData fontData ) {	66	void addProbeToMeasure( FontData fontData ) {
63	Probe probe = RWTFactory.getProbeStore().getProbe( fontData );	67	Probe probe = RWTFactory.getProbeStore().getProbe( fontData );
64	if( probe == null ) {	68	if( probe == null ) {
Lines 66-101 Link Here
66	}	70	}
67	probes.add( probe );	71	probes.add( probe );
68	}	72	}
69		73
70	Probe[] getProbes() {	74	Probe[] getProbes() {
71	return probes.toArray( new Probe[ probes.size() ] );	75	return probes.toArray( new Probe[ probes.size() ] );
72	}	76	}
73		77
74	void addItemToMeasure( MeasurementItem newItem ) {	78	void addItemToMeasure( MeasurementItem newItem ) {
75	if( !requestContainsMeasurementResult( newItem ) ) {	79	if( !requestContainsMeasurementResult( newItem ) ) {
76	items.add( newItem );	80	items.add( newItem );
77	}	81	}
78	}	82	}
79		83
80	int getItemCount() {	84	int getItemCount() {
81	return items.size();	85	return items.size();
82	}	86	}
83		87
84	MeasurementItem[] getItems() {	88	MeasurementItem[] getItems() {
85	return items.toArray( new MeasurementItem[ items.size() ] );	89	return items.toArray( new MeasurementItem[ items.size() ] );
86	}	90	}
87		91
88	//////////////////	92	//////////////////
89	// helping methods	93	// helping methods
90		94
91	private boolean hasProbesToMeasure() {	95	private boolean hasProbesToMeasure() {
92	return !probes.isEmpty();	96	return !probes.isEmpty();
93	}	97	}
94		98
95	private void writeFontProbingStatement() {	99	private void writeFontProbingStatement() {
96	TextSizeUtilFacade.writeFontProbing();	100	TextSizeUtilFacade.writeFontProbing();
97	}	101	}
98		102
99	private void readMeasuredFontProbeSizes() {	103	private void readMeasuredFontProbeSizes() {
100	HttpServletRequest request = ContextProvider.getRequest();	104	HttpServletRequest request = ContextProvider.getRequest();
101	Iterator probeList = probes.iterator();	105	Iterator probeList = probes.iterator();
Lines 109-120 Link Here
109	}	113	}
110	}	114	}
111	}	115	}
112		116
113	private void createProbeResult( Probe probe, String value ) {	117	private void createProbeResult( Probe probe, String value ) {
114	Point size = getSize( value );	118	Point size = getSize( value );
115	ProbeResultStore.getInstance().createProbeResult( probe, size );	119	ProbeResultStore.getInstance().createProbeResult( probe, size );
116	}	120	}
117		121
118	private void addStartupProbesToBuffer() {	122	private void addStartupProbesToBuffer() {
119	Probe[] probeList = RWTFactory.getProbeStore().getProbes();	123	Probe[] probeList = RWTFactory.getProbeStore().getProbes();
120	probes.addAll( Arrays.asList( probeList ) );	124	probes.addAll( Arrays.asList( probeList ) );