Project

General

Profile

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

magiccube / src / main / java / org / distorted / states / RubikStatePlay.java @ 0254cfd7

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.widget.Button;
31
import android.widget.GridLayout;
32
import android.widget.ImageButton;
33
import android.widget.LinearLayout;
34
import android.widget.PopupWindow;
35

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

    
44
import java.util.ArrayList;
45

    
46
///////////////////////////////////////////////////////////////////////////////////////////////////
47

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

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

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

    
70
  private ArrayList<Move> mMoves;
71
  private boolean mCanPrevMove;
72

    
73
  private static class Move
74
    {
75
    private int mAxis, mRow, mAngle;
76

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

    
85
///////////////////////////////////////////////////////////////////////////////////////////////////
86

    
87
  void leaveState(RubikActivity act)
88
    {
89

    
90
    }
91

    
92
///////////////////////////////////////////////////////////////////////////////////////////////////
93

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

    
101
    mCanPrevMove = true;
102

    
103
    if( mMoves==null ) mMoves = new ArrayList<>();
104
    else               mMoves.clear();
105

    
106
    mRowCount = RubikObjectList.getRowCount();
107
    mColCount = RubikObjectList.getColumnCount();
108

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

    
113
    setupObjectWindow(act,width);
114
    setupObjectButton(act,width);
115
    layoutTop.addView(mObjButton);
116

    
117
    setupMenuWindow(act,width);
118
    setupMenuButton(act,width);
119
    layoutTop.addView(mMenuButton);
120

    
121
    setupPlayWindow(act,width);
122
    setupPlayButton(act,width);
123
    layoutTop.addView(mPlayButton);
124

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

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

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

    
138
///////////////////////////////////////////////////////////////////////////////////////////////////
139

    
140
  private void setupObjectButton(final RubikActivity act, final float width)
141
    {
142
    final int padding = (int)(width*RubikActivity.PADDING);
143
    final int margin  = (int)(width*RubikActivity.MARGIN);
144
    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);
145

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

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

    
157
    mObjButton.setOnClickListener( new View.OnClickListener()
158
      {
159
      @Override
160
      public void onClick(View view)
161
        {
162
        if( act.getPreRender().canPlay() )
163
          {
164
          boolean vertical = act.isVertical();
165
          mObjectGrid.setOrientation(vertical ? GridLayout.VERTICAL:GridLayout.HORIZONTAL);
166
          mObjectPopup.showAsDropDown(view, margin, margin, Gravity.LEFT);
167

    
168
          int layhei = mObjectSize * (vertical? mRowCount:mColCount);
169
          int laywid = mObjectSize * (vertical? mColCount:mRowCount);
170
          mObjectPopup.update(view, laywid, layhei);
171
          }
172
        }
173
      });
174
    }
175

    
176
///////////////////////////////////////////////////////////////////////////////////////////////////
177

    
178
  private void setupPlayButton(final RubikActivity act, final float width)
179
    {
180
    final int padding = (int)(width*RubikActivity.PADDING);
181
    final int margin  = (int)(width*RubikActivity.MARGIN);
182
    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,LinearLayout.LayoutParams.MATCH_PARENT, 1.2f);
183
    params.topMargin    = margin;
184
    params.bottomMargin = margin;
185
    params.leftMargin   = margin;
186
    params.rightMargin  = margin;
187

    
188
    mPlayButton = new Button(act);
189
    mPlayButton.setLayoutParams(params);
190
    mPlayButton.setPadding(padding,0,padding,0);
191
    mPlayButton.setTextSize(TypedValue.COMPLEX_UNIT_PX, mButtonSize);
192
    mPlayButton.setText(R.string.play);
193

    
194
    mPlayButton.setOnClickListener( new View.OnClickListener()
195
      {
196
      @Override
197
      public void onClick(View view)
198
        {
199
        mPlayPopup.showAsDropDown(view, margin, margin, Gravity.RIGHT);
200
        mPlayPopup.update(view, mPlayLayoutWidth, (int)(LEVELS_SHOWN*(mMenuItemSize+margin)+margin));
201
        }
202
      });
203
    }
204

    
205
///////////////////////////////////////////////////////////////////////////////////////////////////
206

    
207
  private void setupMenuButton(final RubikActivity act, final float width)
