Example usage for com.badlogic.gdx.scenes.scene2d.ui SelectBox getSelected

List of usage examples for com.badlogic.gdx.scenes.scene2d.ui SelectBox getSelected

Introduction

In this page you can find the example usage for com.badlogic.gdx.scenes.scene2d.ui SelectBox getSelected.

Prototype

public T getSelected() 

Source Link

Document

Returns the first selected item, or null.

Usage

From source file:com.mygdx.game.screens.touchme.MenuTouchMeScreen.java

private void createButtons() {
    TextButton btnInfos = new TextButton("Gnrer une partie", skin);
    btnInfos.setPosition((Gdx.graphics.getWidth() / 2) - (btnInfos.getWidth() / 2),
            (Gdx.graphics.getHeight() / 2) - (btnInfos.getHeight() / 2));
    btnInfos.addListener(new ClickListener() {
        @Override//  w  w w .j a va 2 s .  c o  m
        public void clicked(InputEvent event, float x, float y) {
            dispose();
            game.setScreen(new GenererPartieTouchMeScreen(game));
        };
    });

    File folder = new File(Gdx.files.internal("./TouchMe/").name());
    File[] listOfFiles = folder.listFiles(new FilenameFilter() {
        @Override
        public boolean accept(File folder, String name) {
            return name.toLowerCase().endsWith(".xml");
        }
    });

    String[] arrayFile = new String[listOfFiles.length];
    for (int i = 0; i < listOfFiles.length; i++) {
        arrayFile[i] = listOfFiles[i].getName().replace(".xml", "");
    }

    final SelectBox selectBox = new SelectBox(new Skin(Gdx.files.internal("./skin/uiskin.json")));
    selectBox.setItems((Object[]) arrayFile);
    selectBox.setWidth(200);
    selectBox.setPosition((Gdx.graphics.getWidth() / 2) - (selectBox.getWidth() / 2),
            (Gdx.graphics.getHeight() / 2) - (selectBox.getHeight() / 2) + btnInfos.getHeight() + 70);

    TextButton btnChoixPartie = new TextButton("Choisir une partie existante", skin);
    btnChoixPartie.setPosition((Gdx.graphics.getWidth() / 2) - (btnChoixPartie.getWidth() / 2),
            (Gdx.graphics.getHeight() / 2) - (btnChoixPartie.getHeight() / 2) + btnInfos.getHeight() + 20);
    btnChoixPartie.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent event, float x, float y) {
            if (selectBox.getSelected() != null) {
                dispose();
                String selection = selectBox.getSelected().toString().replace("[", "").replace("]", "");
                game.setScreen(new GameScreen(new TouchMe(selection + ".xml")));
            } else {
                // Ici afficher un messae d'erreur, on ne peut pas ne rien slectionner
            }
        };
    });

    TextButton btnQuitter = new TextButton("Retour", skin);
    btnQuitter.setPosition((Gdx.graphics.getWidth() / 2) - (btnQuitter.getWidth() / 2),
            (Gdx.graphics.getHeight() / 2) - (btnQuitter.getHeight() / 2) - btnInfos.getHeight() - 20);
    btnQuitter.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent event, float x, float y) {
            dispose();
            game.setScreen(new MainMenuScreen(game));
        };
    });

    stage.addActor(selectBox);
    stage.addActor(btnChoixPartie);
    stage.addActor(btnInfos);
    stage.addActor(btnQuitter);
}

From source file:com.ray3k.skincomposer.dialog.DialogFactory.java

License:Open Source License

public void recentFiles() {
    SelectBox<RecentFile> selectBox = new SelectBox(skin);
    Dialog dialog = new Dialog("Recent Files...", skin, "bg") {
        @Override//from  w ww  .j  av a 2s  . c o  m
        protected void result(Object object) {
            super.result(object);
            if ((boolean) object) {
                if (selectBox.getSelected() != null) {
                    FileHandle file = selectBox.getSelected().getFileHandle();
                    if (file.exists()) {
                        projectData.load(file);
                    }
                }
            }
        }
    };
    dialog.getTitleTable().getCells().first().padLeft(5.0f);
    selectBox.setItems(projectData.getRecentFiles());

    dialog.text("Select a file to open");
    dialog.getContentTable().row();
    dialog.getContentTable().add(selectBox).padLeft(10.0f).padRight(10.0f);
    dialog.getContentTable().getCells().first().pad(10.0f);
    dialog.getButtonTable().defaults().padBottom(10.0f).minWidth(50.0f);
    dialog.button("OK", true).key(Input.Keys.ENTER, true);
    dialog.button("Cancel", false).key(Input.Keys.ESCAPE, false);
    dialog.getButtonTable().getCells().first().getActor().addListener(main.getHandListener());
    dialog.getButtonTable().getCells().get(1).getActor().addListener(main.getHandListener());
    dialog.show(stage);
}

From source file:com.uwsoft.editor.gdx.ui.dialogs.CreateNewResolutionDialog.java

License:Apache License

