Project

General

Profile

Download (23.6 KB) Statistics
| Branch: | Tag: | Revision:

magiccube / src / main / java / org / distorted / states / RubikStatePlay.java @ 466b2ffc

1
///////////////////////////////////////////////////////////////////////////////////////////////////
2
// Copyright 2020 Leszek Koltunski                                                               //
3
//                                                                                               //
4
// This file is part of Magic Cube.                                                              //
5
//                                                                                               //
6
// Magic Cube is free software: you can redistribute it and/or modify                            //
7
// it under the terms of the GNU General Public License as published by                          //
8
// the Free Software Foundation, either version 2 of the License, or                             //
9
// (at your option) any later version.                                                           //
10
//                                                                                               //
11
// Magic Cube is distributed in the hope that it will be useful,                                 //
12
// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //
13
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //
14
// GNU General Public License for more details.                                                  //
15
//                                                                                               //
16
// You should have received a copy of the GNU General Public License                             //
17
// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //
18
///////////////////////////////////////////////////////////////////////////////////////////////////
19

    
20
package org.distorted.states;
21

    
22
import android.content.Context;
23
import android.content.SharedPreferences;
24
import android.graphics.drawable.BitmapDrawable;
25
import android.os.Bundle;
26
import android.util.TypedValue;
27
import android.view.Gravity;
28
import android.view.LayoutInflater;
29
import android.view.View;
30
import android.view.Window;
31
import android.widget.Button;
32
import android.widget.GridLayout;
33
import android.widget.ImageButton;
34
import android.widget.LinearLayout;
35
import android.widget.PopupWindow;
36

    
37
import org.distorted.dialogs.RubikDialogAbout;
38
import org.distorted.dialogs.RubikDialogScores;
39
import org.distorted.main.R;
40
import org.distorted.main.RubikActivity;
41
import org.distorted.main.RubikPreRender;
42
import org.distorted.objects.RubikObject;
43
import org.distorted.objects.RubikObjectList;
44
import org.distorted.scores.RubikScores;
45

    
46
import java.util.ArrayList;
47

    
48
///////////////////////////////////////////////////////////////////////////////////////////////////
49

    
50
public class RubikStatePlay extends RubikStateAbstract implements RubikPreRender.ActionFinishedListener
51
  {
52
  private static final int DURATION_MILLIS = 750;
53
  private static final int LEVELS_SHOWN = 10;
54
  public  static final int DEF_OBJECT= RubikObjectList.CUBE.ordinal();
55
  public  static final int DEF_SIZE  =  3;
56

    
57
  private static int[] BUTTON_LABELS = { R.string.scores, R.string.patterns, R.string.solver, R.string.about };
58
  private static final int NUM_BUTTONS = BUTTON_LABELS.length;
59

    
60
  private ImageButton mObjButton, mMenuButton, mPrevButton, mSolveButton;
61
  private Button mPlayButton;
62
  private PopupWindow mObjectPopup, mMenuPopup, mPlayPopup;
63
  private int mObject = DEF_OBJECT;
64
  private int mSize   = DEF_SIZE;
65
  private int mObjectSize, mMenuLayoutWidth, mMenuLayoutHeight, mPlayLayoutWidth;
66
  private GridLayout mObjectGrid;
67
  private int mLevelValue;
68
  private float mButtonSize, mMenuItemSize, mMenuTextSize;
69
  private int mColCount, mRowCount;
70
  private LinearLayout mPlayLayout;
71

    
72
  private ArrayList<Move> mMoves;
73
  private boolean mCanPrevMove;
74

    
75
  private static class Move
76
    {
77
    private int mAxis, mRow, mAngle;
78

    
79
    Move(int axis, int row, int angle)
80
      {
81
      mAxis = axis;
82
      mRow  = row;
83
      mAngle= angle;
84
      }
85
    }
86

    
87
///////////////////////////////////////////////////////////////////////////////////////////////////
88

    
89
  void leaveState(RubikActivity act)
90
    {
91

    
92
    }
93

    
94
///////////////////////////////////////////////////////////////////////////////////////////////////
95

    
96
  void enterState(final RubikActivity act)
97
    {
98
    float width = act.getScreenWidthInPixels();
99
    mMenuTextSize = width*RubikActivity.MENU_MEDIUM_TEXT_SIZE;
100
    mButtonSize   = width*RubikActivity.BUTTON_TEXT_SIZE;
101
    mMenuItemSize = width*RubikActivity.MENU_ITEM_SIZE;
102

    
103
    mCanPrevMove = true;
104

    
105
    if( mMoves==null ) mMoves = new ArrayList<>();
106
    else               mMoves.clear();
107

    
108
    mRowCount = RubikObjectList.getRowCount();
109
    mColCount = RubikObjectList.getColumnCount();
110

    
111
    // TOP ////////////////////////////
112
    LinearLayout layoutTop = act.findViewById(R.id.upperBar);
113
    layoutTop.removeAllViews();
114

    
115
    setupObjectWindow(act,width);
116
    setupObjectButton(act,width);
117
    layoutTop.addView(mObjButton);
118

    
119
    setupMenuWindow(act,width);
120
    setupMenuButton(act,width);
121
    layoutTop.addView(mMenuButton);
122

    
123
    setupPlayWindow(act,width);
124
    setupPlayButton(act,width);
125
    layoutTop.addView(mPlayButton);
126

    
127
    // BOT ////////////////////////////
128
    LinearLayout layoutLeft = act.findViewById(R.id.mainBarLeft);
129
    layoutLeft.removeAllViews();
130

    
131
    setupPrevButton(act,width);
132
    layoutLeft.addView(mPrevButton);
133
    setupSolveButton(act,width);
134
    layoutLeft.addView(mSolveButton);
135

    
136
    LinearLayout layoutRight = act.findViewById(R.id.mainBarRight);
137
    layoutRight.removeAllViews();
138
    }
139

    
140
///////////////////////////////////////////////////////////////////////////////////////////////////
141

    
142
  private void setupObjectButton(final RubikActivity act, final float width)
143
    {
144
    final int padding = (int)(width*RubikActivity.PADDING);
145
    final int margin  = (int)(width*RubikActivity.MARGIN);
146
    final int icon = RubikActivity.getDrawable(R.drawable.ui_small_cube_menu,R.drawable.ui_medium_cube_menu, R.drawable.ui_big_cube_menu, R.drawable.ui_huge_cube_menu);
147

    
148
    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,LinearLayout.LayoutParams.MATCH_PARENT, 1.2f);
149
    params.topMargin    = margin;
150
    params.bottomMargin = margin;
151
    params.leftMargin   = margin;
152
    params.rightMargin  = margin;
153

    
154
    mObjButton = new ImageButton(act);
155
    mObjButton.setLayoutParams(params);
156
    mObjButton.setPadding(padding,0,padding,0);
157
    mObjButton.setImageResource(icon);
158

    
159
    mObjButton.setOnClickListener( new View.OnClickListener()
160
      {
161
      @Override
162
      public void onClick(View view)
163
        {
164
        if( act.getPreRender().canPlay() )
165
          {
166
          mObjectPopup.setFocusable(false);
167
          mObjectPopup.update();
168

    
169
          View popupView = mObjectPopup.getContentView();
170
          popupView.setSystemUiVisibility(RubikActivity.FLAGS);
171

    
172
          mObjectPopup.showAsDropDown(view, margin, margin, Gravity.LEFT);
173
          mObjectPopup.update(view, mObjectSize*mColCount, mObjectSize*mRowCount);
174

    
175
          mObjectPopup.setFocusable(true);
176
          mObjectPopup.update();
177

    
178
          }
179
        }
180
      });
181
    }