208
    {
209
    final int padding = (int)(width*RubikActivity.PADDING);
210
    final int margin  = (int)(width*RubikActivity.MARGIN);
211
    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);
212

    
213
    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT, 1.2f);
214
    params.topMargin    = margin;
215
    params.bottomMargin = margin;
216
    params.leftMargin   = margin;
217
    params.rightMargin  = margin;
218

    
219
    mMenuButton = new ImageButton(act);
220
    mMenuButton.setLayoutParams(params);
221
    mMenuButton.setPadding(padding,0,padding,0);
222
    mMenuButton.setImageResource(icon);
223

    
224
    mMenuButton.setOnClickListener( new View.OnClickListener()
225
      {
226
      @Override
227
      public void onClick(View view)
228
        {
229
        if( act.getPreRender().canPlay() )
230
          {
231
          mMenuPopup.showAsDropDown(view, (int)(-width/12), margin, Gravity.CENTER);
232
          mMenuPopup.update(view, mMenuLayoutWidth, mMenuLayoutHeight);
233
          }
234
        }
235
      });
236
    }
237

    
238
///////////////////////////////////////////////////////////////////////////////////////////////////
239

    
240
  private void setupSolveButton(final RubikActivity act, final float width)
241
    {
242
    int padding  = (int)(width*RubikActivity.PADDING);
243
    int margin   = (int)(width*RubikActivity.MARGIN);
244
    int widthBut = (int)(width/6);
245
    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);
246

    
247
    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(widthBut, LinearLayout.LayoutParams.MATCH_PARENT);
248
    params.topMargin    = margin;
249
    params.bottomMargin = margin;
250
    params.leftMargin   = margin;
251
    params.rightMargin  = margin;
252

    
253
    mSolveButton = new ImageButton(act);
254
    mSolveButton.setLayoutParams(params);
255
    mSolveButton.setPadding(padding,0,padding,0);
256
    mSolveButton.setImageResource(icon);
257

    
258
    mSolveButton.setOnClickListener( new View.OnClickListener()
259
      {
260
      @Override
261
      public void onClick(View v)
262
        {
263
        act.getPreRender().solveObject();
264
        mMoves.clear();
265
        }
266
      });
267
    }
268

    
269
///////////////////////////////////////////////////////////////////////////////////////////////////
270

    
271
  private void setupPrevButton(final RubikActivity act, final float width)
272
    {
273
    int padding  = (int)(width*RubikActivity.PADDING);
274
    int margin   = (int)(width*RubikActivity.MARGIN);
275
    int widthBut = (int)(width/6);
276
    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);
277

    
278
    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(widthBut, LinearLayout.LayoutParams.MATCH_PARENT);
279
    params.topMargin    = margin;
280
    params.bottomMargin = margin;
281
    params.leftMargin   = margin;
282
    params.rightMargin  = margin;
283

    
284
    mPrevButton = new ImageButton(act);
285
    mPrevButton.setLayoutParams(params);
286
    mPrevButton.setPadding(padding,0,padding,0);
287
    mPrevButton.setImageResource(icon);
288

    
289
    mPrevButton.setOnClickListener( new View.OnClickListener()
290
      {
291
      @Override
292
      public void onClick(View v)
293
        {
294
        RubikPreRender pre = act.getPreRender();
295
        backMove(pre);
296
        }
297
      });
298
    }
299

    
300
///////////////////////////////////////////////////////////////////////////////////////////////////
301

    
302
  private void setupObjectWindow(final RubikActivity act, final float width)