public CreateNewResolutionDialog(UIStage s) {
    super(s, "createNewResolutionDlg", 270, 230);

    progressHandler = this;

    setTitle("create new resolution");

    resName = ui.getTextBoxById("resName");
    resWidth = ui.getTextBoxById("resWidth");
    resHeight = ui.getTextBoxById("resHeight");

    final SelectBox<String> selectBox = ui.getSelectBoxById("resolutionBase");
    selectBox.setWidth(75);//w  w w.j  a v  a2 s .com
    String[] strArray = { "width", "height" };
    selectBox.setItems(strArray);
    selectBox.setSelectedIndex(0);
    resWidth.setText(800 + "");
    resHeight.setText(480 + "");

    ui.getTextButtonById("createBtn").addListener(new ClickListener() {
        public void touchUp(InputEvent event, float x, float y, int pointer, int button) {
            super.touchUp(event, x, y, pointer, button);
            if (resName.getText().length() == 0)
                return;

            DataManager.getInstance().resolutionManager.createNewResolution(resName.getText(),
                    Integer.parseInt(resWidth.getText()), Integer.parseInt(resHeight.getText()),
                    (String) selectBox.getSelected(), progressHandler);
        }
    });

    // adding progress bar

    progressBar = new ProgressBar(0, 100, 1, false, DataManager.getInstance().textureManager.editorSkin);
    progressBar.setWidth(getWidth() - 60);
    progressBar.setX(10);
    progressBar.setY(55);
    mainLayer.addActor(progressBar);

    progressLbl = new Label("0%", DataManager.getInstance().textureManager.editorSkin);
    progressLbl.setX(progressBar.getX() + progressBar.getWidth() + 4);
    progressLbl.setY(58);
    mainLayer.addActor(progressLbl);

}

From source file:com.wotf.gui.view.SessionLocal.java

/**
 * {@inheritDoc}//w  w w .  j  a va 2  s .  co m
 */