182

    
183
///////////////////////////////////////////////////////////////////////////////////////////////////
184

    
185
  private void setupPlayButton(final RubikActivity act, final float width)
186
    {
187
    final int padding = (int)(width*RubikActivity.PADDING);
188
    final int margin  = (int)(width*RubikActivity.MARGIN);
189
    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,LinearLayout.LayoutParams.MATCH_PARENT, 1.2f);
190
    params.topMargin    = margin;
191
    params.bottomMargin = margin;
192
    params.leftMargin   = margin;
193
    params.rightMargin  = margin;
194

    
195
    mPlayButton = new Button(act);
196
    mPlayButton.setLayoutParams(params);
197
    mPlayButton.setPadding(padding,0,padding,0);
198
    mPlayButton.setTextSize(TypedValue.COMPLEX_UNIT_PX, mButtonSize);
199
    mPlayButton.setText(R.string.play);
200

    
201
    mPlayButton.setOnClickListener( new View.OnClickListener()
202
      {
203
      @Override
204
      public void onClick(View view)
205
        {
206
        mPlayPopup.setFocusable(false);
207
        mPlayPopup.update();
208

    
209
        View popupView = mPlayPopup.getContentView();
210
        popupView.setSystemUiVisibility(RubikActivity.FLAGS);
211

    
212
        mPlayPopup.showAsDropDown(view, margin, margin, Gravity.RIGHT);
213
        mPlayPopup.update(view, mPlayLayoutWidth, (int)(LEVELS_SHOWN*(mMenuItemSize+margin)+margin));
214

    
215
        mPlayPopup.setFocusable(true);
216
        mPlayPopup.update();
217
        }
218
      });
