Revision cc8ab8e3
Added by Leszek Koltunski almost 2 years ago
src/main/java/org/distorted/screens/RubikScreenPlay.java | ||
---|---|---|
22 | 22 |
import java.lang.ref.WeakReference; |
23 | 23 |
|
24 | 24 |
import android.app.Activity; |
25 |
import android.content.Context; |
|
26 | 25 |
import android.content.SharedPreferences; |
27 |
import android.content.res.Resources; |
|
28 |
import android.graphics.Color; |
|
29 |
import android.graphics.drawable.BitmapDrawable; |
|
30 |
import android.os.Build; |
|
31 |
import android.os.Bundle; |
|
32 | 26 |
import android.util.TypedValue; |
33 |
import android.view.Gravity; |
|
34 | 27 |
import android.view.LayoutInflater; |
35 | 28 |
import android.view.View; |
36 | 29 |
import android.view.ViewGroup; |
37 |
import android.widget.Button; |
|
38 | 30 |
import android.widget.GridLayout; |
39 | 31 |
import android.widget.ImageButton; |
40 | 32 |
import android.widget.LinearLayout; |
41 |
import android.widget.PopupWindow; |
|
42 | 33 |
import android.widget.RelativeLayout; |
43 | 34 |
import android.widget.ScrollView; |
44 | 35 |
import android.widget.TextView; |
45 | 36 |
|
46 |
import org.distorted.config.ConfigActivity; |
|
47 | 37 |
import org.distorted.dialogs.RubikDialogUpdates; |
48 | 38 |
import org.distorted.external.RubikNetwork; |
49 | 39 |
import org.distorted.external.RubikUpdates; |
50 |
import org.distorted.main.RubikRenderer; |
|
51 |
import org.distorted.objectlib.main.ObjectControl; |
|
52 | 40 |
|
53 | 41 |
import org.distorted.main.R; |
54 | 42 |
import org.distorted.main.RubikActivity; |
55 | 43 |
import org.distorted.dialogs.RubikDialogAbout; |
56 |
import org.distorted.dialogs.RubikDialogPattern; |
|
57 |
import org.distorted.dialogs.RubikDialogScores; |
|
58 |
import org.distorted.dialogs.RubikDialogTutorial; |
|
59 |
import org.distorted.helpers.TransparentButton; |
|
60 | 44 |
import org.distorted.helpers.TransparentImageButton; |
61 |
import org.distorted.external.RubikScores; |
|
62 | 45 |
import org.distorted.objects.RubikObject; |
63 | 46 |
import org.distorted.objects.RubikObjectList; |
64 | 47 |
|
65 |
import static android.view.View.inflate; |
|
66 |
|
|
67 | 48 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
68 | 49 |
|
69 | 50 |
public class RubikScreenPlay extends RubikScreenAbstract implements RubikNetwork.Updatee |
... | ... | |
71 | 52 |
public static final int NUM_COLUMNS = 5; |
72 | 53 |
public static final int LEVELS_SHOWN = 10; |
73 | 54 |
|
74 |
private static final float LAST_BUTTON = 1.5f; |
|
75 |
private static final int[] mLocation = new int[2]; |
|
76 |
|
|
77 | 55 |
private TransparentImageButton mAboutButton, mExitButton; |
78 |
private ImageButton mUpdatesButton; |
|
79 |
// private PopupWindow mObjectPopup, mMenuPopup, mPlayPopup; |
|
80 |
private LinearLayout mPlayLayout; |
|
81 | 56 |
private TextView mBubbleUpdates; |
82 | 57 |
private int mCurrentBubbleNumber; |
83 |
private int mObjectSize, mMenuLayoutWidth, mMenuLayoutHeight, mPlayLayoutWidth; |
|
84 | 58 |
private int mLevelValue; |
85 |
private float mButtonSize, mMenuItemSize, mMenuTextSize; |
|
86 |
private int mColCount, mRowCount, mMaxRowCount; |
|
87 |
private int mUpperBarHeight, mLowerBarHeight; |
|
88 |
private boolean mShouldReactToEndOfScrambling; |
|
89 |
private int mBottomHeight; |
|
90 |
private float mScreenWidth, mScreenHeight; |
|
59 |
private int mColCount, mRowCount; |
|
60 |
private float mScreenWidth; |
|
91 | 61 |
private WeakReference<RubikActivity> mWeakAct; |
92 | 62 |
|
93 | 63 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
107 | 77 |
mWeakAct = new WeakReference<>(act); |
108 | 78 |
int numObjects = RubikObjectList.getNumObjects(); |
109 | 79 |
mScreenWidth = act.getScreenWidthInPixels(); |
110 |
mScreenHeight= act.getScreenHeightInPixels(); |
|
111 |
mUpperBarHeight = act.getHeightUpperBar(); |
|
112 |
mLowerBarHeight = act.getHeightLowerBar(); |
|
113 |
|
|
114 |
mMenuTextSize = mScreenWidth*RubikActivity.MENU_MED_TEXT_SIZE; |
|
115 |
mButtonSize = mScreenWidth*RubikActivity.BUTTON_TEXT_SIZE; |
|
116 |
mMenuItemSize = mScreenWidth*RubikActivity.MENU_ITEM_SIZE; |
|
80 |
int screenHeight= act.getScreenHeightInPixels(); |
|
81 |
int upperBarHeight = act.getHeightUpperBar(); |
|
82 |
int lowerBarHeight = act.getHeightLowerBar(); |
|
117 | 83 |
|
118 | 84 |
mRowCount = (numObjects + NUM_COLUMNS-1) / NUM_COLUMNS; |
119 | 85 |
mColCount = NUM_COLUMNS; |
... | ... | |
161 | 127 |
hiddenView.removeAllViews(); |
162 | 128 |
|
163 | 129 |
ViewGroup.LayoutParams paramsMid = hiddenView.getLayoutParams(); |
164 |
paramsMid.height = (int)(mScreenHeight-mUpperBarHeight-mLowerBarHeight);
|
|
130 |
paramsMid.height = (int)(screenHeight-upperBarHeight-lowerBarHeight);
|
|
165 | 131 |
hiddenView.setLayoutParams(paramsMid); |
166 | 132 |
|
167 | 133 |
ScrollView scroll = (ScrollView)inflater.inflate(R.layout.popup_object_simple, null); |
168 | 134 |
hiddenView.addView(scroll); |
169 | 135 |
|
170 |
setupScrollingObjects(act,scroll,mScreenWidth,mScreenHeight);
|
|
136 |
setupScrollingObjects(act,scroll,mScreenWidth); |
|
171 | 137 |
} |
172 | 138 |
|
173 | 139 |
////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
214 | 180 |
TypedValue value = new TypedValue(); |
215 | 181 |
act.getTheme().resolveAttribute(android.R.attr.selectableItemBackgroundBorderless, value, true); |
216 | 182 |
final int icon = RubikActivity.getDrawable(R.drawable.ui_small_download,R.drawable.ui_medium_download, R.drawable.ui_big_download, R.drawable.ui_huge_download); |
217 |
mUpdatesButton = relLayout.findViewById(R.id.buttonUpdates);
|
|
218 |
mUpdatesButton.setImageResource(icon);
|
|
219 |
mUpdatesButton.setBackgroundResource(value.resourceId);
|
|
183 |
ImageButton updatesButton = relLayout.findViewById(R.id.buttonUpdates);
|
|
184 |
updatesButton.setImageResource(icon);
|
|
185 |
updatesButton.setBackgroundResource(value.resourceId);
|
|
220 | 186 |
|
221 |
mUpdatesButton.setOnClickListener( new View.OnClickListener()
|
|
187 |
updatesButton.setOnClickListener( new View.OnClickListener()
|
|
222 | 188 |
{ |
223 | 189 |
@Override |
224 | 190 |
public void onClick(View v) |
... | ... | |
237 | 203 |
|
238 | 204 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
239 | 205 |
|
240 |
private void setupScrollingObjects(final RubikActivity act, final ScrollView view, final float width, final float height)
|
|
206 |
private void setupScrollingObjects(final RubikActivity act, final ScrollView view, final float width) |
|
241 | 207 |
{ |
242 |
int margin = (int)(width*RubikActivity.LARGE_MARGIN); |
|
243 |
int cubeWidth = (int)(width/NUM_COLUMNS) - 2*margin; |
|
244 |
|
|
245 |
mObjectSize = (int)(cubeWidth + 2*margin + 0.5f); |
|
246 |
mMaxRowCount = (int)((height-mUpperBarHeight-mLowerBarHeight)/mObjectSize); |
|
208 |
int margin = (int)(width*RubikActivity.LARGE_MARGIN); |
|
209 |
int cubeSize = (int)(width/NUM_COLUMNS) - 2*margin; |
|
247 | 210 |
|
248 | 211 |
GridLayout objectGrid = view.findViewById(R.id.objectGrid); |
249 | 212 |
|
... | ... | |
293 | 256 |
params.leftMargin = margin; |
294 | 257 |
params.rightMargin = margin; |
295 | 258 |
|
296 |
params.width = cubeWidth; |
|
297 |
params.height= cubeWidth; |
|
298 |
|
|
299 |
nextInRow[row]++; |
|
300 |
|
|
301 |
objectGrid.addView(button, params); |
|
302 |
} |
|
303 |
} |
|
304 |
|
|
305 |
////////////////////////////////////////////////////////////////////////////////////////////////// |
|
306 |
/* |
|
307 |
private void setupObjectButton(final RubikActivity act, final float width) |
|
308 |
{ |
|
309 |
final int margin = (int)(width*RubikActivity.SMALL_MARGIN); |
|
310 |
final int lMargin = (int)(width*RubikActivity.LARGE_MARGIN); |
|
311 |
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); |
|
312 |
LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,LinearLayout.LayoutParams.MATCH_PARENT,1.0f); |
|
313 |
mObjButton = new TransparentImageButton(act, icon, TransparentImageButton.GRAVITY_MIDDLE, params); |
|
314 |
|
|
315 |
mObjButton.setOnClickListener( new View.OnClickListener() |
|
316 |
{ |
|
317 |
@Override |
|
318 |
public void onClick(View view) |
|
319 |
{ |
|
320 |
if( mObjectPopup==null ) |
|
321 |
{ |
|
322 |
float width = act.getScreenWidthInPixels(); |
|
323 |
float height= act.getScreenHeightInPixels(); |
|
324 |
setupObjectWindow(act,width,height); |
|
325 |
} |
|
326 |
|
|
327 |
if( act.getControl().isUINotBlocked()) |
|
328 |
{ |
|
329 |
int rowCount = Math.min(mMaxRowCount,mRowCount); |
|
330 |
View popupView = mObjectPopup.getContentView(); |
|
331 |
popupView.setSystemUiVisibility(RubikActivity.FLAGS); |
|
332 |
displayPopup(act,view,mObjectPopup,mObjectSize*mColCount,mObjectSize*rowCount+mBottomHeight+2*lMargin+5*margin,margin,margin); |
|
333 |
} |
|
334 |
} |
|
335 |
}); |
|
336 |
} |
|
337 |
|
|
338 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
339 |
|
|
340 |
private void setupPlayButton(final RubikActivity act, final float width) |
|
341 |
{ |
|
342 |
final int margin = (int)(width*RubikActivity.SMALL_MARGIN); |
|
343 |
|
|
344 |
mPlayButton = new TransparentButton(act, R.string.play, mButtonSize); |
|
345 |
|
|
346 |
mPlayButton.setOnClickListener( new View.OnClickListener() |
|
347 |
{ |
|
348 |
@Override |
|
349 |
public void onClick(View view) |
|
350 |
{ |
|
351 |
if( mPlayPopup==null ) |
|
352 |
{ |
|
353 |
float width = act.getScreenWidthInPixels(); |
|
354 |
setupPlayWindow(act,width); |
|
355 |
} |
|
356 |
|
|
357 |
if( act.getControl().isUINotBlocked()) |
|
358 |
{ |
|
359 |
adjustSolvedIcons(); |
|
360 |
float height= act.getScreenHeightInPixels(); |
|
361 |
final int maxHeight= (int)(0.9f*(height-mUpperBarHeight) ); |
|
362 |
View popupView = mPlayPopup.getContentView(); |
|
363 |
popupView.setSystemUiVisibility(RubikActivity.FLAGS); |
|
364 |
final int object = RubikObjectList.getCurrObject(); |
|
365 |
final int dbLevel = RubikObjectList.getDBLevel(object); |
|
366 |
final int levelsShown = Math.min(dbLevel,LEVELS_SHOWN); |
|
367 |
final int popupHeight = (int)(levelsShown*(mMenuItemSize+margin)+3*margin+mMenuItemSize*(LAST_BUTTON-1.0f)); |
|
368 |
final int realHeight = Math.min(popupHeight,maxHeight); |
|
369 |
displayPopup(act,view,mPlayPopup,mPlayLayoutWidth,realHeight,margin,margin); |
|
370 |
} |
|
371 |
} |
|
372 |
}); |
|
373 |
} |
|
374 |
|
|
375 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
376 |
|
|
377 |
private void setupMenuButton(final RubikActivity act, final float width) |
|
378 |
{ |
|
379 |
final int margin = (int)(width*RubikActivity.SMALL_MARGIN); |
|
380 |
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); |
|
381 |
LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,LinearLayout.LayoutParams.MATCH_PARENT,1.0f); |
|
382 |
mMenuButton = new TransparentImageButton(act, icon, TransparentImageButton.GRAVITY_MIDDLE, params); |
|
383 |
|
|
384 |
mMenuButton.setOnClickListener( new View.OnClickListener() |
|
385 |
{ |
|
386 |
@Override |
|
387 |
public void onClick(View view) |
|
388 |
{ |
|
389 |
if( mMenuPopup==null ) |
|
390 |
{ |
|
391 |
float width = act.getScreenWidthInPixels(); |
|
392 |
setupMenuWindow(act,width); |
|
393 |
} |
|
394 |
|
|
395 |
if( act.getControl().isUINotBlocked()) |
|
396 |
{ |
|
397 |
View popupView = mMenuPopup.getContentView(); |
|
398 |
popupView.setSystemUiVisibility(RubikActivity.FLAGS); |
|
399 |
displayPopup(act,view,mMenuPopup,mMenuLayoutWidth,mMenuLayoutHeight,(int)(-width/12),margin); |
|
400 |
} |
|
401 |
} |
|
402 |
}); |
|
403 |
} |
|
404 |
|
|
405 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
406 |
|
|
407 |
private void setupObjectWindow(final RubikActivity act, final float width, final float height) |
|
408 |
{ |
|
409 |
int cubeWidth = (int)(width/9); |
|
410 |
int margin = (int)(width*RubikActivity.LARGE_MARGIN); |
|
411 |
mObjectSize = (int)(cubeWidth + 2*margin + 0.5f); |
|
412 |
mMaxRowCount = (int)((height-1.8f*mUpperBarHeight)/mObjectSize); |
|
413 |
|
|
414 |
LinearLayout view = (LinearLayout)inflate( act, R.layout.popup_object, null); |
|
415 |
GridLayout objectGrid = view.findViewById(R.id.objectGrid); |
|
416 |
|
|
417 |
GridLayout.Spec[] rowSpecs = new GridLayout.Spec[mRowCount]; |
|
418 |
GridLayout.Spec[] colSpecs = new GridLayout.Spec[mColCount]; |
|
419 |
|
|
420 |
objectGrid.setColumnCount(mColCount); |
|
421 |
objectGrid.setRowCount(mRowCount); |
|
422 |
|
|
423 |
mObjectPopup = new PopupWindow(act); |
|
424 |
mObjectPopup.setFocusable(true); |
|
425 |
mObjectPopup.setContentView(view); |
|
426 |
|
|
427 |
int[] nextInRow = new int[mRowCount]; |
|
428 |
|
|
429 |
for(int row=0; row<mRowCount; row++) |
|
430 |
{ |
|
431 |
rowSpecs[row] = GridLayout.spec(row); |
|
432 |
nextInRow[row]= 0; |
|
433 |
} |
|
434 |
for(int col=0; col<mColCount; col++) |
|
435 |
{ |
|
436 |
colSpecs[col] = GridLayout.spec(col); |
|
437 |
} |
|
438 |
|
|
439 |
int numObjects = RubikObjectList.getNumObjects(); |
|
440 |
|
|
441 |
for(int object=0; object<numObjects; object++) |
|
442 |
{ |
|
443 |
final int ordinal = object; |
|
444 |
final RubikObject rObject = RubikObjectList.getObject(object); |
|
445 |
int row = object/NUM_COLUMNS; |
|
446 |
ImageButton button = new ImageButton(act); |
|
447 |
if( rObject!=null ) rObject.setIconTo(act,button); |
|
448 |
|
|
449 |
button.setOnClickListener( new View.OnClickListener() |
|
450 |
{ |
|
451 |
@Override |
|
452 |
public void onClick(View v) |
|
453 |
{ |
|
454 |
// TODO |
|
455 |
} |
|
456 |
}); |
|
457 |
|
|
458 |
GridLayout.LayoutParams params = new GridLayout.LayoutParams(rowSpecs[row],colSpecs[nextInRow[row]]); |
|
459 |
params.bottomMargin = margin; |
|
460 |
params.topMargin = margin; |
|
461 |
params.leftMargin = margin; |
|
462 |
params.rightMargin = margin; |
|
463 |
|
|
464 |
params.width = cubeWidth; |
|
465 |
params.height= cubeWidth; |
|
259 |
params.width = cubeSize; |
|
260 |
params.height= cubeSize; |
|
466 | 261 |
|
467 | 262 |
nextInRow[row]++; |
468 | 263 |
|
... | ... | |
470 | 265 |
} |
471 | 266 |
} |
472 | 267 |
|
473 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
474 |
|
|
475 |
private void setupBottomLayout(final RubikActivity act, final RelativeLayout layout) |
|
476 |
{ |
|
477 |
int iconT = RubikActivity.getDrawable(R.drawable.ui_small_tutorial,R.drawable.ui_medium_tutorial, R.drawable.ui_big_tutorial, R.drawable.ui_huge_tutorial); |
|
478 |
int iconD = RubikActivity.getDrawable(R.drawable.ui_small_download,R.drawable.ui_medium_download, R.drawable.ui_big_download, R.drawable.ui_huge_download); |
|
479 |
int iconI = RubikActivity.getDrawable(R.drawable.ui_small_info,R.drawable.ui_medium_info, R.drawable.ui_big_info, R.drawable.ui_huge_info); |
|
480 |
|
|
481 |
ImageButton buttonTut = layout.findViewById(R.id.buttonTut); |
|
482 |
ImageButton buttonDow = layout.findViewById(R.id.buttonDow); |
|
483 |
ImageButton buttonInf = layout.findViewById(R.id.buttonInf); |
|
484 |
|
|
485 |
buttonTut.setImageResource(iconT); |
|
486 |
buttonDow.setImageResource(iconD); |
|
487 |
buttonInf.setImageResource(iconI); |
|
488 |
|
|
489 |
Resources res = act.getResources(); |
|
490 |
BitmapDrawable bd = (BitmapDrawable)res.getDrawable(iconI); |
|
491 |
mBottomHeight = bd.getIntrinsicHeight(); |
|
492 |
|
|
493 |
TypedValue outValue = new TypedValue(); |
|
494 |
act.getTheme().resolveAttribute(android.R.attr.selectableItemBackgroundBorderless, outValue, true); |
|
495 |
buttonTut.setBackgroundResource(outValue.resourceId); |
|
496 |
buttonDow.setBackgroundResource(outValue.resourceId); |
|
497 |
buttonInf.setBackgroundResource(outValue.resourceId); |
|
498 |
|
|
499 |
buttonTut.setOnClickListener( new View.OnClickListener() |
|
500 |
{ |
|
501 |
@Override |
|
502 |
public void onClick(View v) |
|
503 |
{ |
|
504 |
if( mObjectPopup!=null ) mObjectPopup.dismiss(); |
|
505 |
RubikDialogTutorial tDiag = new RubikDialogTutorial(); |
|
506 |
tDiag.show( act.getSupportFragmentManager(), RubikDialogTutorial.getDialogTag() ); |
|
507 |
} |
|
508 |
}); |
|
509 |
|
|
510 |
buttonDow.setOnClickListener( new View.OnClickListener() |
|
511 |
{ |
|
512 |
@Override |
|
513 |
public void onClick(View v) |
|
514 |
{ |
|
515 |
if( mObjectPopup!=null ) mObjectPopup.dismiss(); |
|
516 |
RubikDialogUpdates uDiag = new RubikDialogUpdates(); |
|
517 |
uDiag.show( act.getSupportFragmentManager(), RubikDialogUpdates.getDialogTag() ); |
|
518 |
} |
|
519 |
}); |
|
520 |
|
|
521 |
buttonInf.setOnClickListener( new View.OnClickListener() |
|
522 |
{ |
|
523 |
@Override |
|
524 |
public void onClick(View v) |
|
525 |
{ |
|
526 |
if( mObjectPopup!=null ) mObjectPopup.dismiss(); |
|
527 |
int currObject = RubikObjectList.getCurrObject(); |
|
528 |
act.switchConfig(currObject); |
|
529 |
} |
|
530 |
}); |
|
531 |
|
|
532 |
mBubbleUpdates = layout.findViewById(R.id.bubbleUpdates); |
|
533 |
mBubbleUpdates.setVisibility(View.INVISIBLE); |
|
534 |
|
|
535 |
RubikNetwork network = RubikNetwork.getInstance(); |
|
536 |
network.signUpForUpdates(this); |
|
537 |
} |
|
538 |
|
|
539 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
540 |
|
|
541 |
private void setupMenuWindow(final RubikActivity act, final float width) |
|
542 |
{ |
|
543 |
LayoutInflater layoutInflater = (LayoutInflater)act.getSystemService(Context.LAYOUT_INFLATER_SERVICE); |
|
544 |
final View layout = layoutInflater.inflate(R.layout.popup_menu, null); |
|
545 |
LinearLayout menuLayout = layout.findViewById(R.id.menuGrid); |
|
546 |
|
|
547 |
mMenuPopup = new PopupWindow(act); |
|
548 |
mMenuPopup.setContentView(layout); |
|
549 |
mMenuPopup.setFocusable(true); |
|
550 |
int margin = (int)(width*RubikActivity.SMALL_MARGIN); |
|
551 |
int padding = (int)(width*RubikActivity.PADDING); |
|
552 |
|
|
553 |
mMenuLayoutWidth = (int)(width/2); |
|
554 |
mMenuLayoutHeight= (int)(2*margin + NUM_BUTTONS*(mMenuItemSize+margin)); |
|
555 |
|
|
556 |
LinearLayout.LayoutParams p = new LinearLayout.LayoutParams( mMenuLayoutWidth - 2*padding, (int)mMenuItemSize); |
|
557 |
|
|
558 |
for(int i=0; i<NUM_BUTTONS; i++) |
|
559 |
{ |
|
560 |
final int but = i; |
|
561 |
Button button = new Button(act); |
|
562 |
button.setLayoutParams(p); |
|
563 |
button.setText(BUTTON_LABELS[i]); |
|
564 |
button.setTextSize(TypedValue.COMPLEX_UNIT_PX, mMenuTextSize); |
|
565 |
|
|
566 |
button.setOnClickListener( new View.OnClickListener() |
|
567 |
{ |
|
568 |
@Override |
|
569 |
public void onClick(View v) |
|
570 |
{ |
|
571 |
mMenuPopup.dismiss(); |
|
572 |
MenuAction(act,but); |
|
573 |
} |
|
574 |
}); |
|
575 |
|
|
576 |
menuLayout.addView(button); |
|
577 |
} |
|
578 |
} |
|
579 |
|
|
580 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
581 |
|
|
582 |
private void setupPlayWindow(final RubikActivity act, final float width) |
|
583 |
{ |
|
584 |
LayoutInflater layoutInflater = (LayoutInflater)act.getSystemService(Context.LAYOUT_INFLATER_SERVICE); |
|
585 |
final View layout = layoutInflater.inflate(R.layout.popup_play, null); |
|
586 |
mPlayLayout = layout.findViewById(R.id.playGrid); |
|
587 |
|
|
588 |
mPlayLayoutWidth = (int)(width*0.4f); |
|
589 |
|
|
590 |
mPlayPopup = new PopupWindow(act); |
|
591 |
mPlayPopup.setContentView(layout); |
|
592 |
mPlayPopup.setFocusable(true); |
|
593 |
|
|
594 |
adjustLevels(act); |
|
595 |
} |
|
596 |
|
|
597 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
598 |
|
|
599 |
private void MenuAction(RubikActivity act, int button) |
|
600 |
{ |
|
601 |
switch(button) |
|
602 |
{ |
|
603 |
case 0: Bundle sBundle = new Bundle(); |
|
604 |
int currObject = RubikObjectList.getCurrObject(); |
|
605 |
sBundle.putInt("tab", currObject ); |
|
606 |
sBundle.putBoolean("submitting", false); |
|
607 |
RubikDialogScores scores = new RubikDialogScores(); |
|
608 |
scores.setArguments(sBundle); |
|
609 |
scores.show(act.getSupportFragmentManager(), null); |
|
610 |
break; |
|
611 |
case 1: RubikDialogPattern pDiag = new RubikDialogPattern(); |
|
612 |
pDiag.show( act.getSupportFragmentManager(), RubikDialogPattern.getDialogTag() ); |
|
613 |
break; |
|
614 |
case 2: ScreenList.switchScreen(act, ScreenList.SVER); |
|
615 |
break; |
|
616 |
case 3: RubikDialogTutorial tDiag = new RubikDialogTutorial(); |
|
617 |
tDiag.show( act.getSupportFragmentManager(), RubikDialogTutorial.getDialogTag() ); |
|
618 |
break; |
|
619 |
case 4: act.switchToBandagedCreator(); |
|
620 |
break; |
|
621 |
case 5: RubikDialogAbout aDiag = new RubikDialogAbout(); |
|
622 |
aDiag.show(act.getSupportFragmentManager(), null); |
|
623 |
break; |
|
624 |
} |
|
625 |
} |
|
626 |
|
|
627 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
628 |
|
|
629 |
void setupSolveButton(final RubikActivity act) |
|
630 |
{ |
|
631 |
int icon = RubikActivity.getDrawable(R.drawable.ui_small_cube_solve_new,R.drawable.ui_medium_cube_solve_new, R.drawable.ui_big_cube_solve_new, R.drawable.ui_huge_cube_solve_new); |
|
632 |
LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,LinearLayout.LayoutParams.MATCH_PARENT,1.0f); |
|
633 |
mSolveButton = new TransparentImageButton(act, icon, TransparentImageButton.GRAVITY_END,params); |
|
634 |
|
|
635 |
mSolveButton.setOnClickListener( new View.OnClickListener() |
|
636 |
{ |
|
637 |
@Override |
|
638 |
public void onClick(View v) |
|
639 |
{ |
|
640 |
act.getControl().solveObject(); |
|
641 |
mMovesController.clearMoves(act); |
|
642 |
} |
|
643 |
}); |
|
644 |
} |
|
645 |
|
|
646 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
647 |
|
|
648 |
private void setupScrambleButton(final RubikActivity act) |
|
649 |
{ |
|
650 |
int icon = RubikActivity.getDrawable(R.drawable.ui_small_cube_scramble_new,R.drawable.ui_medium_cube_scramble_new, R.drawable.ui_big_cube_scramble_new, R.drawable.ui_huge_cube_scramble_new); |
|
651 |
LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT,LinearLayout.LayoutParams.MATCH_PARENT,1.0f); |
|
652 |
mScrambleButton = new TransparentImageButton(act, icon, TransparentImageButton.GRAVITY_START, params); |
|
653 |
|
|
654 |
mScrambleButton.setOnClickListener( new View.OnClickListener() |
|
655 |
{ |
|
656 |
@Override |
|
657 |
public void onClick(View v) |
|
658 |
{ |
|
659 |
int currObject = RubikObjectList.getCurrObject(); |
|
660 |
RubikObject object = RubikObjectList.getObject(currObject); |
|
661 |
int numScrambles = object==null ? 0 : object.getNumScramble(); |
|
662 |
mShouldReactToEndOfScrambling = false; |
|
663 |
act.getControl().scrambleObject(numScrambles); |
|
664 |
} |
|
665 |
}); |
|
666 |
} |
|
667 |
*/ |
|
668 | 268 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
669 | 269 |
|
670 | 270 |
public void savePreferences(SharedPreferences.Editor editor) |
... | ... | |
679 | 279 |
mLevelValue = preferences.getInt("play_LevelValue", 0); |
680 | 280 |
} |
681 | 281 |
|
682 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
683 |
|
|
684 |
public void setCurrObject(RubikActivity act) |
|
685 |
{ |
|
686 |
if( mPlayLayout!=null ) adjustLevels(act); |
|
687 |
} |
|
688 |
|
|
689 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
690 |
// work around lame bugs in Android's version <= 10 pop-up and split-screen modes |
|
691 |
|
|
692 |
private void displayPopup(RubikActivity act, View view, PopupWindow window, int w, int h, int xoff, int yoff) |
|
693 |
{ |
|
694 |
View topLayout = act.findViewById(R.id.relativeLayout); |
|
695 |
boolean isFullScreen; |
|
696 |
|
|
697 |
if( topLayout!=null ) |
|
698 |
{ |
|
699 |
topLayout.getLocationOnScreen(mLocation); |
|
700 |
isFullScreen = (mLocation[1]==0); |
|
701 |
} |
|
702 |
else |
|
703 |
{ |
|
704 |
isFullScreen = true; |
|
705 |
} |
|
706 |
|
|
707 |
try |
|
708 |
{ |
|
709 |
// if on Android 11 or we are fullscreen |
|
710 |
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R || isFullScreen ) |
|
711 |
{ |
|
712 |
window.showAsDropDown(view, xoff, yoff, Gravity.CENTER); |
|
713 |
window.update(view, w, h); |
|
714 |
} |
|
715 |
else // Android 10 or below in pop-up mode or split-screen mode |
|
716 |
{ |
|
717 |
view.getLocationOnScreen(mLocation); |
|
718 |
int width = view.getWidth(); |
|
719 |
int height = view.getHeight(); |
|
720 |
int x = mLocation[0]+(width-w)/2; |
|
721 |
int y = mLocation[1]+height+yoff; |
|
722 |
|
|
723 |
window.showAsDropDown(view); |
|
724 |
window.update(x,y,w,h); |
|
725 |
} |
|
726 |
} |
|
727 |
catch( IllegalArgumentException iae ) |
|
728 |
{ |
|
729 |
// ignore, this means window is 'not attached to window manager' - |
|
730 |
// which most probably is because we are already exiting the app. |
|
731 |
} |
|
732 |
} |
|
733 |
|
|
734 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
735 |
|
|
736 |
private void adjustSolvedIcons() |
|
737 |
{ |
|
738 |
if( mPlayLayout!=null ) |
|
739 |
{ |
|
740 |
int currObject = RubikObjectList.getCurrObject(); |
|
741 |
int dbLevel = RubikObjectList.getDBLevel(currObject); |
|
742 |
int numLevel= Math.min(dbLevel, LEVELS_SHOWN); |
|
743 |
RubikScores scores = RubikScores.getInstance(); |
|
744 |
|
|
745 |
for(int i=0; i<numLevel; i++) |
|
746 |
{ |
|
747 |
int level = i<numLevel-1 ? i+1 : dbLevel; |
|
748 |
Button button = (Button)mPlayLayout.getChildAt(i); |
|
749 |
int icon = scores.isSolved(currObject, level-1) ? R.drawable.ui_solved : R.drawable.ui_notsolved; |
|
750 |
button.setCompoundDrawablesWithIntrinsicBounds(icon,0,0,0); |
|
751 |
} |
|
752 |
} |
|
753 |
} |
|
754 |
|
|
755 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
756 |
|
|
757 |
private void adjustLevels(final RubikActivity act) |
|
758 |
{ |
|
759 |
int currObject = RubikObjectList.getCurrObject(); |
|
760 |
int dbLevel = RubikObjectList.getDBLevel(currObject); |
|
761 |
RubikObject object = RubikObjectList.getObject(currObject); |
|
762 |
int numScrambles = object==null ? 0 : object.getNumScramble(); |
|
763 |
int numLevel = Math.min(dbLevel, LEVELS_SHOWN); |
|
764 |
String[] levels = new String[numLevel]; |
|
765 |
|
|
766 |
for(int i=0; i<numLevel-1; i++) |
|
767 |
{ |
|
768 |
levels[i] = act.getString(R.string.lv_placeholder,i+1); |
|
769 |
} |
|
770 |
|
|
771 |
if( numLevel>0 ) |
|
772 |
{ |
|
773 |
levels[numLevel-1] = act.getString(R.string.level_full); |
|
774 |
} |
|
775 |
|
|
776 |
if( mLevelValue>dbLevel || mLevelValue<1 || |
|
777 |
(mLevelValue<dbLevel || mLevelValue>LEVELS_SHOWN ) ) |
|
778 |
{ |
|
779 |
mLevelValue=1; |
|
780 |
} |
|
781 |
|
|
782 |
float width = act.getScreenWidthInPixels(); |
|
783 |
int margin = (int)(width*RubikActivity.SMALL_MARGIN); |
|
784 |
int padding = (int)(width*RubikActivity.PADDING); |
|
785 |
int butWidth = mPlayLayoutWidth - 2*padding; |
|
786 |
int butHeight= (int)mMenuItemSize; |
|
787 |
int lastButH = (int)(mMenuItemSize*LAST_BUTTON) ; |
|
788 |
|
|
789 |
LinearLayout.LayoutParams pM = new LinearLayout.LayoutParams( butWidth, butHeight ); |
|
790 |
pM.setMargins(margin, 0, margin, margin); |
|
791 |
LinearLayout.LayoutParams pT = new LinearLayout.LayoutParams( butWidth, butHeight ); |
|
792 |
pT.setMargins(margin, margin, margin, margin); |
|
793 |
LinearLayout.LayoutParams pB = new LinearLayout.LayoutParams( butWidth, lastButH ); |
|
794 |
pB.setMargins(margin, margin, margin, 2*margin); |
|
795 |
|
|
796 |
mPlayLayout.removeAllViews(); |
|
797 |
|
|
798 |
RubikScores scores = RubikScores.getInstance(); |
|
799 |
|
|
800 |
for(int i=0; i<numLevel; i++) |
|
801 |
{ |
|
802 |
final int level = i<numLevel-1 ? i+1 : dbLevel; |
|
803 |
final int scrambles = i<numLevel-1 ? i+1 : numScrambles; |
|
804 |
Button button = new Button(act); |
|
805 |
button.setLayoutParams(i==0 ? pT : (i==numLevel-1 ? pB : pM)); |
|
806 |
button.setText(levels[i]); |
|
807 |
button.setTextSize(TypedValue.COMPLEX_UNIT_PX, mMenuTextSize); |
|
808 |
|
|
809 |
int icon = scores.isSolved(currObject, level-1) ? R.drawable.ui_solved : R.drawable.ui_notsolved; |
|
810 |
button.setCompoundDrawablesWithIntrinsicBounds(icon,0,0,0); |
|
811 |
|
|
812 |
button.setOnClickListener( new View.OnClickListener() |
|
813 |
{ |
|
814 |
@Override |
|
815 |
public void onClick(View v) |
|
816 |
{ |
|
817 |
ObjectControl control = act.getControl(); |
|
818 |
|
|
819 |
if(control.isUINotBlocked()) |
|
820 |
{ |
|
821 |
// if( mPlayPopup!=null ) mPlayPopup.dismiss(); |
|
822 |
mLevelValue = level; |
|
823 |
mShouldReactToEndOfScrambling = true; |
|
824 |
control.scrambleObject(scrambles); |
|
825 |
} |
|
826 |
} |
|
827 |
}); |
|
828 |
|
|
829 |
mPlayLayout.addView(button); |
|
830 |
} |
|
831 |
} |
|
832 |
|
|
833 | 282 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
834 | 283 |
|
835 | 284 |
public int getLevel() |
... | ... | |
839 | 288 |
|
840 | 289 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
841 | 290 |
|
842 |
public void recreatePopup()
|
|
291 |
public void recreateListOfObjects()
|
|
843 | 292 |
{ |
844 | 293 |
int numObjects = RubikObjectList.getNumObjects(); |
845 | 294 |
mRowCount = (numObjects + NUM_COLUMNS-1) / NUM_COLUMNS; |
... | ... | |
857 | 306 |
hiddenView.removeAllViews(); |
858 | 307 |
ScrollView scroll = (ScrollView)inflater.inflate(R.layout.popup_object_simple, null); |
859 | 308 |
hiddenView.addView(scroll); |
860 |
setupScrollingObjects(act,scroll,mScreenWidth,mScreenHeight);
|
|
309 |
setupScrollingObjects(act,scroll,mScreenWidth); |
|
861 | 310 |
|
862 | 311 |
mCurrentBubbleNumber--; |
863 | 312 |
updateNumberOfNewObjects(); |
... | ... | |
865 | 314 |
}); |
866 | 315 |
} |
867 | 316 |
|
868 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
869 |
|
|
870 |
public boolean shouldReactToEndOfScrambling() |
|
871 |
{ |
|
872 |
return mShouldReactToEndOfScrambling; |
|
873 |
} |
|
874 |
|
|
875 | 317 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
876 | 318 |
|
877 | 319 |
private void updateNumberOfNewObjects() |
Also available in: Unified diff
Progress witth new UI.