com.cloudbees.eclipse.dev.ui.views.jobs.JobsContentProvider.java Source code

Introduction

Here is the source code for com.cloudbees.eclipse.dev.ui.views.jobs.JobsContentProvider.java

Source

/*******************************************************************************
 * Copyright (c) 2013 Cloud Bees, Inc.
 * All rights reserved. 
 * This program is made available under the terms of the 
 * Eclipse Public License v1.0 which accompanies this distribution, 
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Cloud Bees, Inc. - initial API and implementation 
 *******************************************************************************/
package com.cloudbees.eclipse.dev.ui.views.jobs;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.IJobChangeListener;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
import org.eclipse.jface.viewers.AbstractTreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.model.BaseWorkbenchContentProvider;
import org.eclipse.ui.progress.DeferredTreeContentManager;
import org.eclipse.ui.progress.IDeferredWorkbenchAdapter;

public class JobsContentProvider extends BaseWorkbenchContentProvider {
    private List<JobHolder> root;

    private List<Object> expList = new ArrayList<Object>();

    private DeferredTreeContentManager manager;

    private final static Object[] EMPTY_ARRAY = new Object[0];

    private IViewSite viewSite;

    public JobsContentProvider(IViewSite viewSite) {
        super();
        this.viewSite = viewSite;
    }

    public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
        if (newInput instanceof List
                && (((List) newInput).isEmpty() || ((List) newInput).get(0) instanceof JobHolder)) {
            root = (List<JobHolder>) newInput;
        } else {
            root = null; // reset
        }

        if (viewer instanceof AbstractTreeViewer) {
            manager = new DeferredTreeContentManager((AbstractTreeViewer) viewer, viewSite) {
                @Override
                protected IDeferredWorkbenchAdapter getAdapter(Object element) {
                    IDeferredWorkbenchAdapter ret = super.getAdapter(element);
                    if (ret != null) {
                        return ret;
                    }

                    if (element instanceof JobHolder) {
                        if (((JobHolder) element).job.isFolderOrView()) {
                            return new DeferWrapper((JobHolder) element);
                        }
                    }

                    return null;
                }

            };

            final AbstractTreeViewer treeViewer = ((AbstractTreeViewer) viewer);

            Object[] expelems = ((AbstractTreeViewer) viewer).getVisibleExpandedElements();
            expList.clear();
            expList.addAll(Arrays.asList(expelems));

            IJobChangeListener listener = new JobChangeAdapter() {
                @Override
                public void done(IJobChangeEvent event) {
                    if (event.getResult().isOK()) {
                        // try to expand the state again
                        PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
                            public void run() {

                                if (expList.size() == 0) {
                                    // all good, managed to expand all previous nodes
                                    return;
                                }

                                for (Object o : expList) {
                                    treeViewer.setExpandedState(o, true);
                                }

                                List<Object> toremove = new ArrayList<Object>();
                                for (Object o : expList) {
                                    if (treeViewer.getExpandedState(o)) {
                                        toremove.add(o);
                                    }
                                }
                                expList.removeAll(toremove);

                            }
                        });
                    }
                }
            };

            manager.addUpdateCompleteListener(listener);

        }

    }

    public void dispose() {
    }

    public Object[] getElements(Object parent) {
        return getChildren(parent);
    }

    @Override
    public Object[] getChildren(final Object parent) {

        if (parent instanceof IViewSite) {
            if (root == null) {
                return new JobHolder[0];
            } else {
                return root.toArray(new JobHolder[root.size()]);
            }
        }

        if (manager != null) {
            Object[] children = manager.getChildren(parent);
            if (children != null) {
                return children;
            }
        }

        return EMPTY_ARRAY;
    }

    public Object getParent(Object element) {
        // not used for now so we won't track it
        return null;
    }

    @Override
    public boolean hasChildren(Object element) {

        if (manager != null) {
            if (manager.isDeferredAdapter(element))
                return manager.mayHaveChildren(element);
        }

        // only views or folders coming from the deferred manager can have children

        return false;
    }

    public void removeDeferredExpanders(Object element) {
        Iterator<Object> it = expList.iterator();
        List<Object> toremove = new ArrayList<Object>();
        while (it.hasNext()) {
            toremove.add(it.next());
        }
        expList.removeAll(toremove);
    }

}