433 lines
15 KiB
Java
433 lines
15 KiB
Java
package de.vanitasvitae.enigmandroid.layout;
|
|
|
|
import android.app.AlertDialog;
|
|
import android.app.Dialog;
|
|
import android.content.DialogInterface;
|
|
import android.content.res.Resources;
|
|
import android.view.View;
|
|
import android.view.WindowManager;
|
|
import android.widget.Button;
|
|
import android.widget.Toast;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
|
|
import de.vanitasvitae.enigmandroid.MainActivity;
|
|
import de.vanitasvitae.enigmandroid.R;
|
|
import de.vanitasvitae.enigmandroid.enigma.EnigmaStateBundle;
|
|
|
|
/**
|
|
* Builder for the dialog that is used to plug the plugboard/wire the
|
|
* rewirable reflector.
|
|
* Copyright (C) 2015 Paul Schaub
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
* @author vanitasvitae
|
|
*/
|
|
class PluggableDialogBuilder
|
|
{
|
|
private ArrayList<ButtonWrapper> buttons;
|
|
private View dialogView;
|
|
private final MainActivity main;
|
|
private final EnigmaStateBundle state;
|
|
|
|
private boolean allowIncompleteConnections;
|
|
private Button positive;
|
|
|
|
private HashSet<Integer> colors;
|
|
|
|
private int previouslyPressedButton = -1;
|
|
|
|
/**
|
|
* Constructor that prepares layout and buttons.
|
|
* @param state EnigmaStateBundle from which dialog gets restored and which gets manipulated
|
|
*/
|
|
public PluggableDialogBuilder(EnigmaStateBundle state)
|
|
{
|
|
this.state = state;
|
|
main = (MainActivity) MainActivity.ActivitySingleton.getInstance().getActivity();
|
|
initializeLayout();
|
|
setButtonListeners();
|
|
}
|
|
|
|
/**
|
|
* Show dialog for the plugboard
|
|
*/
|
|
public void showDialogPlugboard()
|
|
{
|
|
allowIncompleteConnections = true;
|
|
restoreConfigurationPlugboard();
|
|
AlertDialog.Builder adb = new AlertDialog.Builder(main);
|
|
adb.setTitle(R.string.title_plugboard_dialog);
|
|
Dialog d = adb.setView(dialogView)
|
|
.setCancelable(true)
|
|
.setPositiveButton(R.string.dialog_positive, new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int id) {
|
|
int[] plugs = new int[26];
|
|
for (int i = 0; i < 26; i++) {
|
|
plugs[i] = buttons.get(i).getConnectedButton();
|
|
}
|
|
state.setConfigurationPlugboard(plugs);
|
|
main.onDialogFinished(state);
|
|
Toast.makeText(main.getApplication(), R.string.dialog_plugboard_set, Toast.LENGTH_SHORT).show();
|
|
}
|
|
})
|
|
.setNegativeButton(R.string.dialog_negative, new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int id) {
|
|
dialog.cancel();
|
|
Toast.makeText(main, R.string.dialog_abort,
|
|
Toast.LENGTH_SHORT).show();
|
|
}
|
|
}).create();
|
|
|
|
WindowManager.LayoutParams lp = new WindowManager.LayoutParams();
|
|
lp.copyFrom(d.getWindow().getAttributes());
|
|
lp.width = WindowManager.LayoutParams.MATCH_PARENT;
|
|
lp.height = WindowManager.LayoutParams.WRAP_CONTENT;
|
|
d.show();
|
|
d.getWindow().setAttributes(lp);
|
|
}
|
|
|
|
/**
|
|
* Show the dialog for the reflector. This can only be positively closed when all
|
|
* connections are made.
|
|
*/
|
|
public void showDialogReflector()
|
|
{
|
|
allowIncompleteConnections = false;
|
|
restoreConfigurationReflector();
|
|
AlertDialog.Builder adb = new AlertDialog.Builder(main);
|
|
adb.setTitle(R.string.title_reflector_dialog);
|
|
Dialog d = adb.setView(dialogView)
|
|
.setCancelable(true)
|
|
.setPositiveButton(R.string.dialog_positive, new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int id) {
|
|
int[] plugs = new int[26];
|
|
for (int i = 0; i < 26; i++) {
|
|
plugs[i] = buttons.get(i).getConnectedButton();
|
|
}
|
|
state.setConfigurationReflector(plugs);
|
|
main.onDialogFinished(state);
|
|
Toast.makeText(main.getApplication(), R.string.dialog_reflector_set, Toast.LENGTH_SHORT).show();
|
|
}
|
|
})
|
|
.setNegativeButton(R.string.dialog_negative, new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int id) {
|
|
dialog.cancel();
|
|
Toast.makeText(main, R.string.dialog_abort,
|
|
Toast.LENGTH_SHORT).show();
|
|
}
|
|
}).create();
|
|
|
|
WindowManager.LayoutParams lp = new WindowManager.LayoutParams();
|
|
lp.copyFrom(d.getWindow().getAttributes());
|
|
lp.width = WindowManager.LayoutParams.MATCH_PARENT;
|
|
lp.height = WindowManager.LayoutParams.WRAP_CONTENT;
|
|
d.show();
|
|
positive = ((AlertDialog)d).getButton(AlertDialog.BUTTON_POSITIVE);
|
|
if(!allConnectionsDone())
|
|
{
|
|
positive.setEnabled(false);
|
|
}
|
|
d.getWindow().setAttributes(lp);
|
|
}
|
|
|
|
/**
|
|
* Initialize array of buttons, initialize background-color hashset.
|
|
*/
|
|
private void initializeLayout()
|
|
{
|
|
buttons = new ArrayList<>();
|
|
dialogView = View.inflate(main, R.layout.dialog_plugs, null);
|
|
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.A),0));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.B),1));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.C),2));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.D),3));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.E),4));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.F),5));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.G),6));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.H),7));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.I),8));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.J),9));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.K),10));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.L),11));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.M),12));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.N),13));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.O),14));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.P),15));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.Q),16));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.R),17));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.S),18));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.T),19));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.U),20));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.V),21));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.W),22));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.X),23));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.Y),24));
|
|
buttons.add(new ButtonWrapper((Button) dialogView.findViewById(R.id.Z),25));
|
|
|
|
colors = new HashSet<>();
|
|
colors.add(R.drawable.button_orange);
|
|
colors.add(R.drawable.button_olive);
|
|
colors.add(R.drawable.button_blue);
|
|
colors.add(R.drawable.button_red);
|
|
colors.add(R.drawable.button_yellow);
|
|
colors.add(R.drawable.button_purple);
|
|
colors.add(R.drawable.button_green);
|
|
colors.add(R.drawable.button_cyan);
|
|
colors.add(R.drawable.button_berry);
|
|
colors.add(R.drawable.button_brown);
|
|
colors.add(R.drawable.button_pink);
|
|
colors.add(R.drawable.button_elder);
|
|
colors.add(R.drawable.button_black);
|
|
}
|
|
|
|
/**
|
|
* Set listeners for all buttons
|
|
*/
|
|
private void setButtonListeners()
|
|
{
|
|
for(int i=0; i<26; i++)
|
|
{
|
|
Button b = buttons.get(i).getButton();
|
|
final int id = i;
|
|
b.setOnClickListener(new View.OnClickListener() {
|
|
@Override
|
|
public void onClick(View v) {
|
|
buttonPressed(id);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check, whether all connections are done. If so, return true.
|
|
* return false otherwise
|
|
* @return boolean
|
|
*/
|
|
private boolean allConnectionsDone()
|
|
{
|
|
for(int i=0; i<buttons.size(); i++)
|
|
{
|
|
ButtonWrapper b = buttons.get(i);
|
|
if(b.getConnectedButton() == i || b.getConnectedButton() == -1) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* restore the connections according to the plugboard
|
|
*/
|
|
private void restoreConfigurationPlugboard()
|
|
{
|
|
restoreConfiguration(state.getConfigurationPlugboard());
|
|
}
|
|
|
|
/**
|
|
* restore the connections according to the reflector
|
|
*/
|
|
private void restoreConfigurationReflector()
|
|
{
|
|
restoreConfiguration(state.getConfigurationReflector());
|
|
}
|
|
|
|
/**
|
|
* Connect all the buttons according to c.
|
|
* @param c array of connections
|
|
*/
|
|
private void restoreConfiguration(int[] c)
|
|
{
|
|
for(int i=0; i<26; i++)
|
|
{
|
|
setPlug(i, c[i]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Connect button1 and button2. If two buttons got pressed afterwards and they are not the same
|
|
* they get connected. If one or both of them was connected beforehand, these connections get
|
|
* resolved. If both events come from the same button, the buttons connections (if any) get
|
|
* resolved.
|
|
* @param button1 first and
|
|
* @param button2 second button
|
|
*/
|
|
private void setPlug(int button1, int button2)
|
|
{
|
|
if(button1 == button2)
|
|
{
|
|
setButtonFree(buttons.get(button1).getConnectedButton());
|
|
setButtonFree(button1);
|
|
}
|
|
else
|
|
{
|
|
ButtonWrapper b1 = buttons.get(button1);
|
|
ButtonWrapper b2 = buttons.get(button2);
|
|
|
|
if (b1.getConnectedButton() != button1) {
|
|
setButtonFree(b1.getConnectedButton());
|
|
}
|
|
if (b2.getConnectedButton() != button2) {
|
|
setButtonFree(b2.getConnectedButton());
|
|
}
|
|
|
|
b1.setConnectedButton(button2);
|
|
b2.setConnectedButton(button1);
|
|
|
|
int res;
|
|
Iterator<Integer> it = colors.iterator();
|
|
res = it.next();
|
|
if(res == 0) res = it.next();
|
|
colors.remove(res);
|
|
|
|
b1.setResourceID(res);
|
|
b2.setResourceID(res);
|
|
}
|
|
updatePositiveButton();
|
|
}
|
|
|
|
/**
|
|
* Update state of positive button. Check, if all connections are done and if so, enable positive
|
|
* button. Otherwise disable it.
|
|
*/
|
|
private void updatePositiveButton()
|
|
{
|
|
if(!allowIncompleteConnections && positive != null)
|
|
{
|
|
if(allConnectionsDone()) positive.setEnabled(true);
|
|
else positive.setEnabled(false);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set buttons to not connected. That includes changing background to grey, set connection to
|
|
* itself.
|
|
* @param b index of button
|
|
*/
|
|
private void setButtonFree(int b)
|
|
{
|
|
ButtonWrapper button = buttons.get(b);
|
|
int res = button.getResourceID();
|
|
if(res != R.drawable.button_grey)
|
|
colors.add(button.getResourceID());
|
|
button.setResourceID(R.drawable.button_grey);
|
|
button.setConnectedButton(b);
|
|
}
|
|
|
|
/**
|
|
* Handle button pressed events.
|
|
* @param button button that got pressed
|
|
*/
|
|
private void buttonPressed(int button)
|
|
{
|
|
if(previouslyPressedButton != -1)
|
|
{
|
|
setPlug(previouslyPressedButton, button);
|
|
previouslyPressedButton = -1;
|
|
}
|
|
else
|
|
{
|
|
previouslyPressedButton = button;
|
|
buttons.get(button).setWaiting();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Wrapper class for Buttons, that also stores the index of both, the connected button, as well
|
|
* as the button itself and resourceID of used material.
|
|
*/
|
|
private static class ButtonWrapper
|
|
{
|
|
private Button button;
|
|
private int connectedButton;
|
|
private int resourceID;
|
|
private int index;
|
|
|
|
/**
|
|
* Create ButtonWrapper
|
|
* @param button underlying Button
|
|
* @param index index of the button in the buttons array
|
|
*/
|
|
public ButtonWrapper(Button button, int index)
|
|
{
|
|
this.button = button;
|
|
this.index = index;
|
|
this.connectedButton = index;
|
|
}
|
|
|
|
/**
|
|
* set the index of the connected button and update buttons text
|
|
* @param other index
|
|
*/
|
|
public void setConnectedButton(int other)
|
|
{
|
|
this.connectedButton = other;
|
|
Resources res = MainActivity.ActivitySingleton.getInstance().getActivity().getResources();
|
|
this.getButton().setText(String.format(
|
|
res.getText(R.string.button_plug_title).toString(),
|
|
""+(char) (index+65),
|
|
""+(char) (connectedButton+65)));
|
|
}
|
|
|
|
/**
|
|
* return index of the connected button
|
|
* @return index of connected button
|
|
*/
|
|
public int getConnectedButton()
|
|
{
|
|
return this.connectedButton;
|
|
}
|
|
|
|
/**
|
|
* Indicate, that this button is waiting for another button to connect to.
|
|
*/
|
|
public void setWaiting()
|
|
{
|
|
Resources res = MainActivity.ActivitySingleton.getInstance().getActivity().getResources();
|
|
this.getButton().setText(String.format(
|
|
res.getText(R.string.button_plug_title).toString(),
|
|
""+(char) (index+65)," "));
|
|
}
|
|
|
|
/**
|
|
* Set buttons background and store value in resourceID
|
|
* @param r resourceID of background material
|
|
*/
|
|
public void setResourceID(int r)
|
|
{
|
|
button.setBackgroundResource(r);
|
|
this.resourceID = r;
|
|
}
|
|
|
|
/**
|
|
* get resourceID of buttons background as store in resourceID
|
|
* @return resourceID
|
|
*/
|
|
public int getResourceID()
|
|
{
|
|
return this.resourceID;
|
|
}
|
|
|
|
/**
|
|
* Return stored button object
|
|
* @return button
|
|
*/
|
|
public Button getButton()
|
|
{
|
|
return button;
|
|
}
|
|
}
|
|
} |