Optionally performs gripper visualization after the actions.
10587
def _post_action(self, action):
        """"""
        ret = super()._post_action(action)
        self._gripper_visualization()
        return ret
158519
function(nodes, controller) {
        var that = this;
        this.show(nodes);
        this.animation.setOptions($.merge(controller, {
            $animating: false,
            compute: function(delta) {
                that.plotStep(delta, controller, this.$animating);
                this.$animating = 'expand';
            },
            
            complete: function() {
                that.plotStep(undefined, controller, false);
                controller.onComplete();
            }       
        })).start();
        
    }
362737
private void runAfterImageDraw(final Runnable action) {
        image.getViewTreeObserver().addOnPreDrawListener(new OnPreDrawListener() {
            @Override
            public boolean onPreDraw() {
                image.getViewTreeObserver().removeOnPreDrawListener(this);
                runOnNextFrame(action);
                return true;
            }
        });
        image.invalidate();
    }
737495
def post_run(self, outline=False, dump=False, *args, **kwargs):
        """"""
        hooks = self.context.config.post_build
        handle_hooks(
            "post_build",
            hooks,
            self.provider,
            self.context,
            dump,
            outline
        )
958190
function RenderManager(view) {
	this.running = false;
	this._frame = 0;

	this.view = view;
	this.skipFrames = 0;
	this.skipFramesCounter = 0;
	this.onEnterFrame = new signals.Signal();
	this.onExitFrame = new signals.Signal();
	this.render = this.render.bind(this);
	this.renderLoop = this.renderLoop.bind(this);
}
375466
def _after_handler(self, iid, callback, args):
        """"""
        self._after_id = None
        self.update_state(iid, "normal")
        self.call_callbacks(iid, callback, args)
1118024
function(opt, animating) {
      var viz = this.viz, 
      aGraph = viz.graph, 
      canvas = viz.canvas, 
      id = viz.root, 
      that = this, 
      ctx = canvas.getCtx(), 
      min = Math.min,
      opt = opt || this.viz.controller;
      opt.clearCanvas && canvas.clear();
        
      var T = !!aGraph.getNode(id).visited;
      aGraph.eachNode(function(node) {
        var nodeAlpha = node.getData('alpha');
        node.eachAdjacency(function(adj) {
          var nodeTo = adj.nodeTo;
          if(!!nodeTo.visited === T && node.drawn && nodeTo.drawn) {
            !animating && opt.onBeforePlotLine(adj);
            ctx.save();
            ctx.globalAlpha = min(nodeAlpha, 
                nodeTo.getData('alpha'), 
                adj.getData('alpha'));
            that.plotLine(adj, canvas, animating);
            ctx.restore();
            !animating && opt.onAfterPlotLine(adj);
          }
        });
        ctx.save();
        if(node.drawn) {
          !animating && opt.onBeforePlotNode(node);
          that.plotNode(node, canvas, animating);
          !animating && opt.onAfterPlotNode(node);
        }
        if(!that.labelsHidden && opt.withLabels) {
          if(node.drawn && nodeAlpha >= 0.95) {
            that.labels.plotLabel(canvas, node, opt);
          } else {
            that.labels.hideLabel(node, false);
          }
        }
        ctx.restore();
        node.visited = !T;
      });
    }
1337635
function(handler, options) {
        OpenLayers.Control.prototype.initialize.apply(this, [options]);
        var callbacks = {done: this.measureComplete,
            point: this.measurePartial};
        if (this.immediate){
            callbacks.modify = this.measureImmediate;
        }
        this.callbacks = OpenLayers.Util.extend(callbacks, this.callbacks);

        // let the handler options override, so old code that passes 'persist'
        // directly to the handler does not need an update
        this.handlerOptions = OpenLayers.Util.extend(
            {persist: this.persist}, this.handlerOptions
        );
        this.handler = new handler(this, this.callbacks, this.handlerOptions);
    }
742304
def _postprocess_hover(self, renderer, source):
        
        hover = self.handles.get('hover')
        if hover is None:
            return
        if hover.renderers == 'auto':
            hover.renderers = []
        hover.renderers.append(renderer)

        # If datetime column is in the data replace hover formatter
        for k, v in source.data.items():
            if k+'_dt_strings' in source.data:
                tooltips = []
                for name, formatter in hover.tooltips:
                    if formatter == '@{%s}' % k:
                        formatter = '@{%s_dt_strings}' % k
                    tooltips.append((name, formatter))
                hover.tooltips = tooltips
1158728
function mouseMoveRedraw() {
            if (!bezierEditor.dragElement) {
                animationRequest = null;
                return;
            }

            // Update code
            bezierEditor._commitTimingFunction();

            bezierEditor._updateCanvas();
            animationRequest = window.requestAnimationFrame(mouseMoveRedraw);
        }
537406
function() {
            if (observed.size) {
                observed.forEach(performPropertyChecks);
                handlers.forEach(deliverHandlerRecords);
                nextFrame(runGlobalLoop);
            }
        }