219
    }
220

    
221
///////////////////////////////////////////////////////////////////////////////////////////////////
222

    
223
  private void setupMenuButton(final RubikActivity act, final float width)
224
    {
225
    final int padding = (int)(width*RubikActivity.PADDING);
226
    final int margin  = (int)(width*RubikActivity.MARGIN);
227
    final int icon = RubikActivity.getDrawable(R.drawable.ui_small_menu,R.drawable.ui_medium_menu, R.drawable.ui_big_menu, R.drawable.ui_huge_menu);
228

    
229
    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT, 1.2f);
230
    params.topMargin    = margin;
231
    params.bottomMargin = margin;
232
    params.leftMargin   = margin;
233
    params.rightMargin  = margin;
234

    
235
    mMenuButton = new ImageButton(act);
236
    mMenuButton.setLayoutParams(params);
237
    mMenuButton.setPadding(padding,0,padding,0);
238
    mMenuButton.setImageResource(icon);
239

    
240
    mMenuButton.setOnClickListener( new View.OnClickListener()
241
      {
242
      @Override
243
      public void onClick(View view)
244
        {
245
        if( act.getPreRender().canPlay() )
246
          {
247
          mMenuPopup.setFocusable(false);
248
          mMenuPopup.update();
249

    
250
          View popupView = mMenuPopup.getContentView();
251
          popupView.setSystemUiVisibility(RubikActivity.FLAGS);
252

    
253
          mMenuPopup.showAsDropDown(view, (int)(-width/12), margin, Gravity.CENTER);
254
          mMenuPopup.update(view, mMenuLayoutWidth, mMenuLayoutHeight);
255

    
256
          mMenuPopup.setFocusable(true);
257
          mMenuPopup.update();
258
          }
259
        }
260
      });
261
    }
262

    
263
///////////////////////////////////////////////////////////////////////////////////////////////////
264

    
265
  private void setupSolveButton(final RubikActivity act, final float width)
266
    {
267
    int padding  = (int)(width*RubikActivity.PADDING);
268
    int margin   = (int)(width*RubikActivity.MARGIN);
269
    int widthBut = (int)(width/6);
270
    int icon = RubikActivity.getDrawable(R.drawable.ui_small_cube_solve,R.drawable.ui_medium_cube_solve, R.drawable.ui_big_cube_solve, R.drawable.ui_huge_cube_solve);
271

    
272
    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(widthBut, LinearLayout.LayoutParams.MATCH_PARENT);
273
    params.topMargin    = margin;
274
    params.bottomMargin = margin;
275
    params.leftMargin   = margin;
276
    params.rightMargin  = margin;
277

    
278
    mSolveButton = new ImageButton(act);
279
    mSolveButton.setLayoutParams(params);
280
    mSolveButton.setPadding(padding,0,padding,0);
281
    mSolveButton.setImageResource(icon);
282

    
283
    mSolveButton.setOnClickListener( new View.OnClickListener()
284
      {
285
      @Override
286
      public void onClick(View v)
287
        {
288
        act.getPreRender().solveObject();
289
        mMoves.clear();
290
        }
291
      });
292
    }
