commit ce0c7ca844752e5ffcf3ce70a84765ef802fcf3d
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Tue Jan 21 15:37:15 2020 +0000

    RubikCube: major progress with a separate RubikSettingsEnum enum - almost finished.

diff --git a/src/main/java/org/distorted/magic/RubikActivity.java b/src/main/java/org/distorted/magic/RubikActivity.java
index 3f7929bc..5a157b62 100644
--- a/src/main/java/org/distorted/magic/RubikActivity.java
+++ b/src/main/java/org/distorted/magic/RubikActivity.java
@@ -34,7 +34,7 @@ import org.distorted.library.main.DistortedLibrary;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-public class RubikActivity extends AppCompatActivity implements RubikSettings.OnCompleteListener
+public class RubikActivity extends AppCompatActivity
 {
             static final int DEFAULT_SIZE  = 3;
     private static final int SMALLEST_SIZE = 2;
@@ -44,10 +44,6 @@ public class RubikActivity extends AppCompatActivity implements RubikSettings.On
     public static final int MAX_SCRAMBLE = 10;
 
     private static int mSize = DEFAULT_SIZE;
-
-    private int[] mPos;
-    private int[] mType;
-
     private HorizontalNumberPicker mPicker;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -60,19 +56,11 @@ public class RubikActivity extends AppCompatActivity implements RubikSettings.On
       setContentView(R.layout.main);
       markButton(mSize);
 
-      mPos = new int[RubikSettingsEnum.LENGTH];
-      mType= new int[RubikSettingsEnum.LENGTH];
-
       mPicker = findViewById(R.id.rubikNumberPicker);
       mPicker.setMin(MIN_SCRAMBLE);
       mPicker.setMax(MAX_SCRAMBLE);
 
       restorePreferences();
-
-      for (int i=0; i<RubikSettingsEnum.LENGTH; i++)
-       {
-       applyPreferences(i);
-       }
       }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -117,21 +105,7 @@ public class RubikActivity extends AppCompatActivity implements RubikSettings.On
 
     public void Settings(View v)
       {
-      Bundle args = new Bundle();
-
-      String name;
-
-      for (int i=0; i<RubikSettingsEnum.LENGTH; i++)
-        {
-        RubikSettingsEnum rse = RubikSettingsEnum.getEnum(i);
-        name = rse.name();
-
-        args.putInt(name+"_Pos" , mPos[i]);
-        args.putInt(name+"_Type", mType[i]);
-        }
-
       RubikSettings settings = new RubikSettings();
-      settings.setArguments(args);
       settings.show(getSupportFragmentManager(), null);
       }
 
@@ -161,19 +135,6 @@ public class RubikActivity extends AppCompatActivity implements RubikSettings.On
       view.getRenderer().solveCube();
       }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    public void onComplete(int index, int position, int type )
-      {
-      if( index>=0 && index<RubikSettingsEnum.LENGTH )
-        {
-        mPos[index] = position;
-        mType[index]= type;
-
-        applyPreferences(index);
-        }
-      }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
     public void setSize(View v)