694627
def step(self, viewer=None):
        ""
        if not self.is_completed(self.state):
            for agent in self.agents:
                action = agent.program(self.percept(agent, self.state))
                next_state = self.do_action(self.state, action, agent)
                if viewer:
                    viewer.event(self.state, action, next_state, agent)
                self.state = next_state
                if self.is_completed(self.state):
                    return
857777
function(xy) {
        if(this.panned) {
            var res = null;
            if (this.kinetic) {
                res = this.kinetic.end(xy);
            }
            this.map.pan(
                this.handler.last.x - xy.x,
                this.handler.last.y - xy.y,
                {dragging: !!res, animate: false}
            );
            if (res) {
                var self = this;
                this.kinetic.move(res, function(x, y, end) {
                    self.map.pan(x, y, {dragging: !end, animate: false});
                });
            }
            this.panned = false;
        }
    }
1033586
function () {
		var series = this;

		// cache attributes for shapes
		//series.getAttribs();

		this.drawPoints();

		// draw the mouse tracking area
		if (series.options.enableMouseTracking !== false) {
			series.drawTracker();
		}
        
        // PATCH by Simon Fishel
        //
        // execute beforeLabelRender hook to allow re-formatting of data labels
        //
        // + if(series.options.hooks && series.options.hooks.beforeLabelRender) {
        // +    series.options.hooks.beforeLabelRender(series)
        // + }
        
        if(series.options.hooks && series.options.hooks.beforeLabelRender) {
            series.options.hooks.beforeLabelRender(series)
        }

		this.drawDataLabels();

		if (series.options.animation && series.animate) {
			series.animate();
		}

		series.isDirty = false; // means data is in accordance with what you see
	}
949613
private void animateView(final View target, final int type) {
        if(ANIMATION_EXPAND==type&&target.getVisibility()==VISIBLE){
            return;
        }
        if(ANIMATION_COLLAPSE==type&&target.getVisibility()!=VISIBLE){
            return;
        }
        if(mDefaultAnimExecutor !=null){
            mDefaultAnimExecutor.executeAnim(target,type);
        }

    }
1181003
function() {
        var layer = this.layer;
        for(var i=0; i<8; ++i) {
            if(this.rotate && i % 2 === 0) {
                layer.drawFeature(this.rotationHandles[i/2],
                    this.rotationHandleSymbolizer);
            }
            layer.drawFeature(this.handles[i], this.renderIntent);
        }
    }
255896
private void performStepAnimation(final Node nextSlide) {

        // setSlideLocked(true);
        this.slideStepAnimation = ParallelTransitionBuilder.create()

                                                           .onFinished(new EventHandler<ActionEvent>() {

                                                               @Override
                                                               public void handle(final ActionEvent event) {
                                                                   AbstractTemplateView.this.currentSubSlide = nextSlide;
                                                                   // AbstractTemplateView.this.setSlideLocked(false);
                                                               }
                                                           })

                                                           .children(
                                                                     SequentialTransitionBuilder.create()
                                                                                                .node(this.currentSubSlide)
                                                                                                .children(
                                                                                                          TranslateTransitionBuilder.create()
                                                                                                                                    .duration(Duration.millis(400))
                                                                                                                                    .fromY(0)
                                                                                                                                    .toY(-700)
                                                                                                                                    // .fromZ(-10)
                                                                                                                                    .build(),
                                                                                                          TimelineBuilder.create()
                                                                                                                         .keyFrames(
                                                                                                                                    new KeyFrame(
                                                                                                                                                 Duration.millis(0),
                                                                                                                                                 new KeyValue(
                                                                                                                                                              this.currentSubSlide.visibleProperty(),
                                                                                                                                                              true)),
                                                                                                                                    new KeyFrame(
                                                                                                                                                 Duration.millis(1),
                                                                                                                                                 new KeyValue(
                                                                                                                                                              this.currentSubSlide.visibleProperty(),
                                                                                                                                                              false)))
                                                                                                                         .build())

                                                                                                .build(),
                                                                     SequentialTransitionBuilder.create()
                                                                                                .node(nextSlide)
                                                                                                .children(
                                                                                                          TimelineBuilder.create()
                                                                                                                         .keyFrames(
                                                                                                                                    new KeyFrame(
                                                                                                                                                 Duration.millis(0),
                                                                                                                                                 new KeyValue(
                                                                                                                                                              nextSlide.visibleProperty(),
                                                                                                                                                              false)),
                                                                                                                                    new KeyFrame(
                                                                                                                                                 Duration.millis(1),
                                                                                                                                                 new KeyValue(
                                                                                                                                                              nextSlide.visibleProperty(),
                                                                                                                                                              true)))
                                                                                                                         .build(),
                                                                                                          TranslateTransitionBuilder.create()
                                                                                                                                    .duration(Duration.millis(400))
                                                                                                                                    .fromY(700)
                                                                                                                                    .toY(0)
                                                                                                                                    // .fromZ(-10)
                                                                                                                                    .build())
                                                                                                .build())
                                                           .build();
        this.slideStepAnimation.play();

    }