code

package Login;

import java.awt.Component;
import java.awt.Dimension;
import java.awt.Event;
import java.awt.EventQueue;
import java.awt.Toolkit;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.event.CellEditorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.RowSorterEvent;
import javax.swing.event.RowSorterListener;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableModel;
import javax.swing.table.TableRowSorter;
import javax.swing.JMenuBar;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.AbstractAction;
import javax.swing.ButtonModel;
import javax.swing.JButton;
import javax.swing.JTable;
import javax.swing.KeyStroke;
import javax.swing.RowSorter;
import javax.swing.SortOrder;
import javax.swing.JScrollPane;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.EventObject;
import java.util.List;
import java.util.Objects;
import java.awt.event.ActionEvent;
import java.awt.Font;

public class database extends JFrame {

	/**
	 *
	 */
	private static final long serialVersionUID = 1L;
	private JPanel contentPane;
	private JTable table;

// shit idea starts from here



 // shit idea ends here
	/**
	 * Launch the application.
	 */
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					database frame = new database();
					frame.setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * Create the frame.
	 */
	public database() {
		setResizable(false);
		Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
		setBounds(100, 100, 607, 470);
		setLocation(dim.width/2-this.getSize().width/2, dim.height/2-this.getSize().height/2);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);


		JMenuBar menuBar = new JMenuBar();
		setJMenuBar(menuBar);

		JMenu mnMenu = new JMenu("Menu");
		menuBar.add(mnMenu);

		JMenuItem mntmOpenGuestbook = new JMenuItem("Open guestbook");
		mntmOpenGuestbook.setMnemonic(KeyEvent.VK_O);
		mntmOpenGuestbook.setAccelerator(
                KeyStroke.getKeyStroke(KeyEvent.VK_O, Event.CTRL_MASK));
		mntmOpenGuestbook.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				try{
					Connection conn = DriverManager.
							getConnection("jdbc:mysql://localhost:3306/guestbook",
									"root", "admin");
				 System.out.println(conn);
				 Statement stmt = conn.createStatement();
				 String query = "SELECT * FROM GUESTS";
				 ResultSet rs = stmt.executeQuery(query);

				 DefaultTableModel model = new DefaultTableModel(new String[]{"NUMBER","NAME", "SURNAME", "EMAIL", "COMMENTS","ACTIONS"}, 0);


				  while (rs.next())
			      {
					String id = rs.getString("ID_GUESTS");
			        String firstName = rs.getString("FIRST_NAME");
			        String lastName = rs.getString("SURNAME");
			        String email = rs.getString("EMAIL");
			        String comments = rs.getString("COMMENTS");
			        String empty = "";
			        model.addRow(new Object[]{id,firstName, lastName, email, comments, empty});

			      }table.setModel(model);
			      table.createDefaultColumnsFromModel();
			      TableColumn column = table.getColumnModel().getColumn(5);
			        column.setCellRenderer(new ButtonsRenderer());
			        column.setCellEditor(new ButtonsEditor(table));


			  	// ENABLE SORTING
					table.setAutoCreateRowSorter(true);

					TableRowSorter<TableModel> sorter = new TableRowSorter<>(table.getModel());
					table.setRowSorter(sorter);
					List<RowSorter.SortKey> sortKeys = new ArrayList<>();

					// SORT BY MULTIPE COLUMNS
					int columnIndexForName = 2;
					sortKeys.add(new RowSorter.SortKey(columnIndexForName, SortOrder.ASCENDING));

					int columnIndexForSurname = 1;
					sortKeys.add(new RowSorter.SortKey(columnIndexForSurname, SortOrder.ASCENDING));

					sorter.setSortKeys(sortKeys);

					// LISTEN TO SORTING EVENTS
					sorter.addRowSorterListener(new RowSorterListener() {
						@Override
						public void sorterChanged(RowSorterEvent evt) {
							int indexOfNoColumn = 0;
							for (int i = 0; i < table.getRowCount(); i++) {
								table.setValueAt(i + 1, i, indexOfNoColumn);
							}
						}
					});

					// DISABLE SORTING FOR A SPECIFIC COLUMN
					sorter.setSortable(5, false);
					//sorter.setSortable(0, false);

					// SPECIFY COMPARATOR FOR SORTING A SPECIFIC COLUMN
					sorter.setComparator(columnIndexForName, new Comparator<String>() {

						public int compare(String name1, String name2) {
							return name1.compareTo(name2);
						}
					});
					sorter.sort();
					table.setDefaultEditor(Object.class, null);
					table.setAutoCreateColumnsFromModel(false);
					int par1 = 35;
					//table.removeColumn(table.getColumnModel().getColumn(0));
					table.setRowHeight(par1);




					for (int column1 = 0; column1 < table.getColumnCount(); column1++)
					{
					    TableColumn tableColumn = table.getColumnModel().getColumn(column1);
					    int preferredWidth = tableColumn.getMinWidth();
					    int maxWidth = tableColumn.getMaxWidth();

					    for (int row = 0; row < table.getRowCount(); row++)
					    {
					        TableCellRenderer cellRenderer = table.getCellRenderer(row, column1);
					        Component c = table.prepareRenderer(cellRenderer, row, column1);
					        int width = c.getPreferredSize().width + table.getIntercellSpacing().width;
					        preferredWidth = Math.max(preferredWidth, width);

					        //  We've exceeded the maximum width, no need to check other rows

					        if (preferredWidth >= maxWidth)
					        {
					            preferredWidth = maxWidth;
					            break;
					        }
					    }

					    tableColumn.setPreferredWidth( preferredWidth );}


				}catch(SQLException e3){}

			}

		});
		mnMenu.add(mntmOpenGuestbook);

		JMenuItem mntmSaveAs = new JMenuItem("Save as...");
		mnMenu.add(mntmSaveAs);
		mntmSaveAs.setMnemonic(KeyEvent.VK_S);
		mntmSaveAs.setAccelerator(
                KeyStroke.getKeyStroke(KeyEvent.VK_S, Event.CTRL_MASK));

		JMenuItem mntmExit = new JMenuItem("Exit");
		mntmExit.setMnemonic(KeyEvent.VK_Q);
		mntmExit.setAccelerator(
                KeyStroke.getKeyStroke(KeyEvent.VK_Q, Event.CTRL_MASK));
		mntmExit.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				System.exit(0);
			}
		});
		mnMenu.add(mntmExit);

		JMenu mnHelp = new JMenu("Help");
		menuBar.add(mnHelp);

		JMenuItem mntmAbout = new JMenuItem("About");
		mnHelp.add(mntmAbout);
		mntmAbout.setMnemonic(KeyEvent.VK_A);
		mntmAbout.setAccelerator(
                KeyStroke.getKeyStroke(KeyEvent.VK_H, Event.CTRL_MASK));
		contentPane = new JPanel();
		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
		setContentPane(contentPane);
		contentPane.setLayout(null);

		JButton btnAdd = new JButton("Add");
		btnAdd.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				FeedbackForm form = new FeedbackForm();
				form.setVisible(true);
				form.setLocationRelativeTo(null);



