Java EventConstants.INSERT属性代码示例

/**
 * Fire a Tuple event.
 * @param t the Table on which the event has occurred
 * @param start the first row changed
 * @param end the last row changed
 * @param type the type of event, one of
 * {@link prefuse.data.event.EventConstants#INSERT} or
 * {@link prefuse.data.event.EventConstants#DELETE}.
 */
protected void fireTupleEvent(Table t, int start, int end, int type) {
    if ( m_tupleListeners != null && m_tupleListeners.size() > 0 ) {
        Object[] lstnrs = m_tupleListeners.getArray();
        Tuple[] tuples = new Tuple[end-start+1];
        for ( int i=0, r=start; r <= end; ++r, ++i ) {
            tuples[i] = t.getTuple(r);
        }
        for ( int i=0; i<lstnrs.length; ++i ) {
            TupleSetListener tsl = (TupleSetListener)lstnrs[i];
            if ( type == EventConstants.INSERT ) {
                tsl.tupleSetChanged(this, tuples, EMPTY_ARRAY);
            } else {
                tsl.tupleSetChanged(this, EMPTY_ARRAY, tuples);
            }
        }
    }
}
 

/**
 * @see prefuse.data.event.TableListener#tableChanged(prefuse.data.Table, int, int, int, int)
 */
public void tableChanged(Table t, int start, int end, int col, int type) {
    if ( type == EventConstants.UPDATE || t != m_table 
          || col != EventConstants.ALL_COLUMNS )
        return;
    
    boolean insert = (type==EventConstants.INSERT);
    for ( int r=start; r<=end; ++r )
        rowChanged(r, insert);
}
 

@Override
public void tableChanged(Table t, int start, int end, int col, int type) {
    // switch on the event type
    switch (type) {
    case EventConstants.UPDATE: {
        // do nothing if update on all columns, as this is only
        // used to indicate a non-measurable update.
        if (col == EventConstants.ALL_COLUMNS) {
            break;
        } else {
            for (int r = start; r <= end; ++r) {
                if (r < GranuleCache.this.granules.getRowCount()) {
                    GranuleCache.this.granules.set(null, r);
                }
            }
        }
        break;
    }
    case EventConstants.DELETE:
        if (col == EventConstants.ALL_COLUMNS) {
            // entire rows deleted
            for (int r = start; r <= end; ++r) {
                if (r < GranuleCache.this.granules.getRowCount()) {
                    GranuleCache.this.granules.set(null, r);
                }
            }
        }
        break;
    case EventConstants.INSERT:
        // nothing to do here
    } // switch
}
 

public void tableChanged(Table t, int start, int end, int col, int type) {
    // must come from parent
    if ( t != m_parent )
        return;
    
    CascadedRowManager rowman = (CascadedRowManager)m_rows;
    
    // switch on the event type
    switch ( type ) {
    case EventConstants.UPDATE:
    {
        // do nothing if update on all columns, as this is only
        // used to indicate a non-measurable update.
        if ( col == EventConstants.ALL_COLUMNS ) {
            break;
        }
        
        // process each update, check if filtered state changes
        for ( int r=start, cr=-1; r<=end; ++r ) {
            if ( (cr=rowman.getChildRow(r)) != -1 ) {
                // the parent row has a corresponding row in this table
                if ( m_rowFilter.getBoolean(m_parent.getTuple(r)) ) {
                    // row still passes the filter, check the column
                    int idx = getColumnNumber(m_parent.getColumnName(col));
                    if ( idx >= getLocalColumnCount() )
                        fireTableEvent(cr, cr, idx, EventConstants.UPDATE);
                } else {
                    // row no longer passes the filter, remove it
                    removeCascadedRow(cr);
                }
            } else {
                // does it now pass the filter due to the update?
                if ( m_rowFilter.getBoolean(m_parent.getTuple(r)) ) {
                    if ( (cr=rowman.getChildRow(r)) < 0 )
                        addCascadedRow(r);
                }
            }
        }
        break;
    }
    case EventConstants.DELETE:
    {
        if ( col == EventConstants.ALL_COLUMNS ) {
            // entire rows deleted
            for ( int r=start, cr=-1; r<=end; ++r ) {
                if ( (cr=rowman.getChildRow(r)) != -1 )
                    removeCascadedRow(cr);
            }
        } else {
            // column deleted
            filterColumns();
        }
        break;
    }
    case EventConstants.INSERT:
        if ( col == EventConstants.ALL_COLUMNS ) {
            // entire rows added
            for ( int r=start; r<=end; ++r ) {
                if ( m_rowFilter.getBoolean(m_parent.getTuple(r)) ) {
                    if ( rowman.getChildRow(r) < 0 )
                        addCascadedRow(r);
                }
            }
        } else {
            // column added
            filterColumns();
        }
        break;
    }
}
 

@Override
public void tableChanged(Table t, int start, int end, int col, int type) {
    // must come from parent
    if (t != TemporalElementManager.this.m_table)
        return;

    // switch on the event type
    switch (type) {
    case EventConstants.UPDATE: {
        // do nothing if update on all columns, as this is only
        // used to indicate a non-measurable update.
        if (col == EventConstants.ALL_COLUMNS) {
            break;
        }

        // if primitive has changed, invalidate primitives
        if (col == TemporalElementManager.this.m_table
                .getColumnNumber(TemporalElement.KIND)) {
            for (int r = start; r <= end; ++r) {
                TemporalElementManager.this.invalidate(r);
            }
        }
        break;
    }
    case EventConstants.DELETE:
        if (col == EventConstants.ALL_COLUMNS) {
            // entire rows deleted
            for (int r = start; r <= end; ++r) {
                TemporalElementManager.this.invalidate(r);
            }
        } else {
            // relevant column deleted
            if (col == t.getColumnNumber(TemporalElement.KIND)
                    || col == t.getColumnNumber(TemporalElement.INF)
                    || col == t.getColumnNumber(TemporalElement.SUP)
                    || col == t
                            .getColumnNumber(TemporalElement.GRANULARITY_ID))
                TemporalElementManager.this.invalidateAll();
        }
        break;
    case EventConstants.INSERT:
        // nothing to do here
    } // switch
}