Magic Cube

        <activity android:name="org.distorted.solvers.SolverActivity" android:exported="false" android:screenOrientation="portrait"/>

        <activity android:name="org.distorted.patterns.PatternActivity" android:exported="false" android:screenOrientation="portrait"/>

        <activity android:name="org.distorted.play.PlayActivity" android:exported="false" android:screenOrientation="portrait"/>

import org.distorted.play.PlayActivity;

import org.distorted.play.PlayActivity;

import org.distorted.play.ScreenList;

import org.distorted.play.PlayActivity;

import org.distorted.patterns.PatternActivity;

import org.distorted.patterns.ScreenList;

import org.distorted.patterns.ScreenPattern;

import org.distorted.play.PlayActivity;

import org.distorted.play.PlayActivity;

import org.distorted.solvers.ScreenList;

import org.distorted.solvers.ScreenSetupPosition;

import org.distorted.solvers.SolverActivity;

import org.distorted.solvers.SolverActivity;

import org.distorted.patterns.PatternActivity;

import org.distorted.play.PlayActivity;

import org.distorted.solvers.SolverActivity;

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

// Copyright 2023 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.patterns;

import android.content.SharedPreferences;

import android.os.Build;

import android.os.Bundle;

import android.view.DisplayCutout;

import android.view.ViewGroup;

import android.widget.LinearLayout;

import org.distorted.dialogs.DialogError;

import org.distorted.helpers.BaseActivity;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedScreen;

import org.distorted.main.R;

import org.distorted.objectlib.main.InitAssets;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.objects.RubikObject;

import org.distorted.objects.RubikObjectList;

import org.distorted.os.OSInterface;

import java.io.InputStream;

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

public class PatternActivity extends BaseActivity

{

    public static final float RATIO_UPP       = 0.100f;

    public static final float PADDING         = 0.010f;

    public static final float SMALL_MARGIN    = 0.004f;

    public static final float BUTTON_TEXT_SIZE= 0.050f;

    public static final float TITLE_TEXT_SIZE = 0.045f;

    private static final int ACTIVITY_NUMBER = 5;

    private static final float RATIO_INSET= 0.09f;

    private int mObjectOrdinal;

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

    @Override

    protected void onCreate(Bundle savedState)

      {

      super.onCreate(savedState);

      DistortedLibrary.onCreate(ACTIVITY_NUMBER);

      setContentView(R.layout.pattern);

      Bundle b = getIntent().getExtras();

      mObjectOrdinal = b!=null ? b.getInt("obj") : 0;

      computeScreenDimensions();

      hideNavigationBar();

      cutoutHack();

      computeLowerBarHeight(RATIO_BAR);

      computeUpperBarHeight(RATIO_UPP);

      }

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

    @Override

    public void onAttachedToWindow()

      {

      super.onAttachedToWindow();

      if( Build.VERSION.SDK_INT >= Build.VERSION_CODES.P )

        {

        DisplayCutout cutout = getWindow().getDecorView().getRootWindowInsets().getDisplayCutout();

        int insetHeight = cutout!=null ? cutout.getSafeInsetTop() : 0;

        LinearLayout layoutHid = findViewById(R.id.hiddenBar);

        ViewGroup.LayoutParams paramsHid = layoutHid.getLayoutParams();

        paramsHid.height = (int)(insetHeight*RATIO_INSET);

        layoutHid.setLayoutParams(paramsHid);

        }

      }

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

    @Override

    protected void onPause() 

      {

      super.onPause();

      PatternSurfaceView view = findViewById(R.id.patternSurfaceView);

      view.onPause();

      DistortedLibrary.onPause(ACTIVITY_NUMBER);

      savePreferences();

      }

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

    @Override

    protected void onResume() 

      {

      super.onResume();

      DistortedLibrary.onResume(ACTIVITY_NUMBER);

      PatternSurfaceView view = findViewById(R.id.patternSurfaceView);

      view.onResume();

      createObject();

      restorePreferences();

      ScreenList.setScreen(this);

      }

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