303
    {
304
    LayoutInflater layoutInflater = (LayoutInflater)act.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
305
    final View layout = layoutInflater.inflate(R.layout.popup_objects, null);
306
    mObjectGrid = layout.findViewById(R.id.objectGrid);
307

    
308
    int[] indices = RubikObjectList.getIndices();
309

    
310
    GridLayout.Spec[] rowSpecs = new GridLayout.Spec[mRowCount];
311
    GridLayout.Spec[] colSpecs = new GridLayout.Spec[mColCount];
312

    
313
    mObjectGrid.setColumnCount(mColCount);
314
    mObjectGrid.setRowCount(mRowCount);
315

    
316
    int[] nextInColumn = new int[mColCount];
317

    
318
    for(int row=0; row<mRowCount; row++)
319
      {
320
      rowSpecs[row] = GridLayout.spec(row);
321
      }
322
    for(int col=0; col<mColCount; col++)
323
      {
324
      colSpecs[col] = GridLayout.spec(col);
325
      nextInColumn[col] =0;
326
      }
327

    
328
    mObjectPopup = new PopupWindow(act);
329
    mObjectPopup.setContentView(layout);
330
    mObjectPopup.setFocusable(true);
331
    int icon = RubikActivity.getDrawable(R.drawable.ui_small_cube2,R.drawable.ui_medium_cube2, R.drawable.ui_big_cube2, R.drawable.ui_huge_cube2);
332

    
333
    BitmapDrawable bd = (BitmapDrawable) act.getResources().getDrawable(icon);
334
    int cubeWidth = bd.getIntrinsicWidth();
335
    int margin = (int)(width*RubikActivity.LARGE_MARGIN);
336
    mObjectSize = (int)(cubeWidth + 2*margin + 0.5f);
337

    
338
    for(int object=0; object<RubikObjectList.NUM_OBJECTS; object++)
339
      {
340
      final RubikObjectList list = RubikObjectList.getObject(object);
341
      final int[] sizes = list.getSizes();
342
      int[] icons = list.getIconIDs();
343
      int len = sizes.length;
344
      final int obj = object;
345
      int col = indices[object];
346

    
347
      for(int i=0; i<len; i++)
348
        {
349
        final int index = i;
350

    
351
        ImageButton button = new ImageButton(act);
352
        button.setBackgroundResource(icons[i]);
353
        button.setOnClickListener( new View.OnClickListener()
354
          {
355
          @Override
356
          public void onClick(View v)
357
            {
358
            if( act.getPreRender().canPlay() && RubikState.getCurrentState()==RubikState.PLAY )
359
              {
360
              mObject = obj;
361
              mSize   = sizes[index];
362
              act.changeObject(list,sizes[index], true);
363
              adjustLevels(act);
364
              mMoves.clear();
365
              }
366

    
367
            mObjectPopup.dismiss();
368
            }
369
          });
370

    
371
        GridLayout.LayoutParams params = new GridLayout.LayoutParams(rowSpecs[nextInColumn[col]],colSpecs[col]);
372
        params.bottomMargin = margin;
373
        params.topMargin    = margin;
374
        params.leftMargin   = margin;
375
        params.rightMargin  = margin;
376

    
377
        nextInColumn[col]++;
378

    
379
        mObjectGrid.addView(button, params);
380
        }
381
      }
382
    }
383

    
384
///////////////////////////////////////////////////////////////////////////////////////////////////
385

    
386
  private void setupMenuWindow(final RubikActivity act, final float width)
387
    {
388
    LayoutInflater layoutInflater = (LayoutInflater)act.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
389
    final View layout = layoutInflater.inflate(R.layout.popup_menu, null);
390
    LinearLayout menuLayout = layout.findViewById(R.id.menuGrid);
391

    
392
    mMenuPopup = new PopupWindow(act);
393
    mMenuPopup.setContentView(layout);
394
    mMenuPopup.setFocusable(true);
395
    int margin  = (int)(width*RubikActivity.MARGIN);
396
    int padding = (int)(width*RubikActivity.PADDING);
397

    
398
    mMenuLayoutWidth = (int)(width/2);
399
    mMenuLayoutHeight= (int)(2*margin + NUM_BUTTONS*(mMenuItemSize+margin));
400

    
401
    LinearLayout.LayoutParams pT = new LinearLayout.LayoutParams( mMenuLayoutWidth - 2*padding, (int)mMenuItemSize);
402
    pT.setMargins(margin, 0, margin, margin);
403
    LinearLayout.LayoutParams pM = new LinearLayout.LayoutParams( mMenuLayoutWidth - 2*padding, (int)mMenuItemSize);
404
    pM.setMargins(margin, margin, margin, margin);
405
    LinearLayout.LayoutParams pB = new LinearLayout.LayoutParams( mMenuLayoutWidth - 2*padding, (int)mMenuItemSize);
406
    pB.setMargins(margin, margin, margin, 2*margin);
407

    
408
    for(int i=0; i<NUM_BUTTONS; i++)
409
      {
410
      final int but = i;
411
      Button button = new Button(act);
412
      button.setLayoutParams(pT);//i==0 ? pT : (i==NUM_BUTTONS-1 ? pB : pM));
413
      button.setText(BUTTON_LABELS[i]);
414
      button.setTextSize(TypedValue.COMPLEX_UNIT_PX, mMenuTextSize);
415

    
416
      button.setOnClickListener( new View.OnClickListener()
417
        {
418
        @Override
419
        public void onClick(View v)
420
          {
421
          mMenuPopup.dismiss();
422
          MenuAction(act,but);
423
          }
424
        });
425

    
426
      menuLayout.addView(button);
427
      }
428
    }
