/*

* To change this license header, choose License Headers in Project Properties.

* To change this template file, choose Tools | Templates

* and open the template in the editor.

*/

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.EventQueue;

import java.awt.Font;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Insets;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.ArrayList;

import java.util.List;

import javax.swing.BorderFactory;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JTextField;

import javax.swing.SwingUtilities;

import javax.swing.Timer;

import javax.swing.border.CompoundBorder;

import javax.swing.border.EmptyBorder;
import javax.swing.border.LineBorder;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

/**

* @author FARHAN

*/

public class TestSort {

private List<Sorter> sorters;

int[] values;

int i=0;

BubbleSort sorter1;

String[] parts;

SortPane sortPane ;

private final JLabel label = new JLabel();

private JTextField textfield = new JTextField(10);

private JPanel panel = new JPanel();

private final JButton bubble= new JButton("Bubble Sort");

private final JButton insertion= new JButton("Insertion Sort");

private final JButton merge= new JButton("Merge Sort");

private final JButton selection= new JButton("Selection Sort");

private final JButton quick= new JButton("Quick Sort");

private final JButton radix= new JButton("Radix Sort");

private final JButton heap=new JButton("Heap Sort");

private final JButton create = new JButton("Create");

// main
public static void main(String[] args) {

TestSort testSort = new TestSort();

// constructor

public TestSort() {

EventQueue.invokeLater(new Runnable() {

@Override

public void run() {

JFrame frame = new JFrame("@Team Jojo-Pagal");

// Label

label.setText("Visualization of Sorting Algorithms");

label.setFont(new Font("SansSerif", 3, 36));

label.setForeground(Color.red);

//label.setBackground(new Color(150,235,210,100));

label.setBackground(Color.yellow);

label.setBounds(10,10, 620, 60);

label.setOpaque(true);

label.setBorder(BorderFactory.createLineBorder(Color.white, 3, true));

frame.add(label);

// Buttons

bubble.setBounds(50, 100, 115, 35);

bubble.setForeground(Color.magenta);

bubble.setBackground(Color.white);

bubble.setBorder(BorderFactory.createDashedBorder(Color.GREEN, 5, 2, 0, true));
bubble.setBorderPainted(true);

frame.add(bubble);

insertion.setBounds(50, 150, 115, 35);

insertion.setForeground(Color.magenta);

insertion.setBackground(Color.white);

insertion.setBorder(BorderFactory.createDashedBorder(Color.GREEN, 5, 2, 0, true));

insertion.setBorderPainted(true);

frame.add(insertion);

merge.setBounds(50, 200, 115, 35);

merge.setForeground(Color.magenta);

merge.setBackground(Color.white);

merge.setBorder(BorderFactory.createDashedBorder(Color.GREEN, 5, 2, 0, true));

merge.setBorderPainted(true);

frame.add(merge);

quick.setBounds(50, 250, 115, 35);

quick.setForeground(Color.magenta);

quick.setBackground(Color.white);

quick.setBorder(BorderFactory.createDashedBorder(Color.GREEN, 5, 2, 0, true));

quick.setBorderPainted(true);

frame.add(quick);

selection.setBounds(50, 300, 115, 35);

selection.setForeground(Color.magenta);

selection.setBackground(Color.white);

selection.setBorder(BorderFactory.createDashedBorder(Color.GREEN, 5, 2, 0, true));

selection.setBorderPainted(true);

frame.add(selection);

radix.setBounds(50, 350, 115, 35);

radix.setForeground(Color.magenta);

radix.setBackground(Color.white);

radix.setBorder(BorderFactory.createDashedBorder(Color.GREEN, 5, 2, 0, true));

radix.setBorderPainted(true);

frame.add(radix);

heap.setBounds(50, 400, 115, 35);

heap.setForeground(Color.magenta);

heap.setBackground(Color.white);

heap.setBorder(BorderFactory.createDashedBorder(Color.GREEN, 5, 2, 0, true));

heap.setBorderPainted(true);

frame.add(heap);

create.setBounds(755, 600, 100, 30);

create.setForeground(Color.magenta);

create.setBackground(Color.white);

create.setBorder(BorderFactory.createDashedBorder(Color.GREEN, 5, 2, 0, true));

create.setBorderPainted(true);

frame.add(create);
 // Textfield

textfield.setBounds(550, 600, 200, 30);

textfield.setBorder(BorderFactory.createLineBorder(Color.GREEN, 2, true));

frame.add(textfield);

panel.setBorder(BorderFactory.createTitledBorder(new LineBorder(Color.white, 4, true),

"Sorting Pane"));

panel.setBounds(342, 100, 682, 384);

panel.setLayout(new BorderLayout());

panel.setBackground(Color.GREEN);

frame.add(panel);

create.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent ae) {

panel.removeAll();

String s = textfield.getText();

panel.setVisible(false);

String str= textfield.getText();

parts = str.split(",");

values = new int[parts.length];

for(int i=0; i < parts.length; i++){

values[i] = Integer.parseInt(parts[i]);

}
 panel.setVisible(false);

panel.add(createSortPane(values));

System.out.println("after return create");

panel.setVisible(true);

panel.repaint();

});

sorters = new ArrayList<>(2);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.getContentPane().setLayout(null);

Dimension screensize = Toolkit.getDefaultToolkit().getScreenSize();

frame.setPreferredSize(new Dimension(screensize.width,screensize.height));

frame.getContentPane().setBackground(Color.CYAN);

frame.pack();

frame.setLocationRelativeTo(null);

frame.setVisible(true);

bubble.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent ae) {

panel.removeAll();
 panel.setVisible(false);

panel.add(createSortPane(values));

for (Sorter sorter : sorters) {

sorter.sort();

panel.repaint();

panel.setVisible(true);

});

insertion.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent ae) {

panel.removeAll();

i=1;

panel.setVisible(false);

panel.add(createSortPane(values));

for (Sorter sorter : sorters) {

sorter.sort();

panel.repaint();

panel.setVisible(true);

});
 selection.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent ae) {

i=2;

panel.removeAll();

panel.setVisible(false);

panel.add(createSortPane(values));

for (Sorter sorter : sorters) {

sorter.sort();

panel.repaint();

panel.setVisible(true);

});

});

