title: javaFx radio button and textfield user selection and user input
body: <p>So my question is trying to implement a GUI that has 4 radio buttons to let the user choose what type of sorting they want to do(quick,insertion,bubble,selection) and then they can pick from 3 more radio buttons and choose either already sorted, random, reverse sorted. Then it has a textfield that allows them to chose the input size of the array and then the block size. after the user has chosen the radio buttons and put in the information into the input size text field and the block size text field, they hit go and the program will sort the array and output the sorted array to the console. </p>
  
  <p>So what I need help with is implementing the action event or listener for the go button to get what the information from the radio buttons and text fields. I understand the logic behind it but I wasn't sure how to get it all to link up into the event handler/action event. My code so far compiles and when you hit the 'go' button it prints an array of 100 numbers already sorted in order 1-100. It doesn't take into account what the user selects on the radio buttons or the text field's for block size and input size and I need help with that. here is my code:</p>
  
  <pre><code>package project4practice;
  
  import java.util.Random;
  import javafx.application.Application;
  import javafx.event.ActionEvent;
  import javafx.event.EventHandler;
  import javafx.scene.Scene;
  import javafx.scene.control.Alert;
  import javafx.scene.control.Button;
  import javafx.scene.control.Label;
  import javafx.scene.control.RadioButton;
  import javafx.scene.control.TextField;
  import javafx.scene.control.ToggleGroup;
  import javafx.scene.layout.BorderPane;
  import javafx.scene.layout.GridPane;
  import javafx.stage.Stage;
  
  public class Project4practice extends Application {
  
      @Override
      public void start(Stage primaryStage) {
          BorderPane rootPane = new BorderPane();
          GridPane gp = new GridPane();
          rootPane.setCenter(gp);
          gp.setVgap(5);
          gp.setHgap(5);
          rootPane.prefWidth(700);
          rootPane.prefHeight(400);
          gp.prefWidth(400);
          gp.prefHeight(400);
          Label sort = new Label(" Sorting Algorithm ");
          RadioButton selection = new RadioButton("selection ");
          RadioButton bubble = new RadioButton("bubble ");
          RadioButton insertion = new RadioButton("insertion");
          RadioButton quick = new RadioButton("Quick ");
          Label inputType = new Label(" Input Type ");
          RadioButton sorted = new RadioButton("Already Sorted ");
          RadioButton reverse = new RadioButton("Reverse ");
          RadioButton random = new RadioButton("Random ");
          Label inputSize = new Label(" Input Size: ");
          TextField inputText = new TextField();
  
          inputText.setOnAction((ActionEvent inputText1) -&gt; {
              String inputText2 = inputText.getText();
              double inputText3 = Double.parseDouble(inputText2);
              System.out.println(inputText3);
          });
          Label blockSize = new Label(" Block Size: ");
          TextField block = new TextField();
  
          block.setOnAction((ActionEvent block1) -&gt; {
              String block2 = block.getText();
              double block3 = Double.parseDouble(block2);
              System.out.println(block3);
          });
  
          Button go = new Button("Go ");
          ToggleGroup tg = new ToggleGroup();
  
          selection.setToggleGroup(tg);
          selection.setSelected(true);
          bubble.setToggleGroup(tg);
          insertion.setToggleGroup(tg);
          quick.setToggleGroup(tg);
          ToggleGroup tg1 = new ToggleGroup();
          sorted.setToggleGroup(tg1);
          sorted.setSelected(true);
          reverse.setToggleGroup(tg1);
          random.setToggleGroup(tg1);
  
          gp.add(sort, 0, 0);
          gp.add(selection, 0, 1);
          gp.add(bubble, 0, 2);
          gp.add(insertion, 0, 3);
          gp.add(quick, 0, 4);
          gp.add(inputType, 0, 7);
          gp.add(sorted, 0, 8);
          gp.add(reverse, 0, 9);
          gp.add(random, 0, 10);
          gp.add(inputSize, 0, 12);
          gp.add(inputText, 1, 12);
          gp.add(blockSize, 0, 13);
          gp.add(block, 1, 13);
          gp.add(go, 0, 16);
  
          go.setOnAction(new EventHandler&lt;ActionEvent&gt;() {
              @Override
              public void handle(ActionEvent go1) {
                  //selection sorted
                  if (selection.isSelected() &amp;&amp; sorted.isSelected()) {
                      int arraySize = Integer.parseInt(inputText.getText());
                      int chunk = Integer.parseInt(block.getText());//block size user input
  
                      //         for(int i=0;i&lt;block.length;i+=chunk){
                      //            System.out.println(Arrays.toString(Arrays.copyOfRange(block, i, Math.min(block.length,i+chunk))));
                      //          }
                      int[] array = getSorted(arraySize, true);
                      print(array);
                      selectionSort(array);
  
                  }//selction sorted reverse
                  else if (selection.isSelected() &amp;&amp; reverse.isSelected()) {
                      int arraySize = Integer.parseInt(inputText.getText());
                      int[] array = null;
                      array = getReverse(array);
                      print(array);
                      selectionSort(array);
                  } //selection sorted random
                  else if (selection.isSelected() &amp;&amp; random.isSelected()) {
                      int arraySize = Integer.parseInt(inputText.getText());
                      int[] array = getRandom(arraySize);
                      print(array);
                      selectionSort(array);
                  }//quick sort random
                  else if (quick.isSelected() &amp;&amp; random.isSelected()) {
                      int arraySize = Integer.parseInt(inputText.getText());
                      int[] array = getRandom(arraySize);
                      print(array);
                      quickSort(array, 0, array.length - 1);
  
                  }//quick sort sorted
                  else if (quick.isSelected() &amp;&amp; sorted.isSelected()) {
                      int arraySize = Integer.parseInt(inputText.getText());
                      int[] array = getSorted(arraySize, true);
                      print(array);
                      quickSort(array, 0, array.length - 1);
                  }//quick reverse sort
                  else if (quick.isSelected() &amp;&amp; reverse.isSelected()) {
                      int arraySize = Integer.parseInt(inputText.getText());
                      int[] array = null;
                      array = getReverse(array);
                      print(array);
                      quickSort(array, 0, array.length - 1);
                  }//insertion sorted sort
                  else if (insertion.isSelected() &amp;&amp; sorted.isSelected()) {
                      int arraySize = Integer.parseInt(inputText.getText());
                      int[] array = getSorted(arraySize, true);
                      print(array);
                      insertionSort(array);
                  }//insertion random sort
                  else if (insertion.isSelected() &amp;&amp; random.isSelected()) {
                      int arraySize = Integer.parseInt(inputText.getText());
                      int[] array = getRandom(arraySize);
                      print(array);
                      insertionSort(array);
                  }//insertion reverse
                  else if (insertion.isSelected() &amp;&amp; reverse.isSelected()) {
                      int arraySize = Integer.parseInt(inputText.getText());
                      int[] array = null;
                      array = getReverse(array);
                      print(array);
                      insertionSort(array);
                  }//bubble sort
                  else if (bubble.isSelected() &amp;&amp; sorted.isSelected()) {
                      int arraySize = Integer.parseInt(inputText.getText());
                      int[] array = getSorted(arraySize, true);
                      print(array);
                      bubbleSort(array);
                  }//bubble random sort
                  else if (bubble.isSelected() &amp;&amp; random.isSelected()) {
                      int arraySize = Integer.parseInt(inputText.getText());
                      int[] array = getRandom(arraySize);
                      print(array);
                      bubbleSort(array);
                  }//bubble reverse sort
                  else if (bubble.isSelected() &amp;&amp; reverse.isSelected()) {
                      int arraySize = Integer.parseInt(inputText.getText());
                      int[] array = null;
                      array = getReverse(array);
                      print(array);
                      bubbleSort(array);
                  }
                  Alert alert = new Alert(Alert.AlertType.INFORMATION);
                  alert.setTitle("Thread Sorted!");
                  alert.setHeaderText("Finished");
                  alert.setContentText("Sort completed in milliseconds ");
                  alert.showAndWait();
              }
          });
          Scene scene = new Scene(rootPane, 500, 350);
          primaryStage.setTitle("Project 4");
          primaryStage.setScene(scene);
          primaryStage.show();
      }
  //insertion sort
  
      public static void insertionSort(int array[]) {
         // int loopCount = 0;
          int n = array.length;
          for (int j = 1; j &lt; n; j++) {
              int key = array[j];
              int i = j - 1;
              while ((i &gt; -1) &amp;&amp; (array[i] &gt; key)) {
                  array[i + 1] = array[i];
                  i--;
  
              }
              array[i + 1] = key;
          }
          //return loopCount;
      }
  //quick sort
  
      int partition(int arr[], int left, int right) {
          int i = left, j = right;
          int tmp;
          int pivot = arr[(left + right) / 2];
  
          while (i &lt;= j) {
              while (arr[i] &lt; pivot) {
                  i++;
              }
              while (arr[j] &gt; pivot) {
                  j--;
              }
              if (i &lt;= j) {
                  tmp = arr[i];
                  arr[i] = arr[j];
                  arr[j] = tmp;
                  i++;
                  j--;
              }
          }
  
          return i;
      }
  //quick sort
  
      public void quickSort(int arr[], int left, int right) {
          int index = partition(arr, left, right);
          if (left &lt; index - 1) {
              quickSort(arr, left, index - 1);
          }
          if (index &lt; right) {
              quickSort(arr, index, right);
          }
          //return index;
      }
  //bubble sort
  
      public static void bubbleSort(int[] arr) {
          int n = arr.length;
        //  int loopCount = 0;
          int temp = 0;
          for (int i = 0; i &lt; n; i++) {
              for (int j = 1; j &lt; (n - i); j++) {
                  if (arr[j - 1] &gt; arr[j]) {
                      temp = arr[j - 1];
                      arr[j - 1] = arr[j];
                      arr[j] = temp;
                  }
  
              }
          }
          //return loopCount;
      }
  //selection sort
  
      public static void selectionSort(int[] arr) {
  
          for (int i = 0; i &lt; arr.length - 1; i++) {
              int index = i;
              for (int j = i + 1; j &lt; arr.length; j++) {
                  if (arr[j] &lt; arr[index]) {
                      index = j;
                  }
  
              }
              int smallerNumber = arr[index];
              arr[index] = arr[i];
              arr[i] = smallerNumber;
          }
  
      }
  
      public static int[] getRandom(int size) {
          Random rand = new Random();
          int[] array = new int[size];
          for (int i = 1; i &lt;= size; i++) {
              array[i - 1] = Math.abs(rand.nextInt()) % 100;
          }
          return array;
      }
  
      public static int[] getSorted(int size, boolean accending) {
          int[] array = new int[size];
          if (accending) {
              for (int i = 1; i &lt;= size; i++) {
                  array[i - 1] = i;
              }
          } else {
              for (int i = size; i &gt; 0; i--) {
                  array[size - i] = i;
              }
          }
          return array;
      }
       public static int[] getReverse(int[] arrayw) {
          int[] array = new int[arrayw.length];
         for (int i = 0,j = array.length-1; i&lt;array.length;i++,j--) {
                  array[j] = arrayw[i];
              }
         return array;
      }
  
  
      public static void print(int[] array) {
  
          for (int i = 0; i &lt; array.length; i++) {
              System.out.print(" " + array[i]);
          }
          System.out.println();
      }
  
      /**
       * @param args the command line arguments
       */
      public static void main(String[] args) {
          launch(args);
      }
  }
  </code></pre>