293

    
294
///////////////////////////////////////////////////////////////////////////////////////////////////
295

    
296
  private void setupPrevButton(final RubikActivity act, final float width)
297
    {
298
    int padding  = (int)(width*RubikActivity.PADDING);
299
    int margin   = (int)(width*RubikActivity.MARGIN);
300
    int widthBut = (int)(width/6);
301
    int icon = RubikActivity.getDrawable(R.drawable.ui_small_cube_back,R.drawable.ui_medium_cube_back, R.drawable.ui_big_cube_back, R.drawable.ui_huge_cube_back);
302

    
303
    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(widthBut, LinearLayout.LayoutParams.MATCH_PARENT);
304
    params.topMargin    = margin;
305
    params.bottomMargin = margin;
306
    params.leftMargin   = margin;
307
    params.rightMargin  = margin;
308

    
309
    mPrevButton = new ImageButton(act);
310
    mPrevButton.setLayoutParams(params);
311
    mPrevButton.setPadding(padding,0,padding,0);
312
    mPrevButton.setImageResource(icon);
313

    
314
    mPrevButton.setOnClickListener( new View.OnClickListener()
315
      {
316
      @Override
317
      public void onClick(View v)
318
        {
319
        RubikPreRender pre = act.getPreRender();
320
        backMove(pre);
321
        }
322
      });
323
    }
324

    
325
///////////////////////////////////////////////////////////////////////////////////////////////////
326

    
327
  private void setupObjectWindow(final RubikActivity act, final float width)
328
    {
329
    LayoutInflater layoutInflater = (LayoutInflater)act.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
330
    final View layout = layoutInflater.inflate(R.layout.popup_objects, null);
331
    mObjectGrid = layout.findViewById(R.id.objectGrid);
332

    
333
    int[] indices = RubikObjectList.getIndices();
334

    
335
    GridLayout.Spec[] rowSpecs = new GridLayout.Spec[mRowCount];
336
    GridLayout.Spec[] colSpecs = new GridLayout.Spec[mColCount];
337

    
338
    mObjectGrid.setColumnCount(mColCount);
339
    mObjectGrid.setRowCount(mRowCount);
340

    
341
    int[] nextInColumn = new int[mColCount];
342

    
343
    for(int row=0; row<mRowCount; row++)
344
      {
345
      rowSpecs[row] = GridLayout.spec(row);
346
      }
347
    for(int col=0; col<mColCount; col++)
348
      {
349
      colSpecs[col] = GridLayout.spec(col);
350
      nextInColumn[col] =0;
351
      }
352

    
353
    mObjectPopup = new PopupWindow(act);
354
    mObjectPopup.setContentView(layout);
355
    mObjectPopup.setFocusable(true);
356
    int icon = RubikActivity.getDrawable(R.drawable.ui_small_cube2,R.drawable.ui_medium_cube2, R.drawable.ui_big_cube2, R.drawable.ui_huge_cube2);
357

    
358
    BitmapDrawable bd = (BitmapDrawable) act.getResources().getDrawable(icon);
359
    int cubeWidth = bd.getIntrinsicWidth();
360
    int margin = (int)(width*RubikActivity.LARGE_MARGIN);
361
    mObjectSize = (int)(cubeWidth + 2*margin + 0.5f);
362

    
363
    for(int object=0; object<RubikObjectList.NUM_OBJECTS; object++)
364
      {
365
      final RubikObjectList list = RubikObjectList.getObject(object);
366
      final int[] sizes = list.getSizes();
367
      int[] icons = list.getIconIDs();
368
      int len = sizes.length;
369
      final int obj = object;
370
      int col = indices[object];
371

    
372
      for(int i=0; i<len; i++)
373
        {
374
        final int index = i;
375

    
376
        ImageButton button = new ImageButton(act);
377
        button.setBackgroundResource(icons[i]);
378
        button.setOnClickListener( new View.OnClickListener()
379
          {
380
          @Override
381
          public void onClick(View v)
382
            {
383
            if( act.getPreRender().canPlay() && RubikState.getCurrentState()==RubikState.PLAY )
384
              {
385
              mObject = obj;
386
              mSize   = sizes[index];
387
              act.changeObject(list,sizes[index], true);
388
              adjustLevels(act);
389
              mMoves.clear();
390
              }
391

    
392
            mObjectPopup.dismiss();
393
            }
394
          });
395

    
396
        GridLayout.LayoutParams params = new GridLayout.LayoutParams(rowSpecs[nextInColumn[col]],colSpecs[col]);
397
        params.bottomMargin = margin;
398
        params.topMargin    = margin;
399
        params.leftMargin   = margin;
400
        params.rightMargin  = margin;
401

    
402
        nextInColumn[col]++;
403

    
404
        mObjectGrid.addView(button, params);
405
        }
406
      }
407
    }