429

    
430
///////////////////////////////////////////////////////////////////////////////////////////////////
431

    
432
  private void setupPlayWindow(final RubikActivity act, final float width)
433
    {
434
    LayoutInflater layoutInflater = (LayoutInflater)act.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
435
    final View layout = layoutInflater.inflate(R.layout.popup_play, null);
436
    mPlayLayout = layout.findViewById(R.id.playGrid);
437

    
438
    mPlayLayoutWidth = (int)(width*0.4f);
439

    
440
    mPlayPopup = new PopupWindow(act);
441
    mPlayPopup.setContentView(layout);
442
    mPlayPopup.setFocusable(true);
443

    
444
    adjustLevels(act);
445
    }
446

    
447
///////////////////////////////////////////////////////////////////////////////////////////////////
448

    
449
  private void backMove(RubikPreRender pre)
450
    {
451
    if( mCanPrevMove )
452
      {
453
      int numMoves = mMoves.size();
454

    
455
      if( numMoves>0 )
456
        {
457
        Move move = mMoves.remove(numMoves-1);
458
        RubikObject object = pre.getObject();
459

    
460
        int axis  = move.mAxis;
461
        int row   = (1<<move.mRow);
462
        int angle = move.mAngle;
463
        int numRot= Math.abs(angle*object.getBasicAngle()/360);
464

    
465
        if( angle!=0 )
466
          {
467
          mCanPrevMove = false;
468
          pre.addRotation(this, axis, row, -angle, numRot*DURATION_MILLIS);
469
          }
470
        else
471
          {
472
          android.util.Log.e("solution", "error: trying to back move of angle 0");
473
          }
474
        }
475
      }
476
    }
477

    
478
///////////////////////////////////////////////////////////////////////////////////////////////////
479

    
480
  private void MenuAction(RubikActivity act, int button)
481
    {
482
    switch(button)
483
      {
484
      case 0: RubikStatePlay play = (RubikStatePlay) RubikState.PLAY.getStateClass();
485
              int object = play.getObject();
486
              int size   = play.getSize();
487
              int sizeIndex = RubikObjectList.getSizeIndex(object,size);
488

    
489
              Bundle bundle = new Bundle();
490
              bundle.putInt("tab", RubikObjectList.pack(object,sizeIndex) );
491
              bundle.putBoolean("submitting", false);
492

    
493
              RubikDialogScores scores = new RubikDialogScores();
494
              scores.setArguments(bundle);
495
              scores.show(act.getSupportFragmentManager(), null);
496
              break;
497
      case 1: RubikState.switchState(act,RubikState.PATT);
498
              break;
499
      case 2: RubikState.switchState(act,RubikState.SVER);
500
              break;
501
      case 3: RubikDialogAbout diag = new RubikDialogAbout();
502
              diag.show(act.getSupportFragmentManager(), null);
503
              break;
504
      }
505
    }
506

    
507
///////////////////////////////////////////////////////////////////////////////////////////////////
508

    
509
  public void savePreferences(SharedPreferences.Editor editor)
510
    {
511
    editor.putInt("statePlay_object", mObject);
512
    editor.putInt("statePlay_size"  , mSize);
513

    
514
    if( mObjectPopup!=null )
515
      {
516
      mObjectPopup.dismiss();
517
      mObjectPopup = null;
518
      }
519

    
520
    if( mMenuPopup!=null )
521
      {
522
      mMenuPopup.dismiss();
523
      mMenuPopup = null;
524
      }
525

    
526
    if( mPlayPopup!=null )
527
      {
528
      mPlayPopup.dismiss();
529
      mPlayPopup = null;
530
      }
531
    }
532

    
533
///////////////////////////////////////////////////////////////////////////////////////////////////
534

    
535
  public void restorePreferences(SharedPreferences preferences)