@Override
public void show() {
    stage = new Stage();
    Gdx.input.setInputProcessor(stage);// Make the stage consume events
    //System.out.println(Gdx.files.internal("maps"));
    skin = new Skin(Gdx.files.internal("uiskin.json"));
    teams = new List(skin);

    // Alle teams en labels hiervoor.
    Table teamstable = new Table();
    Table mapstable = new Table();
    Table settingstable = new Table();
    Table teamselecttable = new Table();
    teamstable.setBackground(new NinePatchDrawable(getNinePatch(("GUI/tblbg.png"), 150, 150, 160, 160)));
    mapstable.setBackground(new NinePatchDrawable(getNinePatch(("GUI/tblbg.png"), 220, 220, 160, 160)));
    teamselecttable.setBackground(new NinePatchDrawable(getNinePatch(("GUI/tblbg.png"), 100, 100, 160, 160)));

    Label selectteamlabel = new Label("Team selection", skin);
    teamselecttable.add(selectteamlabel).padBottom(15);
    teamselecttable.row();
    TextButton btnteamalpha = new TextButton("Alpha", skin); // Use the initialized skin
    btnteamalpha.setColor(Color.BLUE);
    btnteamalpha.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent event, float x, float y) {
            Team teamalpha = new Team("Alpha", Color.BLUE);
            teamalpha.setPlayer(defaultPlayer);
            teamalpha.setColorname(teamalpha.getColor().toString());

            int selectedunitcount = Integer.parseInt(unitbox.getSelected().toString());
            addUnitsSingleTeam(selectedunitcount, teamalpha);

            btnteamalpha.setTouchable(Touchable.disabled);
            btnteamalpha.setColor(Color.LIGHT_GRAY);
        }
    });

    teamselecttable.add(btnteamalpha).padBottom(10).width(150).height(50);
    teamselecttable.row();
    TextButton btnteambeta = new TextButton("Beta", skin); // Use the initialized skin
    btnteambeta.setColor(Color.CORAL);
    btnteambeta.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent event, float x, float y) {
            Team teambeta = new Team("Beta", Color.CORAL);
            teambeta.setPlayer(defaultPlayer);
            teambeta.setColorname(teambeta.getColor().toString());

            int selectedunitcount = Integer.parseInt(unitbox.getSelected().toString());
            addUnitsSingleTeam(selectedunitcount, teambeta);

            btnteambeta.setTouchable(Touchable.disabled);
            btnteambeta.setColor(Color.LIGHT_GRAY);
        }
    });
    teamselecttable.add(btnteambeta).padBottom(10).width(150).height(50);
    teamselecttable.row();
    TextButton btnteamgamma = new TextButton("Gamma", skin); // Use the initialized skin
    btnteamgamma.setColor(Color.GREEN);
    btnteamgamma.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent event, float x, float y) {
            Team teamgamma = new Team("Gamma", Color.GREEN);
            teamgamma.setPlayer(defaultPlayer);
            teamgamma.setColorname(teamgamma.getColor().toString());

            int selectedunitcount = Integer.parseInt(unitbox.getSelected().toString());
            addUnitsSingleTeam(selectedunitcount, teamgamma);

            btnteamgamma.setTouchable(Touchable.disabled);
            btnteamgamma.setColor(Color.LIGHT_GRAY);
        }
    });
    teamselecttable.add(btnteamgamma).width(150).height(50);
    teamselecttable.setWidth(200);
    teamselecttable.setHeight(320);
    teamselecttable.setPosition(500, 360);
    stage.addActor(teamselecttable);

    Label wotflabel = new Label("War of the Figures", skin);
    wotflabel.setPosition(Gdx.graphics.getWidth() / 2 - wotflabel.getWidth() / 2, 740);
    stage.addActor(wotflabel);

    Label iplabel = new Label("IP :", skin);
    settingstable.add(iplabel).width(120);
    Label ipvallabel = new Label("127.0.0.1", skin);
    settingstable.add(ipvallabel).width(180);
    settingstable.row();

    Object[] turntimevals = new Object[6];
    turntimevals[0] = "10";
    turntimevals[1] = "20";
    turntimevals[2] = "30";
    turntimevals[3] = "40";
    turntimevals[4] = "50";
    turntimevals[5] = "60";
    Label turntimelabel = new Label("Turn Time :", skin);
    settingstable.add(turntimelabel).width(120);
    SelectBox turntimebox = new SelectBox(skin);
    turntimebox.setItems(turntimevals);
    turntimebox.setSelectedIndex(3);
    turntimebox.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeListener.ChangeEvent event, Actor actor) {
            gameSettings.setTurnTime(Integer.parseInt(turntimebox.getSelected().toString()));
        }
    });
    settingstable.add(turntimebox).width(180);
    settingstable.row();

    Object[] physicsvals = new Object[2];
    physicsvals[0] = "True";
    physicsvals[1] = "False";
    Label physicslabel = new Label("Physics :", skin);
    settingstable.add(physicslabel).width(120);
    SelectBox physicsbox = new SelectBox(skin);
    physicsbox.setItems(physicsvals);
    physicsbox.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            gameSettings.setPhysics(Boolean.parseBoolean(physicsbox.getSelected().toString()));
        }
    });
    settingstable.add(physicsbox).width(180);
    settingstable.row();

    Object[] weaponsvals = new Object[3];
    weaponsvals[0] = "All Weapons";
    weaponsvals[1] = "Non-Explosive";
    weaponsvals[2] = "Grenades Only";
    Label weaponslabel = new Label("Weapons :", skin);
    settingstable.add(weaponslabel).width(120);
    SelectBox weaponsbox = new SelectBox(skin);
    weaponsbox.setItems(weaponsvals);
    settingstable.add(weaponsbox).width(180);
    settingstable.row();

    Object[] timervals = new Object[3];
    timervals[0] = "60";
    timervals[1] = "30";
    timervals[2] = "10";
    Label timerlabel = new Label("Timer :", skin);
    settingstable.add(timerlabel).width(120);
    SelectBox timerbox = new SelectBox(skin);
    timerbox.setItems(timervals);
    timerbox.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            gameSettings.setMaxTime(Integer.parseInt(timerbox.getSelected().toString()));
        }
    });
    settingstable.add(timerbox).width(180);
    settingstable.row();

    Object[] unitvals = new Object[4];
    unitvals[0] = "1";
    unitvals[1] = "2";
    unitvals[2] = "3";
    unitvals[3] = "4";
    Label unitlabel = new Label("Units :", skin);
    settingstable.add(unitlabel).width(120);
    unitbox = new SelectBox(skin);
    unitbox.setItems(unitvals);
    unitbox.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            int selectedunitcount = Integer.parseInt(unitbox.getSelected().toString());
            gameSettings.setMaxUnitCount(selectedunitcount);
            refreshUnitsForTeam(selectedunitcount);

        }
    });
    settingstable.add(unitbox).width(180);

    settingstable.setWidth(300);
    settingstable.setHeight(200);
    settingstable.setPosition(30, 110);
    stage.addActor(settingstable);

    ArrayList<String> mapslist = new ArrayList<>();
    FileHandle dirHandle = Gdx.files.internal("maps");
    for (FileHandle entry : dirHandle.list()) {
        mapslist.add(entry.toString());
    }

    map1 = new Image(new Texture(mapslist.get(0)));
    map1.setPosition(20, 70);
    map1.setWidth(400);
    map1.setHeight(230);
    mapstable.addActor(map1);
    SelectBox chooseMap = new SelectBox(skin);
    chooseMap.setItems(mapslist.toArray());
    chooseMap.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            mapstable.removeActor(map1);
            map1 = new Image(new Texture(mapslist.get(chooseMap.getSelectedIndex())));
            map1.setPosition(20, 70);
            map1.setWidth(400);
            map1.setHeight(230);
            map1.invalidate();
            mapstable.addActor(map1);
            // Table image is not updating for some reason. Does it need to be redrawn? Or the Stage?
        }
    });
    chooseMap.setWidth(400);
    chooseMap.setPosition(20, 20);
    mapstable.addActor(chooseMap);
    mapstable.setPosition(30, 360);
    mapstable.setHeight(320);
    mapstable.setWidth(440);
    stage.addActor(mapstable);

    Label teamslabel = new Label("Teams", skin);
    teamstable.setPosition(730, 360);
    teamstable.add(teamslabel);
    teamstable.row();
    teamstable.add(teams).width(200);
    teamstable.setWidth(300);
    teamstable.setHeight(320);
    stage.addActor(teamstable);

    TextButton start = new TextButton("Start", skin); // Use the initialized skin
    start.setColor(Color.BLACK);
    start.setWidth(300);
    start.setHeight(60);
    start.setPosition(590, 180);
    stage.addActor(start);
    start.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent event, float x, float y) {
            if (teamList.size() < 2) {
                return;
            }

            // Selected MaxTime to an integer.
            gameSettings.setMaxTime(Integer.parseInt(timerbox.getSelected().toString()));

            // Selected TurnTime to an integer.
            gameSettings.setTurnTime(Integer.parseInt(turntimebox.getSelected().toString()));

            gameSettings.setIsLocal(true);
            // Create the map
            Map map = new Map(chooseMap.getSelected().toString().substring(5));

            try {
                sessionLocal = new Session(defaultPlayer, "localHost", gameSettings);
                sessionLocal.addPlayer(defaultPlayer);
            } catch (RemoteException ex) {
                Gdx.app.log("SessionLocal", ex.getMessage());
            }

            game.setScreen(new GameEngine(game, gameSettings, map, sessionLocal, defaultPlayer));
        }
    });

    TextButton exit = new TextButton("Exit", skin); // Use the initialized skin
    exit.setColor(Color.BLACK);
    exit.setWidth(300);
    exit.setHeight(60);
    exit.setPosition(590, 110);
    stage.addActor(exit);
    exit.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent event, float x, float y) {
            game.setScreen(new MainMenu(game));
        }
    });

}