    @Override

    protected void onDestroy() 

      {

      DistortedLibrary.onDestroy(ACTIVITY_NUMBER);

      super.onDestroy();

      }

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

    private void savePreferences()

      {

      SharedPreferences.Editor editor = mPreferences.edit();

      for(int i=0; i< ScreenList.LENGTH; i++ )

        ScreenList.getScreen(i).getScreenClass().savePreferences(editor);

      ScreenList.savePreferences(editor);

      boolean success = editor.commit();

      if( !success ) android.util.Log.e("D", "Failed to save preferences");

      }

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

    private void restorePreferences()

      {

      for (int i=0; i<ScreenList.LENGTH; i++)

        ScreenList.getScreen(i).getScreenClass().restorePreferences(mPreferences);

      ScreenList.restorePreferences(mPreferences);

      }

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

    void OpenGLError()

      {

      DialogError errDiag = new DialogError();

      errDiag.show(getSupportFragmentManager(), null);

      }

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

// PUBLIC API

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

    public TwistyObject getObject()

      {

      PatternSurfaceView view = findViewById(R.id.patternSurfaceView);

      return view.getObjectControl().getObject();

      }

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

    public DistortedScreen getScreen()

      {

      PatternSurfaceView view = findViewById(R.id.patternSurfaceView);

      return view.getRenderer().getScreen();

      }

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

    public ObjectControl getControl()

      {

      PatternSurfaceView view = findViewById(R.id.patternSurfaceView);

      return view.getObjectControl();

      }

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

    public int getObjectOrdinal()

      {

      return mObjectOrdinal;

      }

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

    public void createObject()

      {

      PatternSurfaceView view = findViewById(R.id.patternSurfaceView);

      ObjectControl control = view.getObjectControl();

      RubikObject object = RubikObjectList.getObject(mObjectOrdinal);

      int iconMode  = TwistyObject.MODE_NORM;

      InputStream jsonStream = object==null ? null : object.getObjectStream(this);

      InputStream meshStream = object==null ? null : object.getMeshStream(this);

      String name = object==null ? "NULL" : object.getUpperName();

      OSInterface os = view.getInterface();

      InitAssets asset = new InitAssets(jsonStream,meshStream,os);

      control.changeIfDifferent(mObjectOrdinal,name,iconMode,asset);

      }

}

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

// Copyright 2023 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.patterns;

import com.google.firebase.crashlytics.FirebaseCrashlytics;

import org.distorted.library.message.EffectMessageSender;

import org.distorted.main.BuildConfig;

import org.distorted.objectlib.helpers.BlockController;

import org.distorted.objectlib.helpers.ObjectLibInterface;

import org.distorted.objects.RubikObject;

import org.distorted.objects.RubikObjectList;

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

public class PatternObjectLibInterface implements ObjectLibInterface

{

  PatternObjectLibInterface(PatternActivity act) { }

  public void onScrambleEffectFinished() { }

  public void onRemoveRotation(int axis, int row, int angle) { }

  public void onBeginRotation() { }

  public void failedToDrag() { }

  public void onSolved() { }

  public void onObjectCreated(long time) { }

  public void onWinEffectFinished(long startTime, long endTime, String debug, int scrambleNum) { }

  public void onReplaceModeDown(int cubit, int face) { }

  public void onReplaceModeUp() { }

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

  public void reportProblem(String problem, boolean recordException)

    {

    if( BuildConfig.DEBUG )

      {

      android.util.Log.e("libInterface", problem);

      }

    else

      {

      if( recordException )

        {

        Exception ex = new Exception(problem);

        FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

        crashlytics.setCustomKey("problem" , problem);

        crashlytics.recordException(ex);

        }

      else

        {

        FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

        crashlytics.log(problem);

        }

      }

    }

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

  private void reportScramblingProblem(int place, long pause, long resume, long time)