// FORM settings















			}
		});
		btnAdd.setBounds(492, 377, 89, 23);
		contentPane.add(btnAdd);

		JScrollPane scrollPane = new JScrollPane();
		scrollPane.setBounds(10, 11, 571, 355);
		contentPane.add(scrollPane);

		table = new JTable();
		table.setFont(new Font("Times New Roman", Font.PLAIN, 12));
		scrollPane.setViewportView(table);



    }





/*		Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
		setBounds(100, 100, 607, 470);
		setLocation(dim.width/2-this.getSize().width/2, dim.height/2-this.getSize().height/2);
		*/

	}




/*



FROM HERE ON THERE ARE THE COLUMN BUTTON SETTINGS








*/
class ButtonsPanel extends JPanel {
    /**
	 *
	 */
	private static final long serialVersionUID = 1L;
	public final List<JButton> buttons = Arrays.asList(new JButton("delete"), new JButton("edit"));
    protected ButtonsPanel() {
        super();
        setOpaque(true);
        for (JButton b: buttons) {
            b.setFocusable(false);
            b.setRolloverEnabled(false);
            add(b);
        }
    }
//     @Override public void updateUI() {
//         super.updateUI();
//     }
}

class ButtonsRenderer extends ButtonsPanel implements TableCellRenderer {
    /**
	 *
	 */
	private static final long serialVersionUID = 1L;
	@Override public void updateUI() {
        super.updateUI();
        setName("Table.cellRenderer");
    }
    @Override public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
        this.setBackground(isSelected ? table.getSelectionBackground() : table.getBackground());
        return this;
    }
}

