Magic Cube

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

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

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

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

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

//                                                                                               //

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

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

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

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

//                                                                                               //

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

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

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

package org.distorted.dialog;

import android.app.Dialog;

import android.content.DialogInterface;

import android.os.Bundle;

import android.support.annotation.NonNull;

import android.support.v4.app.FragmentActivity;

import android.support.v4.view.ViewPager;

import android.support.v7.app.AlertDialog;

import android.support.v7.app.AppCompatDialogFragment;

import android.support.design.widget.TabLayout;

import android.view.LayoutInflater;

import android.view.View;

import android.view.Window;

import android.view.WindowManager;

import android.widget.ImageView;

import android.widget.TextView;

import org.distorted.magic.R;

import org.distorted.patterns.RubikPattern;

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

public class RubikDialogPattern extends AppCompatDialogFragment

  {

  RubikDialogPatternPagerAdapter mPagerAdapter;

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

  @Override

  public void onStart()

    {

    super.onStart();

    Window window = getDialog().getWindow();

    window.setFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL,

                    WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL);

    window.clearFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);

    }

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

  @NonNull

  @Override

  public Dialog onCreateDialog(Bundle savedInstanceState)

    {

    FragmentActivity act = getActivity();

    AlertDialog.Builder builder = new AlertDialog.Builder(act);

    LayoutInflater layoutInflater = act.getLayoutInflater();

    TextView tv = (TextView) layoutInflater.inflate(R.layout.dialog_title, null);

    tv.setText(R.string.patterns);

    builder.setCustomTitle(tv);

    builder.setCancelable(true);

    builder.setPositiveButton( R.string.ok, new DialogInterface.OnClickListener()

      {

      @Override

      public void onClick(DialogInterface dialog, int which)

        {

        }

      });

    LayoutInflater inflater = act.getLayoutInflater();

    final View view = inflater.inflate(R.layout.dialog_tabbed, null);

    builder.setView(view);

    ViewPager viewPager = view.findViewById(R.id.viewpager);

    TabLayout tabLayout = view.findViewById(R.id.sliding_tabs);

    mPagerAdapter = new RubikDialogPatternPagerAdapter(act, viewPager);

    tabLayout.setupWithViewPager(viewPager);

    int[] iconID = { R.drawable.cube2, R.drawable.cube3, R.drawable.cube4, R.drawable.cube5 };

    for(int i=0; i< RubikPattern.NUM_CUBES; i++)

      {

      ImageView imageView = new ImageView(act);

      imageView.setImageResource(iconID[i]);

      TabLayout.Tab tab = tabLayout.getTabAt(i);

      if(tab!=null) tab.setCustomView(imageView);

      }

    return builder.create();

    }

  }

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

// 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.dialog;

import android.support.annotation.NonNull;

import android.support.v4.app.FragmentActivity;

import android.support.v4.view.PagerAdapter;

import android.support.v4.view.ViewPager;

import android.view.View;

import android.view.ViewGroup;

import android.widget.LinearLayout;

import org.distorted.patterns.RubikPattern;

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

class RubikDialogPatternPagerAdapter extends PagerAdapter

  {

  private FragmentActivity mAct;

  private RubikDialogPatternView[] mViews;

  private int mNumTabs;

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

// TODO: temporary mockup

  private String[] createCategories(int pos)

    {

    String[] ret = new String[8];

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

      {

      ret[i] = "CATEGORY "+pos+" "+i;

      }

    return ret;

    }

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

  RubikDialogPatternPagerAdapter(FragmentActivity act, ViewPager viewPager)

    {

    mAct = act;

    mNumTabs = RubikPattern.NUM_CUBES;

    mViews = new RubikDialogPatternView[mNumTabs];

    viewPager.setAdapter(this);

    viewPager.setOffscreenPageLimit(mNumTabs-1);

    }

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

  @Override

  @NonNull

  public Object instantiateItem(@NonNull ViewGroup collection, final int position)

    {

    mViews[position] = new RubikDialogPatternView(mAct);

    collection.addView(mViews[position]);

    String[] categories = createCategories(position);

    final LinearLayout section = mViews[position].createSection(mAct, categories);

    mAct.runOnUiThread(new Runnable()

        {

        @Override

        public void run()

          {

          mViews[position].addSection(section);

          }

        });

    return mViews[position];

    }

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

  @Override

  public void destroyItem(ViewGroup collection, int position, @NonNull Object view)

    {

    collection.removeView((View) view);

    }

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

  @Override

  public int getCount()

    {

    return mNumTabs;

    }

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

  @Override

  public boolean isViewFromObject(@NonNull View view, @NonNull Object object)

    {

    return view == object;

    }

  }

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

// 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.dialog;

import android.content.Context;

import android.support.v4.app.FragmentActivity;

import android.util.DisplayMetrics;

import android.view.View;

import android.widget.Button;

import android.widget.FrameLayout;

import android.widget.LinearLayout;

import org.distorted.magic.R;

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

