Dumps an animation channel to stdout.

@param nodeAnim the channel
481400
public static void dumpNodeAnim(AiNodeAnim nodeAnim) {
        for (int i = 0; i < nodeAnim.getNumPosKeys(); i++) {
            System.out.println(i + ": " + nodeAnim.getPosKeyTime(i) + 
                    " ticks, " + nodeAnim.getPosKeyVector(i, Jassimp.BUILTIN));
        }
    }
454611
function(node) {
			this.currentNode = node;// Updates the code path.
			// And emits onCodePathStart/onCodePathSegmentStart events.
			processCodePathToExit(this, node);

			// Emits node events.
			this.original.leaveNode(node);

			// Emits the last onCodePathStart/onCodePathSegmentStart events.
			postprocess(this, node);

			this.currentNode = null;
		}
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();

    }
843640
public void dump(OutputStream out){
        hydrate();
        PrintWriter p = new PrintWriter(out);
        for(Model m : delegate){
            p.write(m.toString());
            p.write('\n');
        }
        p.flush();
    }
617338
public void dumpAll(Iterable<? extends YamlNode> data, OutputStream output) {
        dumpAll(data.iterator(), output);
    }
708611
public void dumpAll(Iterator<? extends YamlNode> data, OutputStream output) {
        getDelegate().dumpAll(data, new OutputStreamWriter(output, Charset
                                                           .forName("UTF-8")));
    }
559610
public static void write(Node node, OutputStream out, String charset, int indent) {
		transform(new DOMSource(node), new StreamResult(out), charset, indent);
	}
304104
@Override
    public void record( final Context context,
                        final InputStream inputStream,
                        final long length,
                        final String encoding,
                        final Node outputNode ) throws Exception {
        final char[] sourceCode = JavaMetadataUtil.getJavaSourceFromTheInputStream(inputStream, length, encoding);
        record(context, sourceCode, outputNode);
    }
1026709
public void dump(PrintStream output) {
        TreeSet<String> keys = new TreeSet<String>(keySet());
        for (String key : keys) {
            output.println(key + ":" + get(key));
        }
    }
268374
@Handler
    public void onOutput(Output<?> event, WebAppMsgChannel appChannel)
            throws InterruptedException {
        appChannel.handleAppOutput(event);
    }
288673
function processAnimation(clip, root) {
      if (!outputJSON.animations) {
        outputJSON.animations = [];
      }

      var channels = [];
      var samplers = [];

      for (var i = 0; i < clip.tracks.length; ++i) {
        var track = clip.tracks[i];
        var trackBinding = THREE.PropertyBinding.parseTrackName(track.name);
        var trackNode = THREE.PropertyBinding.findNode(
          root,
          trackBinding.nodeName
        );
        var trackProperty = PATH_PROPERTIES[trackBinding.propertyName];

        if (trackBinding.objectName === 'bones') {
          if (trackNode.isSkinnedMesh === true) {
            trackNode = trackNode.skeleton.getBoneByName(
              trackBinding.objectIndex
            );
          } else {
            trackNode = undefined;
          }
        }

        if (!trackNode || !trackProperty) {
          console.warn(
            'THREE.GLTFExporter: Could not export animation track "%s".',
            track.name
          );
          return null;
        }

        var inputItemSize = 1;
        var outputItemSize = track.values.length / track.times.length;

        if (trackProperty === PATH_PROPERTIES.morphTargetInfluences) {
          if (
            trackNode.morphTargetInfluences.length !== 1 &&
            trackBinding.propertyIndex !== undefined
          ) {
            console.warn(
              'THREE.GLTFExporter: Skipping animation track "%s". ' +
                'Morph target keyframe tracks must target all available morph targets ' +
                'for the given mesh.',
              track.name
            );
            continue;
          }

          outputItemSize /= trackNode.morphTargetInfluences.length;
        }

        var interpolation;

        // @TODO export CubicInterpolant(InterpolateSmooth) as CUBICSPLINE

        // Detecting glTF cubic spline interpolant by checking factory method's special property
        // GLTFCubicSplineInterpolant is a custom interpolant and track doesn't return
        // valid value from .getInterpolation().
        if (
          track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline ===
          true
        ) {
          interpolation = 'CUBICSPLINE';

          // itemSize of CUBICSPLINE keyframe is 9
          // (VEC3 * 3: inTangent, splineVertex, and outTangent)
          // but needs to be stored as VEC3 so dividing by 3 here.
          outputItemSize /= 3;
        } else if (track.getInterpolation() === THREE.InterpolateDiscrete) {
          interpolation = 'STEP';
        } else {
          interpolation = 'LINEAR';
        }

        samplers.push({
          input: processAccessor(
            new THREE.BufferAttribute(track.times, inputItemSize)
          ),
          output: processAccessor(
            new THREE.BufferAttribute(track.values, outputItemSize)
          ),
          interpolation: interpolation
        });

        channels.push({
          sampler: samplers.length - 1,
          target: {
            node: nodeMap.get(trackNode),
            path: trackProperty
          }
        });
      }

      outputJSON.animations.push({
        name: clip.name || 'clip_' + outputJSON.animations.length,
        samplers: samplers,
        channels: channels
      });

      return outputJSON.animations.length - 1;
    }
