import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
@Override
public void itemsRemoved(List<T> list, int index, Sequence<T> items) {
    if (!updating) {
        // Remove the items from the view
        for (int i = 0, n = items.getLength(); i < n; i++) {
            T item = items.get(i);

            int viewIndex = view.indexOf(item);

            if (viewIndex != -1) {
                Sequence<T> removed = view.remove(viewIndex, 1);
                listListeners.itemsRemoved(FilteredList.this, viewIndex, removed);
            }
        }
    }
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
/**
 * Removes an item from the view and the backing list.
 *
 * @param item
 * The item to remove.
 */
@Override
public int remove(T item) {
    if (view == null) {
        throw new IllegalStateException();
    }

    int index;

    updating = true;
    try {
        // Remove the item from the view
        index = view.indexOf(item);
        if (index != -1) {
            Sequence<T> removed = view.remove(index, 1);
            listListeners.itemsRemoved(this, index, removed);
        }

        // Remove the item from the source
        source.remove(item);
    } finally {
        updating = false;
    }

    return index;
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
/**
 * Clears the view and removes the cleared items from the backing list.
 */
@Override
public void clear() {
    if (view == null) {
        throw new IllegalStateException();
    }

    updating = true;
    try {
        // Remove all items from the view
        Sequence<T> removed = view.remove(0, view.getLength());
        listListeners.listCleared(this);

        // Remove the items from the source
        for (int i = 0, n = removed.getLength(); i < n; i++) {
            source.remove(removed.get(i));
        }
    } finally {
        updating = false;
    }
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
/**
 * Get only packs checked in treeview
 * @param sequence of checked paths in treeview
 * @return list of checked packs
 */
public List<Pack> getCheckedPacks(Sequence<Path> list) {
    List<Pack> selected = new ArrayList<Pack>();

    if (list.getLength() > 0) {
        Path p;
        for(int i = 0; i < list.getLength(); i++) {
            p = list.get(i);
            TreeNode node = treeData.get(p.get(0));
            for(Pack P:packs) {
                if (node.getParent() == null && P.getName().equalsIgnoreCase(node.getText()) ) {
                    selected.add(P);
                    break;
                }
            }
        }
    }
    return selected;
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private Sequence<Song> getSelectedSongs() {
    if (songTable.getFirstSelectedIndex() == -1) {
        // nothing is selected, return all
        return (Sequence<Song>) songTable.getTableData();
    } else {
        return (Sequence<Song>) songTable.getSelectedRows();
    }
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
@Override @SuppressWarnings("unchecked")
public void perform(Component source) {
    Sequence<Track> selectedTracks = selectedOnly ? main.getSelectedDownloadTracks() : new ArrayList<Track>();
    Iterator<Track> it = main.getDownloadTracks().iterator();
    while (it.hasNext()) {
        Track track = it.next();
        if ((selectedOnly && selectedTracks.indexOf(track) != -1)
            || (!selectedOnly && successfulOnly && track.getStatus().isSuccessful())
            || (!selectedOnly && !successfulOnly && track.getStatus().isFinished())) {
            Services.getDownloadService().cancelDownload(track, removeFromDisc);
            it.remove();
            selectedTracks.remove(track);
        }
    }
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
private static String createGroovejamesLink(Sequence<Song> songs) {
    StringBuilder sb = new StringBuilder("groovejames://song");
    for (int i = 0, len = songs.getLength(); i < len; i++) {
        Song song = songs.get(i);
        sb.append(i == 0 ? '?' : '&');
        sb.append("id=").append(song.getSongID());
        if (!isNullOrEmpty(song.getSongName())) {
            sb.append("&songName=").append(urlencode(song.getSongName()));
        }
    }
    sb.append("&autoplay=true");
    return sb.toString();
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
@Override public void perform(Component source) {
    Sequence<Song> selectedRows = main.getSelectedPlayerSongs();
    for (int i = 0, len = selectedRows.getLength(); i < len; i++) {
        Song selectedSong = selectedRows.get(i);
        main.download(selectedSong);
    }
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
public void copyToClipboard(Sequence<String> data)
{
    if (data.getLength() > 0) {
        String selCb = ""; // full selection data string
        for (int i = 0; i < data.getLength(); i++) { // concat selection with line ends
            selCb = String.format("%s%s%n", selCb, data.get(i));//selCb += sel.get(i) + "\n"; 
        }
        
        Out.print(LOG_LEVEL.DEBUG, "Copied to Clipboard: "+ selCb);
        StringSelection selection = new StringSelection(selCb);
        Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
        clipboard.setContents(selection, selection);
    }
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
@Bean
@Lazy
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
@Override
public Sequence.Tree.ImmutablePath createImmutablePath() {
    return new Sequence.Tree.ImmutablePath();
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
@Bean
@Lazy
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
@Override
public Sequence.Tree<? extends Object> createTree() {
    return new Sequence.Tree<>();
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
@SuppressWarnings(value = "unchecked")
public final void processCollectionObject(Object coll) {
    if (coll != null) {
        if (coll instanceof java.util.List) {
            process((java.util.List<T>) coll);
        } else if (coll instanceof java.util.Set) {
            process((java.util.Set<T>) coll);
        } else if (coll instanceof org.apache.pivot.collections.Set) {
            process((org.apache.pivot.collections.Set<T>) coll);
        } else if (coll instanceof org.apache.pivot.collections.Sequence) {
            if (coll instanceof org.apache.pivot.collections.List) {
                process((org.apache.pivot.collections.List<T>) coll);
            } else {
                process((org.apache.pivot.collections.Sequence<T>) coll);
            }
        } else if (coll instanceof java.util.Map) {
            process((java.util.Map<T, V>) coll);
        } else if (coll instanceof org.apache.pivot.collections.Map) {
            process((org.apache.pivot.collections.Map<T, V>) coll);
        } else if (coll instanceof org.apache.pivot.collections.Dictionary) {
            process((org.apache.pivot.collections.Dictionary<T, V>) coll);
        } else if (coll instanceof java.util.Queue) {
            process((java.util.Queue<T>) coll);
        } else if (coll instanceof org.apache.pivot.collections.Queue) {
            process((org.apache.pivot.collections.Queue<T>) coll);
        } else if (coll instanceof org.apache.pivot.collections.Stack) {
            process((org.apache.pivot.collections.Stack<T>) coll);
        } else if (coll.getClass().isArray()) {
            process((T[]) coll);
        }
    }
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public K getFilteredCollection(K src) {
    if ((src != null) && (getFilter() != null)) {
        Filter<T> fil = getFilter();
        K result = null;

        try {
            Class.forName(src.getClass().getName());
            result = (K) src.getClass().newInstance();
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException ex) {
            Logger.getLogger(CollectionFilter.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            if (result != null) {
                Iterator<T> srcIterator = src.iterator();

                while (srcIterator.hasNext()) {
                    T item = srcIterator.next();

                    if (fil.include(item)) {
                        if (src instanceof Sequence<?>) {
                            ((Sequence<T>) result).add(item);
                        } else if (src instanceof Group<?>) {
                            ((Group<T>) result).add(item);
                        }
                    }
                }
            }
        }

        return src;
    }

    return src;
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
public static boolean isCollectionOrSequence(Class<?> type) {
    return (ClassUtils.isAssignable(type, java.util.Collection.class))
            || (ClassUtils.isAssignable(type,
                    org.apache.pivot.collections.Collection.class))
            || (ClassUtils.isAssignable(type,
                    org.apache.pivot.collections.Sequence.class));
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
public static boolean isCollectionOrSequenceOrArrayOrEnum(Class<?> type) {
    if (!((ClassUtils.isAssignable(type, java.util.Collection.class)))
            || (ClassUtils.isAssignable(type,
                    org.apache.pivot.collections.Collection.class))
            || (ClassUtils.isAssignable(type,
                    org.apache.pivot.collections.Sequence.class))) {
        return type.isArray() || type.isEnum();
    }

    return true;
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
public static boolean contains(Sequence<? super Object> seq, Object obj) {
    if (seq != null) {
        return (seq.indexOf(obj) >= 0);
    }

    return false;
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
public static boolean containsAny(Sequence<? super Object> seq, Object... objs) {
    if (seq != null) {
        if (ArrayUtils.isNotEmpty(objs)) {
            for (Object obj : objs) {
                if (seq.indexOf(obj) >= 0) {
                    return true;
                }
            }
        } else {
            return contains(seq, null);
        }
    }

    return false;
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
@Override
public Sequence<File> modifyValueBeforeSubmit(Sequence<File> value) {
    if (value == null) {
        return new ArrayList<>();
    }

    return value;
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
@Override
public boolean canSubmit(Sequence<File> value) {
    if (value != null) {
        return (value.getLength() > 0);
    }

    return false;
}
 

import org.apache.pivot.collections.Sequence; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public Sequence<Track> getSelectedDownloadTracks() {
    return (Sequence<Track>) downloadsTable.getSelectedRows();
}