protected SortPane createSortPane(int[] values) {

sortPane = new SortPane();

sorter1 = new BubbleSort(values);

sortPane.setSorter(sorter1);

sorters.add(sorter1);
 if(i==1){

InsertionSorter sorter2=new InsertionSorter(values);

sortPane.setSorter(sorter2);

sorters.add(sorter2);

i=0;

else if(i==2){

SelectionSorter sorter3 = new SelectionSorter(values);

sortPane.setSorter(sorter3);

sorters.add(sorter3);

i=0;

sortPane.setBorder(new CompoundBorder(new LineBorder(Color.MAGENTA), new

EmptyBorder(25, 25, 25, 25)));

return sortPane;

public class SortPane extends JPanel {

private Sorter sorter;

private ChangeHandler changeHandler;

private int maxValue;

@Override

protected void paintComponent(Graphics g) {

super.paintComponent(g);

Graphics2D g2d = (Graphics2D) g.create();

int[] values = getSorter().getValues();

Insets insets = getInsets();

int width = getWidth() -1 - (insets.right + insets.left);

int height = getHeight() - 1 - (insets.top + insets.bottom);

int colWidth = Math.round((float) width / (float) values.length);

int x = insets.left;

Color fill = Color.YELLOW;

Color highlight = null;

switch (getSorter().getState()) {

case Sorting:

fill = Color.green;

highlight = Color.red;

create.setEnabled(false);

break;

case Done:

fill = Color.blue;

create.setEnabled(true);

break;

for (int index = 0; index < values.length; index++) {

g2d.setColor(fill);

int value = values[index];

int colHeight = (int) ((float) height * ((float) value / (float) maxValue));

g2d.fill3DRect(x, insets.top + height - colHeight, colWidth - 1, colHeight , true);

if (getSorter().isActiveIndex(index) && highlight != null) {

g2d.setColor(highlight);

g2d.draw3DRect(x, insets.top + height - colHeight, colWidth - 1, colHeight , true);

}
 x += colWidth;

g2d.dispose();

this.repaint();

public Sorter getSorter() {

return sorter;

public void setSorter(Sorter value) {

System.out.println("in setsorter");

if (sorter != value) {

if (sorter != null){

sorter.removeChangeListener(getChangeHandler());

sorter = value;

if (sorter != null) {

sorter.addChangeListener(getChangeHandler());

maxValue = 0;

for (int intValue : sorter.getValues()) {

maxValue = Math.max(maxValue, intValue);

this.repaint();

System.out.println("end of the create function");

}
 public ChangeHandler getChangeHandler() {

if (changeHandler == null) {

changeHandler = new ChangeHandler();

return changeHandler;

public class ChangeHandler implements ChangeListener {

@Override

public void stateChanged(ChangeEvent e) {

repaint();

public interface Sorter {

public enum State {

Waiting,

Sorting,

Done

public void addChangeListener(ChangeListener listener);

public void removeChangeListener(ChangeListener listener);

 public int[] getValues();

public void sort();

public State getState();

public boolean isActiveIndex(int index);

public abstract class AbstracSorter implements Sorter {

private final List<ChangeListener> listeners;

private final int[] values;

private State state = State.Waiting;

private final List<Integer> activeIndices;

public AbstracSorter(int[] values) {

this.values = new int[values.length];

System.arraycopy(values, 0, this.values, 0, values.length);

listeners = new ArrayList<>(25);

activeIndices = new ArrayList<>(2);

@Override

public State getState() {

return state;

}
public void setState(State value) {

if (value != state) {

state = value;

fireStateChanged();

@Override

public int[] getValues() {

return values;

@Override

public void addChangeListener(ChangeListener listener) {

listeners.add(listener);

@Override

public void removeChangeListener(ChangeListener listener) {

listeners.remove(listener);

protected void fireStateChanged() {

if (listeners.size() > 0) {

ChangeEvent evt = new ChangeEvent(this);

listeners.forEach((listener) -> {

listener.stateChanged(evt);

});

}
 }

@Override

public boolean isActiveIndex(int index) {

return activeIndices.contains(index);

protected void setActiveIndicies(int lower, int upper) {

activeIndices.clear();

activeIndices.add(lower);

activeIndices.add(upper);

fireStateChanged();

protected void swap(int[] anArrayOfInt, int i, int j) {

setActiveIndicies(i, j);

int x = anArrayOfInt[i];

anArrayOfInt[i] = anArrayOfInt[j];

anArrayOfInt[j] = x;

fireStateChanged();

// Bubble Sort

public class BubbleSort extends AbstracSorter {

private int outter ;

private int inner ;

public BubbleSort(int[] values) {

super(values);

@Override

public void sort() {

setState(Sorter.State.Sorting);

outter = 0;

inner = 1;

Timer timer = new Timer(1000, new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

int[] values = getValues();

inner++;

if (inner >= values.length - outter) {

outter++;

inner = 1;

if (outter < values.length) {

if (values[inner - 1] > values[inner]) {

swap(values, inner - 1 , inner);

} else {

setActiveIndicies(inner - 1, inner);

} else {

((Timer) e.getSource()).stop();
 setState(Sorter.State.Done);

});

timer.setInitialDelay(1000);

timer.setDelay(500);

timer.setRepeats(true);

timer.start();

// Insertion Sort

public class InsertionSorter extends AbstracSorter {

public InsertionSorter(int[] values) {

super(values);

@Override

public void sort() {

setState(State.Sorting);

new Thread(new SortRunnable()).start();

@Override

protected void swap(int[] anArrayOfInt, int i, int j) {

setActiveIndicies(i, j);

int x = anArrayOfInt[i];

anArrayOfInt[i] = anArrayOfInt[j];
 anArrayOfInt[j] = x;

fireStateChanged();

class SortRunnable implements Runnable {

@Override

public void run() {

int[] values = getValues();

for (int i = 1; i < values.length; i++) {

int temp = values[i];

for (int j = i ; j > 0 && temp < values[j - 1]; j--) {

swap(values, j, j - 1);

try {

Thread.sleep(1000);

} catch (InterruptedException ex) {

SwingUtilities.invokeLater(new Runnable() {

@Override

public void run() {

setState(State.Done);

});

}
}

// Selection Sort

class SelectionSorter extends AbstracSorter {

public SelectionSorter(int[] values) {

super(values);

public void sort() {

setState(TestSort.Sorter.State.Sorting);

new Thread(new SortRunnable()).start();

@Override

protected void swap(int[] anArrayOfInt, int i, int j) {

setActiveIndicies(i, j);

int x = anArrayOfInt[i];

anArrayOfInt[i] = anArrayOfInt[j];

anArrayOfInt[j] = x;

fireStateChanged();

class SortRunnable implements Runnable {

@Override

public void run() {

 int[] values = getValues();

for(int i=0; i < values.length - 1 ; i++){

int index = i;

for(int j= i+1; j<values.length;j++){

if(values[j] < values[index]){

index = j;

swap(values , i ,index);

try{

Thread.sleep(1000);

} catch (InterruptedException ex) {

SwingUtilities.invokeLater(new Runnable() {

@Override

public void run() {

setState(TestSort.Sorter.State.Done);

});