commit b498f3f6682c10d4c1ee57b389e3de57d728424e
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Wed Apr 1 22:36:47 2020 +0100

    Introduce RubikPatternsList. Now, if one wants to contribute patterns for a new object, all one has to be is give the list of strings describing the patterns and add them to the List.

diff --git a/src/main/java/org/distorted/dialog/RubikDialogPattern.java b/src/main/java/org/distorted/dialog/RubikDialogPattern.java
index e629664a..70355e78 100644
--- a/src/main/java/org/distorted/dialog/RubikDialogPattern.java
+++ b/src/main/java/org/distorted/dialog/RubikDialogPattern.java
@@ -37,7 +37,8 @@ import android.widget.ImageView;
 import android.widget.TextView;
 
 import org.distorted.magic.R;
-import org.distorted.patterns.RubikPattern;
+import org.distorted.object.RubikObjectList;
+import org.distorted.patterns.RubikPatternList;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -94,12 +95,15 @@ public class RubikDialogPattern extends AppCompatDialogFragment
     tabLayout.setupWithViewPager(viewPager);
     viewPager.setCurrentItem(curTab);
 
-    int[] iconID = { R.drawable.cube2, R.drawable.cube3, R.drawable.cube4, R.drawable.cube5 };
-
-    for(int i=0; i< RubikPattern.NUM_CUBES; i++)
+    for(int i=0; i< RubikPatternList.NUM_OBJECTS; i++)
       {
+      RubikObjectList list = RubikPatternList.getObject(i);
+      int size             = RubikPatternList.getSize(i);
+      int sizeIndex        = RubikObjectList.getSizeIndex(list.ordinal(),size);
+      int iconID           = list.getIconIDs()[sizeIndex];
+
       ImageView imageView = new ImageView(act);
-      imageView.setImageResource(iconID[i]);
+      imageView.setImageResource(iconID);
       TabLayout.Tab tab = tabLayout.getTabAt(i);
       if(tab!=null) tab.setCustomView(imageView);
       }
diff --git a/src/main/java/org/distorted/dialog/RubikDialogPatternPagerAdapter.java b/src/main/java/org/distorted/dialog/RubikDialogPatternPagerAdapter.java
index cbe6b230..e23ed79a 100644
--- a/src/main/java/org/distorted/dialog/RubikDialogPatternPagerAdapter.java
+++ b/src/main/java/org/distorted/dialog/RubikDialogPatternPagerAdapter.java
@@ -27,6 +27,7 @@ import android.view.View;
 import android.view.ViewGroup;
 
 import org.distorted.patterns.RubikPattern;
