Project: bndtools
/*******************************************************************************
 * Copyright (c) 2010 Neil Bartlett. 
 * All rights reserved. This program and the accompanying materials 
 * are 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: 
 *     Neil Bartlett - initial API and implementation 
 ******************************************************************************/
package bndtools.editor; 
 
import java.beans.PropertyChangeEvent; 
import java.beans.PropertyChangeListener; 
import java.util.ArrayList; 
import java.util.List; 
 
import org.eclipse.jface.viewers.ITreeContentProvider; 
import org.eclipse.jface.viewers.TreeViewer; 
import org.eclipse.jface.viewers.Viewer; 
 
import aQute.bnd.build.Workspace; 
import aQute.bnd.build.model.BndEditModel; 
import aQute.bnd.build.model.clauses.ExportedPackage; 
import aQute.bnd.build.model.clauses.HeaderClause; 
import aQute.bnd.build.model.clauses.ImportPattern; 
import aQute.bnd.osgi.Constants; 
import bndtools.launch.LaunchConstants; 
 
public class BndEditorContentOutlineProvider implements ITreeContentProvider, PropertyChangeListener { 
 
    static final String PRIVATE_PKGS = "__private_pkgs"
    static final String EXPORTS = "__exports"
    static final String IMPORT_PATTERNS = "__import_patterns"
    static final String PLUGINS = "__plugins"
 
    private BndEditModel model; 
    private final TreeViewer viewer; 
 
    public BndEditorContentOutlineProvider(TreeViewer viewer) { 
        this.viewer = viewer; 
    } 
 
    public Object[] getElements(Object inputElement) { 
        Object[] result; 
        if (model.isProjectFile()) { 
            result = new String[] { 
                    PRIVATE_PKGS, EXPORTS, IMPORT_PATTERNS, BndEditor.BUILD_PAGE, BndEditor.PROJECT_RUN_PAGE, BndEditor.SOURCE_PAGE 
            }; 
        } else if (model.getBndResource().getName().endsWith(LaunchConstants.EXT_BNDRUN)) { 
            result = new String[] { 
                    BndEditor.PROJECT_RUN_PAGE, BndEditor.SOURCE_PAGE 
            }; 
        } else if (Workspace.BUILDFILE.equals(model.getBndResource().getName())) { 
            result = new String[] { 
                    PLUGINS, BndEditor.SOURCE_PAGE 
            }; 
        } else { 
            result = new String[] { 
                    PRIVATE_PKGS, EXPORTS, IMPORT_PATTERNS, BndEditor.SOURCE_PAGE 
            }; 
        } 
        return result; 
    } 
 
    public void dispose() { 
        if (model != null
            model.removePropertyChangeListener(this); 
    } 
 
    public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { 
        if (model != null
            model.removePropertyChangeListener(this); 
 
        model = (BndEditModel) newInput; 
        if (model != null
            model.addPropertyChangeListener(this); 
    } 
 
    public Object[] getChildren(Object parentElement) { 
        Object[] result = new Object[0]; 
 
        if (parentElement instanceof String) { 
            if (EXPORTS.equals(parentElement)) { 
                List<ExportedPackage> exports = model.getExportedPackages(); 
                if (exports != null
                    result = exports.toArray(new Object[exports.size()]); 
            } else if (PRIVATE_PKGS.equals(parentElement)) { 
                List<String> packages = model.getPrivatePackages(); 
                if (packages != null) { 
                    List<PrivatePkg> wrapped = new ArrayList<PrivatePkg>(packages.size()); 
                    for (String pkg : packages) { 
                        wrapped.add(new PrivatePkg(pkg)); 
                    } 
                    result = wrapped.toArray(new Object[wrapped.size()]); 
                } 
            } else if (IMPORT_PATTERNS.equals(parentElement)) { 
                List<ImportPattern> imports = model.getImportPatterns(); 
                if (imports != null
                    result = imports.toArray(new Object[imports.size()]); 
            } else if (PLUGINS.equals(parentElement)) { 
                List<HeaderClause> plugins = model.getPlugins(); 
                if (plugins != null) { 
                    List<PluginClause> wrapped = new ArrayList<PluginClause>(plugins.size()); 
                    for (HeaderClause header : plugins) 
                        wrapped.add(new PluginClause(header)); 
                    result = wrapped.toArray(new PluginClause[wrapped.size()]); 
                } 
            } 
        } 
        return result; 
    } 
 
    public Object getParent(Object element) { 
        return null
    } 
 
    public boolean hasChildren(Object element) { 
        if (element instanceof String) { 
            if (EXPORTS.equals(element)) { 
                List<ExportedPackage> exports = model.getExportedPackages(); 
                return exports != null && !exports.isEmpty(); 
            } 
            if (PRIVATE_PKGS.equals(element)) { 
                List<String> packages = model.getPrivatePackages(); 
                return packages != null && !packages.isEmpty(); 
            } 
            if (IMPORT_PATTERNS.equals(element)) { 
                List<ImportPattern> imports = model.getImportPatterns(); 
                return imports != null && !imports.isEmpty(); 
            } 
            if (PLUGINS.equals(element)) { 
                List<HeaderClause> plugins = model.getPlugins(); 
                return plugins != null && !plugins.isEmpty(); 
            } 
        } 
        return false
    } 
 
    public void propertyChange(PropertyChangeEvent evt) { 
        if (Constants.EXPORT_PACKAGE.equals(evt.getPropertyName())) { 
            viewer.refresh(EXPORTS); 
            viewer.expandToLevel(EXPORTS, 1); 
        } else if (Constants.PRIVATE_PACKAGE.equals(evt.getPropertyName())) { 
            viewer.refresh(PRIVATE_PKGS); 
            viewer.expandToLevel(PRIVATE_PKGS, 1); 
        } else if (Constants.IMPORT_PACKAGE.equals(evt.getPropertyName())) { 
            viewer.refresh(IMPORT_PATTERNS); 
            viewer.expandToLevel(IMPORT_PATTERNS, 1); 
        } else if (Constants.PLUGIN.equals(evt.getPropertyName())) { 
            viewer.refresh(PLUGINS); 
            viewer.expandToLevel(PLUGINS, 1); 
        } 
    } 
 
class PrivatePkg { 
    final String pkg; 
 
    PrivatePkg(String pkg) { 
        this.pkg = pkg; 
    } 
 
class PluginClause { 
    final HeaderClause header; 
 
    PluginClause(HeaderClause header) { 
        this.header = header; 
    } 
}