(for example) in the
// template instead of | results in a TypeError from JavaScript: "[object
// DOMWindow] has no method 'replaceChild'" (Chrome) or "this.replaceChild is not
// a function" (FireFox).
final HTMLPanel y = getWidget();
y.add( child, /*parent to add to*/child.getElement().getParentElement() );
// element already attached to that parent obviously, but there's no
// addWidgetOnly method. addAndReplaceElement used to work till 2.5, now it
// silently rejects the widget if its element == element to replace
}
private void initB( final BoardV child )
{
child.init();
init( child );
}
@Warning("non-API") interface UiBinderI extends UiBinder {}
// ` e a r l y ````````````````````````````````````````````````````````````````````````
private final Spool spool = new Spool1();
// ------------------------------------------------------------------------------------
/** The view of the {@linkplain VoteTrack#candidate candidate}.
*/
public CandidateV candidateV() { return candidateV; }
private final CandidateV candidateV;
@UiField @Warning("non-API") TableCellElement cElement;
/** Answers whether this view is physically moving in order to visualize a change of
* anchor and a consequent logical shift in votespace. The return value is bound to
* property name moving. Components themselves ought to withold showing a
* change of anchor or related changes till immediately after the motion has stopped.
* Each major component must also explicitly {@linkplain MajorV#setVisible(boolean)
* reshow} itself after the changes are rendered, as this view may have hidden it at
* some point as part of the motion.
*/
public boolean isMoving() { return animation != null; };
private Animation animation;
private void setMoving( final Animation newAnimation )
{
if( animation != null || newAnimation == null )
{
assert false;
return;
}
animation = newAnimation;
fireEvent( new PropertyChange( "moving" ));
}
private void clearMoving()
{
if( animation == null )
{
assert false;
return;
}
animation = null;
fireEvent( new PropertyChange( "moving" ));
}
/** The view of the {@linkplain VoteTrack#peers peers board}.
*/
public PeerBoardV peersBoardV() { return peersBoardV; }
private final PeerBoardV peersBoardV;
@UiField @Warning("non-API") TableCellElement pElement;
@UiField @Warning("non-API") TableCellElement pBoardElement;
@UiField @Warning("non-API") TableCellElement pOutflowElement;
/** The track on which this view is modelled.
*/
public VoteTrack track() { return track; }
private final VoteTrack track;
/** The view of the {@linkplain VoteTrack#voters voters board}.
*/
public BoardV votersBoardV() { return votersBoardV; }
private final BoardV votersBoardV;
@UiField @Warning("non-API") TableCellElement vElement;
@UiField @Warning("non-API") TableCellElement vBoardElement;
@UiField @Warning("non-API") TableCellElement vOutflowElement;
// - C o m p o s i t e ----------------------------------------------------------------
protected @Override HTMLPanel getWidget() { return (HTMLPanel)super.getWidget(); }
// - W i d g e t ----------------------------------------------------------------------
protected @Override void onLoad()
{
if( !spool.isUnwinding() )
{
Stage.i().addInitializer( new TheatreInitializerC() // auto-removed
{
public void initComplete( final Stage stage, boolean _rPending )
{
if( spool.isUnwinding() ) return;
// assume here (for sake of simplicity) that default will not change:
if( !VoteTrack.toPin(stage) ) new Animator( stage );
}
});
}
super.onLoad();
}
protected @Override void onUnload()
{
super.onUnload();
spool.unwind();
}
public @Override void removeFromParent()
{
if( getParent() != null ) throw new UnsupportedOperationException();
}
//// P r i v a t e ///////////////////////////////////////////////////////////////////////
private static DartLight dartLight;
@UiFactory @Warning("non-API") HeadsUpDisplay newHeadsUpDisplay()
{
return new HeadsUpDisplay( VoteTrackV.this, spool );
}
@UiField @Warning("non-API") DivElement overlayDiv;
@UiField @Warning("non-API") TableElement tableElement; // outermost table
// ====================================================================================
private final class Animation extends Timer // OPT instead use AnimationScheduler
{
Animation( int _direction )
{
direction = _direction;
setMoving( Animation.this );
msStart = System.currentTimeMillis();
rate_percentPerMS = /*td.voters width per vote/track.css*/47d / MS_DURATION * direction;
schedule( MS_PERIOD / 2 ); /* for first frame, which has faster start time for
sake of accuracy in face of granular timing */
}
private final int direction; // of track motion, -1 or 1
private Runnable frame = new Runnable()
{
public void run() // first frame only
{
if( direction == -1 ) candidateV.setVisible( false );
// size and position inaccurate, eagerly hide on leftward slide
frame = new Runnable()
{
public void run() // all subsequent frames, and also called into first frame
{
final int msLapse = (int)(System.currentTimeMillis() - msStart);
if( msLapse >= MS_STOP )
{
move( MS_DURATION ); /* do not stop part way even if msLapse
is less because final frame may hold for longer than others,
calling attention to its misplacement */
stop( /*isImmediate*/false );
}
else move( msLapse );
}
};
frame.run();
if( !isCancelled ) scheduleRepeating( MS_PERIOD ); // for subsequent frames
}
};
private boolean isCancelled;
private boolean isStopped;
private void move( final int msLapse )
{
final double distance = msLapse * rate_percentPerMS;
tableStyle.setLeft( distance, Style.Unit.PCT );
}
private static final int MS_DURATION = 200;
private static final int MS_PERIOD = 25; // needn't be especially smooth
private static final int MS_STOP = MS_DURATION - MS_PERIOD / 2;
// faster end time, more accurate, correcting for granularity
private final long msStart;
private final double rate_percentPerMS; // speed of motion
void stop( final boolean isImmediate ) /* "stop" rather than "cancel" because
cancel() is called by superclass on scheduling before the first tick */
{
cancel();
isCancelled = true;
if( isImmediate ) stop2();
else Scheduler.get().scheduleDeferred( new Scheduler.ScheduledCommand()
{
public void execute() /* after browser renders the previous motion. This
delay tends to fail in dev mode, making the end of the animation jumpy;
but it works in production mode */
{
// Hide components till they re-render correctly.
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
for( final Widget component: getWidget() )
{
// before clearing motion and restoring original left position of
// view, hide each component till it finishes re-rendering in
// response to clearMoving. See isMoving
if( component instanceof MajorV ) component.setVisible( false );
}
// Fade in components that show new information.
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
final ArrayList fades = new ArrayList( /*initial capacity*/2 );
if( direction == 1 ) fades.add( vElement );
else
{
fades.add( pElement );
fades.add( cElement );
}
for( Element e: fades ) e.addClassName( "fadedOut" ); // begin faded out
Scheduler.get().scheduleDeferred( new Scheduler.ScheduledCommand()
{
public void execute() // after browser renders fadedOut
{
for( Element e: fades ) e.removeClassName( "fadedOut" ); // fade in
}
});
// - - -
stop2();
}
});
}
private void stop2()
{
isStopped = true;
tableStyle.clearLeft();
clearMoving();
}
private final Style tableStyle = tableElement.getStyle();
// - T i m e r --------------------------------------------------------------------
public void run()
{
if( isStopped || spool.isUnwinding() ) return;
assert animation == Animation.this;
frame.run();
}
}
// ====================================================================================
private final class Animator implements ChangeHandler, PropertyChangeHandler
{
Animator( final Stage stage )
{
// assert !VoteTrack.toPin(stage): "animator not enabled for pinned track";
// // else "animate" style hides overflow, and BoardV.pinImg won't quite render
/// no longer a problem with div.animationBed
addStyleName( "animate" );
spool.add( new Hold()
{
final HandlerRegistration hR = GWTX.i().bus().addHandlerToSource(
Change.TYPE, /*source*/track, Animator.this );
public void release() { hR.removeHandler(); }
});
spool.add( new Hold()
{
final HandlerRegistration hR = GWTX.i().bus().addHandlerToSource(
PropertyChange.TYPE, /*source*/stage, Animator.this );
public void release() { hR.removeHandler(); }
});
spool.add( new Hold()
{
public void release() { if( animation != null )
animation.cancel(); }
});
anchorLast = track.anchor();
}
private CountNodeJS anchorLast;
public void onChange( Change _e )
{
if( spool.isUnwinding() ) return;
final CountNodeJS anchor = track.anchor();
anchorLast = anchor;
}
public void onPropertyChange( final PropertyChange e )
{
// Motion is here triggered by change events that issue immediately from the
// stage. Component views learn of these events somewhat later because of the
// delayed intermediation of VoteTrack.gun. Motion will have commenced by
// then and the component views will therefore postpone their remodelling till
// after the motion stops. See isMoving().
if( !"actorName".equals(e.propertyName()) || spool.isUnwinding() ) return;
if( animation != null )
{
animation.stop( /*isImmediate*/true ); // actor changed in mid-motion, abort motion
return; // do not try to re-animate, just do an immediate transition
}
if( anchorLast == null ) return;
final String anchorName = VoteTrack.anchorName( Stage.i() );
if( anchorName == null ) return;
if( anchorName.equals( anchorLast.candidateName() )) new Animation( /*stage left*/-1 );
else if( CountNodeJS.findNode(anchorName,anchorLast.voters()) != null )
{
new Animation( /*stage right*/1 );
}
}
}
}
|