    {

    String error = "SCRAMBLING BLOCK "+place+" blocked for "+time;

    if( BuildConfig.DEBUG )

       {

       android.util.Log.e("libInterface", error);

       }

    else

      {

      Exception ex = new Exception(error);

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.setCustomKey("pause" , pause );

      crashlytics.setCustomKey("resume", resume );

      crashlytics.recordException(ex);

      }

    }

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

  private void reportRotationProblem(int place, long pause, long resume, long time)

    {

    String error = "ROTATION BLOCK "+place+" blocked for "+time;

    if( BuildConfig.DEBUG )

       {

       android.util.Log.e("libInterface", error);

       }

    else

      {

      Exception ex = new Exception(error);

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.setCustomKey("pause" , pause );

      crashlytics.setCustomKey("resume", resume);

      crashlytics.recordException(ex);

      }

    }

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

  private void reportThreadProblem(int place, long pause, long resume, long time)

    {

    String error = EffectMessageSender.reportState();

    if( BuildConfig.DEBUG )

       {

       android.util.Log.e("libInterface", error);

       }

    else

      {

      Exception ex = new Exception(error);

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.setCustomKey("pause" , pause  );

      crashlytics.setCustomKey("resume", resume );

      crashlytics.recordException(ex);

      }

    }

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

  public void reportBlockProblem(int type, int place, long pause, long resume, long time)

    {

    switch(type)

      {

      case BlockController.TYPE_SCRAMBLING: reportScramblingProblem(place,pause,resume,time); break;

      case BlockController.TYPE_ROTATION  : reportRotationProblem(place,pause,resume,time); break;

      case BlockController.TYPE_THREAD    : reportThreadProblem(place,pause,resume,time); break;

      }

    }

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

  public void reportJSONError(String error, int ordinal)

    {

    RubikObject object = RubikObjectList.getObject(ordinal);

    String name = object==null ? "NULL" : object.getUpperName();

    if( BuildConfig.DEBUG )

       {

       android.util.Log.e("libInterface", "name="+name+" JSON error: "+error);

       }

    else

      {

      Exception ex = new Exception(error);

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.setCustomKey("name" , name );

      crashlytics.setCustomKey("JSONerror", error );

      crashlytics.recordException(ex);

      }

    }

}

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

// Copyright 2023 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.patterns;

import android.content.res.Resources;

import android.opengl.GLES30;

import android.opengl.GLSurfaceView;

import com.google.firebase.crashlytics.FirebaseCrashlytics;

import org.distorted.library.effect.EffectType;

import org.distorted.library.effect.VertexEffectQuaternion;

import org.distorted.library.effect.VertexEffectRotate;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.InternalOutputSurface;

import org.distorted.library.mesh.MeshBase;

import org.distorted.main.BuildConfig;

import org.distorted.objectlib.effects.BaseEffect;

import org.distorted.objectlib.main.ObjectControl;

import java.io.InputStream;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

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

public class PatternRenderer implements GLSurfaceView.Renderer, DistortedLibrary.LibraryUser

{

   private final PatternSurfaceView mView;

   private final Resources mResources;

   private final DistortedScreen mScreen;

   private final ObjectControl mControl;

   private boolean mErrorShown;

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

   PatternRenderer(PatternSurfaceView v)

     {

     mView = v;

     mResources = v.getResources();

     mErrorShown = false;

     mControl = v.getObjectControl();

     mScreen = new DistortedScreen();

     PatternActivity act = (PatternActivity)v.getContext();

     act.setUpBackgroundColor(mScreen);

     mScreen.enableDepthStencil(InternalOutputSurface.DEPTH_NO_STENCIL);

     }

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

   DistortedScreen getScreen()

     {

     return mScreen;

     }

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

// various things are done here delayed, 'after the next render' as not to be done mid-render and

// cause artifacts.

   @Override

   public void onDrawFrame(GL10 glUnused)

     {

     long time = System.currentTimeMillis();

     mControl.preRender();

     mScreen.render(time);

     }

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

   @Override

   public void onSurfaceChanged(GL10 glUnused, int width, int height)

