JTable

/* general utilities */

class Message 
{ public java.lang.String description(){ return "no description available"; }}

interface Port<T>
{ public void of( final T t ); }

interface Disposable
{ public void dispose(); }

class GenericActionListener implements java.awt.event.ActionListener, Disposable
{ final Port<Message> messagePort;
  final Message message;
  public GenericActionListener( final Port<Message> messagePort, final Message message )
  { this.messagePort = messagePort;
    this.message = message; }
  public void actionPerformed( final java.awt.event.ActionEvent actionEvent )
  { this.messagePort.of( this.message ); }
  public void dispose()
  { }}

class GenericMenuItem extends javax.swing.JMenuItem
implements Port<Message>, Disposable
{ private static final long serialVersionUID = 0L;
  Port<Message> messagePort;
  java.awt.event.ActionListener actionListener;
  public GenericMenuItem( final java.lang.String text, final Port<Message> messagePort, final Message message, final int keyShortcut, final int keyEvent, final int modifiers, final java.lang.String description )
  { super( text, keyShortcut );
    this.messagePort = messagePort;
    this.actionListener = new GenericActionListener( this, message ); 
    this.setAccelerator( javax.swing.KeyStroke.getKeyStroke( keyEvent, modifiers ));
    this.getAccessibleContext().setAccessibleDescription( description );
    this.addActionListener( this.actionListener ); }
  public void of( final Message message ){ this.messagePort.of( message ); }
  public void dispose()
  { try{ (( Disposable )this.actionListener ).dispose(); } 
    catch( final java.lang.ClassCastException classCastException ){}
    this.actionListener = null; 
    this.messagePort = null; }}

/* main component */

class MainCommand extends Message { }

class QuitMainCommand extends MainCommand { }

class MainMenu extends javax.swing.JMenu
implements Port<Message>, Disposable
{ private static final long serialVersionUID = 0L;
  Port<Message> target;
  public MainMenu( final Port<Message> target )
  { super( "Prozeß" );
    this.target = target;
    this.setMnemonic( java.awt.event.KeyEvent.VK_P );
    this.getAccessibleContext().setAccessibleDescription( "Steuerung des Prozesses" ); 
    this.add( new GenericMenuItem( "Beenden", this, new QuitMainCommand(), java.awt.event.KeyEvent.VK_B, java.awt.event.KeyEvent.VK_B, java.awt.event.ActionEvent.CTRL_MASK, "Beendet diesen Prozeß." )); }
  public void of( final Message message ){ this.target.of( message ); }
  public void dispose()
  { this.target = null; }}

class MainMenuBar extends javax.swing.JMenuBar
implements Port<Message>, Disposable
{ private static final long serialVersionUID = 0L;
  Port<Message> target = null;
  java.util.List<javax.swing.JMenu> list = null;
  public MainMenuBar()
  { list = new java.util.ArrayList<javax.swing.JMenu>();
    final MainMenu mainMenu = new MainMenu( this );
    this.add( mainMenu ); }
  public MainMenuBar( final Port<Message> target )
  { this(); this.acceptTarget( target ); }
  public void acceptTarget( final Port<Message> target )
  { this.target = target; }
  public void of( final Message message ){ this.target.of( message ); }
  public javax.swing.JMenu add( final javax.swing.JMenu menu )
  { this.list.add( menu );
    return super.add( menu ); }
  public void dispose()
  { for( final javax.swing.JMenu menu: this.list )
    try{ (( Disposable )menu ).dispose(); } 
    catch( final java.lang.ClassCastException classCastException ){}
    list = null;
    this.target = null; }}

class MainFrame extends javax.swing.JFrame
implements Port<Message>, Disposable
{ private static final long serialVersionUID = 0L;
  MainMenuBar mainMenuBar = null;
  ClubPanel clubPanel = null;
  public MainFrame( final ClubPanel clubPanel, final MainMenuBar mainMenuBar ) 
  { super( "Vereinsverwaltung" );
    this.mainMenuBar = mainMenuBar;
    this.setDefaultCloseOperation( javax.swing.JFrame.EXIT_ON_CLOSE ); /* todo */
    mainMenuBar.acceptTarget( this );
    { this.clubPanel = clubPanel;
      this.setContentPane( clubPanel );
      clubPanel.addTo( mainMenuBar ); }
    this.setJMenuBar( mainMenuBar );
    this.pack();
    this.setVisible( true ); }
  /** message port for downward messages */
  public void of( final Message message )
  { this.dispose(); }
  public void dispose()
  { this.clubPanel.dispose();
    this.clubPanel = null;
    this.mainMenuBar.dispose();
    this.setJMenuBar( null );
    super.dispose(); }}

public class Main 
{ public static void main( final java.lang.String[] args ) 
  { javax.swing.SwingUtilities.invokeLater
    ( new java.lang.Runnable() 
      { public void run() 
        { new MainFrame( new ClubPanel(), new MainMenuBar() ); }} ); }}

/* club component */

class ClubCommand extends Message 
{ int selectedRow; }

class DeleteRowClubCommand extends ClubCommand { }