408

    
409
///////////////////////////////////////////////////////////////////////////////////////////////////
410

    
411
  private void setupMenuWindow(final RubikActivity act, final float width)
412
    {
413
    LayoutInflater layoutInflater = (LayoutInflater)act.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
414
    final View layout = layoutInflater.inflate(R.layout.popup_menu, null);
415
    LinearLayout menuLayout = layout.findViewById(R.id.menuGrid);
416

    
417
    mMenuPopup = new PopupWindow(act);
418
    mMenuPopup.setContentView(layout);
419
    mMenuPopup.setFocusable(true);
420
    int margin  = (int)(width*RubikActivity.MARGIN);
421
    int padding = (int)(width*RubikActivity.PADDING);
422

    
423
    mMenuLayoutWidth = (int)(width/2);
424
    mMenuLayoutHeight= (int)(2*margin + NUM_BUTTONS*(mMenuItemSize+margin));
425

    
426
    LinearLayout.LayoutParams pT = new LinearLayout.LayoutParams( mMenuLayoutWidth - 2*padding, (int)mMenuItemSize);
427
    pT.setMargins(margin, 0, margin, margin);
428
    LinearLayout.LayoutParams pM = new LinearLayout.LayoutParams( mMenuLayoutWidth - 2*padding, (int)mMenuItemSize);
429
    pM.setMargins(margin, margin, margin, margin);
430
    LinearLayout.LayoutParams pB = new LinearLayout.LayoutParams( mMenuLayoutWidth - 2*padding, (int)mMenuItemSize);
431
    pB.setMargins(margin, margin, margin, 2*margin);
432

    
433
    for(int i=0; i<NUM_BUTTONS; i++)
434
      {
435
      final int but = i;
436
      Button button = new Button(act);
437
      button.setLayoutParams(pT);//i==0 ? pT : (i==NUM_BUTTONS-1 ? pB : pM));
438
      button.setText(BUTTON_LABELS[i]);
439
      button.setTextSize(TypedValue.COMPLEX_UNIT_PX, mMenuTextSize);
440

    
441
      button.setOnClickListener( new View.OnClickListener()
442
        {
443
        @Override
444
        public void onClick(View v)
445
          {
446
          mMenuPopup.dismiss();
447
          MenuAction(act,but);
448
          }
449
        });
450

    
451
      menuLayout.addView(button);
452
      }
453
    }
454

    
455
///////////////////////////////////////////////////////////////////////////////////////////////////
456

    
457
  private void setupPlayWindow(final RubikActivity act, final float width)
