TwistyPuzzleLib

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is free software: you can redistribute it and/or modify                            //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Magic Cube is distributed in the hope that it will be useful,                                 //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.objectlib.main;

import java.io.InputStream;

import android.app.Activity;

import android.content.SharedPreferences;

import android.util.DisplayMetrics;

import android.view.MotionEvent;

import org.distorted.library.main.QuatHelper;

import org.distorted.library.type.Static2D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.BlockController;

import org.distorted.objectlib.helpers.MovesFinished;

import org.distorted.objectlib.helpers.ObjectLibInterface;

///////////////////////////////////////////////////////////////////////////////////////////////////

public class ObjectControl

{

    public static final int NUM_SPEED_PROBES = 10;

    public static final int INVALID_POINTER_ID = -1;

    public static final int MODE_ROTATE  = 0;

    public static final int MODE_DRAG    = 1;

    public static final int MODE_REPLACE = 2;

    // Moving the finger from the middle of the vertical screen to the right edge will rotate a

    // given face by SWIPING_SENSITIVITY/2 degrees.

    public final static int SWIPING_SENSITIVITY  = 240;

    // Moving the finger by 0.3 of an inch will start a Rotation.

    public final static float ROTATION_SENSITIVITY = 0.3f;

    private final Static4D CAMERA_POINT = new Static4D(0, 0, 0, 0);

    private final ObjectLibInterface mInterface;

    private final ObjectPreRender mPreRender;

    private Movement mMovement;

    private TwistyObjectNode mObjectNode;

    private boolean mDragging, mBeginningRotation, mContinuingRotation;

    private int mScreenWidth, mScreenHeight, mScreenMin;

    private float mMoveX, mMoveY;

    private float mScale;

    private float mRotAngle, mInitDistance;

    private float mStartRotX, mStartRotY;

    private float mAxisX, mAxisY;

    private float mRotationFactor;

    private int mLastCubitColor, mLastCubit;

    private int mCurrentAxis, mCurrentRow;

    private float mCurrentAngle, mCurrRotSpeed;

    private final float[] mLastX;

    private final float[] mLastY;

    private final long[] mLastT;

    private int mFirstIndex, mLastIndex;

    private final int mDensity;

    private int mPointer1, mPointer2;

    private float mX1, mY1, mX2, mY2, mX, mY;

    private final boolean mIsAutomatic;

    private boolean mIsLocked, mRemLocked;

    private static final Static4D mQuat= new Static4D(-0.25189602f,0.3546389f,0.009657208f,0.90038127f);

    private static final Static4D mTemp= new Static4D(0,0,0,1);

    private static boolean mForcedIconMode = false;

///////////////////////////////////////////////////////////////////////////////////////////////////

// cast the 3D axis we are currently rotating along (which is already casted to the surface of the

// currently touched face AND converted into a 4D vector - fourth 0) to a 2D in-screen-surface axis

    private void computeCurrentAxis(Static4D axis)