@@ -223,15 +184,10 @@ public class RubikActivity extends AppCompatActivity implements RubikSettings.On
      {
      SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
      SharedPreferences.Editor editor = preferences.edit();
-     String name;
 
      for (int i=0; i<RubikSettingsEnum.LENGTH; i++)
        {
-       RubikSettingsEnum rse = RubikSettingsEnum.getEnum(i);
-       name = rse.name();
-
-       editor.putInt(name+"_Pos" , mPos[i]);
-       editor.putInt(name+"_Type", mType[i]);
+       RubikSettingsEnum.getEnum(i).savePreferences(editor);
        }
 
      editor.putInt("scramble", mPicker.getValue() );
@@ -245,37 +201,13 @@ public class RubikActivity extends AppCompatActivity implements RubikSettings.On
      {
      SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
 
-     String name;
-
      for (int i=0; i<RubikSettingsEnum.LENGTH; i++)
        {
-       RubikSettingsEnum rse = RubikSettingsEnum.getEnum(i);
-       name = rse.name();
-
-       mPos[i]  = preferences.getInt(name+"_Pos" , rse.getDefaultPos() );
-       mType[i] = preferences.getInt(name+"_Type", rse.getDefaultType());
+       RubikSettingsEnum.getEnum(i).restorePreferences(preferences);
        }
 
      int scramble= preferences.getInt("scramble", MIN_SCRAMBLE);
 
      mPicker.setValue(scramble);
      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   private void applyPreferences(int index)
-     {
-     RubikSurfaceView view = findViewById(R.id.rubikSurfaceView);
-     RubikRenderer renderer = view.getRenderer();
-
-     renderer.setPos (index, translateDuration(mPos[index])+1);
-     renderer.setType(index, mType[index] );
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   public static int translateDuration(int pos)
-     {
-     return (pos/2)*100;
-     }
 }
diff --git a/src/main/java/org/distorted/magic/RubikRenderer.java b/src/main/java/org/distorted/magic/RubikRenderer.java
index b61f889e..a5c224b1 100644
--- a/src/main/java/org/distorted/magic/RubikRenderer.java
+++ b/src/main/java/org/distorted/magic/RubikRenderer.java
@@ -56,8 +56,6 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
     private RubikCube mOldCube, mNewCube;
     private int mScreenWidth, mScreenHeight;
     private MeshFlat mMesh;
-    private int[] mPos;
-    private int[] mType;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -90,14 +88,6 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
       mCanScramble = true;
       mCanSolve    = true;
 
-      mPos  = new int[RubikSettingsEnum.LENGTH];
-      mType = new int[RubikSettingsEnum.LENGTH];
-
-      for (int i=0; i<RubikSettingsEnum.LENGTH; i++)
-        {
-        mPos[i] = 1000;
-        }
-
       mMesh= new MeshFlat(20,20);
       mNextCubeSize =RubikActivity.getSize();
       }
@@ -144,8 +134,7 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
         mCanDrag   = false;
         mCanRotate = false;
         mNextCubeSize = 0;
-
-        sizeChangeEffect();
+        changeSizeNow();
         }
 
       if( mSolveCube )
@@ -239,26 +228,6 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
        }
      }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   private void sizeChangeEffect()
-     {
-     try
-       {
-       SizeChangeEffect effect = SizeChangeEffect.create(mType[0]);
-       mSizeChangeEffectID = effect.start(mPos[0],mScreen,mOldCube,mNewCube,this);
-       }
-     catch(Exception ex)
-       {
-       android.util.Log.e("Renderer", "failed to create SizeChangeEffect, exception: "+ex.getMessage());
-
-       if( mOldCube!=null ) mScreen.detach(mOldCube);
-       mScreen.attach(mNewCube);
-       mCanRotate = true;
-       mCanDrag   = true;
-       }
-     }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
    private float computeFOV(float cameraDistance, int screenHeight)
@@ -275,20 +244,6 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
      mFinishRotation = true;
      }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   void setPos(int index, int pos)