458
    {
459
    LayoutInflater layoutInflater = (LayoutInflater)act.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
460
    final View layout = layoutInflater.inflate(R.layout.popup_play, null);
461
    mPlayLayout = layout.findViewById(R.id.playGrid);
462

    
463
    mPlayLayoutWidth = (int)(width*0.4f);
464

    
465
    mPlayPopup = new PopupWindow(act);
466
    mPlayPopup.setContentView(layout);
467
    mPlayPopup.setFocusable(true);
468

    
469
    adjustLevels(act);
470
    }
471

    
472
///////////////////////////////////////////////////////////////////////////////////////////////////
473

    
474
  private void backMove(RubikPreRender pre)
475
    {
476
    if( mCanPrevMove )
477
      {
478
      int numMoves = mMoves.size();
479

    
480
      if( numMoves>0 )
481
        {
482
        Move move = mMoves.remove(numMoves-1);
483
        RubikObject object = pre.getObject();
484

    
485
        int axis  = move.mAxis;
486
        int row   = (1<<move.mRow);
487
        int angle = move.mAngle;
488
        int numRot= Math.abs(angle*object.getBasicAngle()/360);
489

    
490
        if( angle!=0 )
491
          {
492
          mCanPrevMove = false;
493
          pre.addRotation(this, axis, row, -angle, numRot*DURATION_MILLIS);
494
          }
495
        else
496
          {
497
          android.util.Log.e("solution", "error: trying to back move of angle 0");
498
          }
499
        }
500
      }
501
    }
502

    
503
///////////////////////////////////////////////////////////////////////////////////////////////////
504

    
505
  private void MenuAction(RubikActivity act, int button)
506
    {
507
    switch(button)
508
      {
509
      case 0: RubikStatePlay play = (RubikStatePlay) RubikState.PLAY.getStateClass();
510
              int object = play.getObject();
511
              int size   = play.getSize();
512
              int sizeIndex = RubikObjectList.getSizeIndex(object,size);
513

    
514
              Bundle bundle = new Bundle();
515
              bundle.putInt("tab", RubikObjectList.pack(object,sizeIndex) );
516
              bundle.putBoolean("submitting", false);
517

    
518
              RubikDialogScores scores = new RubikDialogScores();
519
              scores.setArguments(bundle);
520
              scores.show(act.getSupportFragmentManager(), null);
521
              break;
522
      case 1: RubikState.switchState(act,RubikState.PATT);
523
              break;
524
      case 2: RubikState.switchState(act,RubikState.SVER);
525
              break;
526
      case 3: RubikDialogAbout diag = new RubikDialogAbout();
527
              diag.show(act.getSupportFragmentManager(), null);
528
              break;
529
      }
530
    }
531

    
532
///////////////////////////////////////////////////////////////////////////////////////////////////
533

    
534
  public void savePreferences(SharedPreferences.Editor editor)
535
    {
536
    editor.putInt("statePlay_object", mObject);
537
    editor.putInt("statePlay_size"  , mSize);
538

    
539
    if( mObjectPopup!=null )
540
      {
541
      mObjectPopup.dismiss();
542
      mObjectPopup = null;
543
      }
544

    
545
    if( mMenuPopup!=null )
546
      {
547
      mMenuPopup.dismiss();
548
      mMenuPopup = null;
549
      }
550

    
551
    if( mPlayPopup!=null )
552
      {
553
      mPlayPopup.dismiss();
554
      mPlayPopup = null;
555
      }
556
    }
557

    
558
///////////////////////////////////////////////////////////////////////////////////////////////////
559

    
560
  public void restorePreferences(SharedPreferences preferences)
561
    {
562
    mObject     = preferences.getInt("statePlay_object", DEF_OBJECT);
563
    mSize       = preferences.getInt("statePlay_size"  , DEF_SIZE  );
564
    }
565

    
566
///////////////////////////////////////////////////////////////////////////////////////////////////
567

    
568
  public boolean setObjectAndSize(RubikActivity act, RubikObjectList obj, int size)