public class RubikDialogPatternView extends FrameLayout

  {

  LinearLayout mLayout;

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

  public RubikDialogPatternView(Context context)

    {

    super(context);

    View tab = inflate( context, R.layout.dialog_tab, null);

    mLayout = tab.findViewById(R.id.tabLayout);

    addView(tab);

    }

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

  LinearLayout createSection(FragmentActivity act, final String[] categories)

    {

    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT);

    LinearLayout layout = new LinearLayout(act);

    layout.setLayoutParams(params);

    layout.setOrientation(LinearLayout.VERTICAL);

    DisplayMetrics metrics = act.getResources().getDisplayMetrics();

    final float scale = metrics.density;

    int len = categories.length;

    int margin = (int)(3*scale + 0.5f);

    LinearLayout.LayoutParams bParams = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,LinearLayout.LayoutParams.WRAP_CONTENT);

    bParams.setMargins(margin, margin, margin, margin);

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

      {

      android.util.Log.e("view", "adding button "+i +" to layout!");

      final int fi = i;

      Button button = new Button(act);

      button.setLayoutParams(bParams);

      button.setText(categories[i]);

      button.setOnClickListener( new View.OnClickListener()

        {

        @Override

        public void onClick(View view)

          {

          android.util.Log.e("view", "category "+categories[fi]+" clicked");

          }

        });

      }

    return layout;

    }

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

// needs to run on UI thread

  void addSection(LinearLayout section)

    {

    android.util.Log.e("view", "adding section to tab!");

    mLayout.addView(section);

    }

  }

    final View view = inflater.inflate(R.layout.dialog_tabbed, null);

    View tab = inflate(act, R.layout.dialog_tab, null);

import org.distorted.dialog.RubikDialogPattern;

      RubikDialogPattern diag = new RubikDialogPattern();

      diag.show(getSupportFragmentManager(), null);

      RubikDialogAbout diag = new RubikDialogAbout();

      diag.show(getSupportFragmentManager(), null);

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

// 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 java.util.Vector;

import android.graphics.Paint;

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

public class RubikPattern

{

  private static final int MIN_CUBE  = 2;

  private static final int MAX_CUBE  = 5;

  public  static final int NUM_CUBES = MAX_CUBE-MIN_CUBE+1;

  public int[] numCategories = new int[NUM_CUBES];

  private static String buffer="";

  private static Paint mPaint = new Paint();

  private static int width;

  private Vector<Category>[] mCategories;

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

  private class Category

    {

    private String name;

    private int numpatterns;

    private Vector<Pattern> patterns;

    private int curPattern;

    public Category(String n)

      {

      name=n;

      curPattern=0;

      numpatterns=0;

      patterns = new Vector<>();

      }

    public void addPattern(Pattern p)

      {

      patterns.addElement(p);

      numpatterns++;

      }

    public int getNumPatterns()

    {

    return numpatterns;

    };

    public String getName()

    {

    return name;

    }

    public void next()

      {

      curPattern++;

      if( curPattern>=numpatterns )

        curPattern=0;

      }

    public void prev()

      {

      curPattern--;

      if( curPattern<0 )

        curPattern=numpatterns-1;

      }

    public String getPatternName()

      {

      Pattern p = patterns.elementAt(curPattern);

      return  p!=null ? p.getName(curPattern+1,numpatterns):null;

      }

    public int getPatternCurMove()

      {

      Pattern p = patterns.elementAt(curPattern);

      return  p!=null ? p.getCurMove():-1;

      }

    public int getPatternNumMove()

      {

      Pattern p = patterns.elementAt(curPattern);

      return  p!=null ? p.getNumMove():-1;

      }

    public void initializeCube()

      {

      Pattern p = patterns.elementAt(curPattern);

      if( p!=null ) p.initializeCube();

      }

    public void makeNextMove()

      {

      Pattern p = patterns.elementAt(curPattern);

      if( p!=null ) p.makeNextMove();

      }

    public void makePrevMove()

      {

      Pattern p = patterns.elementAt(curPattern);

      if( p!=null ) p.makePrevMove();

      }

    }

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

  private class Pattern

    {

    private String name;

    private String shortname=null;

    private String moves;

    private int curmove;

    private int nummove;

    public Pattern(String n, String m)

      {

      name=n;

      moves=m;

      nummove = moves.length()/4;

      curmove=nummove;

      }

    public String getName(int cur,int num)

      {

      if( shortname==null ) shortname=cutPatternName(name);

      return shortname;

      }

    public int getNumMove()

    {

    return nummove;

    }

    public int getCurMove()

    {

    return curmove;

    }

    public void makeNextMove()

      {

      curmove++;

      if( curmove>nummove)

        {

        curmove= 0;

        initializeCube();

        }

      else

        {

// TODO

//        RubikCube cube = world.getCube();

//        if( cube!=null && !cube.makeMove(moves.substring(4*curmove-4,4*curmove)) )

          curmove--;

        }

      }

    public void makePrevMove()

      {

      curmove--;

      if( curmove<0)

        {

        curmove=nummove;

        initializeCube();

        }

      else

        {

// TODO

//        RubikCube cube = world.getCube();

//        if( cube!=null && !cube.backMove(moves.substring(4*curmove,4*curmove+4)) )

          curmove++;

        }

      }

