text: Clazz.declarePackage ("JV");
  Clazz.load (["JU.BS"], "JV.AnimationManager", ["J.api.Interface", "JU.BSUtil"], function () {
  c$ = Clazz.decorateAsClass (function () {
  this.animationThread = null;
  this.vwr = null;
  this.animationOn = false;
  this.animationFps = 0;
  this.firstFrameDelayMs = 0;
  this.lastFrameDelayMs = 0;
  this.bsVisibleModels = null;
  this.animationReplayMode = 1073742070;
  this.bsDisplay = null;
  this.animationFrames = null;
  this.isMovie = false;
  this.animationPaused = false;
  this.cmi = 0;
  this.caf = 0;
  this.morphCount = 0;
  this.animationDirection = 1;
  this.currentDirection = 1;
  this.firstFrameIndex = 0;
  this.lastFrameIndex = 0;
  this.frameStep = 0;
  this.backgroundModelIndex = -1;
  this.currentMorphModel = 0;
  this.firstFrameDelay = 0;
  this.lastFrameDelay = 1;
  this.lastFramePainted = 0;
  this.lastModelPainted = 0;
  this.intAnimThread = 0;
  this.cai = -1;
  Clazz.instantialize (this, arguments);
  }, JV, "AnimationManager");
  Clazz.prepareFields (c$, function () {
  this.bsVisibleModels =  new JU.BS ();
  });
  Clazz.makeConstructor (c$, 
  function (vwr) {
  this.vwr = vwr;
  }, "JV.viewer");
  Clazz.defineMethod (c$, "setAnimationOn", 
  function (animationOn) {
  if (animationOn == this.animationOn) return;
  if (!animationOn || this.vwr.headless) {
  this.stopThread (false);
  return;
  }if (!this.vwr.tm.spinOn) this.vwr.refresh (3, "Anim:setAnimationOn");
  this.setAnimationRange (-1, -1);
  this.resumeAnimation ();
  }, "~B");
  Clazz.defineMethod (c$, "stopThread", 
  function (isPaused) {
  var stopped = false;
  if (this.animationThread != null) {
  this.animationThread.interrupt ();
  this.animationThread = null;
  stopped = true;
  }this.animationPaused = isPaused;
  if (stopped && !this.vwr.tm.spinOn) this.vwr.refresh (3, "viewer:setAnimationOff");
  this.animation (false);
  this.vwr.setStatusFrameChanged (false, false);
  }, "~B");
  Clazz.defineMethod (c$, "setAnimationNext", 
  function () {
  return this.setAnimationRelative (this.animationDirection);
  });
  Clazz.defineMethod (c$, "currentIsLast", 
  function () {
  return (this.isMovie ? this.lastFramePainted == this.caf : this.lastModelPainted == this.cmi);
  });
  Clazz.defineMethod (c$, "currentFrameIs", 
  function (f) {
  var i = this.cmi;
  return (this.morphCount == 0 ? i == f : Math.abs (this.currentMorphModel - f) < 0.001);
  }, "~N");
  Clazz.defineMethod (c$, "clear", 
  function () {
  this.setMovie (null);
  this.initializePointers (0);
  this.setAnimationOn (false);
  this.setModel (0, true);
  this.currentDirection = 1;
  this.cai = -1;
  this.setAnimationDirection (1);
  this.setAnimationFps (10);
  this.setAnimationReplayMode (1073742070, 0, 0);
  this.initializePointers (0);
  });
  Clazz.defineMethod (c$, "getModelSpecial", 
  function (i) {
  switch (i) {
  case -1:
  if (this.animationFrames != null) return "1";
  i = this.firstFrameIndex;
  break;
  case 0:
  if (this.morphCount > 0) return "-" + (1 + this.currentMorphModel);
  i = this.cmi;
  break;
  case 1:
  if (this.animationFrames != null) return "" + this.animationFrames.length;
  i = this.lastFrameIndex;
  break;
  }
  return this.vwr.getModelNumberDotted (i);
  }, "~N");
  Clazz.defineMethod (c$, "setDisplay", 
  function (bs) {
  this.bsDisplay = (bs == null || bs.isEmpty () ? null : JU.BSUtil.copy (bs));
  }, "JU.BS");
  Clazz.defineMethod (c$, "setMorphCount", 
  function (n) {
  this.morphCount = (this.isMovie ? 0 : n);
  }, "~N");
  Clazz.defineMethod (c$, "morph", 
  function (modelIndex) {
  var m = Clazz.floatToInt (modelIndex);
  if (Math.abs (m - modelIndex) < 0.001) modelIndex = m;
   else if (Math.abs (m - modelIndex) > 0.999) modelIndex = m = m + 1;
  var f = modelIndex - m;
  m -= 1;
  if (f == 0) {
  this.currentMorphModel = m;
  this.setModel (m, true);
  return;
  }var m1;
  this.setModel (m, true);
  m1 = m + 1;
  this.currentMorphModel = m + f;
  if (m1 == m || m1 < 0 || m < 0) return;
  this.vwr.ms.morphTrajectories (m, m1, f);
  }, "~N");
  Clazz.defineMethod (c$, "setModel", 
  function (modelIndex, clearBackgroundModel) {
  if (modelIndex < 0) this.stopThread (false);
  var formerModelIndex = this.cmi;
  var modelSet = this.vwr.ms;
  var modelCount = (modelSet == null ? 0 : modelSet.mc);
  if (modelCount == 1) this.cmi = modelIndex = 0;
   else if (modelIndex < 0 || modelIndex >= modelCount) modelIndex = -1;
  var ids = null;
  var isSameSource = false;
  if (this.cmi != modelIndex) {
  if (modelCount > 0) {
  var ms = this.vwr.ms;
  var toDataModel = ms.isJmolDataFrameForModel (modelIndex);
  var fromDataModel = ms.isJmolDataFrameForModel (this.cmi);
  if (fromDataModel) ms.setJmolDataFrame (null, -1, this.cmi);
  if (this.cmi != -1) this.vwr.saveModelOrientation ();
  if (fromDataModel || toDataModel) {
  ids = ms.getJmolFrameType (modelIndex) + " " + modelIndex + " <-- " + " " + this.cmi + " " + ms.getJmolFrameType (this.cmi);
  isSameSource = (ms.getJmolDataSourceFrame (modelIndex) == ms.getJmolDataSourceFrame (this.cmi));
  }}this.cmi = modelIndex;
  if (ids != null) {
  if (modelIndex >= 0) this.vwr.restoreModelOrientation (modelIndex);
  if (isSameSource && (ids.indexOf ("quaternion") >= 0 || ids.indexOf ("plot") < 0 && ids.indexOf ("ramachandran") < 0 && ids.indexOf (" property ") < 0)) {
  this.vwr.restoreModelRotation (formerModelIndex);
  }}}this.setviewer (clearBackgroundModel);
  }, "~N,~B");
  Clazz.defineMethod (c$, "setBackgroundModelIndex", 
  function (modelIndex) {
  var modelSet = this.vwr.ms;
  if (modelSet == null || modelIndex < 0 || modelIndex >= modelSet.mc) modelIndex = -1;
  this.backgroundModelIndex = modelIndex;
  if (modelIndex >= 0) this.vwr.ms.setTrajectory (modelIndex);
  this.vwr.setTainted (true);
  this.setFrameRangeVisible ();
  }, "~N");
  Clazz.defineMethod (c$, "initializePointers", 
  function (frameStep) {
  this.firstFrameIndex = 0;
  this.lastFrameIndex = (frameStep == 0 ? 0 : this.getFrameCount ()) - 1;
  this.frameStep = frameStep;
  this.vwr.setFrameVariables ();
  }, "~N");
  Clazz.defineMethod (c$, "setAnimationDirection", 
  function (animationDirection) {
  this.animationDirection = animationDirection;
  }, "~N");
  Clazz.defineMethod (c$, "setAnimationFps", 
  function (fps) {
  if (fps < 1) fps = 1;
  if (fps > 50) fps = 50;
  this.animationFps = fps;
  this.vwr.setFrameVariables ();
  }, "~N");
  Clazz.defineMethod (c$, "setAnimationReplayMode", 
  function (animationReplayMode, firstFrameDelay, lastFrameDelay) {
  this.firstFrameDelay = firstFrameDelay > 0 ? firstFrameDelay : 0;
  this.firstFrameDelayMs = Clazz.floatToInt (this.firstFrameDelay * 1000);
  this.lastFrameDelay = lastFrameDelay > 0 ? lastFrameDelay : 0;
  this.lastFrameDelayMs = Clazz.floatToInt (this.lastFrameDelay * 1000);
  this.animationReplayMode = animationReplayMode;
  this.vwr.setFrameVariables ();
  }, "~N,~N,~N");
  Clazz.defineMethod (c$, "setAnimationRange", 
  function (framePointer, framePointer2) {
  var frameCount = this.getFrameCount ();
  if (framePointer < 0) framePointer = 0;
  if (framePointer2 < 0) framePointer2 = frameCount;
  if (framePointer >= frameCount) framePointer = frameCount - 1;
  if (framePointer2 >= frameCount) framePointer2 = frameCount - 1;
  this.firstFrameIndex = framePointer;
  this.currentMorphModel = this.firstFrameIndex;
  this.lastFrameIndex = framePointer2;
  this.frameStep = (framePointer2 < framePointer ? -1 : 1);
  this.rewindAnimation ();
  }, "~N,~N");
  Clazz.defineMethod (c$, "pauseAnimation", 
  function () {
  this.stopThread (true);
  });
  Clazz.defineMethod (c$, "reverseAnimation", 
  function () {
  this.currentDirection = -this.currentDirection;
  if (!this.animationOn) this.resumeAnimation ();
  });
  Clazz.defineMethod (c$, "repaintDone", 
  function () {
  this.lastModelPainted = this.cmi;
  this.lastFramePainted = this.caf;
  });
  Clazz.defineMethod (c$, "resumeAnimation", 
  function () {
  if (this.cmi < 0) this.setAnimationRange (this.firstFrameIndex, this.lastFrameIndex);
  if (this.getFrameCount () <= 1) {
  this.animation (false);
  return;
  }this.animation (true);
  this.animationPaused = false;
  if (this.animationThread == null) {
  this.intAnimThread++;
  this.animationThread = J.api.Interface.getOption ("thread.AnimationThread", this.vwr, "script");
  this.animationThread.setManager (this, this.vwr,  Clazz.newIntArray (-1, [this.firstFrameIndex, this.lastFrameIndex, this.intAnimThread]));
  this.animationThread.start ();
  }});
  Clazz.defineMethod (c$, "setAnimationLast", 
  function () {
  this.setFrame (this.animationDirection > 0 ? this.lastFrameIndex : this.firstFrameIndex);
  });
  Clazz.defineMethod (c$, "rewindAnimation", 
  function () {
  this.setFrame (this.animationDirection > 0 ? this.firstFrameIndex : this.lastFrameIndex);
  this.currentDirection = 1;
  this.vwr.setFrameVariables ();
  });
  Clazz.defineMethod (c$, "setAnimationPrevious", 
  function () {
  return this.setAnimationRelative (-this.animationDirection);
  });
  Clazz.defineMethod (c$, "getAnimRunTimeSeconds", 
  function () {
  var frameCount = this.getFrameCount ();
  if (this.firstFrameIndex == this.lastFrameIndex || this.lastFrameIndex < 0 || this.firstFrameIndex < 0 || this.lastFrameIndex >= frameCount || this.firstFrameIndex >= frameCount) return 0;
  var i0 = Math.min (this.firstFrameIndex, this.lastFrameIndex);
  var i1 = Math.max (this.firstFrameIndex, this.lastFrameIndex);
  var nsec = 1 * (i1 - i0) / this.animationFps + this.firstFrameDelay + this.lastFrameDelay;
  for (var i = i0; i <= i1; i++) nsec += this.vwr.ms.getFrameDelayMs (this.modelIndexForFrame (i)) / 1000;
  
  return nsec;
  });
  Clazz.defineMethod (c$, "setMovie", 
  function (info) {
  this.isMovie = (info != null && info.get ("scripts") == null);
  if (this.isMovie) {
  this.animationFrames = info.get ("frames");
  if (this.animationFrames == null || this.animationFrames.length == 0) {
  this.isMovie = false;
  } else {
  this.caf = (info.get ("currentFrame")).intValue ();
  if (this.caf < 0 || this.caf >= this.animationFrames.length) this.caf = 0;
  }this.setFrame (this.caf);
  }if (!this.isMovie) {
  this.animationFrames = null;
  }this.vwr.setBooleanProperty ("_ismovie", this.isMovie);
  this.bsDisplay = null;
  this.currentMorphModel = this.morphCount = 0;
  this.vwr.setFrameVariables ();
  }, "java.util.Map");
  Clazz.defineMethod (c$, "modelIndexForFrame", 
  function (i) {
  return (this.isMovie ? this.animationFrames[i] - 1 : i);
  }, "~N");
  Clazz.defineMethod (c$, "getFrameCount", 
  function () {
  return (this.isMovie ? this.animationFrames.length : this.vwr.ms.mc);
  });
  Clazz.defineMethod (c$, "setFrame", 
  function (i) {
  try {
  if (this.isMovie) {
  var iModel = this.modelIndexForFrame (i);
  this.caf = i;
  i = iModel;
  } else {
  this.caf = i;
  }this.setModel (i, true);
  } catch (e) {
  if (Clazz.exceptionOf (e, Exception)) {
  } else {
  throw e;
  }
  }
  }, "~N");
  Clazz.defineMethod (c$, "setviewer", 
   function (clearBackgroundModel) {
  this.vwr.ms.setTrajectory (this.cmi);
  this.vwr.tm.setFrameOffset (this.cmi);
  if (this.cmi == -1 && clearBackgroundModel) this.setBackgroundModelIndex (-1);
  this.vwr.setTainted (true);
  var nDisplay = this.setFrameRangeVisible ();
  this.vwr.setStatusFrameChanged (false, false);
  if (!this.vwr.g.selectAllModels) this.setSelectAllSubset (nDisplay < 2);
  }, "~B");
  Clazz.defineMethod (c$, "setSelectAllSubset", 
  function (justOne) {
  if (this.vwr.ms != null) this.vwr.slm.setSelectionSubset (justOne ? this.vwr.ms.getModelAtomBitSetIncludingDeleted (this.cmi, true) : this.vwr.ms.getModelAtomBitSetIncludingDeletedBs (this.bsVisibleModels));
  }, "~B");
  Clazz.defineMethod (c$, "setFrameRangeVisible", 
   function () {
  var nDisplayed = 0;
  this.bsVisibleModels.clearAll ();
  if (this.backgroundModelIndex >= 0) {
  this.bsVisibleModels.set (this.backgroundModelIndex);
  nDisplayed = 1;
  }if (this.cmi >= 0) {
  this.bsVisibleModels.set (this.cmi);
  return ++nDisplayed;
  }if (this.frameStep == 0) return nDisplayed;
  var frameDisplayed = 0;
  nDisplayed = 0;
  for (var iframe = this.firstFrameIndex; iframe != this.lastFrameIndex; iframe += this.frameStep) {
  var i = this.modelIndexForFrame (iframe);
  if (!this.vwr.ms.isJmolDataFrameForModel (i)) {
  this.bsVisibleModels.set (i);
  nDisplayed++;
  frameDisplayed = iframe;
  }}
  var i = this.modelIndexForFrame (this.lastFrameIndex);
  if (this.firstFrameIndex == this.lastFrameIndex || !this.vwr.ms.isJmolDataFrameForModel (i) || nDisplayed == 0) {
  this.bsVisibleModels.set (i);
  if (nDisplayed == 0) this.firstFrameIndex = this.lastFrameIndex;
  nDisplayed = 0;
  }if (nDisplayed == 1 && this.cmi < 0) this.setFrame (frameDisplayed);
  return nDisplayed;
  });
  Clazz.defineMethod (c$, "animation", 
   function (TF) {
  this.animationOn = TF;
  this.vwr.setBooleanProperty ("_animating", TF);
  }, "~B");
  Clazz.defineMethod (c$, "setAnimationRelative", 
   function (direction) {
  var frameStep = this.getFrameStep (direction);
  var thisFrame = (this.isMovie ? this.caf : this.cmi);
  var frameNext = thisFrame + frameStep;
  var morphStep = 0;
  var nextMorphFrame = 0;
  var isDone;
  if (this.morphCount > 0) {
  morphStep = 1 / (this.morphCount + 1);
  nextMorphFrame = this.currentMorphModel + frameStep * morphStep;
  isDone = this.isNotInRange (nextMorphFrame);
  } else {
  isDone = this.isNotInRange (frameNext);
  }if (isDone) {
  switch (this.animationReplayMode) {
  case 1073742070:
  return false;
  case 528411:
  nextMorphFrame = frameNext = (this.animationDirection == this.currentDirection ? this.firstFrameIndex : this.lastFrameIndex);
  break;
  case 1073742082:
  this.currentDirection = -this.currentDirection;
  frameNext -= 2 * frameStep;
  nextMorphFrame -= 2 * frameStep * morphStep;
  }
  }if (this.morphCount < 1) {
  if (frameNext < 0 || frameNext >= this.getFrameCount ()) return false;
  this.setFrame (frameNext);
  return true;
  }this.morph (nextMorphFrame + 1);
  return true;
  }, "~N");
  Clazz.defineMethod (c$, "isNotInRange", 
   function (frameNext) {
  var f = frameNext - 0.001;
  return (f > this.firstFrameIndex && f > this.lastFrameIndex || (f = frameNext + 0.001) < this.firstFrameIndex && f < this.lastFrameIndex);
  }, "~N");
  Clazz.defineMethod (c$, "getFrameStep", 
   function (direction) {
  return this.frameStep * direction * this.currentDirection;
  }, "~N");
  Clazz.defineStatics (c$,
  "FRAME_FIRST", -1,
  "FRAME_LAST", 1,
  "MODEL_CURRENT", 0);
  });
  