From source file:net.spookygames.gdx.sfx.demo.GdxSfxDemo.java

License:Open Source License

@Override
public void create() {

    /******************/
    /* Initialization */
    /******************/

    prefs = Gdx.app.getPreferences("GdxSfxDemo");

    batch = new SpriteBatch();

    Camera camera = new OrthographicCamera();

    FileHandleResolver resolver = new AbsoluteFileHandleResolver();
    assetManager = new AssetManager(resolver);
    assetManager.setLoader(SfxMusic.class, new SfxMusicLoader(resolver));

    skin = new Skin(Gdx.files.internal("skin/uiskin.json"));

    player = new SfxMusicPlayer();

    /************/
    /* Playlist */
    /************/

    final VerticalGroup playlistGroup = new VerticalGroup();
    playlistGroup.fill().left();//from w ww.  ja v  a 2  s.  c  o m

    final Label invitationLabel = new Label("Add some music and let's have fun", skin, "subtitle");
    invitationLabel.setAlignment(Align.center);

    ScrollPane scrollablePlaylistTable = new ScrollPane(playlistGroup, skin);
    scrollablePlaylistTable.setScrollingDisabled(true, false);

    playlistGroup.addActor(invitationLabel);

    /********/
    /* File */
    /********/

    Button fileFinder = new TextButton("Add music", skin, "round");
    fileFinder.addListener(new ChangeListener() {

        @Override
        public void changed(ChangeEvent event, Actor actor) {

            NativeFileChooserConfiguration conf = new NativeFileChooserConfiguration();
            conf.directory = Gdx.files.absolute(prefs.getString("last",
                    Gdx.files.isExternalStorageAvailable() ? Gdx.files.getExternalStoragePath()
                            : (Gdx.files.isLocalStorageAvailable() ? Gdx.files.getLocalStoragePath()
                                    : System.getProperty("user.home"))));
            conf.nameFilter = new FilenameFilter() {
                final String[] extensions = { "wav", "mp3", "ogg" };

                @Override
                public boolean accept(File dir, String name) {
                    int i = name.lastIndexOf('.');
                    if (i > 0 && i < name.length() - 1) {
                        String desiredExtension = name.substring(i + 1).toLowerCase(Locale.ENGLISH);
                        for (String extension : extensions) {
                            if (desiredExtension.equals(extension)) {
                                return true;
                            }
                        }
                    }
                    return false;
                }
            };
            conf.mimeFilter = "audio/*";
            conf.title = "Choose audio file";

            fileChooser.chooseFile(conf, new NativeFileChooserCallback() {
                @Override
                public void onFileChosen(FileHandle file) {
                    if (file == null)
                        return;

                    prefs.putString("last", file.parent().file().getAbsolutePath());
                    MusicParameters parameters = new MusicParameters();
                    parameters.title = file.name();
                    parameters.loadedCallback = new LoadedCallback() {
                        @Override
                        public void finishedLoading(AssetManager assetManager, String fileName,
                                @SuppressWarnings("rawtypes") Class type) {
                            final SfxMusic music = assetManager.get(fileName, SfxMusic.class);
                            if (player.addToPlaylist(music)) {
                                final MusicWidget widget = new MusicWidget(skin, music);
                                playlistGroup.addActor(widget);
                                widget.removeButton.addListener(new ChangeListener() {
                                    @Override
                                    public void changed(ChangeEvent event, Actor actor) {
                                        if (player.removeFromPlaylist(music))
                                            widget.remove();
                                    }
                                });
                            }
                        }
                    };

                    assetManager.load(new AssetDescriptor<SfxMusic>(file, SfxMusic.class, parameters));
                }

                @Override
                public void onCancellation() {
                }

                @Override
                public void onError(Exception exception) {
                }
            });
        }
    });

    /***********/
    /* Control */
    /***********/

    Table controlTable = new Table(skin);

    final Button playPauseButton = new Button(skin, "music");
    playPauseButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            if (playPauseButton.isChecked()) {
                player.play();
            } else {
                player.pause();
            }
        }
    });

    Button previousButton = new Button(skin, "left");
    previousButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            player.previous();
        }
    });

    Button nextButton = new Button(skin, "right");
    nextButton.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            player.next();
        }
    });

    final Button muteButton = new Button(skin, "sound");
    muteButton.setChecked(true);
    muteButton.addListener(new ChangeListener() {
        float formerVolume = player.getVolume();

        @Override
        public void changed(ChangeEvent event, Actor actor) {
            float newVolume;
            if (muteButton.isChecked()) {
                // Un-mute
                newVolume = formerVolume;
            } else {
                // Mute
                formerVolume = player.getVolume();
                newVolume = 0f;
            }
            player.setVolume(newVolume);
        }
    });

    final Slider panSlider = new Slider(-1f, 1f, 0.02f, false, skin);
    panSlider.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            player.setPan(panSlider.getValue());
        }
    });
    panSlider.setValue(player.getPan());

    final Slider volumeSlider = new Slider(0f, 1f, 0.01f, false, skin);
    volumeSlider.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            muteButton.setChecked(true);
            player.setVolume(volumeSlider.getValue());
        }
    });
    volumeSlider.setValue(player.getVolume());

    final CheckBox shuffleCheckBox = new CheckBox("Shuffle", skin, "switch");
    shuffleCheckBox.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            player.setShuffleEnabled(shuffleCheckBox.isChecked());
        }
    });
    shuffleCheckBox.setChecked(player.isShuffleEnabled());

    final CheckBox repeatCheckBox = new CheckBox("Repeat", skin, "switch");
    repeatCheckBox.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            player.setRepeatEnabled(repeatCheckBox.isChecked());
        }
    });
    repeatCheckBox.setChecked(player.isRepeatEnabled());

    final Table fadeTable = new Table(skin);

    final Label fadeDurationLabel = new Label("0.0s", skin);
    final Slider fadeDurationSlider = new Slider(0.1f, 5f, 0.1f, false, skin);
    fadeDurationSlider.addListener(new ChangeListener() {
        String format = "%.1fs";

        @Override
        public void changed(ChangeEvent event, Actor actor) {
            float value = fadeDurationSlider.getValue();
            player.setFadeDuration(value);
            fadeDurationLabel.setText(String.format(format, value));
        }
    });
    fadeDurationSlider.setValue(player.getFadeDuration());

    final SelectBox<String> fadeInterpolationSelectBox = new SelectBox<String>(skin);
    final ObjectMap<String, Interpolation> interpolations = new ObjectMap<String, Interpolation>();
    interpolations.put("Linear", Interpolation.linear);
    interpolations.put("Fade", Interpolation.fade);
    interpolations.put("Circle", Interpolation.circle);
    interpolations.put("Sine", Interpolation.sine);
    interpolations.put("Bounce", Interpolation.bounce);
    interpolations.put("Elastic", Interpolation.elastic);
    interpolations.put("Swing", Interpolation.swing);
    fadeInterpolationSelectBox.setItems(interpolations.keys().toArray());
    fadeInterpolationSelectBox.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            player.setFadeInterpolation(interpolations.get(fadeInterpolationSelectBox.getSelected()));
        }
    });

    fadeTable.defaults().left().pad(1f);
    fadeTable.row();
    fadeTable.add("Duration");
    fadeTable.add(fadeDurationSlider).expandX().fill();
    fadeTable.add(fadeDurationLabel).width(40);
    fadeTable.row();
    fadeTable.add("Interpolation");
    fadeTable.add(fadeInterpolationSelectBox).colspan(2).expandX().fill();

    final CheckBox fadeCheckBox = new CheckBox("Fade", skin, "switch");
    fadeCheckBox.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent event, Actor actor) {
            boolean fade = fadeCheckBox.isChecked();
            player.setFadingEnabled(fade);
            fadeTable.setVisible(fade);
        }
    });
    fadeCheckBox.setChecked(player.isFadingEnabled());
    fadeTable.setVisible(player.isFadingEnabled());

    controlTable.defaults().padTop(4f);
    controlTable.row().colspan(3);
    controlTable.add(shuffleCheckBox).left();
    controlTable.row().colspan(3);
    controlTable.add(repeatCheckBox).left();
    controlTable.row().colspan(3);
    controlTable.add(fadeCheckBox).left();
    controlTable.row().colspan(3);
    controlTable.add(fadeTable);
    controlTable.row();
    controlTable.add("Pan");
    controlTable.add(panSlider).colspan(2);
    controlTable.row().colspan(3);
    controlTable.add().expand();
    controlTable.row();
    controlTable.add(previousButton).right();
    controlTable.add(playPauseButton);
    controlTable.add(nextButton).left();
    controlTable.row();
    controlTable.add("Volume");
    controlTable.add(volumeSlider).colspan(2);
    controlTable.row();
    controlTable.add("Mute");
    controlTable.add(muteButton).colspan(2).left();

    /*********/
    /* Debug */
    /*********/

    Label debugLabel = new Label("", skin) {
        @Override
        public void act(float delta) {
            setText(player.toString());
            super.act(delta);
        }
    };

    /***************/
    /* Stage setup */
    /***************/

    Table leftTable = new Table(skin);
    leftTable.row();
    leftTable.add(scrollablePlaylistTable).expand().fillX().top();
    leftTable.row();
    leftTable.add(debugLabel).expandX().left().padLeft(30f).padTop(8f);

    Table rightTable = new Table(skin);
    rightTable.row();
    rightTable.add(controlTable).expandY().fill();
    rightTable.row();
    rightTable.add(fileFinder).padTop(10f);

    Table rootTable = new Table(skin);
    rootTable.setFillParent(true);
    rootTable.row();
    rootTable.add(leftTable).expand().fill();
    rootTable.add(rightTable).expandY().fill().padTop(25f).padLeft(8f);

    stage = new Stage(new ScreenViewport(camera), batch);
    stage.addActor(rootTable);

    /*********/
    /* Input */
    /*********/

    Gdx.input.setInputProcessor(stage);
}