      {

      mScreen.resize(width,height);

      mView.setScreenSize(width,height);

      }

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

   @Override

   public void onSurfaceCreated(GL10 glUnused, EGLConfig config)

      {

      DistortedLibrary.setMax(EffectType.VERTEX,ObjectControl.MAX_QUATS+1);

      MeshBase.setMaxEffComponents(ObjectControl.MAX_MOVING_PARTS);

      VertexEffectRotate.enable();

      VertexEffectQuaternion.enable();

      BaseEffect.Type.enableEffects();

      DistortedLibrary.onSurfaceCreated(this,1);

      DistortedLibrary.setCull(true);

      }

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

   public void distortedException(Exception ex)

     {

     String message = ex.getMessage();

     String shading = GLES30.glGetString(GLES30.GL_SHADING_LANGUAGE_VERSION);

     String version = GLES30.glGetString(GLES30.GL_VERSION);

     String vendor  = GLES30.glGetString(GLES30.GL_VENDOR);

     String renderer= GLES30.glGetString(GLES30.GL_RENDERER);

     if( message==null ) message = "exception NULL";

     if( BuildConfig.DEBUG )

       {

       android.util.Log.e("DISTORTED", message );

       android.util.Log.e("DISTORTED", "GLSL Version "+shading);

       android.util.Log.e("DISTORTED", "GL Version "  +version);

       android.util.Log.e("DISTORTED", "GL Vendor "   +vendor);

       android.util.Log.e("DISTORTED", "GL Renderer " +renderer);

       }

     else

       {

       FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

       crashlytics.setCustomKey("DistortedError", message );

       crashlytics.setCustomKey("GLSL Version"  , shading );

       crashlytics.setCustomKey("GLversion"     , version );

       crashlytics.setCustomKey("GL Vendor "    , vendor  );

       crashlytics.setCustomKey("GLSLrenderer"  , renderer);

       crashlytics.recordException(ex);

       }

     int glsl = DistortedLibrary.getGLSL();

     if( glsl< 300 && !mErrorShown )

       {

       mErrorShown = true;

       PatternActivity act = (PatternActivity)mView.getContext();

       act.OpenGLError();

       }

     }

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

   public InputStream localFile(int fileID)

     {

     return mResources.openRawResource(fileID);

     }

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

   public void logMessage(String message)

     {

     android.util.Log.e("Rubik", message );

     }

}

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

// Copyright 2023 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.patterns;

import android.annotation.SuppressLint;

import android.app.ActivityManager;

import android.content.Context;

import android.content.pm.ConfigurationInfo;

import android.opengl.GLES30;

import android.opengl.GLSurfaceView;

import android.util.AttributeSet;

import android.view.MotionEvent;

import com.google.firebase.crashlytics.FirebaseCrashlytics;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.TwistyObjectNode;

import org.distorted.os.OSInterface;

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

public class PatternSurfaceView extends GLSurfaceView

{

    private ObjectControl mObjectController;

    private OSInterface mInterface;

    private PatternRenderer mRenderer;

    private boolean mCreated;

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

    void setScreenSize(int width, int height)

      {

      mObjectController.setScreenSizeAndScaling(width,height, Math.min(width, (int)(0.75f*height)));

      if( !mCreated )

        {

        mCreated = true;

        mObjectController.createNode(width,height);

        TwistyObjectNode objectNode = mObjectController.getNode();

        objectNode.glDepthMask(false);

        objectNode.glStencilMask(0);

        mRenderer.getScreen().attach(objectNode);

        }

      }

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

    PatternRenderer getRenderer()

      {

      return mRenderer;

      }

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

    OSInterface getInterface()

      {

      return mInterface;

      }

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

    ObjectControl getObjectControl()

      {

      return mObjectController;

      }

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

// PUBLIC API

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

    public PatternSurfaceView(Context context, AttributeSet attrs)