163299
@SuppressWarnings("unused")
    @Internal
    void dump() {
        System.out.println("declaredAnnotations = " + declaredAnnotations);
        System.out.println("declaredStereotypes = " + declaredStereotypes);
        System.out.println("allAnnotations = " + allAnnotations);
        System.out.println("allStereotypes = " + allStereotypes);
        System.out.println("annotationsByStereotype = " + annotationsByStereotype);
    }
588067
public function animateMessage() {
		if (!$this->_showMessage) {
			$this->_showMessage = true;
			$this->_animateCharNum = 0;
			$msg = $this->_getWaitMsg();
			$msg .= ' ' . $this->_getAnimateChar();
			$this->_consoleOutput->write($msg, 0);
		} else {
			$msg = $this->_getAnimateChar();
			$this->_consoleOutput->overwrite($msg, 0, mb_strlen($msg));
		}
	}
177918
public void queueAnimation(final GQAnimation anim, final int duration) {
    if (isOff()) {
      anim.onStart();
      anim.onComplete();
    } else {
      queue(anim.e, DEFAULT_NAME, new Function() {
        public void cancel(Element e) {
          Animation anim = (Animation) data(e, GQAnimation.ACTUAL_ANIMATION, null);
          if (anim != null) {
            anim.cancel();
          }
        }

        public void f(Element e) {
          anim.run(duration);
        }
      });
    }
  }
896532
@SuppressWarnings("UnusedDeclaration") public void dump() {
    Buffer buffer = new Buffer();
    try {
      dump(buffer);
    } catch (IOException e) {
      throw new AssertionError(e);
    }
    Log.i(TAG, buffer.readUtf8());
  }
226728
function outputStdout(s, outputHandler) {
  if (outputHandler) {
    outputHandler(s);
  } else {
    process.stdout.write(s);
  }
}
1277246
private void dumpNode(Node node, int level, int idx, java.io.PrintStream out) {

        // if node null, then return
        if (node == null) {
            return;
        }

        // print out required spaces
        printSpaces(level, out);

        if (idx == -2) {
            out.print("ROOT -> ");
        } else {
            out.print(idx + " -> ");
        }

        // print out the values
        out.print("S: ");
        if (node.getSpecificValue() != null) {
            out.print(node.getSpecificValue().toString());
        } else {
            out.print("(null)");
        }
        out.print(", W: ");
        if (node.getPrefixValue() != null) {
            out.println(node.getPrefixValue().toString());
        } else {
            out.println("(null)");
        }

        // loop through each child node
        for (int index = 0; index < 10; index++) {
            // dump out this node...
            dumpNode(node.getNode(index), level + 1, index, out);
        }
    }