TransformManager
Date: 2019-10-22

org.jmol.viewer

## Class TransformManager

- java.lang.Object
- - org.jmol.viewer.TransformManager

- Direct Known Subclasses:
    TransformManager4D

      public class TransformManager
      extends java.lang.Object

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected javajs.util.A4` | `aaTest1`
    `protected boolean` | `antialias`
    `protected float` | `aperatureAngle`
    `private javajs.util.A4` | `axisangleT`
    `javajs.util.BS` | `bsFrameOffsets`
    `(package private) javajs.util.BS` | `bsSelectedAtoms`
    `javajs.util.P3` | `camera`
    `protected float` | `cameraDepth`
    `protected float` | `cameraDepthSetting`
    `float` | `cameraDistance`
    `protected float` | `cameraDistanceFromCenter`
    `protected float` | `cameraScaleFactor`
    `javajs.util.P3` | `cameraSetting`
    `(package private) static float` | `DEFAULT_CAMERA_DEPTH`
    `(package private) static int` | `DEFAULT_NAV_FPS`
    `(package private) static boolean` | `DEFAULT_PERSPECTIVE_DEPTH`
    `(package private) static int` | `DEFAULT_PERSPECTIVE_MODEL`
    `(package private) static int` | `DEFAULT_SPIN_FPS`
    `(package private) static int` | `DEFAULT_SPIN_Y`
    `static int` | `DEFAULT_STEREO_DEGREES`
    `static float` | `DEFAULT_VISUAL_RANGE`
    `int` | `defaultMode`
    `static double` | `degreesPerRadian`
    `(package private) int` | `depthPercentSetting`
    `(package private) javajs.util.P4` | `depthPlane`
    `int` | `depthValue`
    `protected boolean` | `doTransform4D`
    `javajs.util.A4` | `fixedRotationAxis`
    `javajs.util.P3` | `fixedRotationCenter`
    `javajs.util.P3` | `fixedRotationOffset`
    `javajs.util.P3` | `fixedTranslation`
    `(package private) javajs.util.P3` | `frameOffset`
    `(package private) javajs.util.P3[]` | `frameOffsets`
    `protected javajs.util.P3` | `fScrPt`
    `protected boolean` | `haveNotifiedNaN`
    `int` | `height`
    `private float` | `internalRotationAngle`
    `javajs.util.A4` | `internalRotationAxis`
    `(package private) javajs.util.P3` | `internalRotationCenter`
    `boolean` | `internalSlab`
    `protected javajs.util.V3` | `internalTranslation`
    `protected javajs.util.P3i` | `iScrPt`
    `boolean` | `isSpinFixed`
    `boolean` | `isSpinInternal`
    `(package private) boolean` | `isSpinSelected`
    `javajs.util.M3` | `matrixRotate`
    `protected javajs.util.M3` | `matrixStereo`
    `protected javajs.util.M4` | `matrixTemp`
    `protected javajs.util.M3` | `matrixTemp3`
    `private javajs.util.M4` | `matrixTemp4`
    `protected javajs.util.M3` | `matrixTest`
    `javajs.util.M4` | `matrixTransform`
    `javajs.util.M4` | `matrixTransformInv`
    `static int` | `MAXIMUM_ZOOM_PERCENTAGE`
    `private static int` | `MAXIMUM_ZOOM_PERSPECTIVE_DEPTH`
    `int` | `mode`
    `static int` | `MODE_NAVIGATION`
    `static int` | `MODE_PERSPECTIVE_PYMOL`
    `static int` | `MODE_STANDARD`
    `float` | `modelCenterOffset`
    `float` | `modelRadius`
    `float` | `modelRadiusPixels`
    `JmolThread` | `movetoThread`
    `private JmolNavigatorInterface` | `nav`
    `static int` | `NAV_MODE_IGNORE`
    `static int` | `NAV_MODE_NEWXY`
    `static int` | `NAV_MODE_NEWXYZ`
    `static int` | `NAV_MODE_NEWZ`
    `static int` | `NAV_MODE_NONE`
    `static int` | `NAV_MODE_RESET`
    `static int` | `NAV_MODE_ZOOMED`
    `float` | `navFps`
    `boolean` | `navigating`
    `javajs.util.P3` | `navigationCenter`
    `float` | `navigationDepthPercent`
    `javajs.util.P3` | `navigationOffset`
    `javajs.util.P3` | `navigationShiftXY`
    `float` | `navigationSlabOffset`
    `int` | `navMode`
    `boolean` | `navOn`
    `float` | `navX`
    `float` | `navY`
    `float` | `navZ`
    `boolean` | `perspectiveDepth`
    `protected int` | `perspectiveModel`
    `protected javajs.util.P3` | `perspectiveOffset`
    `protected javajs.util.P3` | `perspectiveShiftXY`
    `private javajs.util.P3` | `pointT2`
    `float` | `previousX`
    `float` | `previousY`
    `protected float` | `prevZoomSetting`
    `(package private) javajs.util.P3` | `ptOffset`
    `protected javajs.util.P3` | `ptTest1`
    `protected javajs.util.P3` | `ptTest2`
    `protected javajs.util.P3` | `ptTest3`
    `(package private) Point3fi` | `ptVibTemp`
    `float` | `referencePlaneOffset`
    `(package private) javajs.util.V3` | `rotationAxis`
    `private javajs.util.P3` | `rotationCenterDefault`
    `private float` | `rotationRadiusDefault`
    `(package private) float` | `rotationRate`
    `protected boolean` | `scale3D`
    `(package private) float` | `scale3DAngstromsPerInch`
    `float` | `scaleDefaultPixelsPerAngstrom`
    `(package private) float` | `scalePixelsPerAngstrom`
    `(package private) int` | `screenHeight`
    `int` | `screenPixelCount`
    `(package private) int` | `screenWidth`
    `boolean` | `slabEnabled`
    `(package private) int` | `slabPercentSetting`
    `(package private) javajs.util.P4` | `slabPlane`
    `(package private) float` | `slabRange`
    `int` | `slabValue`
    `float` | `spinFps`
    `private boolean` | `spinIsGesture`
    `boolean` | `spinOn`
    `JmolThread` | `spinThread`
    `float` | `spinX`
    `float` | `spinY`
    `float` | `spinZ`
    `(package private) int[]` | `stereoColors`
    `(package private) float` | `stereoDegrees`
    `(package private) boolean` | `stereoDoubleDTI`
    `(package private) boolean` | `stereoDoubleFull`
    `(package private) boolean` | `stereoFrame`
    `(package private) STER` | `stereoMode`
    `(package private) float` | `stereoRadians`
    `protected javajs.util.P3` | `untransformedPoint`
    `private boolean` | `useZoomLarge`
    `private javajs.util.V3` | `vectorT`
    `private javajs.util.V3` | `vectorT2`
    `protected javajs.util.V3` | `vectorTemp`
    `boolean` | `vibrationOn`
    `(package private) float` | `vibrationPeriod`
    `int` | `vibrationPeriodMs`
    `private float` | `vibrationScale`
    `private javajs.util.P3` | `vibrationT`
    `JmolThread` | `vibrationThread`
    `float` | `visualRangeAngstroms`
    `protected Viewer` | `vwr`
    `int` | `width`
    `boolean` | `windowCentered`
    `(package private) float` | `xTranslationFraction`
    `(package private) float` | `yTranslationFraction`
    `int` | `zDepthPercentSetting`
    `int` | `zDepthValue`
    `float` | `zmPct` zoom percent zmPct is the current displayed zoom value, AFTER rendering; may not be the same as zmPctSet, particularly if zoom is not enabled
    `(package private) float` | `zmPctSet` zoom percent setting the current setting of zoom; may not be the same as zmPct, particularly if zoom is not enabled
    `boolean` | `zoomEnabled`
    `float` | `zoomFactor`
    `private boolean` | `zoomHeight`
    `private float` | `zoomRatio`
    `boolean` | `zShadeEnabled`
    `int` | `zSlabPercentSetting`
    `javajs.util.P3` | `zSlabPoint`
    `int` | `zSlabValue`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `TransformManager()`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `private void` | `addZoomTranslationNavigationText(javajs.util.SB sb)`
    `(package private) int` | `angstromsToPixels(float distance)`
    `private javajs.util.P3i` | `applyPerspective(javajs.util.T3 ptXYZ, javajs.util.T3 ptRef)` adjusts the temporary point for perspective and offsets
    `private void` | `applyRotation(javajs.util.M3 mNew, boolean isInternal, javajs.util.BS bsAtoms, javajs.util.V3 translation, boolean translationOnly, javajs.util.M4 m4)`
    `void` | `calcCameraFactors()` sets all camera and scale factors needed by the specific perspective model instantiated
    `private void` | `calcNavCameraFactors(float offset100)`
    `protected void` | `calcNavigationPoint()` All the magic happens here.
    `void` | `calcSlabAndDepthValues()` sets slab and depth, possibly using visual range considerations for setting the slab-clipping plane.
    `void` | `calcTransformMatrix()`
    `void` | `centerAt(int x, int y, javajs.util.P3 pt)`
    `(package private) void` | `clear()`
    `private void` | `clearSpin()`
    `(package private) void` | `clearThreads()`
    `private void` | `clearVibration()`
    `float` | `defaultScaleToScreen(float radius)`
    `(package private) void` | `depthByPercentagePoints(int percentage)`
    `void` | `depthToPercent(int percentDepth)`
    `void` | `finalizeTransformParameters()`
    `float` | `getCameraDepth()`
    `javajs.util.P3[]` | `getCameraFactors()` This method returns data needed by the VRML, X3D, and IDTF/U3D exporters.
    `private java.lang.String` | `getCenterText()`
    `java.lang.String` | `getMoveToText(float timespan, boolean addComments)`
    `private boolean` | `getNav()`
    `javajs.util.P3` | `getNavigationOffset()`
    `float` | `getNavigationOffsetPercent(char XorY)`
    `protected java.lang.String` | `getNavigationState()`
    `protected java.lang.String` | `getNavigationText(boolean addComments)`
    `float` | `getNavPtHeight()`
    `(package private) void` | `getNewFixedRotationCenter()`
    `(package private) java.util.Map<java.lang.String,java.lang.Object>` | `getOrientationInfo()`
    `(package private) java.lang.String` | `getOrientationText(int type, boolean isBest)`
    `boolean` | `getPerspectiveDepth()`
    `float` | `getPerspectiveFactor(float z)` calculate the perspective factor based on z
    `private java.lang.String` | `getRotateXyzText()`
    `private java.lang.String` | `getRotateZyzText(boolean iAddComment)`
    `void` | `getRotation(javajs.util.M3 m)`
    `javajs.util.Quat` | `getRotationQ()`
    `(package private) java.lang.String` | `getRotationText()`
    `protected void` | `getScreenTemp(javajs.util.T3 ptXYZ)`
    `private javajs.util.P4` | `getSlabDepthPlane(boolean isDepth)`
    `int` | `getSlabPercentSetting()`
    `(package private) javajs.util.M3` | `getStereoRotationMatrix(boolean stereoFrame)`
    `(package private) static TransformManager` | `getTransformManager(Viewer vwr, int width, int height, boolean is4D)`
    `java.lang.String` | `getTranslationScript()`
    `float` | `getTranslationXPercent()`
    `float` | `getTranslationYPercent()`
    `javajs.util.T3` | `getVibrationPoint(Vibration v, javajs.util.T3 pt, float scale)` return
    `float` | `getZoomSetting()`
    `void` | `homePosition(boolean resetSpin)`
    `boolean` | `isInPosition(javajs.util.V3 axis, float degrees)`
    `boolean` | `isNavigating()`
    `(package private) boolean` | `isVibrationOn()`
    `boolean` | `isWindowCentered()`
    `(package private) void` | `move(JmolScriptEvaluator eval, javajs.util.V3 dRot, float dZoom, javajs.util.V3 dTrans, float dSlab, float floatSecondsTotal, int fps)`
    `void` | `moveRotationCenter(javajs.util.P3 center, boolean toXY)`
    `(package private) void` | `moveTo(JmolScriptEvaluator eval, float floatSecondsTotal, javajs.util.P3 center, javajs.util.T3 rotAxis, float degrees, javajs.util.M3 matrixEnd, float zoom, float xTrans, float yTrans, float newRotationRadius, javajs.util.P3 navCenter, float xNav, float yNav, float navDepth, float cameraDepth, float cameraX, float cameraY)`
    `boolean` | `moveToPyMOL(JmolScriptEvaluator eval, float floatSecondsTotal, float[] pymolView)`
    `void` | `navigateAxis(javajs.util.V3 rotAxis, float degrees)` scripted entry point for navigation
    `(package private) void` | `navigateKey(int keyCode, int modifiers)` entry point for keyboard-based navigation
    `void` | `navigateList(JmolScriptEvaluator eval, javajs.util.Lst<java.lang.Object[]> list)`
    `private void` | `navInterrupt()`
    `void` | `navTranslatePercentOrTo(float seconds, float x, float y)` seconds < 0 means "to (x,y)"; >= 0 mean "to (x%, y%)"
    `int` | `percentToPixels(char xyz, float percent)`
    `private void` | `resetFitToScreen(boolean andCenter)`
    `protected void` | `resetNavigationPoint(boolean doResetSlab)` something has arisen that requires resetting of the navigation point.
    `void` | `resetRotation()`
    `private void` | `resetXYCenter(int x, int y)`
    `protected void` | `rotate3DBall(float xDeg, float yDeg, javajs.util.BS bsAtoms)`
    `(package private) boolean` | `rotateAboutPointsInternal(JmolScriptEvaluator eval, javajs.util.T3 point1, javajs.util.T3 point2, float degreesPerSecond, float endDegrees, boolean isClockwise, boolean isSpin, javajs.util.BS bsAtoms, boolean isGesture, javajs.util.V3 translation, javajs.util.Lst<javajs.util.P3> finalPoints, float[] dihedralList, javajs.util.M4 m4)`
    `void` | `rotateAxisAngle(javajs.util.V3 rotAxis, float radians)`
    `private void` | `rotateAxisAngle2(javajs.util.A4 axisAngle, javajs.util.BS bsAtoms)`
    `(package private) boolean` | `rotateAxisAngleAtCenter(JmolScriptEvaluator eval, javajs.util.P3 rotCenter, javajs.util.V3 rotAxis, float degreesPerSecond, float endDegrees, boolean isSpin, javajs.util.BS bsAtoms)`
    `void` | `rotateAxisAngleRadiansFixed(float angleRadians, javajs.util.BS bsAtoms)`
    `void` | `rotateAxisAngleRadiansInternal(float radians, javajs.util.BS bsAtoms, javajs.util.M4 m4)`
    `void` | `rotatePoint(javajs.util.T3 pt, javajs.util.T3 ptRot)`
    `void` | `rotateXRadians(float angleRadians, javajs.util.BS bsAtoms)`
    `protected void` | `rotateXYBy(float degX, float degY, javajs.util.BS bsAtoms)`
    `void` | `rotateYRadians(float angleRadians, javajs.util.BS bsAtoms)`
    `(package private) void` | `rotateZBy(int zDelta, int x, int y)`
    `void` | `rotateZRadians(float angleRadians)`
    `(package private) void` | `scaleFitToScreen(boolean andCenter, boolean zoomLarge, boolean resetSlab, boolean resetZoom)`
    `float` | `scaleToPerspective(int z, float sizeAngstroms)`
    `float` | `scaleToScreen(int z, int milliAngstroms)`
    `void` | `setAll(javajs.util.P3 center, javajs.util.M3 m, javajs.util.P3 navCenter, float zoom, float xTrans, float yTrans, float rotationRadius, float pixelScale, float navDepth, float xNav, float yNav, float cameraDepth, float cameraX, float cameraY)`
    `(package private) void` | `setAntialias(boolean TF)`
    `void` | `setCamera(float x, float y)`
    `void` | `setCameraDepthPercent(float percent, boolean resetSlab)` either as a percent -300, or as a float 3.0 note this percent is of zoom=100 size of model
    `(package private) void` | `setCenter()`
    `void` | `setCenterAt(int relativeTo, javajs.util.P3 pt)`
    `(package private) void` | `setDefaultPerspective()`
    `private void` | `setFixedRotationCenter(javajs.util.T3 center)`
    `(package private) void` | `setFrameOffset(int modelIndex)`
    `protected void` | `setNavFps(int navFps)`
    `void` | `setNavigatePt(javajs.util.P3 pt)` scripted entry point for navigation
    `void` | `setNavigationDepthPercent(float percent)` sets the position of the navigation offset relative to the model (50% center; 0% rear, 100% front; can be <0 or >100)
    `(package private) void` | `setNavigationMode(boolean TF)`
    `void` | `setNavigationOffsetRelative()`
    `(package private) void` | `setNavigationSlabOffsetPercent(float percent)`
    `void` | `setNavOn(boolean navOn)`
    `void` | `setNavXYZ(float x, float y, float z)`
    `(package private) void` | `setNewRotationCenter(javajs.util.P3 center, boolean doScale)`
    `(package private) void` | `setPerspectiveDepth(boolean perspectiveDepth)`
    `void` | `setRotation(javajs.util.M3 m)`
    `private void` | `setRotationCenterAndRadiusXYZ(javajs.util.T3 newCenterOfRotation, boolean andRadius)`
    `(package private) void` | `setRotationPointXY(javajs.util.P3 center)`
    `float` | `setRotationRadius(float angstroms, boolean doAll)`
    `(package private) void` | `setScaleAngstromsPerInch(float angstromsPerInch)`
    `(package private) void` | `setScreenParameters(int screenWidth, int screenHeight, boolean useZoomLarge, boolean antialias, boolean resetSlab, boolean resetZoom)`
    `private void` | `setScreenParameters0(int screenWidth, int screenHeight, boolean useZoomLarge, boolean antialias, boolean resetSlab, boolean resetZoom)`
    `(package private) void` | `setSelectedTranslation(javajs.util.BS bsAtoms, char xyz, int xy)`
    `void` | `setSlabDepthInternal(boolean isDepth)` set internal slab or depth from screen-based slab or depth
    `(package private) void` | `setSlabEnabled(boolean slabEnabled)`
    `void` | `setSlabRange(float value)`
    `private void` | `setSpin(JmolScriptEvaluator eval, boolean spinOn, float endDegrees, javajs.util.Lst<javajs.util.P3> endPositions, float[] dihedralList, javajs.util.BS bsAtoms, boolean isGesture)`
    `(package private) void` | `setSpinFps(int value)`
    `void` | `setSpinOff()`
    `void` | `setSpinOn()`
    `(package private) void` | `setSpinXYZ(float x, float y, float z)`
    `(package private) void` | `setStereoDegrees(float stereoDegrees)`
    `(package private) void` | `setStereoMode(STER stereoMode)`
    `(package private) void` | `setStereoMode2(int[] twoColors)`
    `(package private) void` | `setTranslationFractions()`
    `private void` | `setVibrationOn(boolean vibrationOn)`
    `void` | `setVibrationPeriod(float period)` sets the period of vibration -- period > 0: sets the period and turns vibration on -- period < 0: sets the period but does not turn vibration on -- period = 0: sets the period to zero and turns vibration off -- period Float.NaN: uses current setting (frame change)
    `(package private) void` | `setVibrationScale(float scale)`
    `void` | `setVibrationT(float t)`
    `(package private) void` | `setWindowCentered(boolean TF)`
    `(package private) void` | `setZoomEnabled(boolean zoomEnabled)`
    `void` | `setZoomHeight(boolean zoomHeight, boolean zoomLarge)`
    `(package private) void` | `setZShadeEnabled(boolean zShadeEnabled)`
    `(package private) void` | `slabByPercentagePoints(int percentage)`
    `(package private) void` | `slabDepthByPercentagePoints(int percentage)`
    `private void` | `slabDepthChanged()`
    `void` | `slabInternal(javajs.util.P4 plane, boolean isDepth)`
    `void` | `slabReset()`
    `void` | `slabToPercent(int percentSlab)`
    `(package private) void` | `spinXYBy(int xDelta, int yDelta, float speed)`
    `void` | `stopMotion()`
    `javajs.util.P3i` | `transformPt(javajs.util.T3 ptXYZ)` CAUTION! returns a POINTER TO A TEMPORARY VARIABLE
    `javajs.util.P3i` | `transformPt2D(javajs.util.T3 ptXyp)`
    `void` | `transformPt3f(javajs.util.T3 ptXYZ, javajs.util.P3 screen)`
    `void` | `transformPtNoClip(javajs.util.T3 ptXYZ, javajs.util.T3 pointScreen)`
    `void` | `transformPtScr(javajs.util.T3 ptXYZ, javajs.util.P3i pointScreen)`
    `void` | `transformPtScrT3(javajs.util.T3 ptXYZ, javajs.util.T3 pointScreen)`
    `javajs.util.P3i` | `transformPtVib(javajs.util.P3 ptXYZ, Vibration v)`
    `void` | `translateToPercent(char type, float percent)`
    `(package private) void` | `translateXYBy(int xDelta, int yDelta)`
    `(package private) void` | `translateZBy(int pixels)`
    `private static void` | `truncate0(javajs.util.SB sb, float val)`
    `private static void` | `truncate2(javajs.util.SB sb, float val)`
    `float` | `unscaleToScreen(float z, float screenDistance)`
    `void` | `unTransformPoint(javajs.util.T3 screenPt, javajs.util.T3 coordPt)`
    `boolean` | `xyzIsSlabbedInternal(javajs.util.T3 ptRef)`
    `(package private) void` | `zDepthToPercent(int percentDepth)`
    `protected void` | `zoomBy(int pixels)` standard response to user mouse vertical shift-drag
    `(package private) void` | `zoomByFactor(float factor, int x, int y)`
    `(package private) void` | `zoomByPercent(float percentZoom)`
    `void` | `zoomToPercent(float percentZoom)`
    `(package private) void` | `zSlabToPercent(int percentSlab)`
    `int` | `zValueFromPercent(int zPercent)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### vwr

          protected Viewer vwr

    - #### DEFAULT_SPIN_Y

          static final int DEFAULT_SPIN_Y

      See Also:
        Constant Field Values

    - #### DEFAULT_SPIN_FPS

          static final int DEFAULT_SPIN_FPS

      See Also:
        Constant Field Values

    - #### DEFAULT_NAV_FPS

          static final int DEFAULT_NAV_FPS

      See Also:
        Constant Field Values

    - #### DEFAULT_VISUAL_RANGE

          public static final float DEFAULT_VISUAL_RANGE

      See Also:
        Constant Field Values

    - #### DEFAULT_STEREO_DEGREES

          public static final int DEFAULT_STEREO_DEGREES

      See Also:
        Constant Field Values

    - #### MODE_STANDARD

          public static final int MODE_STANDARD

      See Also:
        Constant Field Values

    - #### MODE_NAVIGATION

          public static final int MODE_NAVIGATION

      See Also:
        Constant Field Values

    - #### MODE_PERSPECTIVE_PYMOL

          public static final int MODE_PERSPECTIVE_PYMOL

      See Also:
        Constant Field Values

    - #### DEFAULT_PERSPECTIVE_MODEL

          static final int DEFAULT_PERSPECTIVE_MODEL

      See Also:
        Constant Field Values

    - #### DEFAULT_PERSPECTIVE_DEPTH

          static final boolean DEFAULT_PERSPECTIVE_DEPTH

      See Also:
        Constant Field Values

    - #### DEFAULT_CAMERA_DEPTH

          static final float DEFAULT_CAMERA_DEPTH

      See Also:
        Constant Field Values

    - #### movetoThread

          public JmolThread movetoThread

    - #### vibrationThread

          public JmolThread vibrationThread

    - #### spinThread

          public JmolThread spinThread

    - #### degreesPerRadian

          public static final double degreesPerRadian

      See Also:
        Constant Field Values

    - #### perspectiveModel

          protected int perspectiveModel

    - #### cameraScaleFactor

          protected float cameraScaleFactor

    - #### referencePlaneOffset

          public float referencePlaneOffset

    - #### aperatureAngle

          protected float aperatureAngle

    - #### cameraDistanceFromCenter

          protected float cameraDistanceFromCenter

    - #### modelCenterOffset

          public float modelCenterOffset

    - #### modelRadius

          public float modelRadius

    - #### modelRadiusPixels

          public float modelRadiusPixels

    - #### navigationCenter

          public final javajs.util.P3 navigationCenter

    - #### navigationOffset

          public final javajs.util.P3 navigationOffset

    - #### navigationShiftXY

          public final javajs.util.P3 navigationShiftXY

    - #### navigationDepthPercent

          public float navigationDepthPercent

    - #### matrixTemp

          protected final javajs.util.M4 matrixTemp

    - #### vectorTemp

          protected final javajs.util.V3 vectorTemp

    - #### haveNotifiedNaN

          protected boolean haveNotifiedNaN

    - #### spinX

          public float spinX

    - #### spinY

          public float spinY

    - #### spinZ

          public float spinZ

    - #### spinFps

          public float spinFps

    - #### navX

          public float navX

    - #### navY

          public float navY

    - #### navZ

          public float navZ

    - #### navFps

          public float navFps

    - #### isSpinInternal

          public boolean isSpinInternal

    - #### isSpinFixed

          public boolean isSpinFixed

    - #### isSpinSelected

          boolean isSpinSelected

    - #### doTransform4D

          protected boolean doTransform4D

    - #### fixedRotationOffset

          public final javajs.util.P3 fixedRotationOffset

    - #### fixedRotationCenter

          public final javajs.util.P3 fixedRotationCenter

    - #### perspectiveOffset

          protected final javajs.util.P3 perspectiveOffset

    - #### perspectiveShiftXY

          protected final javajs.util.P3 perspectiveShiftXY

    - #### rotationCenterDefault

          private final javajs.util.P3 rotationCenterDefault

    - #### rotationRadiusDefault

          private float rotationRadiusDefault

    - #### fixedRotationAxis

          public final javajs.util.A4 fixedRotationAxis

    - #### internalRotationAxis

          public final javajs.util.A4 internalRotationAxis

    - #### internalTranslation

          protected javajs.util.V3 internalTranslation

    - #### internalRotationCenter

          final javajs.util.P3 internalRotationCenter

    - #### internalRotationAngle

          private float internalRotationAngle

    - #### matrixRotate

          public final javajs.util.M3 matrixRotate

    - #### matrixTemp3

          protected final javajs.util.M3 matrixTemp3

    - #### matrixTemp4

          private final javajs.util.M4 matrixTemp4

    - #### axisangleT

          private final javajs.util.A4 axisangleT

    - #### vectorT

          private final javajs.util.V3 vectorT

    - #### vectorT2

          private final javajs.util.V3 vectorT2

    - #### pointT2

          private final javajs.util.P3 pointT2

    - #### MAXIMUM_ZOOM_PERCENTAGE

          public static final int MAXIMUM_ZOOM_PERCENTAGE

      See Also:
        Constant Field Values

    - #### MAXIMUM_ZOOM_PERSPECTIVE_DEPTH

          private static final int MAXIMUM_ZOOM_PERSPECTIVE_DEPTH

      See Also:
        Constant Field Values

    - #### rotationAxis

          javajs.util.V3 rotationAxis

    - #### rotationRate

          float rotationRate

    - #### fixedTranslation

          public final javajs.util.P3 fixedTranslation

    - #### camera

          public final javajs.util.P3 camera

    - #### cameraSetting

          public final javajs.util.P3 cameraSetting

    - #### xTranslationFraction

          float xTranslationFraction

    - #### yTranslationFraction

          float yTranslationFraction

    - #### prevZoomSetting

          protected float prevZoomSetting

    - #### previousX

          public float previousX

    - #### previousY

          public float previousY

    - #### zoomEnabled

          public boolean zoomEnabled

    - #### zmPct

          public float zmPct

      zoom percent zmPct is the current displayed zoom value, AFTER rendering; may not be the same as zmPctSet, particularly if zoom is not enabled

    - #### zmPctSet

          float zmPctSet

      zoom percent setting the current setting of zoom; may not be the same as zmPct, particularly if zoom is not enabled

    - #### zoomRatio

          private float zoomRatio

    - #### slabEnabled

          public boolean slabEnabled

    - #### zShadeEnabled

          public boolean zShadeEnabled

    - #### internalSlab

          public boolean internalSlab

    - #### slabPercentSetting

          int slabPercentSetting

    - #### depthPercentSetting

          int depthPercentSetting

    - #### slabValue

          public int slabValue

    - #### depthValue

          public int depthValue

    - #### zSlabPercentSetting

          public int zSlabPercentSetting

    - #### zDepthPercentSetting

          public int zDepthPercentSetting

    - #### zSlabPoint

          public javajs.util.P3 zSlabPoint

    - #### zSlabValue

          public int zSlabValue

    - #### zDepthValue

          public int zDepthValue

    - #### slabRange

          float slabRange

    - #### slabPlane

          javajs.util.P4 slabPlane

    - #### depthPlane

          javajs.util.P4 depthPlane

    - #### perspectiveDepth

          public boolean perspectiveDepth

    - #### scale3D

          protected boolean scale3D

    - #### cameraDepth

          protected float cameraDepth

    - #### cameraDepthSetting

          protected float cameraDepthSetting

    - #### visualRangeAngstroms

          public float visualRangeAngstroms

    - #### cameraDistance

          public float cameraDistance

    - #### width

          public int width

    - #### height

          public int height

    - #### screenPixelCount

          public int screenPixelCount

    - #### scalePixelsPerAngstrom

          float scalePixelsPerAngstrom

    - #### scaleDefaultPixelsPerAngstrom

          public float scaleDefaultPixelsPerAngstrom

    - #### scale3DAngstromsPerInch

          float scale3DAngstromsPerInch

    - #### antialias

          protected boolean antialias

    - #### useZoomLarge

          private boolean useZoomLarge

    - #### zoomHeight

          private boolean zoomHeight

    - #### screenWidth

          int screenWidth

    - #### screenHeight

          int screenHeight

    - #### matrixTransform

          public final javajs.util.M4 matrixTransform

    - #### matrixTransformInv

          public final javajs.util.M4 matrixTransformInv

    - #### fScrPt

          protected final javajs.util.P3 fScrPt

    - #### iScrPt

          protected final javajs.util.P3i iScrPt

    - #### ptVibTemp

          final Point3fi ptVibTemp

    - #### navigating

          public boolean navigating

    - #### mode

          public int mode

    - #### defaultMode

          public int defaultMode

    - #### untransformedPoint

          protected final javajs.util.P3 untransformedPoint

    - #### ptTest1

          protected final javajs.util.P3 ptTest1

    - #### ptTest2

          protected final javajs.util.P3 ptTest2

    - #### ptTest3

          protected final javajs.util.P3 ptTest3

    - #### aaTest1

          protected final javajs.util.A4 aaTest1

    - #### matrixTest

          protected final javajs.util.M3 matrixTest

    - #### spinOn

          public boolean spinOn

    - #### navOn

          public boolean navOn

    - #### spinIsGesture

          private boolean spinIsGesture

    - #### vibrationOn

          public boolean vibrationOn

    - #### vibrationPeriod

          float vibrationPeriod

    - #### vibrationPeriodMs

          public int vibrationPeriodMs

    - #### vibrationScale

          private float vibrationScale

    - #### vibrationT

          private javajs.util.P3 vibrationT

    - #### stereoMode

          STER stereoMode

    - #### stereoColors

          int[] stereoColors

    - #### stereoDoubleDTI

          boolean stereoDoubleDTI

    - #### stereoDoubleFull

          boolean stereoDoubleFull

    - #### stereoDegrees

          float stereoDegrees

    - #### stereoRadians

          float stereoRadians

    - #### stereoFrame

          boolean stereoFrame

    - #### matrixStereo

          protected final javajs.util.M3 matrixStereo

    - #### windowCentered

          public boolean windowCentered

    - #### frameOffset

          final javajs.util.P3 frameOffset

    - #### frameOffsets

          javajs.util.P3[] frameOffsets

    - #### bsFrameOffsets

          public javajs.util.BS bsFrameOffsets

    - #### bsSelectedAtoms

          javajs.util.BS bsSelectedAtoms

    - #### ptOffset

          javajs.util.P3 ptOffset

    - #### NAV_MODE_IGNORE

          public static final int NAV_MODE_IGNORE

      See Also:
        Constant Field Values

    - #### NAV_MODE_ZOOMED

          public static final int NAV_MODE_ZOOMED

      See Also:
        Constant Field Values

    - #### NAV_MODE_NONE

          public static final int NAV_MODE_NONE

      See Also:
        Constant Field Values

    - #### NAV_MODE_RESET

          public static final int NAV_MODE_RESET

      See Also:
        Constant Field Values

    - #### NAV_MODE_NEWXY

          public static final int NAV_MODE_NEWXY

      See Also:
        Constant Field Values

    - #### NAV_MODE_NEWXYZ

          public static final int NAV_MODE_NEWXYZ

      See Also:
        Constant Field Values

    - #### NAV_MODE_NEWZ

          public static final int NAV_MODE_NEWZ

      See Also:
        Constant Field Values

    - #### navMode

          public int navMode

    - #### zoomFactor

          public float zoomFactor

    - #### navigationSlabOffset

          public float navigationSlabOffset

    - #### nav

          private JmolNavigatorInterface nav

  - ### Constructor Detail

    - #### TransformManager

          public TransformManager()

  - ### Method Detail

    - #### getTransformManager

          static TransformManager getTransformManager(Viewer vwr,
                                                      int width,
                                                      int height,
                                                      boolean is4D)

    - #### setDefaultPerspective

          void setDefaultPerspective()

    - #### homePosition

          public void homePosition(boolean resetSpin)

    - #### setRotation

          public void setRotation(javajs.util.M3 m)

    - #### resetRotation

          public void resetRotation()

    - #### clearThreads

          void clearThreads()

    - #### clear

          void clear()

    - #### setFixedRotationCenter

          private void setFixedRotationCenter(javajs.util.T3 center)

    - #### setRotationPointXY

          void setRotationPointXY(javajs.util.P3 center)

    - #### spinXYBy

          void spinXYBy(int xDelta,
                        int yDelta,
                        float speed)

    - #### rotateXYBy

          protected void rotateXYBy(float degX,
                                    float degY,
                                    javajs.util.BS bsAtoms)

    - #### rotateZBy

          void rotateZBy(int zDelta,
                         int x,
                         int y)

    - #### applyRotation

          private void applyRotation(javajs.util.M3 mNew,
                                     boolean isInternal,
                                     javajs.util.BS bsAtoms,
                                     javajs.util.V3 translation,
                                     boolean translationOnly,
                                     javajs.util.M4 m4)

    - #### rotate3DBall

          protected void rotate3DBall(float xDeg,
                                      float yDeg,
                                      javajs.util.BS bsAtoms)

    - #### rotateXRadians

          public void rotateXRadians(float angleRadians,
                                     javajs.util.BS bsAtoms)

    - #### rotateYRadians

          public void rotateYRadians(float angleRadians,
                                     javajs.util.BS bsAtoms)

    - #### rotateZRadians

          public void rotateZRadians(float angleRadians)

    - #### rotateAxisAngle

          public void rotateAxisAngle(javajs.util.V3 rotAxis,
                                      float radians)

    - #### rotateAxisAngle2

          private void rotateAxisAngle2(javajs.util.A4 axisAngle,
                                        javajs.util.BS bsAtoms)

    - #### rotateAxisAngleAtCenter

          boolean rotateAxisAngleAtCenter(JmolScriptEvaluator eval,
                                          javajs.util.P3 rotCenter,
                                          javajs.util.V3 rotAxis,
                                          float degreesPerSecond,
                                          float endDegrees,
                                          boolean isSpin,
                                          javajs.util.BS bsAtoms)

    - #### rotateAxisAngleRadiansFixed

          public void rotateAxisAngleRadiansFixed(float angleRadians,
                                                  javajs.util.BS bsAtoms)

    - #### rotateAboutPointsInternal

          boolean rotateAboutPointsInternal(JmolScriptEvaluator eval,
                                            javajs.util.T3 point1,
                                            javajs.util.T3 point2,
                                            float degreesPerSecond,
                                            float endDegrees,
                                            boolean isClockwise,
                                            boolean isSpin,
                                            javajs.util.BS bsAtoms,
                                            boolean isGesture,
                                            javajs.util.V3 translation,
                                            javajs.util.Lst<javajs.util.P3> finalPoints,
                                            float[] dihedralList,
                                            javajs.util.M4 m4)

      Parameters:
        `eval` -
        `point1` -
        `point2` -
        `degreesPerSecond` -
        `endDegrees` -
        `isClockwise` -
        `isSpin` -
        `bsAtoms` -
        `isGesture` -
        `translation` -
        `finalPoints` -
        `dihedralList` -
        `m4` -
      Returns:
        true if synchronous so that JavaScript can restart properly

    - #### rotateAxisAngleRadiansInternal

          public void rotateAxisAngleRadiansInternal(float radians,
                                                     javajs.util.BS bsAtoms,
                                                     javajs.util.M4 m4)

    - #### getNewFixedRotationCenter

          void getNewFixedRotationCenter()

    - #### setTranslationFractions

          void setTranslationFractions()

    - #### centerAt

          public void centerAt(int x,
                               int y,
                               javajs.util.P3 pt)

    - #### percentToPixels

          public int percentToPixels(char xyz,
                                     float percent)

    - #### angstromsToPixels

          int angstromsToPixels(float distance)

    - #### translateXYBy

          void translateXYBy(int xDelta,
                             int yDelta)

    - #### setCamera

          public void setCamera(float x,
                                float y)

    - #### translateToPercent

          public void translateToPercent(char type,
                                         float percent)

    - #### getTranslationXPercent

          public float getTranslationXPercent()

    - #### getTranslationYPercent

          public float getTranslationYPercent()

    - #### getTranslationScript

          public java.lang.String getTranslationScript()

    - #### getOrientationText

          java.lang.String getOrientationText(int type,
                                              boolean isBest)

    - #### getRotationQ

          public javajs.util.Quat getRotationQ()

    - #### getOrientationInfo

          java.util.Map<java.lang.String,java.lang.Object> getOrientationInfo()

    - #### getRotation

          public void getRotation(javajs.util.M3 m)

    - #### setZoomHeight

          public void setZoomHeight(boolean zoomHeight,
                                    boolean zoomLarge)

    - #### zoomBy

          protected void zoomBy(int pixels)

      standard response to user mouse vertical shift-drag
      Parameters:
        `pixels` -

    - #### zoomByFactor

          void zoomByFactor(float factor,
                            int x,
                            int y)

    - #### zoomToPercent

          public void zoomToPercent(float percentZoom)

    - #### translateZBy

          void translateZBy(int pixels)

    - #### resetXYCenter

          private void resetXYCenter(int x,
                                     int y)

    - #### zoomByPercent

          void zoomByPercent(float percentZoom)

    - #### setScaleAngstromsPerInch

          void setScaleAngstromsPerInch(float angstromsPerInch)

    - #### setSlabRange

          public void setSlabRange(float value)

    - #### setSlabEnabled

          void setSlabEnabled(boolean slabEnabled)

    - #### setZShadeEnabled

          void setZShadeEnabled(boolean zShadeEnabled)

    - #### setZoomEnabled

          void setZoomEnabled(boolean zoomEnabled)

    - #### slabReset

          public void slabReset()

    - #### getSlabPercentSetting

          public int getSlabPercentSetting()

    - #### slabDepthChanged

          private void slabDepthChanged()

    - #### slabByPercentagePoints

          void slabByPercentagePoints(int percentage)

    - #### depthByPercentagePoints

          void depthByPercentagePoints(int percentage)

    - #### slabDepthByPercentagePoints

          void slabDepthByPercentagePoints(int percentage)

    - #### slabToPercent

          public void slabToPercent(int percentSlab)

    - #### depthToPercent

          public void depthToPercent(int percentDepth)

    - #### zSlabToPercent

          void zSlabToPercent(int percentSlab)

    - #### zDepthToPercent

          void zDepthToPercent(int percentDepth)

    - #### slabInternal

          public void slabInternal(javajs.util.P4 plane,
                                   boolean isDepth)

    - #### setSlabDepthInternal

          public void setSlabDepthInternal(boolean isDepth)

      set internal slab or depth from screen-based slab or depth
      Parameters:
        `isDepth` -

    - #### getSlabDepthPlane

          private javajs.util.P4 getSlabDepthPlane(boolean isDepth)

    - #### getCameraFactors

          public javajs.util.P3[] getCameraFactors()

      This method returns data needed by the VRML, X3D, and IDTF/U3D exporters. It also should serve as a valuable resource for anyone adapting Jmol and wanting to know how the Jmol 11+ camera business works.
      Returns:
        a set of camera data

    - #### setPerspectiveDepth

          void setPerspectiveDepth(boolean perspectiveDepth)

    - #### getPerspectiveDepth

          public boolean getPerspectiveDepth()

    - #### setCameraDepthPercent

          public void setCameraDepthPercent(float percent,
                                            boolean resetSlab)

      either as a percent -300, or as a float 3.0 note this percent is of zoom=100 size of model
      Parameters:
        `percent` -
        `resetSlab` -

    - #### getCameraDepth

          public float getCameraDepth()

    - #### setScreenParameters0

          private void setScreenParameters0(int screenWidth,
                                            int screenHeight,
                                            boolean useZoomLarge,
                                            boolean antialias,
                                            boolean resetSlab,
                                            boolean resetZoom)

    - #### setAntialias

          void setAntialias(boolean TF)

    - #### defaultScaleToScreen

          public float defaultScaleToScreen(float radius)

    - #### resetFitToScreen

          private void resetFitToScreen(boolean andCenter)

    - #### scaleFitToScreen

          void scaleFitToScreen(boolean andCenter,
                                boolean zoomLarge,
                                boolean resetSlab,
                                boolean resetZoom)

    - #### scaleToScreen

          public float scaleToScreen(int z,
                                     int milliAngstroms)

    - #### unscaleToScreen

          public float unscaleToScreen(float z,
                                       float screenDistance)

    - #### scaleToPerspective

          public float scaleToPerspective(int z,
                                          float sizeAngstroms)

    - #### setNavigationMode

          void setNavigationMode(boolean TF)

    - #### isNavigating

          public boolean isNavigating()

    - #### finalizeTransformParameters

          public void finalizeTransformParameters()

    - #### getZoomSetting

          public float getZoomSetting()

    - #### calcSlabAndDepthValues

          public void calcSlabAndDepthValues()

      sets slab and depth, possibly using visual range considerations for setting the slab-clipping plane. (slab on; slab 0) superceded in navigation mode

    - #### zValueFromPercent

          public int zValueFromPercent(int zPercent)

    - #### calcTransformMatrix

          public void calcTransformMatrix()

    - #### rotatePoint

          public void rotatePoint(javajs.util.T3 pt,
                                  javajs.util.T3 ptRot)

    - #### getScreenTemp

          protected void getScreenTemp(javajs.util.T3 ptXYZ)

    - #### transformPtScr

          public void transformPtScr(javajs.util.T3 ptXYZ,
                                     javajs.util.P3i pointScreen)

    - #### transformPtScrT3

          public void transformPtScrT3(javajs.util.T3 ptXYZ,
                                       javajs.util.T3 pointScreen)

    - #### transformPt3f

          public void transformPt3f(javajs.util.T3 ptXYZ,
                                    javajs.util.P3 screen)

    - #### transformPtNoClip

          public void transformPtNoClip(javajs.util.T3 ptXYZ,
                                        javajs.util.T3 pointScreen)

    - #### transformPt

          public javajs.util.P3i transformPt(javajs.util.T3 ptXYZ)

      CAUTION! returns a POINTER TO A TEMPORARY VARIABLE
      Parameters:
        `ptXYZ` -
      Returns:
        POINTER TO point3iScreenTemp

    - #### transformPtVib

          public javajs.util.P3i transformPtVib(javajs.util.P3 ptXYZ,
                                                Vibration v)

      Parameters:
        `ptXYZ` -
        `v` -
      Returns:
        POINTER TO TEMPORARY VARIABLE (caution!) point3iScreenTemp

    - #### getVibrationPoint

          public javajs.util.T3 getVibrationPoint(Vibration v,
                                                  javajs.util.T3 pt,
                                                  float scale)

      return
      Parameters:
        `v` -
        `pt` - temporary value; also returned
        `scale` -
      Returns:
        pt

    - #### transformPt2D

          public javajs.util.P3i transformPt2D(javajs.util.T3 ptXyp)

    - #### applyPerspective

          private javajs.util.P3i applyPerspective(javajs.util.T3 ptXYZ,
                                                   javajs.util.T3 ptRef)

      adjusts the temporary point for perspective and offsets
      Parameters:
        `ptXYZ` -
        `ptRef` -
      Returns:
        temporary point!!!

    - #### xyzIsSlabbedInternal

          public boolean xyzIsSlabbedInternal(javajs.util.T3 ptRef)

    - #### move

          void move(JmolScriptEvaluator eval,
                    javajs.util.V3 dRot,
                    float dZoom,
                    javajs.util.V3 dTrans,
                    float dSlab,
                    float floatSecondsTotal,
                    int fps)

    - #### isInPosition

          public boolean isInPosition(javajs.util.V3 axis,
                                      float degrees)

    - #### moveToPyMOL

          public boolean moveToPyMOL(JmolScriptEvaluator eval,
                                     float floatSecondsTotal,
                                     float[] pymolView)

    - #### moveTo

          void moveTo(JmolScriptEvaluator eval,
                      float floatSecondsTotal,
                      javajs.util.P3 center,
                      javajs.util.T3 rotAxis,
                      float degrees,
                      javajs.util.M3 matrixEnd,
                      float zoom,
                      float xTrans,
                      float yTrans,
                      float newRotationRadius,
                      javajs.util.P3 navCenter,
                      float xNav,
                      float yNav,
                      float navDepth,
                      float cameraDepth,
                      float cameraX,
                      float cameraY)

    - #### setAll

          public void setAll(javajs.util.P3 center,
                             javajs.util.M3 m,
                             javajs.util.P3 navCenter,
                             float zoom,
                             float xTrans,
                             float yTrans,
                             float rotationRadius,
                             float pixelScale,
                             float navDepth,
                             float xNav,
                             float yNav,
                             float cameraDepth,
                             float cameraX,
                             float cameraY)

    - #### stopMotion

          public void stopMotion()

    - #### getRotationText

          java.lang.String getRotationText()

    - #### getMoveToText

          public java.lang.String getMoveToText(float timespan,
                                                boolean addComments)

    - #### getCenterText

          private java.lang.String getCenterText()

    - #### getRotateXyzText

          private java.lang.String getRotateXyzText()

    - #### addZoomTranslationNavigationText

          private void addZoomTranslationNavigationText(javajs.util.SB sb)

    - #### getRotateZyzText

          private java.lang.String getRotateZyzText(boolean iAddComment)

    - #### truncate0

          private static void truncate0(javajs.util.SB sb,
                                        float val)

    - #### truncate2

          private static void truncate2(javajs.util.SB sb,
                                        float val)

    - #### setSpinXYZ

          void setSpinXYZ(float x,
                          float y,
                          float z)

    - #### setSpinFps

          void setSpinFps(int value)

    - #### setNavXYZ

          public void setNavXYZ(float x,
                                float y,
                                float z)

    - #### clearSpin

          private void clearSpin()

    - #### setSpinOn

          public void setSpinOn()

    - #### setSpinOff

          public void setSpinOff()

    - #### setSpin

          private void setSpin(JmolScriptEvaluator eval,
                               boolean spinOn,
                               float endDegrees,
                               javajs.util.Lst<javajs.util.P3> endPositions,
                               float[] dihedralList,
                               javajs.util.BS bsAtoms,
                               boolean isGesture)

    - #### setNavOn

          public void setNavOn(boolean navOn)

    - #### setVibrationScale

          void setVibrationScale(float scale)

    - #### setVibrationPeriod

          public void setVibrationPeriod(float period)

      sets the period of vibration -- period > 0: sets the period and turns vibration on -- period < 0: sets the period but does not turn vibration on -- period = 0: sets the period to zero and turns vibration off -- period Float.NaN: uses current setting (frame change)
      Parameters:
        `period` -

    - #### setVibrationT

          public void setVibrationT(float t)

    - #### isVibrationOn

          boolean isVibrationOn()

    - #### setVibrationOn

          private void setVibrationOn(boolean vibrationOn)

    - #### clearVibration

          private void clearVibration()

    - #### setStereoMode2

          void setStereoMode2(int[] twoColors)

    - #### setStereoMode

          void setStereoMode(STER stereoMode)

    - #### setStereoDegrees

          void setStereoDegrees(float stereoDegrees)

    - #### getStereoRotationMatrix

          javajs.util.M3 getStereoRotationMatrix(boolean stereoFrame)

    - #### isWindowCentered

          public boolean isWindowCentered()

    - #### setWindowCentered

          void setWindowCentered(boolean TF)

    - #### setRotationRadius

          public float setRotationRadius(float angstroms,
                                         boolean doAll)

    - #### setRotationCenterAndRadiusXYZ

          private void setRotationCenterAndRadiusXYZ(javajs.util.T3 newCenterOfRotation,
                                                     boolean andRadius)

    - #### setNewRotationCenter

          void setNewRotationCenter(javajs.util.P3 center,
                                    boolean doScale)

    - #### moveRotationCenter

          public void moveRotationCenter(javajs.util.P3 center,
                                         boolean toXY)

    - #### setCenter

          void setCenter()

    - #### setCenterAt

          public void setCenterAt(int relativeTo,
                                  javajs.util.P3 pt)

    - #### setFrameOffset

          void setFrameOffset(int modelIndex)

    - #### setSelectedTranslation

          void setSelectedTranslation(javajs.util.BS bsAtoms,
                                      char xyz,
                                      int xy)

    - #### setNavFps

          protected void setNavFps(int navFps)

    - #### calcCameraFactors

          public void calcCameraFactors()

      sets all camera and scale factors needed by the specific perspective model instantiated

    - #### calcNavCameraFactors

          private void calcNavCameraFactors(float offset100)

    - #### getPerspectiveFactor

          public float getPerspectiveFactor(float z)

      calculate the perspective factor based on z
      Parameters:
        `z` -
      Returns:
        perspectiveFactor

    - #### unTransformPoint

          public void unTransformPoint(javajs.util.T3 screenPt,
                                       javajs.util.T3 coordPt)

    - #### resetNavigationPoint

          protected void resetNavigationPoint(boolean doResetSlab)

      something has arisen that requires resetting of the navigation point.
      Parameters:
        `doResetSlab` -

    - #### setNavigatePt

          public void setNavigatePt(javajs.util.P3 pt)

      scripted entry point for navigation
      Parameters:
        `pt` -

    - #### setNavigationSlabOffsetPercent

          void setNavigationSlabOffsetPercent(float percent)

    - #### getNavigationOffset

          public javajs.util.P3 getNavigationOffset()

    - #### getNavPtHeight

          public float getNavPtHeight()

    - #### getNavigationOffsetPercent

          public float getNavigationOffsetPercent(char XorY)

    - #### getNavigationText

          protected java.lang.String getNavigationText(boolean addComments)

    - #### setScreenParameters

          void setScreenParameters(int screenWidth,
                                   int screenHeight,
                                   boolean useZoomLarge,
                                   boolean antialias,
                                   boolean resetSlab,
                                   boolean resetZoom)

    - #### navInterrupt

          private void navInterrupt()

    - #### getNav

          private boolean getNav()

    - #### navigateList

          public void navigateList(JmolScriptEvaluator eval,
                                   javajs.util.Lst<java.lang.Object[]> list)

    - #### navigateAxis

          public void navigateAxis(javajs.util.V3 rotAxis,
                                   float degrees)

      scripted entry point for navigation
      Parameters:
        `rotAxis` -
        `degrees` -

    - #### setNavigationOffsetRelative

          public void setNavigationOffsetRelative()

    - #### navigateKey

          void navigateKey(int keyCode,
                           int modifiers)

      entry point for keyboard-based navigation
      Parameters:
        `keyCode` - 0 indicates key released
        `modifiers` - shift,alt,ctrl

    - #### setNavigationDepthPercent

          public void setNavigationDepthPercent(float percent)

      sets the position of the navigation offset relative to the model (50% center; 0% rear, 100% front; can be <0 or >100)
      Parameters:
        `percent` -

    - #### navTranslatePercentOrTo

          public void navTranslatePercentOrTo(float seconds,
                                              float x,
                                              float y)

      seconds < 0 means "to (x,y)"; >= 0 mean "to (x%, y%)"
      Parameters:
        `seconds` -
        `x` -
        `y` -

    - #### calcNavigationPoint

          protected void calcNavigationPoint()

      All the magic happens here. all navigation effects go through this method

    - #### getNavigationState

          protected java.lang.String getNavigationState()

      Returns:
        the script that defines the current navigation state