SchedulingGUI.java

package algorithms;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridLayout;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

import javax.swing.AbstractAction;
import javax.swing.ActionMap;
import javax.swing.BorderFactory;
import javax.swing.InputMap;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.KeyStroke;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellRenderer;

public class SchedulingGUI extends JFrame {
	private ArrayList<Process> processList = new ArrayList<>();
	private DefaultTableModel inputTableModel;
	private DefaultTableModel resultTableModel;
	private JTable inputTable;
	private JTable resultTable;
	private JComboBox<String> algorithmComboBox;
	private JTextField processIdField, burstTimeField, priorityField,
			arrivalTimeField, quantumField;
	private JButton addButton, calculateButton, clearButton;
	private JLabel avgWaitTimeLabel, avgTurnaroundTimeLabel;
	private JPanel ganttChartPanel;
	private Color[] processColors;
	private JCheckBox priorityCheckBox, arrivalCheckBox;

	// Simplified color scheme
	private final Color PRIMARY_COLOR = new Color(100, 149, 237); // Cornflower
	private final Color BACKGROUND_COLOR = new Color(240, 240, 240); // blue
	private final Color TEXT_COLOR = new Color(50, 50, 50);
	private final Color BUTTON_COLOR = new Color(100, 149, 237);

	// Simplified fonts
	private final Font HEADER_FONT = new Font("Arial", Font.BOLD, 14);
	private final Font REGULAR_FONT = new Font("Arial", Font.PLAIN, 12);
	private final Font BUTTON_FONT = new Font("Arial", Font.BOLD, 12);

	// Scheduling algorithm instances
	private FCFSScheduling fcfsScheduler;
	private SJFScheduling sjfScheduler;
	private PriorityScheduling priorityScheduler;
	private RoundRobinScheduling rrScheduler;

	public SchedulingGUI() {
		setTitle("CPU Scheduling Simulator");
		setSize(800, 700); // Increased height for algorithm buttons
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setLocationRelativeTo(null);
		getContentPane().setBackground(BACKGROUND_COLOR);

		// Initialize schedulers
		fcfsScheduler = new FCFSScheduling();
		sjfScheduler = new SJFScheduling();
		priorityScheduler = new PriorityScheduling();
		rrScheduler = new RoundRobinScheduling();

		// Initialize process colors
		processColors = new Color[]{new Color(66, 165, 245), // blue
				new Color(236, 64, 122), // pink
				new Color(255, 167, 38), // orange
				new Color(102, 187, 106), // green
				new Color(171, 71, 188), // purple
				new Color(41, 182, 246), // light blue
				new Color(255, 112, 67), // deep orange
				new Color(92, 107, 192), // indigo
				new Color(229, 115, 115), // red
				new Color(120, 144, 156) // blue grey
		};

		initComponents();

		// Set default quantum value
		quantumField.setText("2");
	}