-     {
-     if( index>=0 && index<RubikSettingsEnum.LENGTH )  mPos[index] = pos;
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   void setType(int index, int type)
-     {
-     if( index>=0 && index<RubikSettingsEnum.LENGTH )  mType[index] = type;
-     }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
    boolean createCube(int newSize)
@@ -304,59 +259,74 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-   private void createCubeNow(int newSize)
+   private void recomputeScaleFactor(int screenWidth, int screenHeight)
      {
-     if( mOldCube!=null ) mOldCube.releaseResources();
-     mOldCube = mNewCube;
+     mCubeSizeInScreenSpace = CUBE_SCREEN_RATIO*(screenWidth>screenHeight ? screenHeight:screenWidth);
 
-     DistortedTexture texture = new DistortedTexture(TEXTURE_SIZE,TEXTURE_SIZE);
-     DistortedEffects effects = new DistortedEffects();
+     if( mNewCube!=null )
+       {
+       mNewCube.recomputeScaleFactor(screenWidth, screenHeight, mCubeSizeInScreenSpace);
+       }
+     }
 
-     mNewCube = new RubikCube(newSize, mQuatCurrent, mQuatAccumulated, texture, mMesh, effects);
-     mNewCube.createTexture();
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
-     if( mScreenWidth!=0 )
+   void scrambleCube(int num)
+     {
+     if( mCanScramble )
        {
-       recomputeScaleFactor(mScreenWidth,mScreenHeight);
+       mScrambleCube = true;
+       mScrambleCubeNum = num;
        }
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-   private void recomputeScaleFactor(int screenWidth, int screenHeight)
+   void solveCube()
      {
-     mCubeSizeInScreenSpace = CUBE_SCREEN_RATIO*(screenWidth>screenHeight ? screenHeight:screenWidth);
-
-     if( mNewCube!=null )
+     if( mCanSolve )
        {
-       mNewCube.recomputeScaleFactor(screenWidth, screenHeight, mCubeSizeInScreenSpace);
+       mSolveCube = true;
        }
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-   void scrambleCube(int num)
+   private void createCubeNow(int newSize)
      {
-     if( mCanScramble )
+     if( mOldCube!=null ) mOldCube.releaseResources();
+     mOldCube = mNewCube;
+
+     DistortedTexture texture = new DistortedTexture(TEXTURE_SIZE,TEXTURE_SIZE);
+     DistortedEffects effects = new DistortedEffects();
+
+     mNewCube = new RubikCube(newSize, mQuatCurrent, mQuatAccumulated, texture, mMesh, effects);
+     mNewCube.createTexture();
+
+     if( mScreenWidth!=0 )
        {
-       mScrambleCube = true;
-       mScrambleCubeNum = num;
+       recomputeScaleFactor(mScreenWidth,mScreenHeight);
        }
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-   private void scrambleCubeNow()
+   private void changeSizeNow()
      {
      try
        {
-       ScrambleEffect effect = ScrambleEffect.create(mType[2]);
-       mScrambleEffectID = effect.start(mPos[2],mNewCube,mScrambleCubeNum,this);
+       int pos0 = RubikSettingsEnum.getEnum(0).getCurrentPos();
+       int typ0 = RubikSettingsEnum.getEnum(0).getCurrentType();
+       int pos = RubikSettingsEnum.translatePos(pos0)+1;
+       SizeChangeEffect effect = SizeChangeEffect.create(typ0);
+       mSizeChangeEffectID = effect.start(pos,mScreen,mOldCube,mNewCube,this);
        }
      catch(Exception ex)
        {
-       android.util.Log.e("Renderer", "failed to create ScrambleEffect, exception: "+ex.getMessage());
+       android.util.Log.e("Renderer", "failed to create SizeChangeEffect, exception: "+ex.getMessage());
 
+       if( mOldCube!=null ) mScreen.detach(mOldCube);
+       mScreen.attach(mNewCube);
        mCanRotate = true;
        mCanDrag   = true;
        }
@@ -364,30 +334,44 @@ public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-   void solveCube()
+   private void solveCubeNow()
      {
-     if( mCanSolve )
+     try
        {
-       mSolveCube = true;
+       int pos1 = RubikSettingsEnum.getEnum(1).getCurrentPos();
+       int typ1 = RubikSettingsEnum.getEnum(1).getCurrentType();
+       int pos = RubikSettingsEnum.translatePos(pos1)+1;
+       SolveEffect effect = SolveEffect.create(typ1);
+       mSolveEffectID = effect.start(pos,mScreen,mNewCube,this);
+       }
+     catch(Exception ex)
+       {
+       android.util.Log.e("Renderer", "failed to create SolveEffect, exception: "+ex.getMessage());
+
+       mNewCube.solve();    //
+       mCanRotate = true;   // just solve the cube
+       mCanDrag   = true;   //
        }
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-   private void solveCubeNow()
+   private void scrambleCubeNow()
      {
      try
        {
-       SolveEffect effect = SolveEffect.create(mType[1]);
-       mSolveEffectID = effect.start(mPos[1],mScreen,mNewCube,this);
+       int pos2 = RubikSettingsEnum.getEnum(2).getCurrentPos();
+       int typ2 = RubikSettingsEnum.getEnum(2).getCurrentType();
+       int pos = RubikSettingsEnum.translatePos(pos2)+1;
+       ScrambleEffect effect = ScrambleEffect.create(typ2);
+       mScrambleEffectID = effect.start(pos,mNewCube,mScrambleCubeNum,this);
        }
      catch(Exception ex)
        {
-       android.util.Log.e("Renderer", "failed to create SolveEffect, exception: "+ex.getMessage());
+       android.util.Log.e("Renderer", "failed to create ScrambleEffect, exception: "+ex.getMessage());
 
-       mNewCube.solve();    //
-       mCanRotate = true;   // just solve the cube
-       mCanDrag   = true;   //
+       mCanRotate = true;
+       mCanDrag   = true;
        }
      }
 
diff --git a/src/main/java/org/distorted/magic/RubikSettings.java b/src/main/java/org/distorted/magic/RubikSettings.java
index ff4ccdfe..95d3b535 100644
--- a/src/main/java/org/distorted/magic/RubikSettings.java
+++ b/src/main/java/org/distorted/magic/RubikSettings.java
@@ -20,11 +20,8 @@
 package org.distorted.magic;
 
 import android.app.Dialog;
-import android.content.Context;
-import android.content.DialogInterface;
 import android.os.Bundle;
 import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
 import android.support.v4.app.FragmentActivity;
 import android.support.v7.app.AlertDialog;
 import android.support.v7.app.AppCompatDialogFragment;
@@ -42,74 +39,13 @@ import android.widget.TextView;
 
 public class RubikSettings extends AppCompatDialogFragment implements SeekBar.OnSeekBarChangeListener, AdapterView.OnItemSelectedListener
   {
-  public interface OnCompleteListener
-    {
-    void onComplete(int index, int position, int type);
-    }
-
-  private OnCompleteListener mListener;
-
   private TextView[] mDurationText;
-  private int[] mSeekBarID;
-  private int[] mSpinnerID;
-  private int[] mPos;
-  private int[] mType;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public RubikSettings()
     {
     mDurationText = new TextView[RubikSettingsEnum.LENGTH];
-    mSeekBarID    = new int[RubikSettingsEnum.LENGTH];
-    mSpinnerID    = new int[RubikSettingsEnum.LENGTH];
-    mPos          = new int[RubikSettingsEnum.LENGTH];
-    mType         = new int[RubikSettingsEnum.LENGTH];
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  @Override
-  public void onAttach(Context context)
-    {
-    super.onAttach(context);
-
-    try
-      {
-      mListener = (OnCompleteListener)context;
-      }
-    catch (final ClassCastException e)
-      {
-      throw new ClassCastException(context.toString() + " must implement OnCompleteListener");
-      }
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  @Override
-  public void onCreate(@Nullable Bundle savedInstanceState)
-    {
-    super.onCreate(savedInstanceState);
-
-    Bundle args = getArguments();
-
-    String name;
-
-    for (int i=0; i<RubikSettingsEnum.LENGTH; i++)
-      {
-      RubikSettingsEnum rse = RubikSettingsEnum.getEnum(i);
-      name = rse.name();
-
-      try
-        {
-        mPos[i]  = args.getInt(name+"_Pos" );
-        mType[i] = args.getInt(name+"_Type");
-        }
-      catch(NullPointerException ex)
-        {
-        mPos[i]  = rse.getDefaultPos();
-        mType[i] = rse.getDefaultType();
-        }
-      }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -120,16 +56,7 @@ public class RubikSettings extends AppCompatDialogFragment implements SeekBar.On
     {
     FragmentActivity act = getActivity();
     AlertDialog.Builder builder = new AlertDialog.Builder(act);
-
     builder.setCancelable(false);
-    builder.setPositiveButton( R.string.save, new DialogInterface.OnClickListener()
-      {
-      @Override
-      public void onClick(DialogInterface dialog, int which)
-        {
-        saveOptions();
-        }
-      });
 
     LayoutInflater inflater = act.getLayoutInflater();
     final View view = inflater.inflate(R.layout.settings, null);
@@ -162,7 +89,7 @@ public class RubikSettings extends AppCompatDialogFragment implements SeekBar.On
       ///// TEXT ///////////////////////////////////////////////////////////////////////////
 
       int layoutHeight = (int)(scale*48 + 0.5f);
-      int padding      = (int)(scale*15 + 0.5f);
+      int padding      = (int)(scale*10 + 0.5f);
 
       LinearLayout.LayoutParams textParams = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,layoutHeight);
 
@@ -233,10 +160,8 @@ public class RubikSettings extends AppCompatDialogFragment implements SeekBar.On
       seekBar.setId(index);
       innerLayout1.addView(seekBar);
 
-      mSeekBarID[index] = seekBar.getId();
-
       seekBar.setOnSeekBarChangeListener(this);
-      seekBar.setProgress(mPos[index]);
+      seekBar.setProgress(rsEnum.getCurrentPos());
 
       ///// INNER LAYOUT2 //////////////////////////////////////////////////////////////////
 
@@ -272,31 +197,12 @@ public class RubikSettings extends AppCompatDialogFragment implements SeekBar.On
       spinner.setId(index);
       innerLayout2.addView(spinner);
 
-      mSpinnerID[index] = spinner.getId();
-
       spinner.setOnItemSelectedListener(this);
       String[] appear = RubikSettingsEnum.getNames(index);
       ArrayAdapter<String> adapterType = new ArrayAdapter<>(act,android.R.layout.simple_spinner_item, appear);
       adapterType.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
       spinner.setAdapter(adapterType);
-
-      int type = mType[index];
-
-      if(type>=0 && type<appear.length)
-        {
-        spinner.setSelection(type);
-        }
-      }
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    private void saveOptions()
-      {
-      for (int i=0; i<RubikSettingsEnum.LENGTH; i++)
-        {
-        mListener.onComplete(i, mPos[i], mType[i]);
-        }
+      spinner.setSelection(rsEnum.getCurrentType());
       }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -305,13 +211,9 @@ public class RubikSettings extends AppCompatDialogFragment implements SeekBar.On
       {
       int parentID = parent.getId();
 
-      for (int i=0; i<RubikSettingsEnum.LENGTH; i++)
+      if( parentID>=0 && parentID< RubikSettingsEnum.LENGTH) // ith spinner's ID is equal to i (see createSettingSection)
         {
-        if( mSpinnerID[i] == parentID )
-          {
-          mType[i] = pos;
-          break;
-          }
+        RubikSettingsEnum.getEnum(parentID).setCurrentType(pos);
         }
       }
 
@@ -321,15 +223,11 @@ public class RubikSettings extends AppCompatDialogFragment implements SeekBar.On
       {
       int barID = bar.getId();
 
-      for (int i=0; i<RubikSettingsEnum.LENGTH; i++)
+      if( barID>=0 && barID< RubikSettingsEnum.LENGTH) // ith seekbar's ID is equal to i (see createSettingSection)
         {
-        if( mSeekBarID[i] == barID )
-          {
-          mPos[i] = progress;
-          int ms = RubikActivity.translateDuration(mPos[i]);
-          mDurationText[i].setText(getString(R.string.ms_placeholder,ms));
-          break;
-          }
+        RubikSettingsEnum.getEnum(barID).setCurrentPos(progress);
+        int ms = RubikSettingsEnum.translatePos(progress);
+        mDurationText[barID].setText(getString(R.string.ms_placeholder,ms));
         }
       }
 
diff --git a/src/main/java/org/distorted/magic/RubikSettingsEnum.java b/src/main/java/org/distorted/magic/RubikSettingsEnum.java
index 2c727f43..223efb1d 100644
--- a/src/main/java/org/distorted/magic/RubikSettingsEnum.java
+++ b/src/main/java/org/distorted/magic/RubikSettingsEnum.java
@@ -19,20 +19,23 @@
 
 package org.distorted.magic;
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
+import android.content.SharedPreferences;
 
 import org.distorted.effect.ScrambleEffect;
 import org.distorted.effect.SizeChangeEffect;
 import org.distorted.effect.SolveEffect;
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
 enum RubikSettingsEnum
   {
-  SIZECHANGE  (  20, 1, R.string.sizechange_effect ),
+  SIZECHANGE  (  20, 1, R.string.sizechange_effect),
   SOLVE       (  20, 1, R.string.solve_effect      ),
-  SCRAMBLE    ( 100, 0, R.string.scramble_effect   );
+  SCRAMBLE    ( 100, 1, R.string.scramble_effect   );
 
   public static final int LENGTH = values().length;
-  private int mDefaultPos, mDefaultType;
+  private final int mDefaultPos, mDefaultType;
+  private int mCurrentPos, mCurrentType;
   private int mText;
 
   private static final RubikSettingsEnum[] enums;  // copy the values() to a local variable so that we
@@ -54,30 +57,64 @@ enum RubikSettingsEnum
 
   RubikSettingsEnum( int dPos, int dType, int text )
     {
-    mDefaultPos  = dPos;
-    mDefaultType = dType;
+    mDefaultPos  = mCurrentPos = dPos;
+    mDefaultType = mCurrentType= dType;
     mText        = text;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getDefaultPos()
+  int getText()
     {
-    return mDefaultPos;
+    return mText;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getDefaultType()
+  int getCurrentPos()
     {
-    return mDefaultType;
+    return mCurrentPos;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  int getText()
+  int getCurrentType()
     {
-    return mText;
+    return mCurrentType;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  void setCurrentPos(int pos)
+    {
+    mCurrentPos = pos;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  void setCurrentType(int type)
+    {
+    mCurrentType = type;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  void savePreferences(SharedPreferences.Editor editor)
+    {
+    String name = name();
+
+    editor.putInt(name+"_Pos" , mCurrentPos );
+    editor.putInt(name+"_Type", mCurrentType);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  void restorePreferences(SharedPreferences preferences)
+    {
+    String name = name();
+
+    mCurrentPos  = preferences.getInt(name+"_Pos" , mDefaultPos );
+    mCurrentType = preferences.getInt(name+"_Type", mDefaultType);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -100,4 +137,11 @@ enum RubikSettingsEnum
 
     return null;
     }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  static int translatePos(int pos)
+     {
+     return (pos/2)*100;
+     }
   }