    public void initializeCube()

      {

// TODO

//	    RubikCube cube = world.getCube();

//      if( cube!=null ) cube.setupPosition(moves.substring(0,4*curmove));

      }

    }

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

  public RubikPattern(int wi, int h)

    {

    width = wi;

    mCategories = new Vector[NUM_CUBES];

    mPaint.setTextSize(h);

    initializeCategories(0, RubikPatternData2.patterns);

    initializeCategories(1, RubikPatternData3.patterns);

    initializeCategories(2, RubikPatternData4.patterns);

    initializeCategories(3, RubikPatternData5.patterns);

    }

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

  private void initializeCategories(int num, String[] pat)

    {

    int colon;

    mCategories[num] = new Vector<>();

    Category cat=null;

    String name, pattern;

    Pattern patt;

    numCategories[num]=0;

    for(String p: pat)

      {

      colon = p.indexOf(':');

      if( colon==-1 )

        {

        cat = new Category(p);

        mCategories[num].addElement(cat);

        numCategories[num]++;

        }

      else

        {

        pattern = p.substring(colon+1);

        name    = p.substring(0,colon);

        patt = new Pattern(name,pattern);

        cat.addPattern(patt);

        }

      }

    }

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

  private static String cutPatternName(String n)

    {

    int len1 = (int)mPaint.measureText(n);

    if( len1>width )

      {

      int l = n.length();

      while( l>=2 && len1>width )

        {

        l--;

        buffer = n.substring(0,l);

        len1 = (int)mPaint.measureText(buffer);

        }

      return buffer+"...";

      }

    return n;

    }

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

  public String getCategoryName(int size,int num)

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      return c!=null ? c.getName() : null;

      }

    return null;

    }

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

  public String getPatternName(int size,int num)

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      return c!=null ? c.getPatternName() : null;

      }

    return null;

    }

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

  public int getNumPatterns(int size, int num )

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      return c!=null ? c.getNumPatterns() : 0;

      }

    return 0;

    }

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

  public void nextPattern(int size, int num )

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      if( c!=null )

        {

// TODO

//        RubikMenu.texDirty[0] = true;

        c.next();

        c.initializeCube();

        }

      }

    }

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

  public void prevPattern(int size, int num )

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      if( c!=null )

        {

// TODO

//        RubikMenu.texDirty[0] = true;

        c.prev();

        c.initializeCube();

        }

      }

    }

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

  public int getCurrPattern(int size, int num )

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      return c!=null ? c.curPattern:0;

      }

    return 0;

    }

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

  public int getCurMove(int size, int num )

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      return c!=null ? c.getPatternCurMove():0;

      }

    return 0;

    }

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

  public int getNumMove(int size, int num )

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      return c!=null ? c.getPatternNumMove():0;

      }

    return 0;

    }

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

  public void makeNextMove(int size, int num)

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      if( c!=null ) c.makeNextMove();

      }

    }

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

  public void makePrevMove(int size, int num)

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      if( c!=null ) c.makePrevMove();

      }

    }

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

  public void initializeCube(int size,int num)

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      if( c!=null ) c.initializeCube();

      }

    }

}

  private static RubikState mCurrState, mPrevState;

    return mCurrState;

    editor.putInt("curr_state", mCurrState.ordinal() );

    editor.putInt("prev_state", mPrevState.ordinal() );

    int currState = preferences.getInt("curr_state", RubikState.MAIN.ordinal() );

    int prevState = preferences.getInt("prev_state", RubikState.MAIN.ordinal() );

    mCurrState = getState(currState);

    mPrevState = getState(prevState);

    switchState(act, mCurrState.mBack );

    mCurrState.enterState(act,mPrevState);

      if( mCurrState!=null ) mCurrState.leaveState(act);

      state.enterState(act,mCurrState);

      mPrevState = mCurrState;

      mCurrState = state;

  public void enterState(RubikActivity act, RubikState prevState)

    mClass.enterState(act,prevState);

  abstract void enterState(RubikActivity act, RubikState prev);

  void enterState(RubikActivity act, RubikState prev)

  void enterState(final RubikActivity act, RubikState prev)

  void enterState(RubikActivity act, RubikState prev)

<?xml version="1.0" encoding="utf-8"?>

<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"

    android:id="@+id/tabScrollView"

    android:layout_width="match_parent"

    android:layout_height="match_parent">

    <LinearLayout

        android:id="@+id/tabLayout"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:orientation="vertical" >

    </LinearLayout>

</ScrollView>

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:layout_weight="1"

    android:orientation="vertical" >

    <android.support.design.widget.TabLayout

        android:id="@+id/sliding_tabs"

        android:layout_width="match_parent"

        android:layout_height="32dp"

        android:theme="@style/Theme.AppCompat.NoActionBar">

    </android.support.design.widget.TabLayout>

    <android.support.v4.view.ViewPager

        android:id="@+id/viewpager"

        android:layout_width="match_parent"

        android:layout_height="0dp"

        android:layout_weight="1"

        android:background="@android:color/black" />

</LinearLayout>