	private void initComponents() {
		// Main layout
		setLayout(new BorderLayout(10, 10));

		// Controls Panel
		JPanel controlsPanel = new JPanel(new GridLayout(2, 1, 5, 5));
		controlsPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 5, 10));

		// Process Options Panel
		JPanel processOptionsPanel = new JPanel(
				new FlowLayout(FlowLayout.LEFT, 5, 0));

		// Process ID field
		JLabel processIdLabel = new JLabel("Process ID:");
		processIdField = new JTextField(5);
		processOptionsPanel.add(processIdLabel);
		processOptionsPanel.add(processIdField);

		// Burst Time field
		JLabel burstTimeLabel = new JLabel("Burst Time:");
		burstTimeField = new JTextField(5);
		processOptionsPanel.add(burstTimeLabel);
		processOptionsPanel.add(burstTimeField);

		// Priority field with checkbox
		JLabel priorityLabel = new JLabel("Priority:");
		priorityField = new JTextField(5);
		priorityField.setEnabled(false);
		priorityCheckBox = new JCheckBox("Use Priority");
		priorityCheckBox.addActionListener(e -> {
			boolean selected = priorityCheckBox.isSelected();
			priorityField.setEnabled(selected);
		});
		processOptionsPanel.add(priorityLabel);
		processOptionsPanel.add(priorityField);
		processOptionsPanel.add(priorityCheckBox);

		// Arrival Time field with checkbox
		JLabel arrivalTimeLabel = new JLabel("Arrival Time:");
		arrivalTimeField = new JTextField(5);
		arrivalTimeField.setEnabled(false);
		arrivalCheckBox = new JCheckBox("Use Arrival Time");
		arrivalCheckBox.addActionListener(e -> {
			boolean selected = arrivalCheckBox.isSelected();
			arrivalTimeField.setEnabled(selected);
		});
		processOptionsPanel.add(arrivalTimeLabel);
		processOptionsPanel.add(arrivalTimeField);
		processOptionsPanel.add(arrivalCheckBox);

		// Add Process button
		addButton = createButton("Add Process");
		processOptionsPanel.add(addButton);

		controlsPanel.add(processOptionsPanel);

		// Algorithm Options Panel
		JPanel algorithmOptionsPanel = new JPanel(
				new FlowLayout(FlowLayout.LEFT, 5, 0));

		// Algorithm ComboBox
		JLabel algorithmLabel = new JLabel("Algorithm:");
		algorithmComboBox = new JComboBox<>(
				new String[]{"First Come First Serve", "Priority Scheduling",
						"Shortest Job First", "Round Robin"});
		algorithmOptionsPanel.add(algorithmLabel);
		algorithmOptionsPanel.add(algorithmComboBox);

		// Quantum field for Round Robin
		JLabel quantumLabel = new JLabel("Time Quantum (RR):");
		quantumField = new JTextField(5);
		quantumField.setEnabled(false);
		algorithmOptionsPanel.add(quantumLabel);
		algorithmOptionsPanel.add(quantumField);

		// Action buttons
		calculateButton = createButton("Calculate");
		clearButton = createButton("Clear");

		algorithmOptionsPanel.add(calculateButton);
		algorithmOptionsPanel.add(clearButton);

		controlsPanel.add(algorithmOptionsPanel);

		// Algorithm selection listener
		algorithmComboBox.addActionListener(e -> {
			boolean isRR = algorithmComboBox.getSelectedItem()
					.equals("Round Robin");
			quantumField.setEnabled(isRR);
		});

		// Content Panels (Tables and Chart)
		JPanel contentPanel = new JPanel(new BorderLayout(10, 10));
		contentPanel.setBorder(BorderFactory.createEmptyBorder(0, 10, 5, 10));

		// Tables Panel (Input and Results side by side)
		JPanel tablesPanel = new JPanel(new GridLayout(1, 2, 10, 0));

		// Input Table
		JPanel inputPanel = new JPanel(new BorderLayout());
		inputPanel
				.setBorder(BorderFactory.createTitledBorder("Input Processes"));

		String[] inputColumnNames = {"Process", "Arrival Time", "Burst Time",
				"Priority"};
		inputTableModel = new DefaultTableModel(inputColumnNames, 0) {
			@Override
			public boolean isCellEditable(int row, int column) {
				return false;
			}
		};
		inputTable = new JTable(inputTableModel);
		inputTable.setFillsViewportHeight(true);
		JScrollPane inputScrollPane = new JScrollPane(inputTable);
		inputPanel.add(inputScrollPane, BorderLayout.CENTER);
		tablesPanel.add(inputPanel);

		// Results Table
		JPanel resultPanel = new JPanel(new BorderLayout());
		resultPanel.setBorder(BorderFactory.createTitledBorder("Results"));

		String[] resultColumnNames = {"Process", "Arrival Time", "Burst Time",
				"Start Time", "Completion Time", "Turnaround Time",
				"Waiting Time"};
		resultTableModel = new DefaultTableModel(resultColumnNames, 0) {
			@Override
			public boolean isCellEditable(int row, int column) {
				return false;
			}
		};
		resultTable = new JTable(resultTableModel);
		resultTable.setFillsViewportHeight(true);
		resultTable.setDefaultRenderer(Object.class, new TableCellRenderer() {
			private final TableCellRenderer defaultRenderer = resultTable
					.getDefaultRenderer(Object.class);

			@Override
			public Component getTableCellRendererComponent(JTable table,
					Object value, boolean isSelected, boolean hasFocus, int row,
					int column) {
				Component c = defaultRenderer.getTableCellRendererComponent(
						table, value, isSelected, hasFocus, row, column);

				if (column == 0 && c instanceof JLabel) {
					// Color the process ID cell with process color
					int processId = Integer
							.parseInt(((JLabel) c).getText().replace("P", ""));
					c.setBackground(
							processColors[processId % processColors.length]);
					c.setForeground(Color.WHITE);
				} else {
					if (!isSelected) {
						c.setBackground(row % 2 == 0
								? Color.WHITE
								: new Color(245, 245, 245));
						c.setForeground(TEXT_COLOR);
					}
				}
				return c;
			}
		});
		JScrollPane resultScrollPane = new JScrollPane(resultTable);
		resultPanel.add(resultScrollPane, BorderLayout.CENTER);
		tablesPanel.add(resultPanel);

		contentPanel.add(tablesPanel, BorderLayout.CENTER);

		// Gantt Chart Panel
		JPanel chartContainer = new JPanel(new BorderLayout());
		chartContainer
				.setBorder(BorderFactory.createTitledBorder("Gantt Chart"));

		ganttChartPanel = new JPanel() {
			@Override
			protected void paintComponent(Graphics g) {
				super.paintComponent(g);
				// Fix: Call drawGanttChart method properly
				if (processList.isEmpty()) {
					return;
				}

				Process[] processes = processList.toArray(new Process[0]);
				String selectedAlgorithm = (String) algorithmComboBox
						.getSelectedItem();

				// Use Graphics2D for better rendering
				Graphics2D g2d = (Graphics2D) g;
				g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
						RenderingHints.VALUE_ANTIALIAS_ON);

				int width = getWidth();
				int height = getHeight();
				int padding = 20;
				int chartHeight = 40;
				int y = (height - chartHeight) / 2 - 10;

				// Find total time
				int totalTime = 0;
				for (Process p : processes) {
					totalTime = Math.max(totalTime, p.completionTime);
				}

				if (totalTime == 0) {
					g2d.setFont(new Font("Arial", Font.ITALIC, 14));
					g2d.setColor(Color.GRAY);
					String msg = "No processes scheduled";
					int msgWidth = g2d.getFontMetrics().stringWidth(msg);
					g2d.drawString(msg, (width - msgWidth) / 2, height / 2);
					return;
				}

				// Calculate scale factor
				float scale = (float) (width - 2 * padding) / totalTime;

				// Special handling for Round Robin
				if (selectedAlgorithm.equals("Round Robin")
						&& processes.length > 0
						&& processes[0].ganttData != null) {
					drawRoundRobinGantt(g2d, processes[0], width, height,
							padding, chartHeight, y, scale);
				} else {
					// Draw standard Gantt chart for other algorithms
					drawStandardGantt(g2d, processes, width, height, padding,
							chartHeight, y, scale);
				}

				// Draw timeline
				int timelineY = y + chartHeight + 10;
				g2d.setColor(Color.BLACK);
				g2d.drawLine(padding, timelineY, width - padding, timelineY);

				// Draw time markers
				g2d.setFont(new Font("Arial", Font.PLAIN, 10));
				for (int i = 0; i <= totalTime; i++) {
					if (i % 1 == 0 || i == totalTime) { // Draw fewer markers
														// for readability
						int x = padding + (int) (i * scale);
						g2d.drawLine(x, timelineY, x, timelineY + 5);
						String timeLabel = Integer.toString(i);
						int labelWidth = g2d.getFontMetrics()
								.stringWidth(timeLabel);
						g2d.drawString(timeLabel, x - labelWidth / 2,
								timelineY + 15);
					}
				}
			}
		};
		ganttChartPanel.setPreferredSize(new Dimension(0, 100));
		ganttChartPanel.setBackground(Color.WHITE);
		chartContainer.add(ganttChartPanel, BorderLayout.CENTER);

		// Average time labels
		JPanel statsPanel = new JPanel(
				new FlowLayout(FlowLayout.CENTER, 20, 5));
		avgWaitTimeLabel = new JLabel("Average Waiting Time: 0.0");
		avgTurnaroundTimeLabel = new JLabel("Average Turnaround Time: 0.0");
		avgWaitTimeLabel.setFont(HEADER_FONT);
		avgTurnaroundTimeLabel.setFont(HEADER_FONT);
		statsPanel.add(avgWaitTimeLabel);
		statsPanel.add(avgTurnaroundTimeLabel);
		chartContainer.add(statsPanel, BorderLayout.SOUTH);

		contentPanel.add(chartContainer, BorderLayout.SOUTH);

		// Add components to main frame
		add(controlsPanel, BorderLayout.NORTH);
		add(contentPanel, BorderLayout.CENTER);

		// Add event listeners
		addEventListeners();

		// Setup keyboard shortcuts
		setupKeyboardShortcuts();
	}

	private JButton createButton(String text) {
		JButton button = new JButton(text);
		button.setFont(BUTTON_FONT);
		button.setBackground(BUTTON_COLOR);
		button.setForeground(Color.WHITE);
		button.setFocusPainted(false);
		return button;
	}

	private void addEventListeners() {
		// Add process button
		addButton.addActionListener(e -> {
			try {
				if (processIdField.getText().isEmpty()
						|| burstTimeField.getText().isEmpty()) {
					JOptionPane.showMessageDialog(this,
							"Process ID and Burst Time are required!",
							"Input Error", JOptionPane.ERROR_MESSAGE);
					return;
				}

				int processId = Integer.parseInt(processIdField.getText());
				int burstTime = Integer.parseInt(burstTimeField.getText());
				int priority = priorityCheckBox.isSelected()
						? Integer.parseInt(priorityField.getText())
						: 0;
				int arrivalTime = arrivalCheckBox.isSelected()
						? Integer.parseInt(arrivalTimeField.getText())
						: 0;

				// Check if process ID already exists
				for (Process p : processList) {
					if (p.id == processId) {
						JOptionPane.showMessageDialog(this,
								"Process ID already exists!", "Input Error",
								JOptionPane.ERROR_MESSAGE);
						return;
					}
				}

				// Add process to list
				Process process = new Process(processId, burstTime, priority,
						arrivalTime);
				processList.add(process);

				// Add to input table
				inputTableModel.addRow(new Object[]{"P" + processId,
						arrivalTime, burstTime,
						priorityCheckBox.isSelected() ? priority : "-"});

				// Clear input fields
				processIdField.setText("");
				burstTimeField.setText("");
				priorityField.setText("");
				arrivalTimeField.setText("");

			} catch (NumberFormatException ex) {
				JOptionPane.showMessageDialog(this,
						"Please enter valid numeric values!", "Input Error",
						JOptionPane.ERROR_MESSAGE);
			}
		});

		// Calculate button
		calculateButton.addActionListener(e -> {
			if (processList.isEmpty()) {
				JOptionPane.showMessageDialog(this,
						"Please add at least one process!", "Input Error",
						JOptionPane.ERROR_MESSAGE);
				return;
			}

			// Convert ArrayList to array for scheduling
			Process[] processes = processList.toArray(new Process[0]);
			String selectedAlgorithm = (String) algorithmComboBox
					.getSelectedItem();

			// Apply selected algorithm
			switch (selectedAlgorithm) {
				case "First Come First Serve" :
					fcfsScheduler.schedule(processes);
					break;
				case "Shortest Job First" :
					sjfScheduler.schedule(processes);
					break;
				case "Priority Scheduling" :
					priorityScheduler.schedule(processes);
					break;
				case "Round Robin" :
					try {
						int quantum = Integer.parseInt(quantumField.getText());
						if (quantum <= 0) {
							JOptionPane.showMessageDialog(this,
									"Time quantum must be greater than zero!",
									"Input Error", JOptionPane.ERROR_MESSAGE);
							return;
						}
						rrScheduler.schedule(processes, quantum);
					} catch (NumberFormatException ex) {
						JOptionPane.showMessageDialog(this,
								"Please enter a valid time quantum!",
								"Input Error", JOptionPane.ERROR_MESSAGE);
						return;
					}
					break;
			}

			// Calculate average times
			double avgWaitTime = 0;
			double avgTurnaroundTime = 0;

			switch (selectedAlgorithm) {
				case "First Come First Serve" :
					avgWaitTime = fcfsScheduler
							.getAverageWaitingTime(processes);
					avgTurnaroundTime = fcfsScheduler
							.getAverageTurnaroundTime(processes);
					break;
				case "Shortest Job First" :
					avgWaitTime = sjfScheduler.getAverageWaitingTime(processes);
					avgTurnaroundTime = sjfScheduler
							.getAverageTurnaroundTime(processes);
					break;
				case "Priority Scheduling" :
					avgWaitTime = priorityScheduler
							.getAverageWaitingTime(processes);
					avgTurnaroundTime = priorityScheduler
							.getAverageTurnaroundTime(processes);
					break;
				case "Round Robin" :
					avgWaitTime = rrScheduler.getAverageWaitingTime(processes);
					avgTurnaroundTime = rrScheduler
							.getAverageTurnaroundTime(processes);
					break;
			}

			// Update result table
			updateResultTable(processes);

			// Update average time labels
			avgWaitTimeLabel.setText(
					String.format("Average Waiting Time: %.2f", avgWaitTime));
			avgTurnaroundTimeLabel.setText(String.format(
					"Average Turnaround Time: %.2f", avgTurnaroundTime));

			// Repaint Gantt chart
			ganttChartPanel.repaint();
		});

		// Clear button
		clearButton.addActionListener(e -> {
			processList.clear();
			inputTableModel.setRowCount(0);
			resultTableModel.setRowCount(0);
			avgWaitTimeLabel.setText("Average Waiting Time: 0.0");
			avgTurnaroundTimeLabel.setText("Average Turnaround Time: 0.0");
			ganttChartPanel.repaint();
		});

	}

	private void updateResultTable(Process[] processes) {
		// Clear result table
		resultTableModel.setRowCount(0);

		// Sort processes by ID for display
		Arrays.sort(processes, Comparator.comparingInt(p -> p.id));

		// Add processes to result table
		for (Process p : processes) {
			resultTableModel.addRow(new Object[]{"P" + p.id, p.arrivalTime,
					p.burstTime, p.startTime, p.completionTime,
					p.turnAroundTime, p.waitingTime});
		}
	}

	private void drawStandardGantt(Graphics2D g2d, Process[] processes,
			int width, int height, int padding, int chartHeight, int y,
			float scale) {
		// Reduce chart height slightly
		int adjustedChartHeight = chartHeight - 5;

		// Sort processes by start time for drawing
		Arrays.sort(processes, Comparator.comparingInt(p -> p.startTime));

		for (int i = 0; i < processes.length; i++) {
			Process p = processes[i];

			// Calculate position and width
			int x = padding + (int) (p.startTime * scale);
			int blockWidth = Math.max(1, (int) (p.burstTime * scale));

			// Draw process block
			Color processColor = processColors[p.id % processColors.length];
			g2d.setColor(processColor);
			g2d.fillRect(x, y, blockWidth, adjustedChartHeight);
			g2d.setColor(Color.BLACK);
			g2d.drawRect(x, y, blockWidth, adjustedChartHeight);

			// Draw process label
			g2d.setColor(Color.BLACK);
			g2d.setFont(new Font("Arial", Font.BOLD, 12));
			String label = "P" + p.id;
			int labelWidth = g2d.getFontMetrics().stringWidth(label);
			int labelHeight = g2d.getFontMetrics().getHeight();

			// Better center the label within the block (both horizontally and
			// vertically)
			if (labelWidth < blockWidth - 4) {
				int textX = x + (blockWidth - labelWidth) / 2;
				int textY = y + (adjustedChartHeight + labelHeight) / 2 - 2;
				g2d.drawString(label, textX, textY);
			}

			// Draw time at start of block
			g2d.setFont(new Font("Arial", Font.PLAIN, 10));
			String startTime = Integer.toString(p.startTime);
			labelWidth = g2d.getFontMetrics().stringWidth(startTime);
			g2d.drawString(startTime, x - labelWidth / 2, y - 2);
		}
	}
	private void drawRoundRobinGantt(Graphics2D g2d, Process process, int width,
			int height, int padding, int chartHeight, int y, float scale) {
		ArrayList<Integer> executionOrder = process.ganttData;
		ArrayList<Integer> executionTimes = process.ganttTimes;

		if (executionOrder == null || executionTimes == null
				|| executionOrder.size() == 0
				|| executionTimes.size() != executionOrder.size() + 1) {
			return;
		}

		for (int i = 0; i < executionOrder.size(); i++) {
			int processId = executionOrder.get(i);
			int startTime = executionTimes.get(i);
			int endTime = executionTimes.get(i + 1);
			int duration = endTime - startTime;

			// Calculate position and width
			int x = padding + (int) (startTime * scale);
			int blockWidth = Math.max(1, (int) (duration * scale));

			// Draw process block
			Color processColor = processColors[processId
					% processColors.length];
			g2d.setColor(processColor);
			g2d.fillRect(x, y, blockWidth, chartHeight);
			g2d.setColor(Color.BLACK);
			g2d.drawRect(x, y, blockWidth, chartHeight);

			// Draw process label
			g2d.setColor(Color.BLACK);
			g2d.setFont(new Font("Arial", Font.BOLD, 12));
			String label = "P" + processId;
			int labelWidth = g2d.getFontMetrics().stringWidth(label);

			// Center the label within the block
			if (labelWidth < blockWidth - 4) {
				g2d.drawString(label, x + (blockWidth - labelWidth) / 2,
						y + chartHeight / 2 + 5);
			}

			// Draw time at block boundaries
			g2d.setFont(new Font("Arial", Font.PLAIN, 10));
			String time = Integer.toString(startTime);
			labelWidth = g2d.getFontMetrics().stringWidth(time);
			g2d.drawString(time, x - labelWidth / 2, y - 2);
		}

		// Draw final time
		if (!executionTimes.isEmpty()) {
			int finalTime = executionTimes.get(executionTimes.size() - 1);
			int x = padding + (int) (finalTime * scale);
			g2d.setFont(new Font("Arial", Font.PLAIN, 10));
			String time = Integer.toString(finalTime);
			int labelWidth = g2d.getFontMetrics().stringWidth(time);
			g2d.drawString(time, x - labelWidth / 2, y - 2);
		}
	}

	private void setupKeyboardShortcuts() {
		// Add process with Enter key in process fields
		ActionMap actionMap = getRootPane().getActionMap();
		InputMap inputMap = getRootPane()
				.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);

		String addProcessKey = "addProcess";
		inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0),
				addProcessKey);
		actionMap.put(addProcessKey, new AbstractAction() {
			@Override
			public void actionPerformed(ActionEvent e) {
				if (processIdField.hasFocus() || burstTimeField.hasFocus()
						|| priorityField.hasFocus()
						|| arrivalTimeField.hasFocus()) {
					addButton.doClick();
				}
			}
		});

		// Calculate with Ctrl+Enter
		String calculateKey = "calculate";
		inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER,
				KeyEvent.CTRL_DOWN_MASK), calculateKey);
		actionMap.put(calculateKey, new AbstractAction() {
			@Override
			public void actionPerformed(ActionEvent e) {
				calculateButton.doClick();
			}
		});

		// Clear with Escape
		String clearKey = "clear";
		inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), clearKey);
		actionMap.put(clearKey, new AbstractAction() {
			@Override
			public void actionPerformed(ActionEvent e) {
				clearButton.doClick();
			}
		});
	}

	public static void main(String[] args) {
		try {
			// Set System look and feel
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		} catch (Exception e) {
			e.printStackTrace();
		}

		SwingUtilities.invokeLater(() -> {
			new SchedulingGUI().setVisible(true);
		});
	}
}