      {

      Static4D result = QuatHelper.rotateVectorByQuat(axis, mQuat);

      mAxisX =result.get0();

      mAxisY =result.get1();

      float len = (float)Math.sqrt(mAxisX*mAxisX + mAxisY*mAxisY);

      mAxisX /= len;

      mAxisY /= len;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void addSpeedProbe(float x, float y)

      {

      long currTime = System.currentTimeMillis();

      boolean theSame = mLastIndex==mFirstIndex;

      mLastIndex++;

      if( mLastIndex>=NUM_SPEED_PROBES ) mLastIndex=0;

      mLastT[mLastIndex] = currTime;

      mLastX[mLastIndex] = x;

      mLastY[mLastIndex] = y;

      if( mLastIndex==mFirstIndex)

        {

        mFirstIndex++;

        if( mFirstIndex>=NUM_SPEED_PROBES ) mFirstIndex=0;

        }

      if( theSame )

        {

        mLastT[mFirstIndex] = currTime;

        mLastX[mFirstIndex] = x;

        mLastY[mFirstIndex] = y;

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void computeCurrentSpeedInInchesPerSecond()

      {

      long firstTime = mLastT[mFirstIndex];

      long lastTime  = mLastT[mLastIndex];

      float fX = mLastX[mFirstIndex];

      float fY = mLastY[mFirstIndex];

      float lX = mLastX[mLastIndex];

      float lY = mLastY[mLastIndex];

      long timeDiff = lastTime-firstTime;

      mLastIndex = 0;

      mFirstIndex= 0;

      mCurrRotSpeed = timeDiff>0 ? 1000*retFingerDragDistanceInInches(fX,fY,lX,lY)/timeDiff : 0;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private float retFingerDragDistanceInInches(float xFrom, float yFrom, float xTo, float yTo)

      {

      float xDist = mScreenWidth*(xFrom-xTo);

      float yDist = mScreenHeight*(yFrom-yTo);

      float distInPixels = (float)Math.sqrt(xDist*xDist + yDist*yDist);

      return distInPixels/mDensity;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void replaceMode(TwistyObject object, boolean down)

      {

      mBeginningRotation= false;

      if( down )

        {

        int color = mInterface.getCurrentColor();

        float[] point = mMovement.getTouchedPoint3D();

        mLastCubit = object.getCubit(point);

        mLastCubitColor = mInterface.cubitIsLocked(mLastCubit);

        int face;

        if( mLastCubitColor>=0 )

          {

          face =4;

          }

        else

          {

          int touchedFace = mMovement.getTouchedFace();

          if( mLastCubit<8 ) face = touchedFace;

          else

            {

            switch(touchedFace)

              {

              case  0: face = mLastCubit==15 || mLastCubit==18 ? 3 : 5; break;

              case  1: face = mLastCubit==13 || mLastCubit==16 ? 3 : 5; break;

              case  2: face = mLastCubit==10                   ? 5 : 3; break;

              case  3: face = mLastCubit== 8                   ? 3 : 5; break;

              case  4: face = mLastCubit== 9                   ? 3 : 5; break;

              case  5: face = mLastCubit== 8                   ? 5 : 3; break;

              default: face =-1;

              }

            }

          }

        mPreRender.setTextureMap( mLastCubit, face , color );

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void setUpDragOrRotate(boolean down, float x, float y, int mode)

      {

      if( mode==MODE_DRAG )

        {

        mDragging           = true;

        mBeginningRotation  = false;

        mContinuingRotation = false;

        }

      else

        {

        TwistyObject object = mPreRender.getObject();

        CAMERA_POINT.set2( object==null ? 1.21f : mObjectNode.getCameraDist() );

        Static4D touchPoint = new Static4D(x, y, 0, 0);

        Static4D rotatedTouchPoint= QuatHelper.rotateVectorByInvertedQuat(touchPoint, mQuat);

        Static4D rotatedCamera= QuatHelper.rotateVectorByInvertedQuat(CAMERA_POINT, mQuat);

        if( object!=null && mMovement!=null && mMovement.faceTouched(rotatedTouchPoint,rotatedCamera,object.getObjectRatio() ) )

          {

          mDragging           = false;

          mContinuingRotation = false;

          if( mode==MODE_ROTATE )

            {

            mBeginningRotation= !mPreRender.isTouchBlocked();

            }

          else if( mode==MODE_REPLACE ) replaceMode(object,down);

          }

        else

          {

          mDragging           = (!mIsLocked || mIsAutomatic);

          mBeginningRotation  = false;

          mContinuingRotation = false;

          if( !mDragging ) mInterface.failedToDrag();

          }

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void drag(float x, float y)

      {

      if( mPointer1!=INVALID_POINTER_ID && mPointer2!=INVALID_POINTER_ID)

        {

        float x2 = (mX2 - mScreenWidth*0.5f)/mScreenMin;

        float y2 = (mScreenHeight*0.5f - mY2)/mScreenMin;

        float angleNow = getAngle(x,y,x2,y2);

        float angleDiff = angleNow-mRotAngle;

        float sinA =-(float)Math.sin(angleDiff);

        float cosA = (float)Math.cos(angleDiff);

        Static4D dragQuat = QuatHelper.quatMultiply(new Static4D(0,0,sinA,cosA), mQuat);

        mTemp.set(dragQuat);

        mRotAngle = angleNow;

        float distNow  = (float)Math.sqrt( (x-x2)*(x-x2) + (y-y2)*(y-y2) );

        float distQuot = mInitDistance<0 ? 1.0f : distNow/ mInitDistance;

        mInitDistance = distNow;

        TwistyObject object = mPreRender.getObject();

        if( object!=null ) object.setObjectRatio(distQuot, mObjectNode.getMinSize() );

        }

      else

        {

        Static4D dragQuat = QuatHelper.quatMultiply(QuatHelper.quatFromDrag(mX-x,y-mY), mQuat);

        mTemp.set(dragQuat);

        }

      mPreRender.setQuatOnNextRender();

      mX = x;

      mY = y;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void finishRotation()

      {

      TwistyObject object = mPreRender.getObject();

      int[] angles = object.getBasicAngle();

      if( mCurrentAxis<angles.length )

        {

        computeCurrentSpeedInInchesPerSecond();

        int angle = object.computeNearestAngle(mCurrentAxis,mCurrentAngle, mCurrRotSpeed);

        mPreRender.finishRotation(angle);

        mPreRender.rememberMove(mCurrentAxis,mCurrentRow,angle);

        if( angle!=0 )

          {

          int basicAngle= angles[mCurrentAxis];

          int realAngle = (angle*basicAngle)/360;

          mInterface.onFinishRotation(mCurrentAxis,mCurrentRow,realAngle);

          }

        mContinuingRotation = false;

        mBeginningRotation  = false;

        mDragging           = true;

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void continueRotation(float x, float y)

      {

      float dx = x-mStartRotX;

      float dy = y-mStartRotY;

      float alpha = dx*mAxisX + dy*mAxisY;

      float x2 = dx - alpha*mAxisX;

      float y2 = dy - alpha*mAxisY;

      float len = (float)Math.sqrt(x2*x2 + y2*y2);

      // we have the length of 1D vector 'angle', now the direction:

      float tmp = mAxisY==0 ? -mAxisX*y2 : mAxisY*x2;

      float angle = (tmp>0 ? 1:-1)*len*mRotationFactor;

      mCurrentAngle = SWIPING_SENSITIVITY*angle;

      mPreRender.getObject().continueRotation(mCurrentAngle);

      addSpeedProbe(x2,y2);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void beginRotation(float x, float y)

      {

      mStartRotX = x;

      mStartRotY = y;

      TwistyObject object = mPreRender.getObject();

      int[] numLayers = object.getNumLayers();

      Static4D touchPoint = new Static4D(x, y, 0, 0);

      Static4D rotatedTouchPoint= QuatHelper.rotateVectorByInvertedQuat(touchPoint, mQuat);

      Static2D res = mMovement.newRotation(rotatedTouchPoint,object.getObjectRatio());

      mCurrentAxis = (int)res.get0();

      mCurrentRow  = (int)res.get1();

      computeCurrentAxis( mMovement.getCastedRotAxis(mCurrentAxis) );

      mRotationFactor = mMovement.returnRotationFactor(numLayers,mCurrentRow);

      object.beginNewRotation( mCurrentAxis, mCurrentRow );

      mInterface.onBeginRotation();

      addSpeedProbe(x,y);

      mBeginningRotation = false;

      mContinuingRotation= true;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private float getAngle(float x1, float y1, float x2, float y2)

      {

      return (float) Math.atan2(y1-y2, x1-x2);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void prepareDown(MotionEvent event)

      {

      mPointer1 = event.getPointerId(0);

      mX1 = event.getX() - mMoveX;

      mY1 = event.getY() + mMoveY;

      mPointer2 = INVALID_POINTER_ID;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void prepareMove(MotionEvent event)

      {

      int index1 = event.findPointerIndex(mPointer1);

      if( index1>=0 )

        {

        mX1 = event.getX(index1) - mMoveX;

        mY1 = event.getY(index1) + mMoveY;

        }

      int index2 = event.findPointerIndex(mPointer2);

      if( index2>=0 )

        {

        mX2 = event.getX(index2) - mMoveX;

        mY2 = event.getY(index2) + mMoveY;

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void prepareUp(MotionEvent event)

      {

      mPointer1 = INVALID_POINTER_ID;

      mPointer2 = INVALID_POINTER_ID;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void prepareDown2(MotionEvent event)

      {

      int index = event.getActionIndex();

      if( mPointer1==INVALID_POINTER_ID )

        {

        mPointer1 = event.getPointerId(index);

        mX1 = event.getX(index) - mMoveX;

        mY1 = event.getY(index) + mMoveY;

        }

      else if( mPointer2==INVALID_POINTER_ID )

        {

        mPointer2 = event.getPointerId(index);

        mX2 = event.getX(index) - mMoveX;

        mY2 = event.getY(index) + mMoveY;

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void prepareUp2(MotionEvent event)

      {

      int index = event.getActionIndex();

           if( index==event.findPointerIndex(mPointer1) ) mPointer1 = INVALID_POINTER_ID;

      else if( index==event.findPointerIndex(mPointer2) ) mPointer2 = INVALID_POINTER_ID;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void actionMove(float x1, float y1, float x2, float y2, int mode)

      {

      float pX = mPointer1 != INVALID_POINTER_ID ? x1 : x2;

      float pY = mPointer1 != INVALID_POINTER_ID ? y1 : y2;

      float x = (pX - mScreenWidth*0.5f)/mScreenMin;

      float y = (mScreenHeight*0.5f -pY)/mScreenMin;

      if( mBeginningRotation )

        {

        if( retFingerDragDistanceInInches(mX,mY,x,y) > ROTATION_SENSITIVITY )

          {

          beginRotation(x,y);

          }

        }

      else if( mContinuingRotation )

        {

        continueRotation(x,y);

        }

      else if( mDragging )

        {

        drag(x,y);

        }

      else

        {

        setUpDragOrRotate(false,x,y,mode);

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void actionDown(float x, float y, int mode)

      {

      mX = (x -  mScreenWidth*0.5f)/mScreenMin;

      mY = (mScreenHeight*0.5f - y)/mScreenMin;

      setUpDragOrRotate(true,mX,mY,mode);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void actionUp()

      {

      if( mContinuingRotation )

        {

        finishRotation();

        }

      if( mLastCubitColor>=0 )

        {

        mPreRender.setTextureMap( mLastCubit, 4, mLastCubitColor );

        mLastCubitColor = -1;

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void actionDown2(float x1, float y1, float x2, float y2)

      {

      mRotAngle = getAngle(x1,-y1, x2,-y2);

      mInitDistance = -1;

      mX = (x1 - mScreenWidth*0.5f )/mScreenMin;

      mY = (mScreenHeight*0.5f - y1)/mScreenMin;

      if( mBeginningRotation )

        {

        mContinuingRotation = false;

        mBeginningRotation  = false;

        mDragging           = true;

        }

      else if( mContinuingRotation )

        {

        finishRotation();

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void actionUp2(boolean p1isUp, float x1, float y1, boolean p2isUp, float x2, float y2)

      {

      if( p1isUp )

        {

        mX = (x2 -  mScreenWidth*0.5f)/mScreenMin;

        mY = (mScreenHeight*0.5f - y2)/mScreenMin;

        }

      if( p2isUp )

        {

        mX = (x1 -  mScreenWidth*0.5f)/mScreenMin;

        mY = (mScreenHeight*0.5f - y1)/mScreenMin;

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    void setMovement(Movement movement)

      {

      mMovement = movement;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

// INTERNAL API (for AutomaticControl)

///////////////////////////////////////////////////////////////////////////////////////////////////

    public ObjectPreRender getPreRender()

      {

      return mPreRender;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public ObjectLibInterface getInterface()

      {

      return mInterface;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public static void setIconMode(boolean mode)

      {

      mForcedIconMode = mode;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public static boolean isInIconMode()

      {

      return mForcedIconMode;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

// PUBLIC API

///////////////////////////////////////////////////////////////////////////////////////////////////

    public ObjectControl(Activity act, ObjectLibInterface actioner)

      {

      mIsAutomatic = false;

      mLastCubitColor = -1;

      mCurrRotSpeed   = 0.0f;

      mScale = 1.0f;

      mLastX = new float[NUM_SPEED_PROBES];

      mLastY = new float[NUM_SPEED_PROBES];

      mLastT = new long[NUM_SPEED_PROBES];

      mFirstIndex =0;

      mLastIndex  =0;

      DisplayMetrics dm = new DisplayMetrics();

      act.getWindowManager().getDefaultDisplay().getMetrics(dm);

      mDensity = dm.densityDpi;

      mPreRender = new ObjectPreRender(act,this,actioner);

      mInterface = actioner;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public TwistyObjectNode getNode()

      {

      return mObjectNode;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void createNode(int width, int height)

      {

      if( mObjectNode==null ) mObjectNode = new TwistyObjectNode(width,height);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void setScreenSize(int width, int height)

      {

      mScreenWidth = width;

      mScreenHeight= height;

      mScreenMin   = Math.min(width,height);

      mPreRender.setScreenSize();

      if( mObjectNode!=null ) mObjectNode.setSize(width,height);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void setObjectMove(int xmove, int ymove)

      {

      mMoveX = xmove;

      mMoveY = ymove;

      mPreRender.setMove(xmove,ymove);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void setObjectScale(float scale)

      {

      mScale = scale;

      mPreRender.setScale(scale);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void onPause()

      {

      BlockController.onPause();

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void onResume()

      {

      mPointer1 = INVALID_POINTER_ID;

      mPointer2 = INVALID_POINTER_ID;

      unlock();

      BlockController.onResume();

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void rotateNow(Static4D quat)

      {

      mTemp.set(quat);

      mQuat.set(mTemp);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void scaleNow(float scale)

      {

      mPreRender.getObject().setObjectRatioNow(scale,mObjectNode.getMinSize() );

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void setQuat()

      {

      mQuat.set(mTemp);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public Static4D getQuat()

      {

      return mQuat;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void preRender()

      {

      mPreRender.preRender();

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void blockEverything(int place)

      {

      setLock(true);

      mPreRender.blockEverything(place);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void blockTouch(int place)

      {

      setLock(true);

      mPreRender.blockTouch(place);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void unblockEverything()

      {

      unsetLock();

      mPreRender.unblockEverything();

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void unblockTouch()

      {

      unsetLock();

      mPreRender.unblockTouch();

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void unblockUI()

      {

      mPreRender.unblockUI();

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public boolean isTouchBlocked()

      {

      return mPreRender.isTouchBlocked();

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public boolean isUINotBlocked()

      {

      return mPreRender.isUINotBlocked();

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void initializeObject(int[][] moves)

      {

      mPreRender.initializeObject(moves);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void changeObject(int ordinal, InputStream jsonStream, InputStream meshStream)

      {

      mPreRender.changeObject(ordinal, jsonStream, meshStream);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void changeIfDifferent(int ordinal, InputStream jsonStream, InputStream meshStream)

      {

      TwistyObject object = mPreRender.getObject();

      ObjectType old = object==null ? null : object.getObjectType();

      if( old==null || old.ordinal() != ordinal )

        {

        mPreRender.changeObject(ordinal, jsonStream, meshStream);

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void scrambleObject(int num)

      {

      mPreRender.scrambleObject(num);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void solveObject()

      {

      mPreRender.solveObject();

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void solveOnly()

      {

      mPreRender.solveOnly();

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void addRotation(MovesFinished listener, int axis, int rowBitmap, int angle, int duration)

      {

      mPreRender.addRotation(listener,axis,rowBitmap,angle,duration);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void resetAllTextureMaps()

      {

      mPreRender.resetAllTextureMaps();

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public TwistyObject getObject()

      {

      return mPreRender.getObject();

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void savePreferences(SharedPreferences.Editor editor)

      {

      mPreRender.savePreferences(editor);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void restorePreferences(SharedPreferences preferences)

      {

      mPreRender.restorePreferences(preferences);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public boolean retLocked()

      {

      return mIsLocked;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void toggleLock()

      {

      mIsLocked = !mIsLocked;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void unlock()

      {

      mIsLocked = false;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void setLock(boolean value)

      {

      mRemLocked = mIsLocked;

      mIsLocked = value;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void unsetLock()

      {

      mIsLocked = mRemLocked;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public boolean onTouchEvent(MotionEvent event, int mode)

      {

      int action = event.getActionMasked();

      switch(action)

         {

         case MotionEvent.ACTION_DOWN        : prepareDown(event);

                                               actionDown(mX1, mY1, mode);

                                               break;

         case MotionEvent.ACTION_MOVE        : prepareMove(event);

                                               actionMove(mX1, mY1, mX2, mY2, mode);

                                               break;

         case MotionEvent.ACTION_UP          : prepareUp(event);

                                               actionUp();

                                               break;

         case MotionEvent.ACTION_POINTER_DOWN: prepareDown2(event);

                                               actionDown2(mX1, mY1, mX2, mY2);

                                               break;

         case MotionEvent.ACTION_POINTER_UP  : prepareUp2(event);

                                               boolean p1isUp = mPointer1==INVALID_POINTER_ID;

                                               boolean p2isUp = mPointer2==INVALID_POINTER_ID;

                                               actionUp2(p1isUp, mX1, mY1, p2isUp, mX2, mY2);

                                               break;

         }

      return true;

      }

}