      {

      super(context,attrs);

      mCreated = false;

      if(!isInEditMode())

        {

        PatternActivity act = (PatternActivity)context;

        PatternObjectLibInterface ref = new PatternObjectLibInterface(act);

        mInterface = new OSInterface(act,ref);

        mObjectController = new ObjectControl(mInterface);

        mRenderer = new PatternRenderer(this);

        final ActivityManager activityManager= (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);

        try

          {

          final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();

          int esVersion = configurationInfo.reqGlEsVersion>>16;

          setEGLContextClientVersion(esVersion);

          setRenderer(mRenderer);

          }

        catch(Exception ex)

          {

          act.OpenGLError();

          String shading = GLES30.glGetString(GLES30.GL_SHADING_LANGUAGE_VERSION);

          String version = GLES30.glGetString(GLES30.GL_VERSION);

          String vendor  = GLES30.glGetString(GLES30.GL_VENDOR);

          String renderer= GLES30.glGetString(GLES30.GL_RENDERER);

          FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

          crashlytics.setCustomKey("GLSL Version"  , shading );

          crashlytics.setCustomKey("GL version"    , version );

          crashlytics.setCustomKey("GL Vendor "    , vendor  );

          crashlytics.setCustomKey("GLSL renderer" , renderer);

          crashlytics.recordException(ex);

          }

        }

      }

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

    @Override

    public void onPause()

      {

      super.onPause();

      mObjectController.onPause();

      }

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

    @Override

    public void onResume()

      {

      super.onResume();

      mObjectController.onResume();

      }

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

    @SuppressLint("ClickableViewAccessibility")

    @Override

    public boolean onTouchEvent(MotionEvent event)

      {

      mInterface.setMotionEvent(event);

      int mode = ScreenList.getMode();

      return mObjectController.onTouchEvent(mode);

      }

}

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

// Copyright 2023 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.patterns;

import android.content.SharedPreferences;

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

public abstract class ScreenAbstract

  {

  abstract void enterScreen(PatternActivity act);

  abstract void leaveScreen(PatternActivity act);

  public abstract void savePreferences(SharedPreferences.Editor editor);

  public abstract void restorePreferences(SharedPreferences preferences);

  }

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

// Copyright 2023 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.patterns;

import static org.distorted.objectlib.main.ObjectControl.MODE_DRAG;

import android.content.SharedPreferences;

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

public enum ScreenList

  {

  PATT ( null, MODE_DRAG, new ScreenPattern()  ),

  ;

  public static final int LENGTH = values().length;

  private static final ScreenList[] screens;

  private final ScreenList mBack;

  private final int mMode;

  private final ScreenAbstract mClass;

  private static ScreenList mCurrScreen;

  static

    {

    int i = 0;

    screens = new ScreenList[LENGTH];

    for(ScreenList state: ScreenList.values()) screens[i++] = state;

    }

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

  public static ScreenList getScreen(int ordinal)

    {

    return ordinal>=0 && ordinal<LENGTH ?  screens[ordinal] : PATT;

    }

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

  public static ScreenList getScreenFromName(String name)

    {

    for(int i=0; i<LENGTH; i++)

      {

      if( name.equals(screens[i].name()) )

        {

        return screens[i];

        }

      }

    return PATT;

    }

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

  public static ScreenList getCurrentScreen()

    {

    return mCurrScreen;

    }

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

  public static int getMode()

    {

    return mCurrScreen.mMode;

    }

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

  public static void savePreferences(SharedPreferences.Editor editor)

    {

    editor.putString("curr_state_name", mCurrScreen.name() );

    }

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

  public static void restorePreferences(SharedPreferences preferences)

    {

    String currScreenName = preferences.getString("curr_state_name", ScreenList.PATT.name() );

    mCurrScreen = getScreenFromName(currScreenName);

    }

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

  public static void goBack(PatternActivity act)

    {

    switchScreen(act, mCurrScreen.mBack );

    }

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

  public static void setScreen(PatternActivity act)

    {

    mCurrScreen.enterScreen(act);

    }

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

  public static void switchScreen(PatternActivity act, ScreenList next)

    {

    if( next!=null )

      {

      if( mCurrScreen !=null ) mCurrScreen.leaveScreen(act);

      next.enterScreen(act);

      mCurrScreen = next;

      }

    else

      {

      act.finish();

      }

    }

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

  ScreenList(ScreenList back, int mode, ScreenAbstract clazz)

    {

    mBack = back;

    mMode = mode;

    mClass= clazz;

    }

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

  public ScreenAbstract getScreenClass()

    {

    return mClass;

    }

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

  public void leaveScreen(PatternActivity act)

    {

    mClass.leaveScreen(act);

    }

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

  public void enterScreen(PatternActivity act)

    {

    mClass.enterScreen(act);

    }

  }

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