569
    {
570
    if( mObject!=obj.ordinal() || mSize != size )
571
      {
572
      boolean success = false;
573

    
574
      for( int s: obj.getSizes() )
575
        if( s==size )
576
          {
577
          success = true;
578
          break;
579
          }
580

    
581
      if( success )
582
        {
583
        mObject = obj.ordinal();
584
        mSize   = size;
585

    
586
        if( mPlayLayout!=null ) adjustLevels(act);
587
        }
588

    
589
      return success;
590
      }
591

    
592
    return true;
593
    }
594

    
595
///////////////////////////////////////////////////////////////////////////////////////////////////
596

    
597
  private void adjustLevels(final RubikActivity act)
598
    {
599
    int sizeIndex = RubikObjectList.getSizeIndex(mObject,mSize);
600
    int maxLevel = RubikObjectList.getMaxLevel(mObject, sizeIndex);
601
    String[] levels = new String[maxLevel];
602

    
603
    for(int i=0; i<maxLevel; i++)
604
      {
605
      levels[i] = act.getString(R.string.lv_placeholder,i+1);
606
      }
607

    
608
    if( mLevelValue>maxLevel ) mLevelValue=1;
609

    
610
    float width = act.getScreenWidthInPixels();
611
    int margin  = (int)(width*RubikActivity.MARGIN);
612
    int padding = (int)(width*RubikActivity.PADDING);
613

    
614
    LinearLayout.LayoutParams pM = new LinearLayout.LayoutParams( mPlayLayoutWidth - 2*padding, (int)mMenuItemSize);
615
    pM.setMargins(margin, 0, margin, margin);
616
    LinearLayout.LayoutParams pT = new LinearLayout.LayoutParams( mPlayLayoutWidth - 2*padding, (int)mMenuItemSize);
617
    pT.setMargins(margin, margin, margin, margin);
618
    LinearLayout.LayoutParams pB = new LinearLayout.LayoutParams( mPlayLayoutWidth - 2*padding, (int)mMenuItemSize);
619
    pB.setMargins(margin, margin, margin, 2*margin);
620

    
621
    mPlayLayout.removeAllViews();
622

    
623
    int realSize= RubikObjectList.getSizeIndex(mObject,mSize);
624
    RubikScores scores = RubikScores.getInstance();
625

    
626
    for(int i=0; i<maxLevel; i++)
627
      {
628
      final int but = i;
629
      Button button = new Button(act);
630
      button.setLayoutParams(i==0 ? pT : (i==maxLevel-1 ? pB : pM));
631
      button.setText(levels[i]);
632
      button.setTextSize(TypedValue.COMPLEX_UNIT_PX, mMenuTextSize);
633

    
634
      int icon = scores.isSolved(mObject, realSize, i) ? R.drawable.ui_solved : R.drawable.ui_notsolved;
635
      button.setCompoundDrawablesWithIntrinsicBounds(icon,0,0,0);
636

    
637
      button.setOnClickListener( new View.OnClickListener()
638
        {
639
        @Override
640
        public void onClick(View v)
641
          {
642
          mPlayPopup.dismiss();
643
          mLevelValue = but+1;
644
          act.getPreRender().scrambleObject(mLevelValue);
645
          }
646
        });
647

    
648
      mPlayLayout.addView(button);
649
      }
650
    }
651

    
652
///////////////////////////////////////////////////////////////////////////////////////////////////
653

    
654
  int getLevel()
655
    {
656
    return mLevelValue;
657
    }
658

    
659
///////////////////////////////////////////////////////////////////////////////////////////////////
660

    
661
  public void addMove(int axis, int row, int angle)
662
    {
663
    mMoves.add(new Move(axis,row,angle));
664
    }
665

    
666
///////////////////////////////////////////////////////////////////////////////////////////////////
667

    
668
  public int getObject()
669
    {
670
    return mObject;
671
    }
672

    
673
///////////////////////////////////////////////////////////////////////////////////////////////////
674

    
675
  public int getSize()
676
    {
677
    return mSize;
678
    }
679

    
680
///////////////////////////////////////////////////////////////////////////////////////////////////
681

    
682
  public void onActionFinished(final long effectID)
683
    {
684
    mCanPrevMove = true;
685
    }
686
  }
(5-5/9)