+import org.distorted.patterns.RubikPatternList;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -43,7 +44,7 @@ class RubikDialogPatternPagerAdapter extends PagerAdapter
     {
     mAct = act;
     mDialog = dialog;
-    mNumTabs = RubikPattern.NUM_CUBES;
+    mNumTabs = RubikPatternList.NUM_OBJECTS;
     mViews = new RubikDialogPatternView[mNumTabs];
 
     viewPager.setAdapter(this);
diff --git a/src/main/java/org/distorted/dialog/RubikDialogPatternView.java b/src/main/java/org/distorted/dialog/RubikDialogPatternView.java
index 793e9001..663103f9 100644
--- a/src/main/java/org/distorted/dialog/RubikDialogPatternView.java
+++ b/src/main/java/org/distorted/dialog/RubikDialogPatternView.java
@@ -36,6 +36,7 @@ import org.distorted.magic.R;
 import org.distorted.magic.RubikActivity;
 import org.distorted.object.RubikObjectList;
 import org.distorted.patterns.RubikPattern;
+import org.distorted.patterns.RubikPatternList;
 import org.distorted.uistate.RubikState;
 import org.distorted.uistate.RubikStatePattern;
 
@@ -153,9 +154,13 @@ public class RubikDialogPatternView extends FrameLayout implements AdapterView.O
         @Override
         public void onClick(View view)
           {
-          int[] sizes = RubikObjectList.CUBE.getSizes();
           int[][] moves = pattern.reInitialize(mTab, category, ii);
-          act.changeObject(RubikObjectList.CUBE,sizes[mTab],moves);
+
+          RubikObjectList list = RubikPatternList.getObject(mTab);
+          int size             = RubikPatternList.getSize(mTab);
+
+          act.changeObject( list, size, moves);
+
           RubikStatePattern state = (RubikStatePattern) RubikState.PATT.getStateClass();
           state.setPattern(act, mTab, category, ii);
           mDialog.rememberState();
diff --git a/src/main/java/org/distorted/object/RubikObjectList.java b/src/main/java/org/distorted/object/RubikObjectList.java
index cba72e19..b9073015 100644
--- a/src/main/java/org/distorted/object/RubikObjectList.java
+++ b/src/main/java/org/distorted/object/RubikObjectList.java
@@ -85,12 +85,12 @@ public enum RubikObjectList
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public static int pack(int object, int size)
+  public static int pack(int object, int sizeIndex)
     {
     int ret = 0;
     for(int i=0; i<object; i++) ret += objects[i].mObjectSizes.length;
 
-    return ret+size;
+    return ret+sizeIndex;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/main/java/org/distorted/patterns/RubikPattern.java b/src/main/java/org/distorted/patterns/RubikPattern.java
index cc2e30c2..591daffe 100644
--- a/src/main/java/org/distorted/patterns/RubikPattern.java
+++ b/src/main/java/org/distorted/patterns/RubikPattern.java
@@ -20,24 +20,21 @@
 package org.distorted.patterns;
 
 import org.distorted.magic.RubikPostRender;
-import org.distorted.object.RubikObject;
 
 import java.util.ArrayList;
 import java.util.List;
 
+import static org.distorted.patterns.RubikPatternList.NUM_OBJECTS;
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 public class RubikPattern
 {
   private static final int DURATION_MILLIS = 800;
 
-  public static final int MIN_CUBE  = 2;
-  public static final int MAX_CUBE  = 5;
-  public static final int NUM_CUBES = MAX_CUBE-MIN_CUBE+1;
-
-  private int[] numCategories   = new int[NUM_CUBES];
-  private int[] currentCategory = new int[NUM_CUBES];
-  private int[] currentScrollPos= new int[NUM_CUBES];
+  private int[] numCategories   = new int[NUM_OBJECTS];
+  private int[] currentCategory = new int[NUM_OBJECTS];
+  private int[] currentScrollPos= new int[NUM_OBJECTS];
 
   private List<List<Category>> mCategories;
   private static RubikPattern mThis;
@@ -55,9 +52,8 @@ public class RubikPattern
 
     Category(String[] lines)
       {
-      mLines=lines;
-      numPatterns=lines.length-1;
-      mPatterns = new ArrayList<>();
+      mLines       = lines;
+      numPatterns  = lines.length-1;
       mInitialized = false;
       }
 
@@ -69,6 +65,8 @@ public class RubikPattern
       String moves, name;
       Pattern pattern;
 
+      mPatterns = new ArrayList<>();
+
       for(int i=0; i<numPatterns; i++)
         {
         colon = mLines[i+1].indexOf(":");
@@ -204,10 +202,10 @@ public class RubikPattern
 
   /////////////////////////////////////////////////////////////
 
-    Pattern(String n, String m)
+    Pattern(String name, String moves)
       {
-      nameStr = n;
-      moveStr = m;
+      nameStr      = name;
+      moveStr      = moves;
       mCanRotate   = true;
       mInitialized = false;
       }
@@ -269,7 +267,6 @@ public class RubikPattern
       if( !mInitialized ) initialize();
 
       curMove++;
-      RubikObject object = post.getObject();
 
       if( mCanRotate )
         {
@@ -280,10 +277,10 @@ public class RubikPattern
           }
         else
           {
-          int axis     =moves[curMove-1][0];
-		      int rowBitmap=moves[curMove-1][1];
-		      int bareAngle=moves[curMove-1][2];
-          int angle    = bareAngle*(360/object.getBasicAngle());
+          int axis     = moves[curMove-1][0];
+		      int rowBitmap= moves[curMove-1][1];
+		      int bareAngle= moves[curMove-1][2];
+          int angle    = bareAngle*(360/post.getObject().getBasicAngle());
           int numRot   = Math.abs(bareAngle);
 
           if( angle!=0 )
@@ -311,7 +308,6 @@ public class RubikPattern
       if( !mInitialized ) initialize();
 
       curMove--;
-      RubikObject object = post.getObject();
 
       if( mCanRotate )
         {
@@ -322,10 +318,10 @@ public class RubikPattern
           }
         else
           {
-          int axis     =moves[curMove][0];
-		      int rowBitmap=moves[curMove][1];
-		      int bareAngle=moves[curMove][2];
-          int angle    = bareAngle*(360/object.getBasicAngle());
+          int axis     = moves[curMove][0];
+		      int rowBitmap= moves[curMove][1];
+		      int bareAngle= moves[curMove][2];
+          int angle    = bareAngle*(360/post.getObject().getBasicAngle());
           int numRot   = Math.abs(bareAngle);
 
           if( angle!=0 )
@@ -371,27 +367,28 @@ public class RubikPattern
     {
     mCategories = new ArrayList<>();
 
-    initializeCategories(0, RubikPatternCube2.patterns);
-    initializeCategories(1, RubikPatternCube3.patterns);
-    initializeCategories(2, RubikPatternCube4.patterns);
-    initializeCategories(3, RubikPatternCube5.patterns);
+    for(int i=0; i<NUM_OBJECTS; i++)
+      {
+      List<Category> list = new ArrayList<>();
+      String[][] patStrings = RubikPatternList.getPatterns(i);
+
+      for(String[] lines: patStrings) list.add(new Category(lines));
+
+      mCategories.add(list);
+      numCategories[i]=patStrings.length;
+      }
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private void initializeCategories(int num, String[][] pat)
+  private Category getCategory(int tab, int cat)
     {
-    List<Category> list = new ArrayList<>();
-    Category cat;
-
-    for(String[] lines: pat)
+    if( tab>=0 && tab<NUM_OBJECTS && cat>=0 && cat<numCategories[tab] )
       {
-      cat = new Category(lines);
-      list.add(cat);
+      return mCategories.get(tab).get(cat);
       }
 
-    mCategories.add(num,list);
-    numCategories[num]=pat.length;
+    return null;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -412,27 +409,14 @@ public class RubikPattern
 
   public int getNumCategories(int tab)
     {
-    return tab>=0 && tab<NUM_CUBES ? numCategories[tab] : 0;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public String getCategoryName(int tab, int cat)
-    {
-    if( tab>=0 && tab<NUM_CUBES && cat>=0 && cat< numCategories[tab] )
-      {
-      Category c = mCategories.get(tab).get(cat);
-      return c!=null ? c.getName() : null;
-      }
-
-    return null;
+    return tab>=0 && tab<NUM_OBJECTS ? numCategories[tab] : 0;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public void rememberState(int tab, int cat, int scrollPos)
     {
-    if( tab>=0 && tab<NUM_CUBES )
+    if( tab>=0 && tab<NUM_OBJECTS )
       {
       currentCategory[tab] = cat;
       currentScrollPos[tab]= scrollPos;
@@ -443,100 +427,77 @@ public class RubikPattern
 
   public int recallCategory(int tab)
     {
-    return tab>=0 && tab<NUM_CUBES ? currentCategory[tab] : 0;
+    return tab>=0 && tab<NUM_OBJECTS ? currentCategory[tab] : 0;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public int recallScrollPos(int tab)
     {
-    return tab>=0 && tab<NUM_CUBES ? currentScrollPos[tab] : 0;
+    return tab>=0 && tab<NUM_OBJECTS ? currentScrollPos[tab] : 0;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public String getPatternName(int tab, int cat, int pat)
+  public String getCategoryName(int tab, int cat)
     {
-    if( tab>=0 && tab<NUM_CUBES && cat>=0 && cat< numCategories[tab] )
-      {
-      Category c = mCategories.get(tab).get(cat);
-      return c!=null ? c.getPatternName(pat) : null;
-      }
+    Category c = getCategory(tab,cat);
+    return c!=null ? c.getName() : null;
+    }
 
-    return null;
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public String getPatternName(int tab, int cat, int pat)
+    {
+    Category c = getCategory(tab,cat);
+    return c!=null ? c.getPatternName(pat) : null;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public int getNumPatterns(int tab, int cat)
     {
-    if( tab>=0 && tab<NUM_CUBES && cat>=0 && cat< numCategories[tab] )
-      {
-      Category c = mCategories.get(tab).get(cat);
-      return c!=null ? c.getNumPatterns() : 0;
-      }
-
-    return 0;
+    Category c = getCategory(tab,cat);
+    return c!=null ? c.getNumPatterns() : 0;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public int getCurMove(int tab, int cat, int pat)
     {
-    if( tab>=0 && tab<NUM_CUBES && cat>=0 && cat< numCategories[tab] )
-      {
-      Category c = mCategories.get(tab).get(cat);
-      return c!=null ? c.getPatternCurMove(pat):0;
-      }
-
-    return 0;
+    Category c = getCategory(tab,cat);
+    return c!=null ? c.getPatternCurMove(pat) : 0;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public int getNumMoves(int tab, int cat, int pat)
     {
-    if( tab>=0 && tab<NUM_CUBES && cat>=0 && cat< numCategories[tab] )
-      {
-      Category c = mCategories.get(tab).get(cat);
-      return c!=null ? c.getPatternNumMove(pat):0;
-      }
-
-    return 0;
+    Category c = getCategory(tab,cat);
+    return c!=null ? c.getPatternNumMove(pat) : 0;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public void makeMove(RubikPostRender post, int tab, int cat, int pat)
     {
-    if( tab>=0 && tab<NUM_CUBES && cat>=0 && cat< numCategories[tab] )
-      {
-      Category c = mCategories.get(tab).get(cat);
-      if( c!=null ) c.makeMove(post,pat);
-      }
+    Category c = getCategory(tab,cat);
+    if( c!=null ) c.makeMove(post,pat);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public void backMove(RubikPostRender post, int tab, int cat, int pat)
     {
-    if( tab>=0 && tab<NUM_CUBES && cat>=0 && cat< numCategories[tab] )
-      {
-      Category c = mCategories.get(tab).get(cat);
-      if( c!=null ) c.backMove(post,pat);
-      }
+    Category c = getCategory(tab,cat);
+    if( c!=null ) c.backMove(post,pat);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public int[][] reInitialize(int tab, int cat, int pat)
     {
-    if( tab>=0 && tab<NUM_CUBES && cat>=0 && cat< numCategories[tab] )
-      {
-      Category c = mCategories.get(tab).get(cat);
-      if( c!=null ) return c.reInitialize(pat);
-      }
-
-    return null;
+    Category c = getCategory(tab,cat);
+    return c!=null ? c.reInitialize(pat) : null;
     }
 }
diff --git a/src/main/java/org/distorted/patterns/RubikPatternList.java b/src/main/java/org/distorted/patterns/RubikPatternList.java
new file mode 100644
index 00000000..0159cbcd
--- /dev/null
+++ b/src/main/java/org/distorted/patterns/RubikPatternList.java
@@ -0,0 +1,105 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Copyright 2020 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.patterns;
+
+import org.distorted.object.RubikObjectList;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+public enum RubikPatternList
+  {
+  CUBE2 (RubikObjectList.CUBE, 2, RubikPatternCube2.patterns),
+  CUBE3 (RubikObjectList.CUBE, 3, RubikPatternCube3.patterns),
+  CUBE4 (RubikObjectList.CUBE, 4, RubikPatternCube4.patterns),
+  CUBE5 (RubikObjectList.CUBE, 5, RubikPatternCube5.patterns),
+  ;
+
+  public static final int NUM_OBJECTS = values().length;
+  private RubikObjectList mObject;
+  private int mSize;
+  private String[][] mPatterns;
+
+  private static final RubikPatternList[] objects;
+
+  static
+    {
+    objects = new RubikPatternList[NUM_OBJECTS];
+    int i=0;
+
+    for(RubikPatternList object: RubikPatternList.values())
+      {
+      objects[i++] = object;
+      }
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  static RubikPatternList[] getPatterns()
+    {
+    return objects;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  static String[][] getPatterns(int ordinal)
+    {
+    return objects[ordinal].mPatterns;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  RubikPatternList(RubikObjectList object, int size, String[][] patterns)
+    {
+    mObject   = object;
+    mSize     = size;
+    mPatterns = patterns;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// PUBLIC API
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public static int getOrdinal(int objectOrdinal, int size)
+    {
+    for(int i=0; i<NUM_OBJECTS; i++)
+      {
+      if( objects[i].mObject.ordinal() == objectOrdinal && objects[i].mSize == size )
+        {
+        return i;
+        }
+      }
+
+    return -1;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public static RubikObjectList getObject(int ordinal)
+    {
+    return objects[ordinal].mObject;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public static int getSize(int ordinal)
+    {
+    return objects[ordinal].mSize;
+    }
+  }
diff --git a/src/main/java/org/distorted/uistate/RubikStatePattern.java b/src/main/java/org/distorted/uistate/RubikStatePattern.java
index fae5631e..1ffe984d 100644
--- a/src/main/java/org/distorted/uistate/RubikStatePattern.java
+++ b/src/main/java/org/distorted/uistate/RubikStatePattern.java
@@ -37,20 +37,18 @@ import org.distorted.magic.RubikActivity;
 import org.distorted.magic.RubikPostRender;
 import org.distorted.object.RubikObjectList;
 import org.distorted.patterns.RubikPattern;
+import org.distorted.patterns.RubikPatternList;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 public class RubikStatePattern extends RubikStateAbstract
   {
-  // TODO: read this from upper_text.xml;  this is the height of the TextView there.
-  private static final int DEFAULT_TEXT_SIZE = 30;
-
   private TextView mText;
   private Button mBackButton;
   private ImageButton mPrevButton, mNextButton;
   private TextView mMovesText;
   private int mNumMoves;
-  private int mSizeIndex, mCategory, mPattern;
+  private int mPatternOrdinal, mCategory, mPattern;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -64,14 +62,16 @@ public class RubikStatePattern extends RubikStateAbstract
   void leaveState(RubikActivity act)
     {
     RubikStatePlay play = (RubikStatePlay)RubikState.PLAY.getStateClass();
-    int s = RubikObjectList.CUBE.getSizes()[mSizeIndex];
 
-    if( !play.setObjectAndSize(RubikObjectList.CUBE, s) )
+    RubikObjectList object = RubikPatternList.getObject(mPatternOrdinal);
+    int size = RubikPatternList.getSize(mPatternOrdinal);
+
+    if( !play.setObjectAndSize(object,size) )
       {
-      int object= play.getObject();
-      int size  = play.getSize();
+      int objectPlay= play.getObject();
+      int sizePlay  = play.getSize();
 
-      act.changeObject(RubikObjectList.getObject(object),size,null);
+      act.changeObject(RubikObjectList.getObject(objectPlay),sizePlay,null);
       }
     }
 
@@ -83,14 +83,12 @@ public class RubikStatePattern extends RubikStateAbstract
     int obj  = play.getObject();
     int size = play.getSize();
 
-    if( size>=RubikPattern.MIN_CUBE && size<=RubikPattern.MAX_CUBE && obj==RubikObjectList.CUBE.ordinal() )
-      {
-      mSizeIndex = RubikObjectList.getSizeIndex(obj,size);
-      }
-    else
+    mPatternOrdinal = RubikPatternList.getOrdinal(obj,size);
+
+    if( mPatternOrdinal<0 )
       {
-      mSizeIndex = RubikObjectList.getSizeIndex(RubikObjectList.CUBE.ordinal(),RubikStatePlay.DEF_SIZE);
-      act.changeObject(RubikObjectList.CUBE,RubikStatePlay.DEF_SIZE,null);
+      mPatternOrdinal = RubikObjectList.getSizeIndex(RubikStatePlay.DEF_OBJECT,RubikStatePlay.DEF_SIZE);
+      act.changeObject(RubikObjectList.getObject(RubikStatePlay.DEF_OBJECT),RubikStatePlay.DEF_SIZE,null);
       }
 
     FragmentManager mana = act.getSupportFragmentManager();
@@ -132,11 +130,9 @@ public class RubikStatePattern extends RubikStateAbstract
 
   private void showDialog(FragmentManager manager)
     {
-    Bundle bundle = new Bundle();
-    int object = RubikObjectList.CUBE.ordinal();
-    bundle.putInt("tab", RubikObjectList.pack(object,mSizeIndex) );
-
     RubikDialogPattern diag = new RubikDialogPattern();
+    Bundle bundle = new Bundle();
+    bundle.putInt("tab", mPatternOrdinal );
     diag.setArguments(bundle);
     diag.show( manager, RubikDialogPattern.getDialogTag() );
     }
@@ -162,7 +158,6 @@ public class RubikStatePattern extends RubikStateAbstract
 
         if( diag==null )
           {
-          mText.setTextSize(DEFAULT_TEXT_SIZE);
           showDialog(mana);
           }
         else
@@ -193,8 +188,8 @@ public class RubikStatePattern extends RubikStateAbstract
         {
         RubikPattern pattern = RubikPattern.getInstance();
         RubikPostRender post = act.getPostRender();
-        pattern.backMove( post, mSizeIndex, mCategory, mPattern);
-        int currMove = pattern.getCurMove(mSizeIndex, mCategory, mPattern);
+        pattern.backMove( post, mPatternOrdinal, mCategory, mPattern);
+        int currMove = pattern.getCurMove(mPatternOrdinal, mCategory, mPattern);
         mMovesText.setText(act.getString(R.string.mo_placeholder,currMove,mNumMoves));
         }
       });
@@ -218,8 +213,8 @@ public class RubikStatePattern extends RubikStateAbstract
         {
         RubikPattern pattern = RubikPattern.getInstance();
         RubikPostRender post = act.getPostRender();
-        pattern.makeMove( post, mSizeIndex, mCategory, mPattern);
-        int currMove = pattern.getCurMove(mSizeIndex, mCategory, mPattern);
+        pattern.makeMove( post, mPatternOrdinal, mCategory, mPattern);
+        int currMove = pattern.getCurMove(mPatternOrdinal, mCategory, mPattern);
         mMovesText.setText(act.getString(R.string.mo_placeholder,currMove,mNumMoves));
         }
       });
@@ -239,24 +234,24 @@ public class RubikStatePattern extends RubikStateAbstract
     mMovesText.setGravity(Gravity.CENTER);
 
     RubikPattern pattern = RubikPattern.getInstance();
-    int currMove = pattern.getCurMove(mSizeIndex, mCategory, mPattern);
+    int currMove = pattern.getCurMove(mPatternOrdinal, mCategory, mPattern);
     mMovesText.setText(act.getString(R.string.mo_placeholder,currMove,mNumMoves));
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public void setPattern(final RubikActivity act, int sizeIndex, int category, int pattern)
+  public void setPattern(final RubikActivity act, int ordinal, int category, int pattern)
     {
-    mSizeIndex = sizeIndex;
-    mCategory  = category;
-    mPattern   = pattern;
+    mPatternOrdinal = ordinal;
+    mCategory       = category;
+    mPattern        = pattern;
 
     RubikPattern patt = RubikPattern.getInstance();
-    String patternName = patt.getPatternName(sizeIndex,category,pattern);
+    String patternName = patt.getPatternName(ordinal,category,pattern);
     mText.setText(patternName);
 
-    mNumMoves   = patt.getNumMoves(sizeIndex,category,pattern);
-    int currMove= patt.getCurMove(sizeIndex,category,pattern);
+    mNumMoves   = patt.getNumMoves(ordinal,category,pattern);
+    int currMove= patt.getCurMove(ordinal,category,pattern);
 
     mMovesText.setText(act.getString(R.string.mo_placeholder,currMove,mNumMoves));
     }