536
    {
537
    mObject     = preferences.getInt("statePlay_object", DEF_OBJECT);
538
    mSize       = preferences.getInt("statePlay_size"  , DEF_SIZE  );
539
    }
540

    
541
///////////////////////////////////////////////////////////////////////////////////////////////////
542

    
543
  public boolean setObjectAndSize(RubikActivity act, RubikObjectList obj, int size)
544
    {
545
    if( mObject!=obj.ordinal() || mSize != size )
546
      {
547
      boolean success = false;
548

    
549
      for( int s: obj.getSizes() )
550
        if( s==size )
551
          {
552
          success = true;
553
          break;
554
          }
555

    
556
      if( success )
557
        {
558
        mObject = obj.ordinal();
559
        mSize   = size;
560

    
561
        if( mPlayLayout!=null ) adjustLevels(act);
562
        }
563

    
564
      return success;
565
      }
566

    
567
    return true;
568
    }
569

    
570
///////////////////////////////////////////////////////////////////////////////////////////////////
571

    
572
  private void adjustLevels(final RubikActivity act)
573
    {
574
    int sizeIndex = RubikObjectList.getSizeIndex(mObject,mSize);
575
    int maxLevel = RubikObjectList.getMaxLevel(mObject, sizeIndex);
576
    String[] levels = new String[maxLevel];
577

    
578
    for(int i=0; i<maxLevel; i++)
579
      {
580
      levels[i] = act.getString(R.string.lv_placeholder,i+1);
581
      }
582

    
583
    if( mLevelValue>maxLevel ) mLevelValue=1;
584

    
585
    float width = act.getScreenWidthInPixels();
586
    int margin  = (int)(width*RubikActivity.MARGIN);
587
    int padding = (int)(width*RubikActivity.PADDING);
588

    
589
    LinearLayout.LayoutParams pM = new LinearLayout.LayoutParams( mPlayLayoutWidth - 2*padding, (int)mMenuItemSize);
590
    pM.setMargins(margin, 0, margin, margin);
591
    LinearLayout.LayoutParams pT = new LinearLayout.LayoutParams( mPlayLayoutWidth - 2*padding, (int)mMenuItemSize);
592
    pT.setMargins(margin, margin, margin, margin);
593
    LinearLayout.LayoutParams pB = new LinearLayout.LayoutParams( mPlayLayoutWidth - 2*padding, (int)mMenuItemSize);
594
    pB.setMargins(margin, margin, margin, 2*margin);
595

    
596
    mPlayLayout.removeAllViews();
597

    
598
    for(int i=0; i<maxLevel; i++)
599
      {
600
      final int but = i;
601
      Button button = new Button(act);
602
      button.setLayoutParams(i==0 ? pT : (i==maxLevel-1 ? pB : pM));
603
      button.setText(levels[i]);
604
      button.setTextSize(TypedValue.COMPLEX_UNIT_PX, mMenuTextSize);
605

    
606
      button.setOnClickListener( new View.OnClickListener()
607
        {
608
        @Override
609
        public void onClick(View v)
610
          {
611
          mPlayPopup.dismiss();
612
          mLevelValue = but+1;
613
          act.getPreRender().scrambleObject(mLevelValue);
614
          }
615
        });
616

    
617
      mPlayLayout.addView(button);
618
      }
619
    }
620

    
621
///////////////////////////////////////////////////////////////////////////////////////////////////
622

    
623
  int getLevel()
624
    {
625
    return mLevelValue;
626
    }
627

    
628
///////////////////////////////////////////////////////////////////////////////////////////////////
629

    
630
  public void addMove(int axis, int row, int angle)
631
    {
632
    mMoves.add(new Move(axis,row,angle));
633
    }
634

    
635
///////////////////////////////////////////////////////////////////////////////////////////////////
636

    
637
  public int getObject()
638
    {
639
    return mObject;
640
    }
641

    
642
///////////////////////////////////////////////////////////////////////////////////////////////////
643

    
644
  public int getSize()
645
    {
646
    return mSize;
647
    }
648

    
649
///////////////////////////////////////////////////////////////////////////////////////////////////
650

    
651
  public void onActionFinished(final long effectID)
652
    {
653
    mCanPrevMove = true;
654
    }
655
  }
(5-5/9)