Magic Cube

    static final float RATIO_SCROLL             = 0.30f;

    public static final float SPINNER_TEXT_SIZE = 0.03f;

    private static final float PADDING          = 0.010f;

    public static final int FLAGS               = MainActivity.FLAGS;

import org.distorted.main_old.RubikActivity;

    int padding= (int)(height*RubikActivity.PADDING/3);

import org.distorted.main_old.RubikActivity;

    public static final int FLAGS = RubikActivity.FLAGS;

import org.distorted.main_old.RubikActivity;

    int margin    = (int)(height*RubikActivity.POPUP_MARGIN);

    int padding   = (int)(height*RubikActivity.POPUP_PADDING);

        popupView.setSystemUiVisibility(RubikActivity.FLAGS);

import org.distorted.main_old.RubikActivity;

import org.distorted.screens.ScreenList;

    final RubikActivity ract = (RubikActivity)getContext();

    ScreenList.goBack(ract);

    }

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

  public void negativeAction()

    {

    }

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

  public void prepareBody(Dialog dialog, View view, FragmentActivity act, float size)

    {

import org.distorted.main_old.RubikActivity;

      window.getDecorView().setSystemUiVisibility(RubikActivity.FLAGS);

      act.finish();

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

// Copyright 2020 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.dialogs;

import android.app.Dialog;

import androidx.fragment.app.FragmentActivity;

import androidx.viewpager.widget.ViewPager;

import com.google.android.material.tabs.TabLayout;

import android.view.View;

import android.view.ViewGroup;

import android.view.Window;

import android.view.WindowManager;

import android.widget.ImageView;

import org.distorted.main.R;

import org.distorted.main_old.RubikActivity;

import org.distorted.objects.RubikObject;

import org.distorted.objects.RubikObjectList;

import org.distorted.objectlib.patterns.RubikPatternList;

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

public class RubikDialogPattern extends RubikDialogAbstract

  {

  private RubikDialogPatternPagerAdapter mPagerAdapter;

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

  @Override

  public void onResume()

    {

    super.onResume();

    Window window = getDialog().getWindow();

    if( window!=null )

      {

      WindowManager.LayoutParams params = window.getAttributes();

      params.width  = (int)Math.min( mHeight*0.65f,mWidth*0.98f );

      params.height = (int)Math.min( mHeight*0.85f,mWidth*1.30f );

      window.setAttributes(params);

      }

    }

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

  public int getResource()      { return R.layout.dialog_tabbed; }

  public int getTitleResource() { return R.string.choose_pattern; }

  public boolean hasArgument()  { return false; }

  public int getPositive()      { return R.string.ok; }

  public int getNegative()      { return -1; }

  public void positiveAction()  { }

  public void negativeAction()  { }

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

  public void prepareBody(Dialog dialog, View view, FragmentActivity act, float size)

    {

    final int tabHeight= (int)(mHeight*RubikActivity.TAB_HEIGHT);

    final int tabWidth = (int)(mHeight*RubikActivity.TAB_WIDTH);

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

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

    mPagerAdapter = new RubikDialogPatternPagerAdapter(act, viewPager, this);

    tabLayout.setupWithViewPager(viewPager);

    int obj = RubikObjectList.getCurrObject();

    int ord = RubikPatternList.getOrdinal(obj);

    if( ord<0 ) ord = RubikPatternList.getOrdinal(RubikObjectList.DEF_OBJECT);

    viewPager.setCurrentItem(ord);

    ViewGroup.LayoutParams paramsView = new ViewGroup.LayoutParams( tabWidth,tabHeight );

    for(int i=0; i< RubikPatternList.NUM_OBJECTS; i++)

      {

      int ordinal = RubikPatternList.getObject(i);

      RubikObject object = RubikObjectList.getObject(ordinal);

      ImageView imageView = new ImageView(act);

      if( object!=null ) object.setIconTo(act,imageView);

      imageView.setLayoutParams(paramsView);

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

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

      }

    }

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

  public void rememberState()

    {

    mPagerAdapter.rememberState();

    }

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

  public static String getDialogTag()

    {

    return "DialogPattern";

    }

  }

// Copyright 2020 Leszek Koltunski                                                               //

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

// Copyright 2020 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.dialogs;

import androidx.annotation.NonNull;

import androidx.fragment.app.FragmentActivity;

import androidx.viewpager.widget.PagerAdapter;

import androidx.viewpager.widget.ViewPager;

import android.view.View;

import android.view.ViewGroup;

import org.distorted.objectlib.patterns.RubikPattern;

import org.distorted.objectlib.patterns.RubikPatternList;

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

class RubikDialogPatternPagerAdapter extends PagerAdapter

  {

  private final FragmentActivity mAct;

  private final RubikDialogPatternView[] mViews;

  private final RubikDialogPattern mDialog;

  private final int mNumTabs;

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

  RubikDialogPatternPagerAdapter(FragmentActivity act, ViewPager viewPager, RubikDialogPattern dialog)

    {

    mAct = act;

    mDialog = dialog;

    mNumTabs = RubikPatternList.NUM_OBJECTS;

    mViews = new RubikDialogPatternView[mNumTabs];

    viewPager.setAdapter(this);

    viewPager.setOffscreenPageLimit(mNumTabs-1);

    }

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

  void rememberState()

    {

    RubikPattern pattern = RubikPattern.getInstance();

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

      {

      int cat = mViews[i].getCurrentCategory();

      int pos = mViews[i].getCurrentVisiblePos();

      int exp = mViews[i].getExpanded();

      pattern.rememberState(i,cat,pos,exp);

      }

    }

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

  @Override

  @NonNull

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

    {

    mViews[position] = new RubikDialogPatternView(mAct, mDialog, position);

    collection.addView(mViews[position]);

    return mViews[position];

    }

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

  @Override

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

    {

    collection.removeView((View) view);

    mViews[position] = null;

    }

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

  @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 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.dialogs;

import android.content.Context;

import androidx.fragment.app.FragmentActivity;

import android.util.AttributeSet;

import android.view.View;

import android.widget.ExpandableListView;

import android.widget.FrameLayout;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.patterns.RubikPattern;

import org.distorted.objectlib.patterns.RubikPatternList;

import org.distorted.main.R;

import org.distorted.main_old.RubikActivity;

import org.distorted.screens.ScreenList;

import org.distorted.screens.RubikScreenPattern;

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

public class RubikDialogPatternView extends FrameLayout

  {

  private ExpandableListView mListView;

  private RubikDialogPattern mDialog;

  private int mTab, mPos;

  private int mExpandedGroup;

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

  public RubikDialogPatternView(Context context, AttributeSet attrs, int defStyle)

    {

    super(context, attrs, defStyle);

    }

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

  public RubikDialogPatternView(Context context, AttributeSet attrs)

    {

    super(context, attrs);

    }

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

  public RubikDialogPatternView(FragmentActivity act, RubikDialogPattern dialog, int position)

    {

    super(act);

    final RubikActivity ract = (RubikActivity)getContext();

    final ObjectControl control = ract.getControl();

    mTab = position;

    mDialog = dialog;

    RubikPattern pattern = RubikPattern.getInstance();

    mExpandedGroup = pattern.recallExpanded(position);

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

    mListView = tab.findViewById(R.id.patternListView);

    RubikDialogPatternListAdapter listAdapter = new RubikDialogPatternListAdapter(act,mTab, ract.getScreenWidthInPixels());

    mListView.setAdapter(listAdapter);

    if( mExpandedGroup>=0 )

      {

      mListView.expandGroup(mExpandedGroup);

      }

    int visible = pattern.recallVisiblePos(mTab);

    mListView.setSelectionFromTop(visible,0);

    mListView.setOnChildClickListener(new ExpandableListView.OnChildClickListener()

      {

      @Override

      public boolean onChildClick(ExpandableListView parent, View v, int groupPosition, int childPosition, long id)

        {

        RubikPattern pattern = RubikPattern.getInstance();

        int[][] moves   = pattern.reInitialize(mTab, groupPosition, childPosition);

        int object = RubikPatternList.getObject(mTab);

        ract.changeIfDifferent(object,control);

        control.initializeObject(moves);

        ScreenList.switchScreen(ract, ScreenList.PATT);

        RubikScreenPattern state = (RubikScreenPattern) ScreenList.PATT.getScreenClass();

        state.setPattern(ract, mTab, groupPosition, childPosition);

        mDialog.rememberState();

        mDialog.dismiss();

        return false;

        }

      });

    mListView.setOnGroupExpandListener(new ExpandableListView.OnGroupExpandListener()

      {

      @Override

      public void onGroupExpand(int groupPosition)

        {

        if(mExpandedGroup!=-1 && groupPosition!=mExpandedGroup)

          {

          mListView.collapseGroup(mExpandedGroup);

          }

        mExpandedGroup = groupPosition;

        }

      });

    addView(tab);

    }

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

  int getCurrentCategory()

    {

    return mPos;

    }

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

  int getCurrentVisiblePos()

    {

    return mListView.getFirstVisiblePosition();

    }

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

  int getExpanded()

    {

    return mExpandedGroup;

    }

  }

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

// Copyright 2020 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.dialogs;

import android.app.Dialog;

import android.text.method.LinkMovementMethod;

import android.text.method.MovementMethod;

import android.view.View;

import android.widget.TextView;

import androidx.fragment.app.FragmentActivity;

import org.distorted.main.R;

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

public class RubikDialogPrivacy extends RubikDialogAbstract

  {

  public int getResource()      { return R.layout.dialog_privacy; }

  public int getTitleResource() { return R.string.privacy_policy; }

  public boolean hasArgument()  { return false; }

  public int getPositive()      { return R.string.accept; }

  public int getNegative()      { return R.string.decline; }

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

  public void positiveAction()

    {

    //final RubikActivity act = (RubikActivity)getContext();

    //if( act!=null ) act.acceptPrivacy();

    }

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

  public void negativeAction()

    {

    //final RubikActivity act = (RubikActivity)getContext();

    //if( act!=null ) act.declinePrivacy();

    }

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

  public void prepareBody(Dialog dialog, View view, FragmentActivity act, float size)

    {

    MovementMethod mm = LinkMovementMethod.getInstance();

    TextView text = view.findViewById(R.id.privacy_string);

    text.setMovementMethod(mm);

    }

  }

import org.distorted.main_old.RubikActivity;

    final int tabHeight= (int)(mHeight*RubikActivity.TAB_HEIGHT);

    final int tabWidth = (int)(mHeight*RubikActivity.TAB_WIDTH);

import android.widget.LinearLayout;

import org.distorted.screens.RubikScreenPlay;

      mNumLevels[i] = Math.min(numScramble-1, RubikScreenPlay.LEVELS_SHOWN);

import org.distorted.main_old.RubikActivity;

    int size = (int)(mHeight*RubikActivity.SCORES_LEVEL_TEXT);

    int height = (int)(mHeight* RubikActivity.SCORES_ITEM_TEXT);

import org.distorted.main_old.RubikActivity;

import org.distorted.screens.ScreenList;

        RubikActivity act = (RubikActivity)getActivity();

        ScreenList.switchScreen(act, ScreenList.PLAY);

import org.distorted.main_old.RubikActivity;

import org.distorted.screens.ScreenList;

    RubikActivity act = (RubikActivity)getActivity();

    ScreenList.switchScreen(act, ScreenList.PLAY);

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

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

import android.util.TypedValue;

import android.view.View;

import android.widget.Button;

import android.widget.ImageView;

import android.widget.LinearLayout;

import android.widget.TextView;

import org.distorted.main.R;

import org.distorted.main_old.RubikActivity;

import org.distorted.objects.RubikObject;

import org.distorted.objects.RubikObjectList;

import org.distorted.screens.ScreenList;

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

public class RubikDialogSolverView

  {

  private final View mView;

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

  public RubikDialogSolverView(final RubikActivity act, final RubikDialogSolvers dialog, int index, int object,

                               int title, int desc, int padding, int fontSize, LinearLayout.LayoutParams pView,

                               LinearLayout.LayoutParams pText, LinearLayout.LayoutParams pButt )

    {

    mView = act.getLayoutInflater().inflate(R.layout.dialog_solvers_pane, null);

    mView.setLayoutParams(pView);

    mView.setPadding(padding,padding,padding,padding);

    TextView titleView = mView.findViewById(R.id.solvers_pane_title);

    titleView.setText(title);

    TextView descView = mView.findViewById(R.id.solvers_pane_description);

    descView.setText(desc);

    titleView.setLayoutParams(pText);

    ImageView icon = mView.findViewById(R.id.solvers_pane_image);

    RubikObject robject = RubikObjectList.getObject(object);

    if( robject!=null ) robject.setIconTo(act,icon);

    Button button = mView.findViewById(R.id.solvers_pane_button);

    button.setOnClickListener( new View.OnClickListener()

      {

      @Override

      public void onClick(View v)

        {

        dialog.dismiss();

        act.setSolverIndex(index);

        ScreenList.switchScreen(act, ScreenList.SVER);

        }

      });

    button.setTextSize(TypedValue.COMPLEX_UNIT_PX, fontSize);

    button.setLayoutParams(pButt);

    }

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

  public View getView()

    {

    return mView;

    }

  }

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

// Copyright 2022 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.dialogs;

import android.app.Dialog;

import android.view.View;

import android.view.Window;

import android.view.WindowManager;

import android.widget.LinearLayout;

import android.widget.TextView;

import androidx.fragment.app.FragmentActivity;

import org.distorted.main.R;

import org.distorted.main_old.RubikActivity;

import org.distorted.solvers.ImplementedSolversList;

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

public class RubikDialogSolvers extends RubikDialogAbstract

  {

  @Override

  public void onResume()

    {

    super.onResume();

    Window window = getDialog().getWindow();

    if( window!=null )

      {

      WindowManager.LayoutParams params = window.getAttributes();

      params.width  = (int)Math.min( mHeight*0.65f,mWidth*0.98f );

      window.setAttributes(params);

      }

    }

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

  public int getResource()            { return R.layout.dialog_scrollable_panes; }

  public int getTitleResource()       { return R.string.solver; }

  public boolean hasArgument()        { return false; }

  public int getPositive()            { return R.string.ok; }

  public int getNegative()            { return -1; }

  public static String getDialogTag() { return "DialogSolvers"; }

  public void positiveAction()        { }

  public void negativeAction()        { }

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

  public void prepareBody(Dialog dialog, View view, FragmentActivity act, float size)

    {

    int margin= (int)(mHeight*0.010f);

    int padd  = (int)(mHeight*0.010f);

    int font  = (int)(mHeight*0.025f);

    LinearLayout layout= view.findViewById(R.id.dialog_scrollable_main_layout);

    TextView text  = view.findViewById(R.id.dialog_scrollable_message);

    text.setVisibility(View.GONE);

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

    pV.setMargins(margin, margin, margin, 0);

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

    pL.setMargins(margin, margin, margin, margin);

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

    pT.setMargins(0,0,0,2*margin);

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

    pB.setMargins(0,2*margin,0,0);

    int num = ImplementedSolversList.NUM_OBJECTS;

    RubikActivity ract = (RubikActivity) getContext();

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

      {

      ImplementedSolversList solver = ImplementedSolversList.getSolver(i);

      int object = solver.getObject();

      int title  = solver.getTitle();

      int description = solver.getDescription();

      RubikDialogSolverView pane = new RubikDialogSolverView(ract,this,i,object,title,description, padd, font, (i==num-1?pL:pV),pT,pB);

      layout.addView(pane.getView());

      }

    }

  }

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

// Copyright 2020 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.dialogs;

import android.app.Dialog;

import android.view.View;

import android.view.ViewGroup;

import android.view.Window;

import android.view.WindowManager;

import android.widget.ImageView;

import androidx.fragment.app.FragmentActivity;

import androidx.viewpager.widget.ViewPager;

import com.google.android.material.tabs.TabLayout;

import org.distorted.main.R;

import org.distorted.main_old.RubikActivity;

import org.distorted.objects.RubikObject;

import org.distorted.objects.RubikObjectList;

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

public class RubikDialogTutorial extends RubikDialogAbstract

  {

  private RubikDialogTutorialPagerAdapter mPagerAdapter;

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

  @Override

  public void onResume()

    {

    super.onResume();

    if( mPagerAdapter!=null ) mPagerAdapter.clickPossible();

    Window window = getDialog().getWindow();

    if( window!=null )

      {

      WindowManager.LayoutParams params = window.getAttributes();

      params.width  = (int)Math.min( mHeight*0.65f,mWidth*0.98f );

      params.height = (int)Math.min( mHeight*0.85f,mWidth*1.30f );

      window.setAttributes(params);

      }

    }

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

  public int getResource()      { return R.layout.dialog_tabbed; }

  public int getTitleResource() { return R.string.tutorials; }

  public boolean hasArgument()  { return false; }

  public int getPositive()      { return R.string.ok; }

  public int getNegative()      { return -1; }

  public void positiveAction()  { }

  public void negativeAction()  { }

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

  public void prepareBody(Dialog dialog, View view, FragmentActivity act, float size)

    {

    final int tabHeight= (int)(mHeight*RubikActivity.TAB_HEIGHT);

    final int tabWidth = (int)(mHeight*RubikActivity.TAB_WIDTH);

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

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

    mPagerAdapter = new RubikDialogTutorialPagerAdapter(act,viewPager);

    tabLayout.setupWithViewPager(viewPager);

    int obj = RubikObjectList.getCurrObject();

    int ord = RubikObjectList.getTutorialOrdinal(obj);

    viewPager.setCurrentItem(ord);

    ViewGroup.LayoutParams paramsView = new ViewGroup.LayoutParams( tabWidth,tabHeight );

    int numObjects = RubikObjectList.getNumTutorialObjects();

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

      {

      int oOrdinal = RubikObjectList.getObjectOrdinal(i);

      RubikObject object = RubikObjectList.getObject(oOrdinal);

      ImageView imageView = new ImageView(act);

      imageView.setLayoutParams(paramsView);

      if( object!=null ) object.setIconTo(act,imageView);

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

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

      }

    }

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

  public static String getDialogTag()

    {

    return "DialogTutorial";

    }

  }

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

// Copyright 2020 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.dialogs;

import android.util.DisplayMetrics;

import android.view.View;

import android.view.ViewGroup;

import androidx.annotation.NonNull;

import androidx.fragment.app.FragmentActivity;

import androidx.viewpager.widget.PagerAdapter;

import androidx.viewpager.widget.ViewPager;

import org.distorted.objects.RubikObjectList;

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

class RubikDialogTutorialPagerAdapter extends PagerAdapter

  {

  private final FragmentActivity mAct;

  private final RubikDialogTutorialView[] mViews;

  private final int mNumTabs;

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

  RubikDialogTutorialPagerAdapter(FragmentActivity act, ViewPager viewPager)

    {

    mAct     = act;

    mNumTabs = RubikObjectList.getNumTutorialObjects();

    mViews   = new RubikDialogTutorialView[mNumTabs];

    viewPager.setAdapter(this);

    viewPager.setOffscreenPageLimit(1);

    }

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

  void clickPossible()

    {

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

      {

      if( mViews[i]!=null )

        {

        mViews[i].clickPossible(true);

        }

      }

    }

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

  @Override

  @NonNull

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

    {

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

    mViews[position] = new RubikDialogTutorialView(mAct, metrics.heightPixels, position);

    collection.addView(mViews[position]);

    return mViews[position];

    }

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

  @Override

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

    {

    collection.removeView((View) view);

    mViews[position] = null;

    }

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

  @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 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.dialogs;

import android.content.Context;

import android.content.res.Resources;

import android.os.Bundle;

import android.util.AttributeSet;

import android.util.TypedValue;

import android.view.View;

import android.widget.Button;

import android.widget.FrameLayout;

import android.widget.ImageView;

import android.widget.LinearLayout;

import android.widget.TextView;

import androidx.fragment.app.FragmentActivity;

import com.google.firebase.analytics.FirebaseAnalytics;

import org.distorted.main.BuildConfig;

import org.distorted.main.R;

import org.distorted.main_old.RubikActivity;

import org.distorted.objectlib.json.JsonReader;

import org.distorted.objects.RubikObject;

import org.distorted.objects.RubikObjectList;

import java.io.InputStream;

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

public class RubikDialogTutorialView extends FrameLayout

  {

  public static final float PANE_HEIGHT  = 0.06f;

  private boolean mCanClick;

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

  public RubikDialogTutorialView(Context context, AttributeSet attrs, int defStyle)

    {

    super(context, attrs, defStyle);

    }

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

  public RubikDialogTutorialView(Context context, AttributeSet attrs)

    {

    super(context, attrs);

    }

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

  public RubikDialogTutorialView(FragmentActivity act, int height, int position)

    {

    super(act);

    int objectOrdinal = RubikObjectList.getObjectOrdinal(position);

    RubikObject robject = RubikObjectList.getObject(objectOrdinal);

    InputStream jsonStream = robject==null ? null : robject.getExtrasStream(act);

    String[][] tutorials=null;

    if( jsonStream!=null )

      {

      try

        {

        JsonReader reader = new JsonReader();

        reader.parseJsonTutorial(jsonStream);

        tutorials = reader.getTutorials();

        }

      catch(Exception ignored) { }

      }

    if( tutorials!=null )

      {

      clickPossible(true);

      int size = (int)(height*PANE_HEIGHT);

      RubikActivity ract = (RubikActivity)getContext();

      Resources res = act.getResources();

      String packageName = act.getPackageName();

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

      LinearLayout layout = tab.findViewById(R.id.tabLayout);

      int colorB = getResources().getColor(R.color.light_grey);

      int colorT = getResources().getColor(R.color.white);

      for (String[] tutorial : tutorials)

        {

        String coun = tutorial[0];

        String url  = tutorial[1];

        String desc = tutorial[2];

        String auth = tutorial[3];

        int countryID = res.getIdentifier(coun, "drawable", packageName);

        View row = createRow(ract, countryID, desc, url, auth, size, objectOrdinal, colorB, colorT);

        layout.addView(row);

        }

      addView(tab);

      }

    }

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

  void clickPossible(boolean click)

    {

    mCanClick = click;

    }

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

  private View createRow(final RubikActivity act, int countryID, final String desc, final String url,

                         final String auth, int size, final int obj, int colorB, int colorT)

    {

    float textSize = 0.43f*size;

    View row = inflate( act, R.layout.dialog_tutorial_row, null);

    LinearLayout layout = row.findViewById(R.id.tutorialLayout);

    layout.setMinimumHeight(size);

    Button butt = row.findViewById(R.id.tutorialButton);

    butt.setText(R.string.view);

    butt.setTextColor(colorT);

    butt.setBackgroundColor(colorB);

    butt.setTextSize(TypedValue.COMPLEX_UNIT_PX, textSize);

    butt.setHeight(size);

    butt.setOnClickListener( new View.OnClickListener()

      {

      @Override

      public void onClick(View v)

        {

        if( mCanClick )

          {

          act.switchToTutorial(url,obj);

          analyticsReport(act,desc,auth,obj);

          clickPossible(false);

          }

        }

      });

    ImageView image = row.findViewById(R.id.tutorialCountry);

    int id = countryID!=0 ? countryID : org.distorted.flags.R.drawable.unknown;

    image.setImageResource(id);

    TextView author = row.findViewById(R.id.tutorialAuthor);

    author.setTextSize(TypedValue.COMPLEX_UNIT_PX, textSize);

    author.setText(auth);

    TextView title  = row.findViewById(R.id.tutorialTitle);

    title.setTextSize(TypedValue.COMPLEX_UNIT_PX, textSize);

    title.setText(desc);

    return row;

    }

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

  private void analyticsReport(RubikActivity act, String desc, String author, int obj)

    {

    String message = desc+" ("+author+")";

    if( BuildConfig.DEBUG )

       {

       android.util.Log.d("tutorial", message);

       }

    else

      {

      FirebaseAnalytics analytics = act.getAnalytics();

      if( analytics!=null )

        {

        RubikObject object = RubikObjectList.getObject(obj);

        Bundle bundle = new Bundle();

        bundle.putString(FirebaseAnalytics.Param.CONTENT_TYPE, message);

        bundle.putString(FirebaseAnalytics.Param.ITEM_NAME, object==null ? "NULL" : object.getLowerName() );

        analytics.logEvent(FirebaseAnalytics.Event.TUTORIAL_BEGIN, bundle);

        }

      }

    }

  }

import static org.distorted.main_old.RubikActivity.SHOW_DOWNLOADED_DEBUG;

import static org.distorted.main_old.RubikActivity.SHOW_DOWNLOADED_DEBUG;

import static org.distorted.screens.RubikScreenPlay.LEVELS_SHOWN;

import org.distorted.screens.RubikScreenPlay;

import static org.distorted.screens.RubikScreenPlay.LEVELS_SHOWN;

      for(int level=0; level<=RubikScreenPlay.LEVELS_SHOWN; level++)

    int ret=0, level = RubikScreenPlay.LEVELS_SHOWN;

      if( isSolved(obj,level) ) ret++;