// Copyright 2023 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.patterns;

import android.content.SharedPreferences;

import android.os.Bundle;

import android.util.TypedValue;

import android.view.Gravity;

import android.view.View;

import android.widget.LinearLayout;

import android.widget.TextView;

import org.distorted.dialogs.DialogPattern;

import org.distorted.helpers.TransparentButton;

import org.distorted.helpers.TransparentImageButton;

import org.distorted.main.R;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.patterns.RubikPattern;

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

public class ScreenPattern extends ScreenAbstract

  {

  private TransparentImageButton mPrevButton, mNextButton, mBackButton;

  private TransparentImageButton mPrevPatt, mNextPatt;

  private TransparentButton mTextButton;

  private TextView mMovesText;

  private int mNumMoves;

  private int mPatternOrdinal, mCategory, mPattern;

  private float mButtonSize;

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

  ScreenPattern()

    {

    }

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

  void leaveScreen(PatternActivity act)

    {

    }

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

  void enterScreen(final PatternActivity act)

    {

    float width = act.getScreenWidthInPixels();

    mButtonSize = width*PatternActivity.BUTTON_TEXT_SIZE;

    mPatternOrdinal = -1;

    mCategory       = -1;

    mPattern        = -1;

    // TOP ////////////////////////////

    LinearLayout layoutTop = act.findViewById(R.id.upperBar);

    layoutTop.removeAllViews();

    setupPrevPatt(act);

    setupNextPatt(act);

    setupTextButton(act,width);

    LinearLayout.LayoutParams pTL = new LinearLayout.LayoutParams((int)(  width/6),LinearLayout.LayoutParams.MATCH_PARENT);

    LinearLayout.LayoutParams pTM = new LinearLayout.LayoutParams((int)(2*width/3),LinearLayout.LayoutParams.MATCH_PARENT);

    LinearLayout.LayoutParams pTR = new LinearLayout.LayoutParams((int)(  width/6),LinearLayout.LayoutParams.MATCH_PARENT);

    LinearLayout layoutTL = new LinearLayout(act);

    layoutTL.setLayoutParams(pTL);

    LinearLayout layoutTM = new LinearLayout(act);

    layoutTM.setLayoutParams(pTM);

    LinearLayout layoutTR = new LinearLayout(act);

    layoutTR.setLayoutParams(pTR);

    layoutTL.addView(mPrevPatt);

    layoutTM.addView(mTextButton);

    layoutTR.addView(mNextPatt);

    layoutTop.addView(layoutTL);

    layoutTop.addView(layoutTM);

    layoutTop.addView(layoutTR);

    // BOT ////////////////////////////

    LinearLayout layoutBot = act.findViewById(R.id.lowerBar);

    layoutBot.removeAllViews();

    setupPrevButton(act);

    setupNextButton(act);

    setupTextView(act,width);

    LinearLayout.LayoutParams pBL = new LinearLayout.LayoutParams((int)(width/2),LinearLayout.LayoutParams.MATCH_PARENT);

    LinearLayout.LayoutParams pBM = new LinearLayout.LayoutParams((int)(width/6),LinearLayout.LayoutParams.MATCH_PARENT);

    LinearLayout.LayoutParams pBR = new LinearLayout.LayoutParams((int)(width/3),LinearLayout.LayoutParams.MATCH_PARENT);

    LinearLayout layoutBL = new LinearLayout(act);

    layoutBL.setLayoutParams(pBL);

    LinearLayout layoutBM = new LinearLayout(act);

    layoutBM.setLayoutParams(pBM);

    LinearLayout layoutBR = new LinearLayout(act);

    layoutBR.setLayoutParams(pBR);

    layoutBL.addView(mPrevButton);

    layoutBL.addView(mMovesText);

    layoutBL.addView(mNextButton);

    setupBackButton(act);

    layoutBR.addView(mBackButton);

    layoutBot.addView(layoutBL);

    layoutBot.addView(layoutBM);

    layoutBot.addView(layoutBR);

    }

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

  private void showDialog(final PatternActivity act)

    {

    int ordinal = act.getObjectOrdinal();

    Bundle bundle = new Bundle();

    bundle.putString("argument", String.valueOf(ordinal) );

    DialogPattern diag = new DialogPattern();

    diag.setArguments(bundle);

    diag.show( act.getSupportFragmentManager(), DialogPattern.getDialogTag());

    }

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

  private void setupPrevPatt(final PatternActivity act)

    {

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(0,LinearLayout.LayoutParams.MATCH_PARENT,1.0f);

    mPrevPatt = new TransparentImageButton(act,R.drawable.ui_left,params);

    mPrevPatt.setOnClickListener( new View.OnClickListener()

      {

      @Override

      public void onClick(View v)

        {

        if( mPatternOrdinal<0 ) showDialog(act);

        else prevPattern(act);

        }

      });

    }

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

  private void setupNextPatt(final PatternActivity act)

    {

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(0,LinearLayout.LayoutParams.MATCH_PARENT,1.0f);

    mNextPatt = new TransparentImageButton(act,R.drawable.ui_right,params);

    mNextPatt.setOnClickListener( new View.OnClickListener()

      {

      @Override

      public void onClick(View v)

        {

        if( mPatternOrdinal<0 ) showDialog(act);

        else nextPattern(act);

        }

      });

    }

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

  private void setupTextButton(final PatternActivity act, float width)

    {

    float textSize = width*PatternActivity.TITLE_TEXT_SIZE;

    mTextButton = new TransparentButton(act,R.string.choose_pattern,textSize);

    mTextButton.setOnClickListener( new View.OnClickListener()

      {

      @Override

      public void onClick(View v)

        {

        showDialog(act);

        }

      });

    }

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

  private void setupBackButton(final PatternActivity act)

    {

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,LinearLayout.LayoutParams.MATCH_PARENT,1.0f);

    mBackButton = new TransparentImageButton(act,R.drawable.ui_back,params);

    mBackButton.setOnClickListener( new View.OnClickListener()

      {

      @Override

      public void onClick(View v)

        {

        ScreenList.goBack(act);

        }

      });

    }

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

  private void setupPrevButton(final PatternActivity act)

    {

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(0,LinearLayout.LayoutParams.MATCH_PARENT,1.0f);

    mPrevButton = new TransparentImageButton(act,R.drawable.ui_left,params);

    mPrevButton.setOnClickListener( new View.OnClickListener()

      {

      @Override

      public void onClick(View v)

        {

        if( mPatternOrdinal>=0 )

          {

          RubikPattern pattern = RubikPattern.getInstance();

          ObjectControl control = act.getControl();

          pattern.backMove(control, mPatternOrdinal, mCategory, mPattern);

          int currMove = pattern.getCurMove(mPatternOrdinal, mCategory, mPattern);

          mMovesText.setText(act.getString(R.string.mo_placeholder, currMove, mNumMoves));

          }

        }

      });

    }

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

  private void setupNextButton(final PatternActivity act)

    {

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(0,LinearLayout.LayoutParams.MATCH_PARENT,1.0f);

    mNextButton = new TransparentImageButton(act,R.drawable.ui_right,params);

    mNextButton.setOnClickListener( new View.OnClickListener()

      {

      @Override

      public void onClick(View v)

        {

        if( mPatternOrdinal>=0 )

          {

          RubikPattern pattern = RubikPattern.getInstance();

          ObjectControl control = act.getControl();

          pattern.makeMove(control, mPatternOrdinal, mCategory, mPattern);

          int currMove = pattern.getCurMove(mPatternOrdinal, mCategory, mPattern);

          mMovesText.setText(act.getString(R.string.mo_placeholder, currMove, mNumMoves));

          }

        }

      });

    }

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

  private void setupTextView(final PatternActivity act, final float width)

    {

    int padding = (int)(width*PatternActivity.PADDING);

    int margin  = (int)(width*PatternActivity.SMALL_MARGIN);

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(0,LinearLayout.LayoutParams.MATCH_PARENT,2.0f);

    params.topMargin    = margin;

    params.bottomMargin = margin;

    params.leftMargin   = margin;

    params.rightMargin  = margin;

    mMovesText = new TextView(act);

    mMovesText.setTextSize(20);

    mMovesText.setLayoutParams(params);

    mMovesText.setPadding(padding,0,padding,0);

    mMovesText.setGravity(Gravity.CENTER);

    mMovesText.setTextSize(TypedValue.COMPLEX_UNIT_PX, mButtonSize);

    mMovesText.setText(act.getString(R.string.mo_placeholder,0,0));

    }

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

  public void setPattern(final PatternActivity act, int ordinal, int category, int pattern)

    {

    mPatternOrdinal = ordinal;

    mCategory       = category;

    mPattern        = pattern;

    RubikPattern patt = RubikPattern.getInstance();

    String patternName = patt.getPatternName(ordinal,category,pattern);

    mTextButton.setText(patternName);

    mNumMoves   = patt.getNumMoves(ordinal,category,pattern);

    int currMove= patt.getCurMove(ordinal,category,pattern);

    mMovesText.setText(act.getString(R.string.mo_placeholder,currMove,mNumMoves));

    }

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

  private void prevPattern(final PatternActivity act)

    {

    RubikPattern patt = RubikPattern.getInstance();

    if( mPattern>0 )

      {

      setPattern(act,mPatternOrdinal,mCategory,mPattern-1);

      }

    else

      {

      if( mCategory>0 )

        {

        int numPat = patt.getNumPatterns(mPatternOrdinal,mCategory-1);

        setPattern(act,mPatternOrdinal,mCategory-1,numPat-1);

        }

      else

        {

        int numCat = patt.getNumCategories(mPatternOrdinal);

        int numPat = patt.getNumPatterns(mPatternOrdinal,numCat-1);

        setPattern(act,mPatternOrdinal,numCat-1,numPat-1);

        }

      }

    int[][] moves = patt.reInitialize(mPatternOrdinal, mCategory, mPattern);

    ObjectControl control = act.getControl();

    if( control!=null ) control.initializeObject(moves);

    }

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

  private void nextPattern(final PatternActivity act)

    {

    RubikPattern patt = RubikPattern.getInstance();

    int numPat = patt.getNumPatterns(mPatternOrdinal,mCategory);

    if( mPattern<numPat-1 )

      {

      setPattern(act,mPatternOrdinal,mCategory,mPattern+1);

      }

    else

      {

      int numCat = patt.getNumCategories(mPatternOrdinal);

      if( mCategory<numCat-1 )

        {

        setPattern(act,mPatternOrdinal,mCategory+1,0);

        }

      else

        {

        setPattern(act,mPatternOrdinal,0,0);

        }

      }

    int[][] moves = patt.reInitialize(mPatternOrdinal, mCategory, mPattern);

    ObjectControl control = act.getControl();

    if( control!=null ) control.initializeObject(moves);

    }

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

  public void savePreferences(SharedPreferences.Editor editor)

    {

    }

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

  public void restorePreferences(SharedPreferences preferences)

    {

    }

  }