From source file:org.anism.lotw.LOTW.java

License:Open Source License

public void initEverything() {
    Color fullAnti = new Color(G.getAntiColor());
    fullAnti.a = 1;/*from w ww  .j  a  va 2s  . c  om*/

    Texture upTexture = new Texture(Gdx.files.internal("images/grey_button_up.png"));
    Texture downTexture = new Texture(Gdx.files.internal("images/grey_button_down.png"));
    NinePatch buttonPatchUp = new NinePatch(upTexture, 11, 11, 11, 11);
    NinePatch buttonPatchDown = new NinePatch(downTexture, 11, 11, 11, 11);

    NinePatchDrawable npdUp = new NinePatchDrawable(buttonPatchUp);
    NinePatchDrawable npdDown = new NinePatchDrawable(buttonPatchDown);
    textButtonStyle = new TextButton.TextButtonStyle(npdUp, npdDown, npdUp, G.roboto16);
    textButtonStyle.fontColor = new Color(G.getAntiColor());
    textButtonStyle.fontColor.a = 1;
    buttonStyle = new ButtonStyle(npdUp, npdDown, npdUp);

    labelStyle = new Label.LabelStyle(G.roboto24, G.getAntiColor());
    labelStyleSmall = new Label.LabelStyle(G.roboto16, G.getAntiColor());
    resumeButton = addIconButton(game, G.playIcon, new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            if (!G.pausing) {
                G.pause();
            }
        }
    }, buttonWidth / dpi / 2 + 4 * dpi, -48, buttonWidth / dpi, 88);
    resumeButton.setColor(G.colors.green);
    exitButton = addIconButton(game, G.backIcon, new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            if (!G.pausing) {
                G.gameOver();
            }
        }
    }, -buttonWidth / dpi / 2 - 4 * dpi, -48, buttonWidth / dpi, 88);
    exitButton.setColor(G.colors.red);
    togglePauseButtons();

    //intro.addActor(logo);
    //putLogo(settings);
    putLogo(instructions);
    //putLogo(statistics);

    /*
    // intro screen:
    addButton(intro, game, "Start Game", 0, 0, 200f, 40f);
    addButton(intro, settings, "Settings", 0, -70, 100f, 40f);
    addButton(intro, instructions, "How to Play", 0, -120, 100f, 40f);
    */

    // settings screen:

    ImageTextButton.ImageTextButtonStyle lbs = new ImageTextButton.ImageTextButtonStyle(textButtonStyle);
    TextureRegionDrawable gamepadDrawable = new TextureRegionDrawable(new TextureRegion(G.controllerIcon));
    lbs.imageChecked = gamepadDrawable;
    lbs.imageCheckedOver = gamepadDrawable;
    lbs.imageDisabled = gamepadDrawable;
    lbs.imageDown = gamepadDrawable;
    lbs.imageOver = gamepadDrawable;
    lbs.imageUp = gamepadDrawable;

    logButton = new ImageTextButton("Sign In", lbs);
    if (actionResolver.getSignedInGPGS()) {
        logButton.setText("Sign Out");
    }
    logButton.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            if (actionResolver.getSignedInGPGS()) {
                actionResolver.logoutGPGS();
            } else {
                actionResolver.loginGPGS();
            }
            G.toggleAutologin();
        }
    });
    logButton.setWidth(184 * dpi);
    logButton.setHeight(88 * dpi);
    logButton.setColor(G.colors.grey);
    logButton.getImage().setColor(fullAnti);
    //settings.addActor(logButton);

    TextureRegionDrawable cbOn = new TextureRegionDrawable(new TextureRegion(G.dashIcon));
    TextureRegionDrawable cbOff = new TextureRegionDrawable(new TextureRegion(G.circleIcon));
    CheckBoxStyle cbs = new CheckBoxStyle(cbOff, cbOn, G.roboto16, fullAnti);
    cbs.checked = npdUp;
    cbs.checkedOver = npdUp;
    cbs.down = npdDown;
    cbs.over = npdUp;
    cbs.up = npdUp;

    // colorblind settings:
    CheckBox colorButton = new CheckBox("", cbs);
    colorButton.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            G.toggleColorblind();
        }
    });
    colorButton.setWidth(88 * dpi);
    colorButton.setHeight(88 * dpi);
    /*
    colorButton.setPosition(G.width/2 - 188 * dpi,
    G.height/2 + 100*dpi);
    */
    Table colorTable = makeSettingsTable("Display");
    colorButton.setColor(Math.random() > 0.5 ? G.colors.green : G.colors.red);
    colorButton.getImage().setColor(fullAnti);
    colorButton.setChecked(G.settings.colorblind);
    ListStyle listStyle = new ListStyle(G.roboto16, G.getAntiColor(), G.getAntiColor(), npdDown);
    listStyle.background = npdUp;
    SelectBoxStyle sbs = new SelectBoxStyle(G.roboto16, new Color(0x00000000), npdUp,
            new ScrollPane.ScrollPaneStyle(), listStyle);
    final SelectBox<Season> seasonPicker = new SelectBox(sbs);
    seasonPicker.setItems((Season[]) G.settings.getUnlockedSeasons());
    if (G.settings.unlock) {
        seasonPicker.setSelected(G.settings.unlockSeason);
    } else {
        seasonPicker.setSelected(G.settings.getSeason());
    }
    seasonPicker.setColor(G.colors.grey);
    seasonPicker.getList().setColor(G.colors.grey);
    Stack seasonStack = new Stack();
    final Container seasonImage = new Container(new Image(seasonPicker.getSelected().getIcon()));
    seasonImage.setSize(32, 32);
    seasonImage.setTouchable(Touchable.disabled);
    seasonImage.getActor().setColor(G.getAntiColor());
    seasonStack.add(seasonPicker);
    seasonStack.add(seasonImage);
    seasonPicker.addListener(new ChangeListener() {
        @Override
        public void changed(ChangeEvent e, Actor a) {
            Season s = seasonPicker.getSelected();
            if (s.getName().toUpperCase().equals("UNLOCK")) {
                G.glider.score = 0;
                G.settings.unlock = true;
                G.settings.setSeason(G.settings.getSeasons()[0]);
                G.updateBgColor();
                G.lotw.resetEverything();
            } else {
                G.settings.unlock = false;
                G.changeSeason(s);
            }
        }
    });
    putSettingsButton(colorTable, seasonStack, "Season.");
    CheckBox ninjaButton = new CheckBox("", cbs);
    ninjaButton.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            G.toggleNinja();
        }
    });
    ninjaButton.setColor(G.colors.grey);
    ninjaButton.getImage().setColor(fullAnti);
    ninjaButton.setChecked(G.settings.ninjaMode);
    putSettingsButton(colorTable, colorButton, "Add markings to distinguish red and green orbs.");
    putSettingsButton(colorTable, ninjaButton, "Ninja mode.");

    // advanced settings:
    CheckBox bottomButton = new CheckBox("", cbs);
    bottomButton.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            G.toggleBottomOut();
        }
    });
    bottomButton.setChecked(G.settings.bottomOut);
    bottomButton.setColor(G.colors.grey);
    bottomButton.getImage().setColor(fullAnti);
    Table bottomTable = makeSettingsTable("Advanced");
    putSettingsButton(bottomTable, bottomButton,
            "The glider respawns if it falls too far. Experienced players may wish to turn this off.");
    ImageButton statsButton = addIconButton(null, G.image("icons/stats.png"), new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            seeStats();
        }
    }, 96, -48, 88, 88);
    statsButton.setColor(G.colors.grey);
    putSettingsButton(bottomTable, statsButton, "View aggregate and record statistics.");
    ImageButton aboutButton = addIconButton(null, G.infoIcon, new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            setStage(about);
        }
    }, 0, 0, 0, 0);
    aboutButton.setColor(G.colors.grey);
    putSettingsButton(bottomTable, aboutButton, "About.");

    // online settings:
    ImageButton leaderButton = addIconButton(null, G.leaderIcon, new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            actionResolver.getLeaderboardGPGS(G.constants.scoreBoard);
        }
    }, 48, -G.height / 2 / dpi + 48, 88, 88);
    leaderButton.setColor(G.colors.gold);
    ImageButton achieveButton = addIconButton(null, G.achieveIcon, new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            actionResolver.getAchievementsGPGS();
        }
    }, -48, -G.height / 2 / dpi + 48, 88, 88);
    achieveButton.setColor(G.colors.blue);
    Table loginTable = makeSettingsTable("Online");
    putSettingsButton(loginTable, achieveButton, "View achievements.");
    putSettingsButton(loginTable, leaderButton, "Access leaderboards.");
    loginTable.add(logButton).width(182 * dpi).pad(4 * dpi).colspan(2).center();

    // control settings:
    Table controlTable = makeSettingsTable("Controls");
    CheckBox twoTouchControls = new CheckBox("", cbs);
    twoTouchControls.setColor(G.colors.grey);
    twoTouchControls.getImage().setColor(fullAnti);
    twoTouchControls.setChecked(G.settings.twoTouch());
    twoTouchControls.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            G.settings.setControl("TWO_TOUCH");
        }
    });
    CheckBox tiltControls = new CheckBox("", cbs);
    tiltControls.setColor(G.colors.grey);
    tiltControls.getImage().setColor(fullAnti);
    tiltControls.setChecked(G.settings.tilt());
    tiltControls.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            G.settings.setControl("TILT");
        }
    });
    CheckBox dragControls = new CheckBox("", cbs);
    dragControls.setColor(G.colors.grey);
    dragControls.getImage().setColor(fullAnti);
    dragControls.setChecked(G.settings.oneTouch());
    dragControls.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            G.settings.setControl("ONE_TOUCH");
        }
    });
    ButtonGroup controlGroup = new ButtonGroup(twoTouchControls, tiltControls, dragControls);
    controlGroup.setMaxCheckCount(1);
    controlGroup.setMinCheckCount(1);
    controlGroup.setUncheckLast(true);
    putSettingsButton(controlTable, twoTouchControls, "Touch on the left or right.");
    putSettingsButton(controlTable, tiltControls, "Tilt your device.");
    putSettingsButton(controlTable, dragControls, "Touch and drag.");

    // mode settings:
    Table modeTable = makeSettingsTable("Mode");
    CheckBox hellMode = new CheckBox("", cbs);
    hellMode.setColor(G.colors.red);
    hellMode.getImage().setColor(fullAnti);
    hellMode.setChecked(G.settings.hell());
    hellMode.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            G.settings.setMode(-1);
        }
    });
    CheckBox normalMode = new CheckBox("", cbs);
    normalMode.setColor(G.colors.grey);
    normalMode.getImage().setColor(fullAnti);
    normalMode.setChecked(G.settings.normal());
    normalMode.addListener(new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            G.settings.setMode(0);
        }
    });
    ButtonGroup modeGroup = new ButtonGroup(hellMode, normalMode);
    modeGroup.setMaxCheckCount(1);
    modeGroup.setMinCheckCount(1);
    modeGroup.setUncheckLast(true);
    putSettingsButton(modeTable, normalMode, "Normal mode: catch orbs for points.");
    putSettingsButton(modeTable, hellMode, "Hell mode: dodge red orbs.");

    putActionBar(settings);
    putActionBar(colorSettings);
    putActionBar(controlSettings);
    putActionBar(modeSettings);
    putActionBar(loginSettings);
    putActionBar(bottomSettings);

    putSettingsMenu(settings);
    putSettingsMenu(colorSettings);
    colorSettings.addActor(colorTable);
    putSettingsMenu(controlSettings);
    controlSettings.addActor(controlTable);
    putSettingsMenu(loginSettings);
    loginSettings.addActor(loginTable);
    putSettingsMenu(modeSettings);
    modeSettings.addActor(modeTable);
    putSettingsMenu(bottomSettings);
    bottomSettings.addActor(bottomTable);

    Table aboutTable = new Table();
    aboutTable.setSize(G.width, G.height - 88 * dpi);
    aboutTable.setPosition(0, 88 * dpi);
    aboutTable.add(new Label("About", labelStyle));
    aboutTable.row();
    Label aboutTextLabel = new Label(
            "Leaf on the Wind copyright 2014 Ethan Goldberg, all rights reserved.\n\nIcons made by Google and licensed under CC BY 4.0.\n\n\nThank you for playing!",
            labelStyleSmall);
    aboutTextLabel.setWrap(true);
    aboutTextLabel.setAlignment(Align.center, Align.center);
    aboutTable.add(aboutTextLabel).width(G.width / 2);
    ImageButton aboutBackButton = addIconButton(about, G.backIcon, new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            setStage(bottomSettings);
        }
    }, 0, -G.height / 2 / dpi + 48, buttonWidth / dpi, 88);
    aboutBackButton.setColor(G.colors.red);
    about.addActor(aboutTable);
    about.addActor(aboutBackButton);

    // instructions:

    //delay
    float d = 0f;
    addLabel(instructions, "This is your glider.", 0, G.height / 2 / dpi - 96, 8, tr)
            .addAction(Actions.delay(d, Actions.fadeIn(fadeDur)));
    // wait two seconds:
    d += 2.5;
    addLabel(instructions, "Touch the screen", 0, G.height / 2 / dpi - 136, 8, tr)
            .addAction(Actions.delay(d, Actions.fadeIn(fadeDur)));
    d += 1;
    addLabel(instructions, "on the left,", -G.width / 4 / dpi, G.height / 2 / dpi - 166, 8, tr)
            .addAction(Actions.delay(d, Actions.fadeIn(fadeDur)));
    d += 1.5;
    addLabel(instructions, "or the right.", G.width / 4 / dpi, G.height / 2 / dpi - 166, 8, tr)
            .addAction(Actions.delay(d, Actions.fadeIn(fadeDur)));

    d += 3;
    int pickUpOffset = G.size * 2;
    addLabel(instructions, "Catch these,", -G.width / 4 / dpi, -G.height / 6 / dpi, G.size * 2 / dpi, tr)
            .addAction(Actions.delay(d, Actions.fadeIn(fadeDur)));
    Goody i;
    d += 1.5;

    Color r = new Color(G.colors.goodyRed);
    r.a = 0;
    Color gr = new Color(G.colors.goodyGreen);
    gr.a = 0;
    Color go = new Color(G.colors.goodyGold);
    go.a = 0;
    Color b = new Color(G.colors.goodyBlue);
    b.a = 0;

    i = addDumbGoody(instructions, b, -G.width / 4 / dpi - (G.size * 2) / dpi,
            -G.height / 6 / dpi + pickUpOffset);
    i.addAction(Actions.delay(d, Actions.alpha(1)));
    //bounce(i, 0, 8, 0.33f, 8);
    bounce(i, 0, 8, 0.33f, 4);
    d += .5;
    i = addDumbGoody(instructions, gr, -G.width / 4 / dpi, -G.height / 6 / dpi + pickUpOffset);
    i.addAction(Actions.delay(d, Actions.alpha(1)));
    //bounce(i, 0.25f, 8, 0.33f, 8);
    bounce(i, 0.25f, 8, 0.33f, 4);
    d += .5;
    i = addDumbGoody(instructions, go, -G.width / 4 / dpi + (G.size * 2) / dpi,
            -G.height / 6 / dpi + pickUpOffset);
    i.addAction(Actions.delay(d, Actions.alpha(1)));
    //bounce(i, 0.5f, 8, 0.33f, 8);
    bounce(i, 0.5f, 8, 0.33f, 4);

    d += 1.5;
    addLabel(instructions, "not these.", G.width / 4 / dpi, -G.height / 6 / dpi, G.size * 2 / dpi, tr)
            .addAction(Actions.delay(d, Actions.fadeIn(fadeDur)));
    d += 2;
    i = addDumbBaddy(instructions, r, G.width / 4 / dpi, -G.height / 6 / dpi + pickUpOffset);
    i.addAction(Actions.delay(d, Actions.alpha(1)));
    //bounce(i, 0.75f, 8, 0.33f, 8);
    bounce(i, 0.75f, 8, 0.33f, 4);

    d += 2;

    addIconButton(instructions, G.playIcon, new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            setStage(game);
        }
    }, G.width / 2 / dpi - buttonWidth / dpi / 2 - 4, -G.height / 2 / dpi + 48, buttonWidth / dpi, 88)
            .setColor(G.colors.green);
    addIconButton(instructions, G.image("icons/settings.png"), new ClickListener() {
        @Override
        public void clicked(InputEvent e, float x, float y) {
            setStage(settings);
        }
    }, -G.width / 2 / dpi + buttonWidth / 2 / dpi + 4, -G.height / 2 / dpi + 48, buttonWidth / dpi, 88)
            .setColor(G.colors.grey);

    d += 2;

    Color c = new Color(G.getAntiColor());
    c.a = 0;
    addImage(instructions, G.playWrite, c, G.width / 2 / dpi - 3 * buttonWidth / 2 / dpi - 8,
            -G.height / 2 / dpi + 48, buttonWidth / 2 / dpi, 48)
                    .addAction(Actions.delay(d, Actions
                            .forever(Actions.sequence(Actions.fadeOut(fadeDur), Actions.fadeIn(fadeDur)))));

    /*
    TextButton b1 = addButton(instructions, game, "Start", 
    0, -G.height/2/dpi + 88f, 192, 40f);
    TextButton b2 = addButton(instructions, settings, "Settings", 
    0, -G.height/2/dpi + 40f, 192, 40f);
    b1.addAction(Actions.alpha(.5f));
    b2.addAction(Actions.alpha(.25f));
    b1.addAction(Actions.delay(d, Actions.fadeIn(fadeDur)));
    b2.addAction(Actions.delay(d, Actions.fadeIn(fadeDur)));
    */
}