class ClubMenu extends javax.swing.JMenu
implements Port<Message>, Disposable
{ private static final long serialVersionUID = 0L;
  Port<Message> target;
  public ClubMenu( final Port<Message> target )
  { super( "Verein" );
    this.target = target;
    this.setMnemonic( java.awt.event.KeyEvent.VK_V );
    this.getAccessibleContext().setAccessibleDescription( "Vereinsoperationen" ); 
    this.add( new GenericMenuItem( "Zeile entfernen", this, new DeleteRowClubCommand(), java.awt.event.KeyEvent.VK_Z, java.awt.event.KeyEvent.VK_Z, java.awt.event.ActionEvent.CTRL_MASK, "Entfernt die selektierte Zeile." )); }
  public void of( final Message message ){ this.target.of( message ); }
  public void dispose()
  { this.target = null; }}

class ClubTableModel extends javax.swing.table.AbstractTableModel 
implements Port<ClubCommand>, Disposable
{ private static final long serialVersionUID = 0L;
  private String[] columnNames = 
  {   "Vorname", "Nachname",  "Hobby", "Jahre", "Mitglied" };
  private Object[][] data = 
  { { "Maria",   "Bergmann",  "Skifahren",   7, true  },
    { "Michael", "Meier",     "Angeln",      5, true  },
    { "Hans",    "Neumann",   "Schneidern", 24, false },
    { "Sabine",  "Wiener",    "Segeln",      8, true  },
    { "Ernst",   "Berger",    "Billard",     9, false }};
  int rowCount = data.length;
  public int getColumnCount(){ return columnNames.length; }
  public int getRowCount(){ return this.rowCount; }
  public String getColumnName( final int col ){ return columnNames[ col ]; }
  public Object getValueAt( final int row, final int col ) 
  { return data[ row ][ col ]; }
  public Class getColumnClass( final int c ) 
  { return getValueAt( 0, c ).getClass(); }
  public boolean isCellEditable( final int row, final int col ) 
  { return col >= 2; }
  public void setValueAt( final Object value, final int row, final int col ) 
  { data[ row ][ col ]= value;
    this.fireTableCellUpdated( row, col ); }
  public void of( final ClubCommand clubCommand )
  { final int row = clubCommand.selectedRow;
    for( int r = row; r < this.rowCount - 1; ++r )data[ r ]= data[ r + 1 ];
    if( this.rowCount > 0 )--this.rowCount;
    fireTableRowsDeleted( row, row ); }
  public void dispose()
  { this.columnNames = null;
    this.data = null; }}

class ClubTable extends javax.swing.JTable
implements Port<ClubCommand>, Disposable
{ private static final long serialVersionUID = 0L;
  private Port<ClubCommand> target;
  ClubTableModel clubTableModel = null;
  public ClubTable( final ClubTableModel clubTableModel ) 
  { super( clubTableModel, null, null );
    this.clubTableModel = clubTableModel;
    this.target = clubTableModel; 
    final javax.swing.table.DefaultTableCellRenderer tableRenderer =
    ( javax.swing.table.DefaultTableCellRenderer )
    this.getTableHeader().getDefaultRenderer();
    tableRenderer.setHorizontalAlignment( javax.swing.SwingConstants.LEFT ); }
  public void of( final ClubCommand clubCommand )
  { clubCommand.selectedRow = this.getSelectedRow();
    target.of( clubCommand ); }
  public void dispose()
  { this.clubTableModel.dispose();
    this.clubTableModel = null;
    this.target = null; }}

class ClubScrollPane extends javax.swing.JScrollPane
implements Port<ClubCommand>, Disposable
{ private static final long serialVersionUID = 0L;
  Port<ClubCommand> target;
  ClubTable myTable;
  public ClubScrollPane( final ClubTable myTable )
  { super( myTable );
    this.myTable = myTable;
    this.target = myTable;
    myTable.setPreferredScrollableViewportSize
    ( new java.awt.Dimension( 502, 68 ));
    myTable.setFillsViewportHeight( true );  }
  public void of( final ClubCommand clubCommand )
  { this.target.of( clubCommand ); }
  public void dispose()
  { this.myTable.dispose();
    this.myTable = null;
    this.target = null; }}

class ClubPanel extends javax.swing.JPanel 
implements Port<Message>, Disposable
{ private static final long serialVersionUID = 0L;
  Port<ClubCommand> target;
  ClubScrollPane myScrollPane = null;
  public void of( final Message message )
  { this.target.of(( ClubCommand )message ); }
  public void addTo( final javax.swing.JMenuBar menuBar )
  { menuBar.add( new ClubMenu( this )); }
  public ClubPanel() 
  { super( new java.awt.GridLayout( 1, 0 ));
    this.setOpaque( true ); /* Content panes have to be opaque. */
    myScrollPane = new ClubScrollPane( new ClubTable( new ClubTableModel() ));
    this.target = myScrollPane;
    this.add( myScrollPane ); }
  public void dispose()
  { this.myScrollPane.dispose();
    this.myScrollPane = null;
    this.target = null; }}

/*
Transport der Löschnachricht:
GenericActionListener
GenericMenuItem
ClubMenu
ClubPanel
ClubScrollPane
ClubTable
ClubTableModel
Object[][] (data[ r ]= data[ r + 1 ];)

Transport der Endnachricht:
GenericActionListener
GenericMenuItem
MainMenu
MainMenuBar
MainFrame
dispose()
*/