javax.swing.event.CellEditorListener Java Examples

protected void fireEditingCanceled() {
  final CellEditorListener[] listeners = this.listeners.getListeners( CellEditorListener.class );
  final ChangeEvent event = new ChangeEvent( this );
  for ( int i = 0; i < listeners.length; i++ ) {
    final CellEditorListener listener = listeners[ i ];
    listener.editingCanceled( event );
  }
}
 

protected void fireEditingStopped() {
  final CellEditorListener[] listeners = eventListenerList.getListeners( CellEditorListener.class );
  final ChangeEvent event = new ChangeEvent( this );
  for ( int i = 0; i < listeners.length; i++ ) {
    final CellEditorListener listener = listeners[ i ];
    listener.editingStopped( event );
  }
}
 

@Override
public boolean stopCellEditing() {
    for (CellEditorListener l : listeners) {
        l.editingStopped(new ChangeEvent(this));
    }
    return true;
}
 

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) {
            ((CellEditorListener) listeners[i + 1]).editingStopped(
                    new ChangeEvent(this));
        }
    }
}
 

/**
 * Add the specified listener to <em>all</em> the delegate editors.
 * @param l the listener to add
 */
@Override
public void addCellEditorListener(CellEditorListener l) {
  for(TableCellEditor e : editors) {
    e.addCellEditorListener(l);
  }
}
 

@Override
protected void processKeyEvent(KeyEvent e) {
    KeyStroke ks = KeyStroke.getKeyStrokeForEvent(e);
    if (enter.equals(ks)) {
        // Prevent JComponent.processKeyBindings() to be called (it is called from
        // JComponent.processKeyEvent() ), notify only registered key listeners
        int id = e.getID();
        for (KeyListener keyListener : getKeyListeners()) {
            switch(id) {
              case KeyEvent.KEY_TYPED:
                  keyListener.keyTyped(e);
                  break;
              case KeyEvent.KEY_PRESSED:
                  keyListener.keyPressed(e);
                  break;
              case KeyEvent.KEY_RELEASED:
                  keyListener.keyReleased(e);
                  break;
            }
        }
        if (!e.isConsumed() && id == KeyEvent.KEY_PRESSED) {
            synchronized(listeners) {
                List<CellEditorListener> list = new ArrayList<CellEditorListener>(listeners);
                for (CellEditorListener listener : list) {
                    listener.editingStopped(new ChangeEvent(this));
                }
            }
        }
        e.consume();
    } else {
        super.processKeyEvent(e);
    }
}
 

protected void fireEditingCanceled() {
  final CellEditorListener[] listeners = eventListenerList.getListeners( CellEditorListener.class );
  final ChangeEvent event = new ChangeEvent( this );
  for ( int i = 0; i < listeners.length; i++ ) {
    final CellEditorListener listener = listeners[ i ];
    listener.editingCanceled( event );
  }
}
 

@Override
protected void processKeyEvent(KeyEvent e) {
    KeyStroke ks = KeyStroke.getKeyStrokeForEvent(e);
    if (enter.equals(ks)) {
        // Prevent JComponent.processKeyBindings() to be called (it is called from
        // JComponent.processKeyEvent() ), notify only registered key listeners
        int id = e.getID();
        for (KeyListener keyListener : getKeyListeners()) {
            switch(id) {
              case KeyEvent.KEY_TYPED:
                  keyListener.keyTyped(e);
                  break;
              case KeyEvent.KEY_PRESSED:
                  keyListener.keyPressed(e);
                  break;
              case KeyEvent.KEY_RELEASED:
                  keyListener.keyReleased(e);
                  break;
            }
        }
        if (!e.isConsumed() && id == KeyEvent.KEY_PRESSED) {
            synchronized(listeners) {
                List<CellEditorListener> list = new ArrayList<CellEditorListener>(listeners);
                for (CellEditorListener listener : list) {
                    listener.editingStopped(new ChangeEvent(this));
                }
            }
        }
        e.consume();
    } else {
        super.processKeyEvent(e);
    }
}
 

/**
 * Notify all listeners that have registered interest for notification on
 * this event type.
 *
 * @see EventListenerList
 */
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) {
            ((CellEditorListener) listeners[i + 1]).editingCanceled(new ChangeEvent(this));
        }
    }
}
 

protected void fireEditingCanceled() {
  final CellEditorListener[] listeners = this.listeners.getListeners( CellEditorListener.class );
  final ChangeEvent event = new ChangeEvent( this );
  for ( int i = 0; i < listeners.length; i++ ) {
    final CellEditorListener listener = listeners[ i ];
    listener.editingCanceled( event );
  }
}
 

protected void fireEditingStopped() {
  final CellEditorListener[] listeners = eventListenerList.getListeners( CellEditorListener.class );
  final ChangeEvent event = new ChangeEvent( this );
  for ( int i = 0; i < listeners.length; i++ ) {
    final CellEditorListener listener = listeners[ i ];
    listener.editingStopped( event );
  }
}
 

protected void fireEditingStopped() {
  final CellEditorListener[] listeners = eventListenerList.getListeners( CellEditorListener.class );
  final ChangeEvent event = new ChangeEvent( this );
  for ( int i = 0; i < listeners.length; i++ ) {
    final CellEditorListener listener = listeners[ i ];
    listener.editingStopped( event );
  }
}
 

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) {
	((CellEditorListener)listeners[i+1]).editingStopped(new ChangeEvent(this));
    }
}
   }
 

protected void fireStopCellEditing() {
    ChangeEvent changeEvent = new ChangeEvent(this);
    synchronized (cellEditorListenerSet) {
        Iterator<CellEditorListener> it = cellEditorListenerSet.iterator();
        while (it.hasNext()) {
            it.next().editingStopped(changeEvent);
        }
    }
}
 

protected void fireCancelCellEditing() {
    ChangeEvent changeEvent = new ChangeEvent(this);
    synchronized (cellEditorListenerSet) {
        Iterator<CellEditorListener> it = cellEditorListenerSet.iterator();
        while (it.hasNext()) {
            it.next().editingCanceled(changeEvent);
        }
    }
}
 

@Override
public void removeCellEditorListener(CellEditorListener l) {
	// Removes a listener from the list that's notified
	listeners.remove(l);
}
 

@Override
public void removeCellEditorListener(CellEditorListener l)
{
}
 

public void addCellEditorListener(CellEditorListener l) {
}
 

public void addCellEditorListener(CellEditorListener l) {
}
 

public void addCellEditorListener( final CellEditorListener l ) {
  backend.addCellEditorListener( l );
}
 

public void removeCellEditorListener(CellEditorListener l) {
}
 

public void removeCellEditorListener(CellEditorListener l) {
}
 

public void addCellEditorListener(CellEditorListener listener) {
    evtListenerList.add(CellEditorListener.class,listener);
}
 

public void removeCellEditorListener(CellEditorListener l) {
listenerList.remove(CellEditorListener.class, l);
   }
 

public void addCellEditorListener(CellEditorListener listener) {
    evtListenerList.add(CellEditorListener.class,listener);
}
 

@Override
public void removeCellEditorListener(CellEditorListener listener) {
    synchronized(listeners) {
        listeners.remove(listener);
    }
}
 

@Override
public void addCellEditorListener(CellEditorListener listener) {
    synchronized(listeners) {
        listeners.add(listener);
    }
}
 

@Override
public void addCellEditorListener(CellEditorListener l) {
}
 

public void removeCellEditorListener(CellEditorListener l) {
    impl.removeCellEditorListener(l);
}
 

@Override
public void removeCellEditorListener(CellEditorListener l) {
	// TODO Auto-generated method stub
	
}