class ViewAction extends AbstractAction {
    /**
	 *
	 */
	private static final long serialVersionUID = 1L;
	private final JTable table;
    protected ViewAction(JTable table) {
        super("delete");
        this.table = table;
    }
    @Override public void actionPerformed(ActionEvent e) {

    	//	MAKE  ROW DELEATABLE


       int row = table.convertRowIndexToModel(table.getEditingRow());
       Object o = table.getModel().getValueAt(row, 0);
       JOptionPane.showMessageDialog(table, "deleting: " + o);
       try
       {
          Class.forName("com.mysql.jdbc.Driver");
          Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/guestbook",
					"root", "admin");

          java.sql.PreparedStatement st = connection.prepareStatement("DELETE FROM Guests WHERE ID_GUESTS = " + o + ";");
          st.executeUpdate();


       }
       catch(Exception e1)
       {
           System.out.println(e1);
       }


    }
}

class EditAction extends AbstractAction {
    /**
	 *
	 */
	private static final long serialVersionUID = 1L;
	private final JTable table;
    protected EditAction(JTable table) {
        super("edit");
        this.table = table;
    }
    @Override public void actionPerformed(ActionEvent e) {


    	// MAKE CELL EDITEABLE

    	 //Object o = table.getModel().getValueAt(table.getSelectedRow(), 0);
        int row = table.convertRowIndexToModel(table.getEditingRow());
        Object o = table.getModel().getValueAt(row, 0);

        table.isCellEditable(row, 0);



    }
    }


class ButtonsEditor extends ButtonsPanel implements TableCellEditor {
    /**
	 *
	 */
	private static final long serialVersionUID = 1L;
	protected transient ChangeEvent changeEvent;
    protected final JTable table;
    private class EditingStopHandler extends MouseAdapter implements ActionListener {
        @Override public void mousePressed(MouseEvent e) {
            Object o = e.getSource();
            if (o instanceof TableCellEditor) {
                actionPerformed(null);
            } else if (o instanceof JButton) {
                //DEBUG: view button click -> control key down + edit button(same cell) press -> remain selection color
                ButtonModel m = ((JButton) e.getComponent()).getModel();
                if (m.isPressed() && table.isRowSelected(table.getEditingRow()) && e.isControlDown()) {
                    setBackground(table.getBackground());
                }
            }
        }
        @Override public void actionPerformed(ActionEvent e) {
            EventQueue.invokeLater(() -> fireEditingStopped());
        }
    }
    protected ButtonsEditor(JTable table) {
        super();
        this.table = table;
        buttons.get(0).setAction(new ViewAction(table));
        buttons.get(1).setAction(new EditAction(table));

        EditingStopHandler handler = new EditingStopHandler();
        for (JButton b: buttons) {
            b.addMouseListener(handler);
            b.addActionListener(handler);
        }
        addMouseListener(handler);
    }
    @Override public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
        this.setBackground(table.getSelectionBackground());
        return this;
    }
    @Override public Object getCellEditorValue() {
        return "";
    }

    //Copied from AbstractCellEditor
    //protected EventListenerList listenerList = new EventListenerList();
    //protected transient ChangeEvent changeEvent;
    @Override public boolean isCellEditable(EventObject e) {
        return true;
    }
    @Override public boolean shouldSelectCell(EventObject anEvent) {
        return true;
    }
    @Override public boolean stopCellEditing() {
        fireEditingStopped();
        return true;
    }
    @Override public void cancelCellEditing() {
        fireEditingCanceled();
    }
    @Override public void addCellEditorListener(CellEditorListener l) {
        listenerList.add(CellEditorListener.class, l);
    }
    @Override public void removeCellEditorListener(CellEditorListener l) {
        listenerList.remove(CellEditorListener.class, l);
    }
    public CellEditorListener[] getCellEditorListeners() {
        return listenerList.getListeners(CellEditorListener.class);
    }
    protected void fireEditingStopped() {
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length - 2; i >= 0; i -= 2) {
            if (listeners[i] == CellEditorListener.class) {
                // Lazily create the event:
                if (Objects.isNull(changeEvent)) {
                    changeEvent = new ChangeEvent(this);
                }
                ((CellEditorListener) listeners[i + 1]).editingStopped(changeEvent);
            }
        }
    }
    protected void fireEditingCanceled() {
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length - 2; i >= 0; i -= 2) {
            if (listeners[i] == CellEditorListener.class) {
                // Lazily create the event:
                if (Objects.isNull(changeEvent)) {
                    changeEvent = new ChangeEvent(this);
                }
                ((CellEditorListener) listeners[i + 1]).editingCanceled(changeEvent);
            }
        }
    }
}