Attachment #115415 for bug #243441

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry;

public class ConfigurationAttributeAdapter extends ParentAdapter {

	public ConfigurationAttributeAdapter(Object object) {
		super(object);
	}

	protected Object[] createChildren() {
		return null;
	}

}




/*******************************************************************************
 * Copyright (c) 2008 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry;

import org.eclipse.pde.internal.runtime.registry.RegistryBrowserContentProvider.BundleFolder;
import org.osgi.framework.Bundle;

/**
 * Adapter for bundle objects.
 *
 */
public class PluginAdapter extends ParentAdapter {

	public PluginAdapter(Bundle object) {
		super(object);
	}

	protected Object[] createChildren() {
		Bundle bundle = (Bundle) getObject();

		Object[] array = new Object[7];
		array[0] = new BundleFolder(bundle, IBundleFolder.F_LOCATION);
		array[1] = new BundleFolder(bundle, IBundleFolder.F_IMPORTS);
		array[2] = new BundleFolder(bundle, IBundleFolder.F_LIBRARIES);
		array[3] = new BundleFolder(bundle, IBundleFolder.F_EXTENSION_POINTS);
		array[4] = new BundleFolder(bundle, IBundleFolder.F_EXTENSIONS);
		array[5] = new BundleFolder(bundle, IBundleFolder.F_REGISTERED_SERVICES);
		array[6] = new BundleFolder(bundle, IBundleFolder.F_SERVICES_IN_USE);
		return array;
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry;

public interface IConfigurationAttribute {
	public String getLabel();
}




 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry;

import java.util.ArrayList;
import org.eclipse.core.runtime.*;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.pde.internal.runtime.registry.model.*;
import org.eclipse.pde.internal.runtime.PDERuntimePlugin;
import org.osgi.framework.*;

public class RegistryBrowserContentProvider implements ITreeContentProvider {
	private Hashtable fExtensionPointMap = new Hashtable();
	public boolean isInExtensionSet;
	private RegistryBrowser fRegistryBrowser;

	public RegistryBrowserContentProvider(RegistryBrowser registryBrowser) {
		fRegistryBrowser = registryBrowser;
		private Bundle bundle;
		private Object[] children;

		public BundleFolder(Bundle pd, int id) {
			this.bundle = pd;
			this.id = id;
		}

		public Bundle getBundle() {
			return bundle;
		}

		public Object[] getChildren() {
			if (children == null) {
				children = getFolderChildren(bundle, id);
			}
			return children;
		}

		/**
		 * Resets folder's previously cached knowledge about it's children. 
		 */
		public void refresh() {
			children = null;
		}

		public int getFolderId() {
			return id;
		}

		public Object getAdapter(Class key) {
			return null;
		}
	}

	static class BundlePrerequisite implements IBundlePrerequisite {
		private ManifestElement underlyingElement;

		public BundlePrerequisite(ManifestElement element) {
			underlyingElement = element;
		}

		public ManifestElement getPrerequisite() {
			return underlyingElement;
		}

		public boolean isExported() {
			String visibility = underlyingElement.getDirective(Constants.VISIBILITY_DIRECTIVE);
			return Constants.VISIBILITY_REEXPORT.equals(visibility);
		}

		public String getLabel() {
			String version = underlyingElement.getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE);
			String value = underlyingElement.getValue();
			if (version == null)
				return value;
			if (Character.isDigit(version.charAt(0)))
				version = '(' + version + ')';
			return value + ' ' + version;
		}
	}

	static class BundleLibrary implements IBundleLibrary {
		private ManifestElement underlyingElement;

		public BundleLibrary(ManifestElement element) {
			underlyingElement = element;
		}

		public String getLibrary() {
			return underlyingElement.getValue();
		}
	}

	/**
	 * Creates contents adapter for given folder id.
	 * @param object Folder contents to be wrapped in adapter
	 * @param id Type of folder
	 * @return Adapter 
	 */
	static protected PluginObjectAdapter createAdapter(Object object, int id) {
		if (id == IBundleFolder.F_EXTENSIONS)
			return new ExtensionAdapter(object);
		if (id == IBundleFolder.F_EXTENSION_POINTS)
			return new ExtensionPointAdapter(object);
		return new PluginObjectAdapter(object);
	}

	public void dispose() { // nothing to dispose

		if (element == null)
			return null;

		if (element instanceof Extension)
			return ((Extension) element).getConfigurationElements();

		isInExtensionSet = false;
		if (element instanceof ExtensionPoint)
			return ((ExtensionPoint) element).getExtensions().toArray();

		if (element instanceof ConfigurationElement)
			return ((ConfigurationElement) element).getElements();

		if (element instanceof Bundle) {
			Bundle bundle = (Bundle) element;

			Folder[] folders = new Folder[6];
			folders[0] = new Folder(Folder.F_IMPORTS, bundle);
			folders[1] = new Folder(Folder.F_LIBRARIES, bundle);
			folders[2] = new Folder(Folder.F_EXTENSION_POINTS, bundle);
			folders[3] = new Folder(Folder.F_EXTENSIONS, bundle);
			folders[4] = new Folder(Folder.F_REGISTERED_SERVICES, bundle);
			folders[5] = new Folder(Folder.F_SERVICES_IN_USE, bundle);

			// filter out empty folders
			ArrayList folderList = new ArrayList();
			folderList.add(new Attribute(bundle.getModel(), Attribute.F_LOCATION, bundle.getLocation()));

			for (int i = 0; i < folders.length; i++) {
				if ((folders[i].getChildren() != null) && (folders[i].getChildren().length > 0))
					folderList.add(folders[i]);
			}
			return folderList.toArray();

			return folders;
		}

		if (element instanceof Folder) {
			Folder folder = (Folder) element;
			isInExtensionSet = folder.getId() == Folder.F_EXTENSIONS;
			Object[] objs = ((Folder) element).getChildren();
			return objs;
		}
		if (element instanceof ConfigurationElement) {
			return ((ConfigurationElement) element).getElements();
		}

		if (element instanceof ExtensionPoint) {
			ExtensionPoint extensionPoint = (ExtensionPoint) element;
			Object[] objs = extensionPoint.getExtensions().toArray();
			return objs;
		}

		if (element instanceof Object[]) {
			return (Object[]) element;
		}
		if (element instanceof IExtensionPoint) {
			IExtensionPoint extensionPoint = (IExtensionPoint) element;
			String id = extensionPoint.getUniqueIdentifier();

			Object[] children = (Object[]) fExtensionPointMap.get(id);
			if (children == null) {
				Object[] array = extensionPoint.getExtensions();
				if (array != null && array.length > 0) {
					children = new Object[array.length];
					for (int i = 0; i < array.length; i++) {
						children[i] = createAdapter(array[i], IBundleFolder.F_EXTENSIONS);
					}

					fExtensionPointMap.put(id, children);
				}
			}

			return children;
		}
		return null;
	}

	public Object getParent(Object element) {
		if (!(element instanceof ModelObject)) {
			return null;
		switch (id) {
			case IBundleFolder.F_EXTENSIONS :
				array = Platform.getExtensionRegistry().getExtensions(bundleId);
				break;
			case IBundleFolder.F_EXTENSION_POINTS :
				array = Platform.getExtensionRegistry().getExtensionPoints(bundleId);
				break;
			case IBundleFolder.F_IMPORTS :
				array = getManifestHeaderArray(bundle, Constants.REQUIRE_BUNDLE);
				break;
			case IBundleFolder.F_LIBRARIES :
				array = getManifestHeaderArray(bundle, Constants.BUNDLE_CLASSPATH);
				break;
			case IBundleFolder.F_REGISTERED_SERVICES :
				return getServices(bundle, IBundleFolder.F_REGISTERED_SERVICES);
			case IBundleFolder.F_SERVICES_IN_USE :
				return getServices(bundle, IBundleFolder.F_SERVICES_IN_USE);
		}
		Object[] result = null;
		if (array != null && array.length > 0) {
			result = new Object[array.length];
			for (int i = 0; i < array.length; i++) {
				result[i] = createAdapter(array[i], id);
			}
		}
		return result;
	}

	protected static Object[] getServices(Bundle bundle, int type) {
		Set result = new HashSet();

		ModelObject object = (ModelObject) element;
			ServiceReference[] references = PDERuntimePlugin.getDefault().getBundleContext().getAllServiceReferences(null, null);

		boolean extOnly = fRegistryBrowser.showExtensionsOnly();
				ServiceReference ref = references[i];

				if ((type == IBundleFolder.F_REGISTERED_SERVICES) && (bundle.equals(ref.getBundle()))) {
					result.add(new ServiceReferenceAdapter(ref));
				}

				Bundle[] usingBundles = ref.getUsingBundles();
				if ((type == IBundleFolder.F_SERVICES_IN_USE) && (usingBundles != null && Arrays.asList(usingBundles).contains(bundle))) {
					result.add(new ServiceReferenceAdapter(ref));
				}
			}

		if (element instanceof Folder) {
			return ((Folder) element).getParent();
		}

		if (result.size() == 0)
			return null;

		return result.toArray(new ServiceReferenceAdapter[result.size()]);
	}

	public Object getParent(Object element) {
		return null;
	}


	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { // do nothing
	}

	static private Object[] getManifestHeaderArray(Bundle bundle, String headerKey) {
		String libraries = (String) bundle.getHeaders().get(headerKey);
		try {
			ManifestElement[] elements = ManifestElement.parseHeader(headerKey, libraries);
			if (elements == null)
				return null;
			if (headerKey.equals(Constants.BUNDLE_CLASSPATH)) {
				IBundleLibrary[] array = new IBundleLibrary[elements.length];
				for (int i = 0; i < elements.length; i++)
					array[i] = new BundleLibrary(elements[i]);
				return array;
			} else if (headerKey.equals(Constants.REQUIRE_BUNDLE)) {
				IBundlePrerequisite[] array = new IBundlePrerequisite[elements.length];
				for (int i = 0; i < elements.length; i++)
					array[i] = new BundlePrerequisite(elements[i]);
				return array;
			}
		} catch (BundleException e) { // do nothing
		}
		return null;
	}

}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry;

import org.eclipse.osgi.util.ManifestElement;

public interface IBundlePrerequisite {
	public ManifestElement getPrerequisite();

	public boolean isExported();

	public String getLabel();
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry;

public abstract class ParentAdapter extends PluginObjectAdapter {
	Object[] fChildren;

	public ParentAdapter(Object object) {
		super(object);
	}

	protected abstract Object[] createChildren();

	public Object[] getChildren() {
		if (fChildren == null)
			fChildren = createChildren();
		return fChildren;
	}
}

Lines 11-16 Link Here

(-)src/org/eclipse/pde/internal/runtime/registry/RegistryBrowser.java (-114 / +74 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.pde.internal.runtime.registry;	12	package org.eclipse.pde.internal.runtime.registry;
13		13
		14	import java.net.URI;
		15	import java.net.URISyntaxException;
14	import java.util.*;	16	import java.util.*;
15	import java.util.List;	17	import java.util.List;
16	import org.eclipse.core.runtime.*;	18	import org.eclipse.core.runtime.*;
Lines 18-26 Link Here
18	import org.eclipse.jface.dialogs.Dialog;	20	import org.eclipse.jface.dialogs.Dialog;
19	import org.eclipse.jface.dialogs.MessageDialog;	21	import org.eclipse.jface.dialogs.MessageDialog;
20	import org.eclipse.jface.viewers.*;	22	import org.eclipse.jface.viewers.*;
21	import org.eclipse.osgi.service.resolver.*;
22	import org.eclipse.osgi.util.NLS;	23	import org.eclipse.osgi.util.NLS;
23	import org.eclipse.pde.internal.runtime.*;	24	import org.eclipse.pde.internal.runtime.*;
		25	import org.eclipse.pde.internal.runtime.registry.model.*;
24	import org.eclipse.swt.SWT;	26	import org.eclipse.swt.SWT;
25	import org.eclipse.swt.custom.BusyIndicator;	27	import org.eclipse.swt.custom.BusyIndicator;
26	import org.eclipse.swt.dnd.*;	28	import org.eclipse.swt.dnd.*;
Lines 33-40 Link Here
33	import org.eclipse.ui.dialogs.PatternFilter;	35	import org.eclipse.ui.dialogs.PatternFilter;
34	import org.eclipse.ui.part.DrillDownAdapter;	36	import org.eclipse.ui.part.DrillDownAdapter;
35	import org.eclipse.ui.part.ViewPart;	37	import org.eclipse.ui.part.ViewPart;
36	import org.osgi.framework.*;	38	import org.osgi.framework.BundleException;
37	import org.osgi.service.packageadmin.PackageAdmin;
38		39
39	public class RegistryBrowser extends ViewPart {	40	public class RegistryBrowser extends ViewPart {
40		41
Lines 43-54 Link Here
43	public static final String SHOW_EXTENSIONS_ONLY = "RegistryView.showExtensions.label"; //$NON-NLS-1$	44	public static final String SHOW_EXTENSIONS_ONLY = "RegistryView.showExtensions.label"; //$NON-NLS-1$
44	public static final String SHOW_DISABLED_MODE = "RegistryView.showDisabledMode.label"; //$NON-NLS-1$	45	public static final String SHOW_DISABLED_MODE = "RegistryView.showDisabledMode.label"; //$NON-NLS-1$
45		46
46	private RegistryBrowserListener fListener;
47	private FilteredTree fFilteredTree;	47	private FilteredTree fFilteredTree;
48	private TreeViewer fTreeViewer;	48	private TreeViewer fTreeViewer;
49	private IMemento fMemento;	49	private IMemento fMemento;
50	private int fTotalItems = 0;	50	private int fTotalItems = 0;
51		51
		52	private RegistryModel model;
		53	private ModelChangeListener listener;
		54
		55	private RegistryBrowserContentProvider fContentProvider;
		56
52	// menus and action items	57	// menus and action items
53	private Action fRefreshAction;	58	private Action fRefreshAction;
54	private Action fShowPluginsAction;	59	private Action fShowPluginsAction;
Lines 70-81 Link Here
70	private DrillDownAdapter fDrillDownAdapter;	75	private DrillDownAdapter fDrillDownAdapter;
71	private ViewerFilter fActiveFilter = new ViewerFilter() {	76	private ViewerFilter fActiveFilter = new ViewerFilter() {
72	public boolean select(Viewer viewer, Object parentElement, Object element) {	77	public boolean select(Viewer viewer, Object parentElement, Object element) {
73	if (element instanceof PluginObjectAdapter)	78	if (element instanceof ExtensionPoint)
74	element = ((PluginObjectAdapter) element).getObject();	79	element = Platform.getBundle(((ExtensionPoint) element).getNamespaceIdentifier());
75	if (element instanceof IExtensionPoint)	80	else if (element instanceof Extension)
76	element = Platform.getBundle(((IExtensionPoint) element).getNamespaceIdentifier());	81	element = Platform.getBundle(((Extension) element).getNamespaceIdentifier());
77	else if (element instanceof IExtension)
78	element = Platform.getBundle(((IExtension) element).getNamespaceIdentifier());
79	if (element instanceof Bundle)	82	if (element instanceof Bundle)
80	return ((Bundle) element).getState() == Bundle.ACTIVE;	83	return ((Bundle) element).getState() == Bundle.ACTIVE;
81	return true;	84	return true;
Lines 83-99 Link Here
83	};	86	};
84		87
85	private ViewerFilter fDisabledFilter = new ViewerFilter() {	88	private ViewerFilter fDisabledFilter = new ViewerFilter() {
86	PlatformAdmin plaformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
87	State state = plaformAdmin.getState(false);
88
89	public boolean select(Viewer viewer, Object parentElement, Object element) {	89	public boolean select(Viewer viewer, Object parentElement, Object element) {
90	if (element instanceof PluginObjectAdapter)
91	element = ((PluginObjectAdapter) element).getObject();
92
93	if (element instanceof Bundle) {	90	if (element instanceof Bundle) {
94	Bundle bundle = (Bundle) element;	91	return !((Bundle) element).isEnabled();
95	BundleDescription description = state.getBundle(bundle.getBundleId());
96	return ((state.getDisabledInfos(description)).length > 0);
97	}	92	}
98	return false;	93	return false;
99	}	94	}
Lines 133-138 Link Here
133	}	128	}
134	}	129	}
135		130
		131	public RegistryBrowser() {
		132	try {
		133	model = RegistryModelFactory.getRegistryModel(new URI("local"));
		134	} catch (URISyntaxException e) {
		135	PDERuntimePlugin.log(e);
		136	}
		137	model.connect();
		138
		139	listener = new RegistryBrowserModelChangeListener(this);
		140	model.addModelChangeListener(listener);
		141	}
		142
136	public void init(IViewSite site, IMemento memento) throws PartInitException {	143	public void init(IViewSite site, IMemento memento) throws PartInitException {
137	super.init(site, memento);	144	super.init(site, memento);
138	if (memento == null)	145	if (memento == null)
Lines 140-147 Link Here
140	else	147	else
141	this.fMemento = memento;	148	this.fMemento = memento;
142	initializeMemento();	149	initializeMemento();
143
144	fListener = new RegistryBrowserListener(this);
145	}	150	}
146		151
147	private void initializeMemento() {	152	private void initializeMemento() {
Lines 159-170 Link Here
159	}	164	}
160		165
161	public void dispose() {	166	public void dispose() {
162	if (fListener != null) {	167	model.disconnect();
163	Platform.getExtensionRegistry().removeRegistryChangeListener(fListener);	168	model.removeModelChangeListener(listener);
164	PDERuntimePlugin.getDefault().getBundleContext().removeBundleListener(fListener);	169	if (fClipboard != null) {
165	PDERuntimePlugin.getDefault().getBundleContext().removeServiceListener(fListener);	170	fClipboard.dispose();
166	}	171	}
167	fClipboard.dispose();
168	super.dispose();	172	super.dispose();
169	}	173	}
170		174
Lines 179-188 Link Here
179	createTreeViewer(composite);	183	createTreeViewer(composite);
180	fClipboard = new Clipboard(fTreeViewer.getTree().getDisplay());	184	fClipboard = new Clipboard(fTreeViewer.getTree().getDisplay());
181	fillToolBar();	185	fillToolBar();
182
183	PDERuntimePlugin.getDefault().getBundleContext().addBundleListener(fListener);
184	Platform.getExtensionRegistry().addRegistryChangeListener(fListener);
185	PDERuntimePlugin.getDefault().getBundleContext().addServiceListener(fListener);
186	}	186	}
187		187
188	private void createTreeViewer(Composite parent) {	188	private void createTreeViewer(Composite parent) {
Lines 198-214 Link Here
198	GridData gd = new GridData(GridData.FILL_BOTH);	198	GridData gd = new GridData(GridData.FILL_BOTH);
199	fFilteredTree.setLayoutData(gd);	199	fFilteredTree.setLayoutData(gd);
200	fTreeViewer = fFilteredTree.getViewer();	200	fTreeViewer = fFilteredTree.getViewer();
201	fTreeViewer.setContentProvider(new RegistryBrowserContentProvider());	201	fContentProvider = new RegistryBrowserContentProvider(this);
		202	fTreeViewer.setContentProvider(fContentProvider);
202	fTreeViewer.setLabelProvider(new RegistryBrowserLabelProvider(fTreeViewer));	203	fTreeViewer.setLabelProvider(new RegistryBrowserLabelProvider(fTreeViewer));
203	fTreeViewer.setUseHashlookup(true);	204	fTreeViewer.setUseHashlookup(true);
204	fTreeViewer.setComparator(new ViewerComparator() {	205	fTreeViewer.setComparator(new ViewerComparator() {
205	public int compare(Viewer viewer, Object e1, Object e2) {	206	public int compare(Viewer viewer, Object e1, Object e2) {
206	if (e1 instanceof PluginObjectAdapter)	207	if (e1 instanceof Folder && e2 instanceof Folder)
207	e1 = ((PluginObjectAdapter) e1).getObject();	208	return ((Folder) e1).getId() - ((Folder) e2).getId();
208	if (e2 instanceof PluginObjectAdapter)
209	e2 = ((PluginObjectAdapter) e2).getObject();
210	if (e1 instanceof IBundleFolder && e2 instanceof IBundleFolder)
211	return ((IBundleFolder) e1).getFolderId() - ((IBundleFolder) e2).getFolderId();
212	if (e1 instanceof Bundle && e2 instanceof Bundle) {	209	if (e1 instanceof Bundle && e2 instanceof Bundle) {
213	e1 = ((Bundle) e1).getSymbolicName();	210	e1 = ((Bundle) e1).getSymbolicName();
214	e2 = ((Bundle) e2).getSymbolicName();	211	e2 = ((Bundle) e2).getSymbolicName();
Lines 240-254 Link Here
240	tree.setMenu(menu);	237	tree.setMenu(menu);
241	}	238	}
242		239
243	private PluginObjectAdapter[] getBundles() {
244	Bundle[] bundles = PDERuntimePlugin.getDefault().getBundleContext().getBundles();
245	ArrayList list = new ArrayList();
246	for (int i = 0; i < bundles.length; i++)
247	if (bundles[i].getHeaders().get(Constants.FRAGMENT_HOST) == null)
248	list.add(new PluginAdapter(bundles[i]));
249	return (PluginObjectAdapter[]) list.toArray(new PluginObjectAdapter[list.size()]);
250	}
251
252	private void fillToolBar() {	240	private void fillToolBar() {
253	fDrillDownAdapter = new RegistryDrillDownAdapter(fTreeViewer);	241	fDrillDownAdapter = new RegistryDrillDownAdapter(fTreeViewer);
254	IActionBars bars = getViewSite().getActionBars();	242	IActionBars bars = getViewSite().getActionBars();
Lines 424-484 Link Here
424	fEnableAction = new Action(PDERuntimeMessages.RegistryView_enableAction_label) {	412	fEnableAction = new Action(PDERuntimeMessages.RegistryView_enableAction_label) {
425	public void run() {	413	public void run() {
426	List bundles = getSelectedBundles();	414	List bundles = getSelectedBundles();
427	State state = PDERuntimePlugin.getDefault().getState();
428	for (Iterator it = bundles.iterator(); it.hasNext();) {	415	for (Iterator it = bundles.iterator(); it.hasNext();) {
429	Bundle bundle = (Bundle) it.next();	416	Bundle bundle = (Bundle) it.next();
430	BundleDescription desc = state.getBundle(bundle.getBundleId());	417	bundle.setEnabled(true);
431	DisabledInfo[] infos = state.getDisabledInfos(desc);
432	for (int i = 0; i < infos.length; i++) {
433	PlatformAdmin platformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
434	platformAdmin.removeDisabledInfo(infos[i]);
435	}
436	}	418	}
437	PackageAdmin packageAdmin = PDERuntimePlugin.getDefault().getPackageAdmin();
438	packageAdmin.refreshPackages((Bundle[]) bundles.toArray(new Bundle[bundles.size()]));
439	}	419	}
440	};	420	};
441		421
442	fDisableAction = new Action(PDERuntimeMessages.RegistryView_disableAction_label) {	422	fDisableAction = new Action(PDERuntimeMessages.RegistryView_disableAction_label) {
443	public void run() {	423	public void run() {
444	List bundles = getSelectedBundles();	424	List bundles = getSelectedBundles();
445	State state = PDERuntimePlugin.getDefault().getState();
446	for (Iterator it = bundles.iterator(); it.hasNext();) {	425	for (Iterator it = bundles.iterator(); it.hasNext();) {
447	Bundle bundle = (Bundle) it.next();	426	Bundle bundle = (Bundle) it.next();
448	BundleDescription desc = state.getBundle(bundle.getBundleId());	427	bundle.setEnabled(false);
449	DisabledInfo info = new DisabledInfo("org.eclipse.pde.ui", "Disabled via PDE", desc); //$NON-NLS-1$ //$NON-NLS-2$
450	PlatformAdmin platformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
451	platformAdmin.addDisabledInfo(info);
452	}	428	}
453	PackageAdmin packageAdmin = PDERuntimePlugin.getDefault().getPackageAdmin();
454	packageAdmin.refreshPackages((Bundle[]) bundles.toArray(new Bundle[bundles.size()]));
455	}	429	}
456	};	430	};
457		431
458	fDiagnoseAction = new Action(PDERuntimeMessages.RegistryView_diagnoseAction_label) {	432	fDiagnoseAction = new Action(PDERuntimeMessages.RegistryView_diagnoseAction_label) {
459	public void run() {	433	public void run() {
460	List bundles = getSelectedBundles();	434	List bundles = getSelectedBundles();
461	State state = PDERuntimePlugin.getDefault().getState();
462	for (Iterator it = bundles.iterator(); it.hasNext();) {	435	for (Iterator it = bundles.iterator(); it.hasNext();) {
463	Bundle bundle = (Bundle) it.next();	436	Bundle bundle = (Bundle) it.next();
464	BundleDescription desc = state.getBundle(bundle.getBundleId());	437	MultiStatus problems = bundle.diagnose();
465	PlatformAdmin platformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
466	VersionConstraint[] unsatisfied = platformAdmin.getStateHelper().getUnsatisfiedConstraints(desc);
467	ResolverError[] resolverErrors = platformAdmin.getState(false).getResolverErrors(desc);
468	MultiStatus problems = new MultiStatus(PDERuntimePlugin.ID, IStatus.INFO, PDERuntimeMessages.RegistryView_found_problems, null);
469	for (int i = 0; i < resolverErrors.length; i++) {
470	if ((resolverErrors[i].getType() & (ResolverError.MISSING_FRAGMENT_HOST \| ResolverError.MISSING_GENERIC_CAPABILITY \| ResolverError.MISSING_IMPORT_PACKAGE \| ResolverError.MISSING_REQUIRE_BUNDLE)) != 0)
471	continue;
472	IStatus status = new Status(IStatus.WARNING, PDERuntimePlugin.ID, resolverErrors[i].toString());
473	problems.add(status);
474	}
475		438
476	for (int i = 0; i < unsatisfied.length; i++) {
477	IStatus status = new Status(IStatus.WARNING, PDERuntimePlugin.ID, MessageHelper.getResolutionFailureMessage(unsatisfied[i]));
478	problems.add(status);
479	}
480	Dialog dialog;	439	Dialog dialog;
481	if (unsatisfied.length != 0 \|\| resolverErrors.length != 0) {	440	if (problems.getChildren().length > 0) {
482	dialog = new DiagnosticsDialog(getSite().getShell(), PDERuntimeMessages.RegistryView_diag_dialog_title, null, problems, IStatus.WARNING);	441	dialog = new DiagnosticsDialog(getSite().getShell(), PDERuntimeMessages.RegistryView_diag_dialog_title, null, problems, IStatus.WARNING);
483	dialog.open();	442	dialog.open();
484	} else {	443	} else {
Lines 499-515 Link Here
499	fCollapseAllAction.setToolTipText(PDERuntimeMessages.RegistryView_collapseAll_tooltip);	458	fCollapseAllAction.setToolTipText(PDERuntimeMessages.RegistryView_collapseAll_tooltip);
500	}	459	}
501		460
		461	public boolean showExtensionsOnly() {
		462	return fShowExtensionsOnlyAction.isChecked();
		463	}
		464
502	protected void updateItems(boolean resetInput) {	465	protected void updateItems(boolean resetInput) {
503	Object[] input = null;	466	Object[] input = null;
504	boolean extOnly = fShowExtensionsOnlyAction.isChecked();	467	if (showExtensionsOnly())
505	if (extOnly)	468	input = model.getExtensionPoints();
506	input = Platform.getExtensionRegistry().getExtensionPoints();
507	else	469	else
508	input = getBundles();	470	input = model.getBundles();
509	fListener.fExtOnly = extOnly;
510	fTotalItems = input.length;	471	fTotalItems = input.length;
511	if (resetInput)	472	if (resetInput)
512	fTreeViewer.setInput(new PluginObjectAdapter(input));	473	fTreeViewer.setInput(input);
513	updateTitle();	474	updateTitle();
514	}	475	}
515		476
Lines 531-552 Link Here
531	return NLS.bind(PDERuntimeMessages.RegistryView_titleSummary, (new String[] {Integer.toString(tree.getItemCount()), Integer.toString(fTotalItems), type}));	492	return NLS.bind(PDERuntimeMessages.RegistryView_titleSummary, (new String[] {Integer.toString(tree.getItemCount()), Integer.toString(fTotalItems), type}));
532	}	493	}
533		494
534	// TODO hackish, should rewrite
535	private boolean isBundleSelected() {	495	private boolean isBundleSelected() {
536	IStructuredSelection selection = (IStructuredSelection) fTreeViewer.getSelection();	496	IStructuredSelection selection = (IStructuredSelection) fTreeViewer.getSelection();
537	if (selection != null) {	497	if (selection != null) {
538	Object[] elements = selection.toArray();	498	Object[] elements = selection.toArray();
539	for (int i = 0; i < elements.length; i++) {	499	for (int i = 0; i < elements.length; i++) {
540	if (elements[i] instanceof PluginObjectAdapter) {	500	if (!(elements[i] instanceof Bundle)) {
541	PluginObjectAdapter adapter = (PluginObjectAdapter) elements[i];
542	Object object = adapter.getObject();
543	if (!(object instanceof Bundle))
544	return false;
545	} else {
546	return false;	501	return false;
547	}	502	}
548	}	503	}
549	}	504	}
		505
550	return true;	506	return true;
551	}	507	}
552		508
Lines 556-572 Link Here
556	if (selection != null) {	512	if (selection != null) {
557	Object[] elements = selection.toArray();	513	Object[] elements = selection.toArray();
558	for (int i = 0; i < elements.length; i++) {	514	for (int i = 0; i < elements.length; i++) {
559	if (elements[i] instanceof PluginObjectAdapter) {	515	if (elements[i] instanceof Bundle) {
560	PluginObjectAdapter adapter = (PluginObjectAdapter) elements[i];	516	bundles.add(elements[i]);
561	Object object = adapter.getObject();
562	if (object instanceof Bundle)
563	bundles.add(object);
564	}	517	}
565	}	518	}
566	}	519	}
567	return bundles;	520	return bundles;
568	}	521	}
569		522
		523	/**
		524	* @return true if none is stopped, false if at least one is stopped
		525	*/
570	private boolean selectedBundlesStarted() {	526	private boolean selectedBundlesStarted() {
571	List bundles = getSelectedBundles();	527	List bundles = getSelectedBundles();
572	for (Iterator it = bundles.iterator(); it.hasNext();) {	528	for (Iterator it = bundles.iterator(); it.hasNext();) {
Lines 577-582 Link Here
577	return true;	533	return true;
578	}	534	}
579		535
		536	/**
		537	* @return true if none is active, false if at least one is active
		538	*/
580	private boolean selectedBundlesStopped() {	539	private boolean selectedBundlesStopped() {
581	List bundles = getSelectedBundles();	540	List bundles = getSelectedBundles();
582	for (Iterator it = bundles.iterator(); it.hasNext();) {	541	for (Iterator it = bundles.iterator(); it.hasNext();) {
Lines 587-620 Link Here
587	return true;	546	return true;
588	}	547	}
589		548
		549	/**
		550	* @return true if none is enabled, false if at least one is enabled
		551	*/
590	private boolean selectedBundlesDisabled() {	552	private boolean selectedBundlesDisabled() {
591	List bundles = getSelectedBundles();	553	List bundles = getSelectedBundles();
592	for (Iterator it = bundles.iterator(); it.hasNext();) {	554	for (Iterator it = bundles.iterator(); it.hasNext();) {
593	Bundle bundle = (Bundle) it.next();	555	Bundle bundle = (Bundle) it.next();
594	State state = PDERuntimePlugin.getDefault().getState();	556	if (bundle.isEnabled())
595	BundleDescription desc = state.getBundle(bundle.getBundleId());
596	DisabledInfo[] infos = state.getDisabledInfos(desc);
597	if (infos.length == 0)
598	return false;	557	return false;
599	}	558	}
600	return true;	559	return true;
601	}	560	}
602		561
		562	/**
		563	* @return true if none is disabled, false if at least one is disabled
		564	*/
603	private boolean selectedBundlesEnabled() {	565	private boolean selectedBundlesEnabled() {
604	List bundles = getSelectedBundles();	566	List bundles = getSelectedBundles();
605	for (Iterator it = bundles.iterator(); it.hasNext();) {	567	for (Iterator it = bundles.iterator(); it.hasNext();) {
606	Bundle bundle = (Bundle) it.next();	568	Bundle bundle = (Bundle) it.next();
607	State state = PDERuntimePlugin.getDefault().getState();	569	if (!bundle.isEnabled())
608	BundleDescription desc = state.getBundle(bundle.getBundleId());
609	DisabledInfo[] infos = state.getDisabledInfos(desc);
610	if (infos.length > 0)
611	return false;	570	return false;
612	}	571	}
613	return true;	572	return true;
614	}	573	}
615		574
616	protected void add(Object object) {	575	public void add(Object object) {
617	add(fTreeViewer.getInput(), object);	576	Object parent = fContentProvider.getParent(object);
		577	if (parent == null) {
		578	add(fTreeViewer.getInput(), object);
		579	} else {
		580	refresh(parent);
		581	}
618	}	582	}
619		583
620	protected void add(Object parent, Object object) {	584	protected void add(Object parent, Object object) {
Lines 625-631 Link Here
625	updateTitle();	589	updateTitle();
626	}	590	}
627		591
628	protected void remove(Object object) {	592	public void remove(Object object) {
629	if (fDrillDownAdapter.canGoHome())	593	if (fDrillDownAdapter.canGoHome())
630	return;	594	return;
631	fTotalItems -= 1;	595	fTotalItems -= 1;
Lines 633-647 Link Here
633	updateTitle();	597	updateTitle();
634	}	598	}
635		599
636	protected void update(Object object) {	600	public void update(Object object) {
637	fTreeViewer.update(object, null);	601	fTreeViewer.update(object, null);
638	}	602	}
639		603
640	protected void refresh(Object object) {	604	public void refresh(Object object) {
641	fTreeViewer.refresh(object);	605	fTreeViewer.refresh(object);
642	}	606	}
643
644	protected TreeItem[] getTreeItems() {
645	return fTreeViewer.getTree().getItems();
646	}
647	}	607	}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry;

import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;

public class ExtensionAdapter extends ParentAdapter {

	public ExtensionAdapter(Object object) {
		super(object);
	}

	protected Object[] createChildren() {
		IExtension extension = (IExtension) getObject();

		IConfigurationElement[] elements = extension.getConfigurationElements();
		Object[] result = new ConfigurationElementAdapter[elements.length];
		for (int i = 0; i < elements.length; i++) {
			IConfigurationElement config = elements[i];
			result[i] = new ConfigurationElementAdapter(config);
		}
		return result;
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry;

import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;

public class ExtensionPointAdapter extends ParentAdapter {

	public ExtensionPointAdapter(Object object) {
		super(object);
	}

	protected Object[] createChildren() {
		IExtensionPoint extensionPoint = (IExtensionPoint) getObject();

		IExtension[] extensions = extensionPoint.getExtensions();
		Object[] result = new Object[extensions.length];
		for (int i = 0; i < extensions.length; i++) {
			IExtension extension = extensions[i];
			result[i] = new ExtensionAdapter(extension);
		}
		return result;
	}
}




/*******************************************************************************
 * Copyright (c) 2008 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry;

import org.osgi.framework.ServiceReference;

public class ServiceReferenceAdapter extends ParentAdapter {

	public ServiceReferenceAdapter(ServiceReference object) {
		super(object);
	}

	protected Object[] createChildren() {
		// TODO pluggable support for different services
		return null;
	}

	public boolean equals(Object obj) {
		// imitate ServiceReference behavior, that multiple ServiceReference instances are equal
		return (obj instanceof ServiceReferenceAdapter) ? getObject().equals(((ServiceReferenceAdapter) obj).getObject()) : false;
	}

	public int hashCode() {
		// imitate ServiceReference behavior, that multiple ServiceReference instances return the same hashCode
		return getObject().hashCode();
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry;

import org.eclipse.core.runtime.PlatformObject;

public class PluginObjectAdapter extends PlatformObject {
	private Object fObject;

	public PluginObjectAdapter(Object object) {
		this.fObject = object;
	}

	public Object getObject() {
		return fObject;
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry;

import org.eclipse.core.runtime.IConfigurationElement;

public class ConfigurationElementAdapter extends ParentAdapter {

	class ConfigurationAttribute implements IConfigurationAttribute {
		private String fLabel;

		public ConfigurationAttribute(String name, String value) {
			fLabel = name + " = " + value; //$NON-NLS-1$
		}

		public String getLabel() {
			return fLabel;
		}
	}

	public ConfigurationElementAdapter(Object object) {
		super(object);
	}

	protected Object[] createChildren() {
		IConfigurationElement config = (IConfigurationElement) getObject();
		String[] atts = config.getAttributeNames();
		IConfigurationAttribute[] catts = new IConfigurationAttribute[atts.length];
		for (int i = 0; i < atts.length; i++)
			catts[i] = new ConfigurationAttribute(atts[i], config.getAttribute(atts[i]));
		IConfigurationElement[] children = config.getChildren();
		Object[] result = new Object[children.length + catts.length];
		for (int i = 0; i < children.length; i++) {
			IConfigurationElement child = children[i];
			result[i] = new ConfigurationElementAdapter(child);
		}
		for (int i = 0; i < catts.length; i++) {
			IConfigurationAttribute child = catts[i];
			result[children.length + i] = new ConfigurationAttributeAdapter(child);
		}
		return result;
	}
}




/******************************************************************************
 * Copyright (c) 2008 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry;

import org.eclipse.core.runtime.*;
import org.eclipse.pde.internal.runtime.registry.RegistryBrowserContentProvider.BundleFolder;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.osgi.framework.*;

public class RegistryBrowserListener implements IRegistryChangeListener, BundleListener, ServiceListener {

	protected RegistryBrowser fBrowser;
	protected boolean fExtOnly;

	protected RegistryBrowserListener(RegistryBrowser browser) {
		fBrowser = browser;
	}

	public void registryChanged(final IRegistryChangeEvent event) {
		final Tree tree = fBrowser.getUndisposedTree();
		if (tree == null)
			return;

		tree.getDisplay().asyncExec(new Runnable() {
			public void run() {
				IExtensionDelta[] deltas = event.getExtensionDeltas();
				for (int i = 0; i < deltas.length; i++) {
					if (fExtOnly)
						handleExtOnlyEvent(deltas[i]);
					else
						handleEvent(deltas[i]);
				}
			}
		});
	}

	public void bundleChanged(final BundleEvent event) {
		final Tree tree = fBrowser.getUndisposedTree();
		if (tree == null)
			return;

		tree.getDisplay().asyncExec(new Runnable() {
			public void run() {
				if (fExtOnly)
					handleExtOnlyEvent(event.getType(), event.getBundle());
				else
					handleEvent(event.getType(), event.getBundle());
			}
		});
	}

	void handleEvent(IExtensionDelta delta) {
		handleDelta(delta, false);
	}

	void handleExtOnlyEvent(IExtensionDelta delta) {
		handleDelta(delta, true);
	}

	private void handleDelta(IExtensionDelta delta, boolean extOnly) {
		IExtension ext = delta.getExtension();
		IExtensionPoint extPoint = delta.getExtensionPoint();
		// TODO fix this method (and addToTree/removeFromTree)
		// bug 130655
		if (delta.getKind() == IExtensionDelta.ADDED) {
			addExtensionObjectToTree(ext, extOnly);
			addExtensionObjectToTree(extPoint, extOnly);
		} else if (delta.getKind() == IExtensionDelta.REMOVED) {
			removeFromTree(ext);
			removeFromTree(extPoint);
		}
	}

	//	private void addToTree(Object object) {
	//		String namespace = getNamespaceIdentifier(object);
	//		if (namespace == null)
	//			return;
	//		TreeItem[] items = fTreeViewer.getTree().getItems();
	//		for (int i = 0; i < items.length; i++) {
	//			Object data = items[i].getData();
	//			Object adapted = null;
	//			if (data instanceof PluginObjectAdapter)
	//				adapted = ((PluginObjectAdapter)data).getObject();
	//			if (adapted instanceof Bundle && ((Bundle)adapted).getSymbolicName().equals(namespace)) {
	//				addBundleToTree(items[i], data, object);
	//			}
	//		}
	//	}

	private void addExtensionObjectToTree(Object child, boolean extOnly) {
		Object parent = null;
		if (!extOnly)
			parent = getAdoptingBundleParent(child);
		else if (child instanceof IExtensionPoint) {
			// add to root
			fBrowser.add(child);
			return;
		} else if (child instanceof IExtension) {
			// search all extensionPoints and return the correct one
			String extPoint = ((IExtension) child).getExtensionPointUniqueIdentifier();
			TreeItem[] items = fBrowser.getTreeItems();
			for (int i = 0; i < items.length; i++) {
				Object data = items[i].getData();
				if (data instanceof PluginObjectAdapter)
					data = ((PluginObjectAdapter) data).getObject();
				if (data instanceof IExtensionPoint && ((IExtensionPoint) data).getUniqueIdentifier().equals(extPoint)) {
					parent = items[i].getData();
					break;
				}
			}
		}
		if (parent != null)
			fBrowser.add(parent, child);
	}

	private Object getAdoptingBundleParent(Object child) {
		TreeItem bundleItem = findBundleItem(getNamespaceIdentifier(child));
		if (bundleItem != null) {
			// TODO fix this
			// remove this if (true) clause and return the proper parent
			if (true) {
				fBrowser.refresh(bundleItem.getData());
				fBrowser.updateItems(false);
				return null;
			}
			TreeItem[] folders = bundleItem.getItems();
			for (int j = 0; j < folders.length; j++) {
				// make sure to check extensionsOnlyMode()
				// and add to root/proper extension if true
				IBundleFolder folder = (IBundleFolder) folders[j].getData();
				if (correctFolder(folder, child))
					return folder;
			}
			// folder not found - 1st extension - refresh bundle item
			// to rebuild folders
			fBrowser.refresh(bundleItem.getData());
		}
		return null;
	}

	private TreeItem findBundleItem(String namespace) {
		if (namespace == null)
			return null;
		TreeItem[] items = fBrowser.getTreeItems();
		for (int i = 0; i < items.length; i++) {
			Object data = items[i].getData();
			if (data instanceof PluginObjectAdapter)
				data = ((PluginObjectAdapter) data).getObject();
			if (data instanceof Bundle && ((Bundle) data).getSymbolicName().equals(namespace))
				return items[i];
		}
		return null;
	}

	//	private void addBundleToTree(TreeItem item, Object data, Object object) {
	//		// TODO fix this method
	//		if (true) {
	//			fTreeViewer.refresh(data);
	//			updateItems(false);
	//			return;
	//		}
	//		TreeItem[] folders = item.getItems();
	//		for (int j = 0; j < folders.length; j++) {
	//			// make sure to check extensionsOnlyMode()
	//			// and add to root/proper extension if true
	//			IBundleFolder folder = (IBundleFolder)folders[j].getData();
	//			if (correctFolder(folder, object)) {
	//				fTreeViewer.add(folder, object);
	//				return;
	//			}
	//		}
	//		// folder not found - 1st extension - refresh bundle item
	//		fTreeViewer.refresh(data);
	//	}

	private String getNamespaceIdentifier(Object object) {
		if (object instanceof IExtensionPoint)
			return ((IExtensionPoint) object).getNamespaceIdentifier();
		if (object instanceof IExtension)
			return ((IExtension) object).getContributor().getName();
		return null;
	}

	private boolean correctFolder(IBundleFolder folder, Object child) {
		if (folder == null)
			return false;
		if (child instanceof IExtensionPoint)
			return folder.getFolderId() == IBundleFolder.F_EXTENSION_POINTS;
		if (child instanceof IExtension)
			return folder.getFolderId() == IBundleFolder.F_EXTENSIONS;
		return false;
	}

	private void removeFromTree(Object object) {
		String namespace = getNamespaceIdentifier(object);
		if (namespace == null)
			return;
		TreeItem[] bundles = fBrowser.getTreeItems();
		for (int i = 0; i < bundles.length; i++) {
			Object data = bundles[i].getData();
			Object adapted = null;
			if (data instanceof PluginObjectAdapter)
				adapted = ((PluginObjectAdapter) data).getObject();
			if (adapted instanceof Bundle && ((Bundle) adapted).getSymbolicName().equals(namespace)) {
				TreeItem[] folders = bundles[i].getItems();
				// TODO fix this method
				if (true) {
					fBrowser.refresh(data);
					fBrowser.updateItems(false);
					return;
				}
				for (int j = 0; j < folders.length; j++) {
					IBundleFolder folder = (IBundleFolder) folders[j].getData();
					if (correctFolder(folder, object)) {
						fBrowser.remove(object);
						return;
					}
				}
				// folder not found - 1st extension - refresh bundle item
				fBrowser.refresh(data);
			}
		}
	}

	protected Object findTreeBundleData(Object searchData) {
		final Tree tree = fBrowser.getUndisposedTree();
		if (tree == null)
			return null;

		Object data = null;
		TreeItem[] items = fBrowser.getTreeItems();
		if (items == null)
			return null;
		for (int i = 0; i < items.length; i++) {
			Object object = items[i].getData();
			data = object;
			if (object instanceof PluginObjectAdapter)
				object = ((PluginObjectAdapter) object).getObject();
			if (searchData.equals(object))
				return data;
		}
		return null;
	}

	void handleEvent(int changeType, Bundle bundle) {
		Object data = findTreeBundleData(bundle);
		switch (changeType) {
			case BundleEvent.INSTALLED :
				if (data == null)
					fBrowser.add(new PluginAdapter(bundle));
				break;
			case BundleEvent.UNINSTALLED :
				if (data != null)
					fBrowser.remove(data);
				break;
			case BundleEvent.STARTED :
			case BundleEvent.STOPPED :
			case BundleEvent.UPDATED :
			case BundleEvent.RESOLVED :
			case BundleEvent.STARTING :
			case BundleEvent.STOPPING :
			case BundleEvent.UNRESOLVED :
			case BundleEvent.LAZY_ACTIVATION :
				if (data != null)
					fBrowser.update(data);
				break;
		}
	}

	void handleExtOnlyEvent(int changeType, Bundle bundle) {
		switch (changeType) {
			case BundleEvent.INSTALLED :
			case BundleEvent.UNINSTALLED :
				// add/remove all extension points contributed by new bundle
				IExtensionPoint[] points = Platform.getExtensionRegistry().getExtensionPoints(bundle.getSymbolicName());
				for (int i = 0; i < points.length; i++) {
					Object pointData = findTreeBundleData(points[i]);
					if (pointData == null) {
						if (changeType == BundleEvent.INSTALLED)
							fBrowser.add(new ExtensionPointAdapter(points[i]));
						else
							// changeType == BundleEvent.UNINSTALLED
							fBrowser.remove(pointData);
					}
				}
				// add/remove all extensions contributed by new bundle
				IExtension[] extensions = Platform.getExtensionRegistry().getExtensions(bundle.getSymbolicName());
				for (int i = 0; i < extensions.length; i++) {
					String pointId = extensions[i].getExtensionPointUniqueIdentifier();
					if (changeType == BundleEvent.INSTALLED) {
						IExtensionPoint point = Platform.getExtensionRegistry().getExtensionPoint(pointId);
						Object pointData = findTreeBundleData(point);
						if (pointData != null)
							fBrowser.add(pointData, new ExtensionAdapter(extensions[i]));
					} else { // changeType == BundleEvent.UNINSTALLED
						Object extensionData = findTreeBundleData(extensions[i]);
						if (extensionData != null)
							fBrowser.remove(extensionData);
					}
				}
				break;
			case BundleEvent.STARTED :
			case BundleEvent.STOPPED :
			case BundleEvent.UPDATED :
			case BundleEvent.RESOLVED :
			case BundleEvent.STARTING :
			case BundleEvent.STOPPING :
			case BundleEvent.UNRESOLVED :
			case BundleEvent.LAZY_ACTIVATION :
				// nothing needs to be done for any other cases
				break;
		}
	}

	public void serviceChanged(final ServiceEvent event) {
		final Tree tree = fBrowser.getUndisposedTree();
		if (tree == null)
			return;

		tree.getDisplay().asyncExec(new Runnable() {
			public void run() {
				handleServiceChangedEvent(event);
			}
		});

	}

	protected void handleServiceChangedEvent(ServiceEvent event) {
		ServiceReference ref = event.getServiceReference();
		switch (event.getType()) {
			case ServiceEvent.REGISTERED :
			case ServiceEvent.UNREGISTERING :
				Bundle bundle = ref.getBundle();
				if (bundle == null)
					return;
				String name = bundle.getSymbolicName();
				if (name == null)
					return;
				TreeItem bundleItem = findBundleItem(name);
				if (bundleItem == null)
					return;
				PluginAdapter bundleAdapter = ((PluginAdapter) bundleItem.getData());
				Object[] folders = bundleAdapter.getChildren();

				for (int j = 0; j < folders.length; j++) {
					if (folders[j] instanceof IBundleFolder) {
						IBundleFolder folder = (IBundleFolder) folders[j];

						if (folder.getFolderId() == IBundleFolder.F_REGISTERED_SERVICES) {
							if ((event.getType() == ServiceEvent.REGISTERED) || (event.getType() == ServiceEvent.UNREGISTERING)) {
								((BundleFolder) folder).refresh(); // refresh model
								fBrowser.refresh(folder); // refresh view

								// refresh whole bundle in case there were folders added - they might have not existed if bundle had no service before
								fBrowser.refresh(bundleAdapter);
							}
						}
					}
				}

				break;
			case ServiceEvent.MODIFIED :
				break;
		}
	}

}




 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry;

import java.io.IOException;
import java.net.URL;
import java.util.Arrays;
import org.eclipse.core.runtime.*;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.osgi.service.resolver.*;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.internal.runtime.*;
import org.eclipse.pde.internal.runtime.registry.model.*;
import org.eclipse.swt.graphics.Image;
import org.osgi.framework.Bundle;
import org.osgi.framework.ServiceReference;

public class RegistryBrowserLabelProvider extends LabelProvider {


	}

	public Image getImage(Object element) {
		if (element instanceof PluginObjectAdapter)
			element = ((PluginObjectAdapter) element).getObject();

		if (element instanceof Bundle) {
			Bundle bundle = (Bundle) element;

			if (!bundle.isEnabled())
			PlatformAdmin plaformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
			State state = plaformAdmin.getState(false);

			BundleDescription description = state.getBundle(bundle.getBundleId());
			if ((state.getDisabledInfos(description)).length > 0)
				return fDisabledImage;

			switch (bundle.getState()) {

				case Bundle.UNINSTALLED :
					return fUnresolvedPluginImage;
				case Bundle.INSTALLED :
					if (!bundle.isEnabled())
						return fUnresolvedPluginImage;
				default :
					return fPluginImage;
			}
		}

		if (element instanceof ServiceRegistration) {
			return fServiceImage;
		}

		if (element instanceof Folder) {
			int id = ((Folder) element).getId();
			switch (id) {
				case Folder.F_EXTENSIONS :
					return fExtensionsImage;
				case Folder.F_EXTENSION_POINTS :
					return fExtensionPointsImage;
				case Folder.F_IMPORTS :
					return fRequiresImage;
				case Folder.F_LIBRARIES :
					return fRuntimeImage;
				case Folder.F_REGISTERED_SERVICES :
					return fLocationImage;
				case IBundleFolder.F_REGISTERED_SERVICES :
					return fExporterImage;
				case Folder.F_SERVICES_IN_USE :
					return fImporterImage;
			}
			return null;
		}
		if (element instanceof Extension)
			return fExtensionImage;

		if (element instanceof ExtensionPoint)
			return fExtensionPointImage;

		if (element instanceof BundlePrerequisite)
			return ((BundlePrerequisite) element).isExported() ? fExpReqPluginImage : fReqPluginImage;

		if (element instanceof BundleLibrary)
			return fLibraryImage;

		if (element instanceof ConfigurationElement)
			return fGenericTagImage;

		if (element instanceof Attribute) {
			Attribute attr = (Attribute) element;
			if (Attribute.F_LOCATION.equals(attr.getName())) {
				return fLocationImage;
			}
			return fGenericAttrImage;
		}

		return null;
	}

	public String getText(Object element) {
		if (element instanceof PluginObjectAdapter)
			element = ((PluginObjectAdapter) element).getObject();
		if (element instanceof Bundle) {
			String id = ((Bundle) element).getSymbolicName();
			String version = ((Bundle) element).getVersion();
			if (version == null)
				return id;
			return id + " (" + version + ")"; //$NON-NLS-1$ //$NON-NLS-2$
		}
		if (element instanceof ServiceRegistration) {
			ServiceRegistration ref = (ServiceRegistration) element;
			String[] classes = ref.getClasses();
			Long id = ref.getId();
			String identifier = " (id=" + id.toString() + ")"; //$NON-NLS-1$ //$NON-NLS-2$
			return Arrays.asList(classes).toString().concat(identifier);
		}
		if (element instanceof Folder) {
			switch (((Folder) element).getId()) {
				case Folder.F_IMPORTS :
					return PDERuntimeMessages.RegistryView_folders_imports;
				case Folder.F_LIBRARIES :
					return PDERuntimeMessages.RegistryView_folders_libraries;
				case Folder.F_EXTENSION_POINTS :
					return PDERuntimeMessages.RegistryView_folders_extensionPoints;
				case Folder.F_EXTENSIONS :
					return PDERuntimeMessages.RegistryView_folders_extensions;
				case Folder.F_REGISTERED_SERVICES :
					return PDERuntimeMessages.RegistryBrowserLabelProvider_registeredServices;
				case Folder.F_SERVICES_IN_USE :
					return PDERuntimeMessages.RegistryBrowserLabelProvider_usedServices;
				case IBundleFolder.F_LOCATION :
					Bundle bundle = ((IBundleFolder) element).getBundle();
					URL bundleEntry = bundle.getEntry("/"); //$NON-NLS-1$
					try {
						bundleEntry = FileLocator.resolve(bundleEntry);
					} catch (IOException e) { // do nothing
					}
					IPath path = new Path(bundleEntry.getFile());
					String pathString = path.removeTrailingSeparator().toOSString();
					if (pathString.startsWith("file:")) //$NON-NLS-1$
						pathString = pathString.substring(5);
					if (pathString.endsWith("!")) //$NON-NLS-1$
						pathString = pathString.substring(0, pathString.length() - 1);
					return pathString;
			}
		}
		if (element instanceof Extension) {
			if (((RegistryBrowserContentProvider) fViewer.getContentProvider()).isInExtensionSet) {
				String name = ((Extension) element).getLabel();
				String id = ((Extension) element).getExtensionPointUniqueIdentifier();
				if (name != null && name.length() > 0)
					return NLS.bind(PDERuntimeMessages.RegistryBrowserLabelProvider_nameIdBind, id, name);
				return id;
			}

			String contributor = ((Extension) element).getNamespaceIdentifier();
			return NLS.bind(PDERuntimeMessages.RegistryBrowserLabelProvider_contributedBy, contributor);

		}
		if (element instanceof ExtensionPoint) {
			String id = ((ExtensionPoint) element).getUniqueIdentifier();
			String name = ((ExtensionPoint) element).getLabel();
			if (name != null && name.length() > 0)
				return NLS.bind(PDERuntimeMessages.RegistryBrowserLabelProvider_nameIdBind, id, name);
			return id;
		}
		if (element instanceof BundlePrerequisite)
			return ((BundlePrerequisite) element).getName();

		if (element instanceof BundleLibrary)
			return ((BundleLibrary) element).getLibrary();

		if (element instanceof ConfigurationElement) {
			return ((ConfigurationElement) element).getName();
		}
		if (element instanceof Attribute) {
			Attribute attribute = (Attribute) element;
			return attribute.getName() + " = " + attribute.getValue(); //$NON-NLS-1$
				label = ((IConfigurationElement) element).getAttribute("name"); //$NON-NLS-1$

			if (label == null && ((IConfigurationElement) element).getAttribute("id") != null) { //$NON-NLS-1$
				String[] labelSplit = ((IConfigurationElement) element).getAttribute("id").split("\\."); //$NON-NLS-1$ //$NON-NLS-2$
				label = labelSplit.length == 0 ? null : labelSplit[labelSplit.length - 1];
			}
			return label;
		}
		if (element instanceof IConfigurationAttribute)
			return ((IConfigurationAttribute) element).getLabel();

		return super.getText(element);
	}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry;

import org.eclipse.core.runtime.IAdaptable;
import org.osgi.framework.Bundle;

public interface IBundleFolder extends IAdaptable {
	public static final int F_LOCATION = 0;
	public static final int F_EXTENSIONS = 1;
	public static final int F_EXTENSION_POINTS = 2;
	public static final int F_IMPORTS = 3;
	public static final int F_LIBRARIES = 4;
	public static final int F_REGISTERED_SERVICES = 5;
	public static final int F_SERVICES_IN_USE = 6;

	public Object[] getChildren();

	public void refresh();

	int getFolderId();

	public Bundle getBundle();
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry;

public interface IBundleLibrary {
	public String getLibrary();
}

Lines 17-22 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
17	Eclipse-LazyStart: true	17	Eclipse-LazyStart: true
18	Export-Package: org.eclipse.pde.internal.runtime;x-internal:=true,	18	Export-Package: org.eclipse.pde.internal.runtime;x-internal:=true,
19	org.eclipse.pde.internal.runtime.registry;x-internal:=true,	19	org.eclipse.pde.internal.runtime.registry;x-internal:=true,
		20	org.eclipse.pde.internal.runtime.registry.model;x-internal:=true,
20	org.eclipse.pde.internal.runtime.spy;x-internal:=true,	21	org.eclipse.pde.internal.runtime.spy;x-internal:=true,
21	org.eclipse.pde.internal.runtime.spy.dialogs;x-internal:=true,	22	org.eclipse.pde.internal.runtime.spy.dialogs;x-internal:=true,
22	org.eclipse.pde.internal.runtime.spy.handlers;x-internal:=true,	23	org.eclipse.pde.internal.runtime.spy.handlers;x-internal:=true,

Lines 32-37 Link Here

(-)src/org/eclipse/pde/internal/runtime/PDERuntimePlugin.java (-5 / +4 lines)
32	private ServiceTracker packageAdminTracker;	32	private ServiceTracker packageAdminTracker;
33	private ServiceTracker platformAdminTracker;	33	private ServiceTracker platformAdminTracker;
34		34
		35	public PDERuntimePlugin() {
		36	inst = this;
		37	}
		38
35	private static boolean isBundleAvailable(String bundleID) {	39	private static boolean isBundleAvailable(String bundleID) {
36	Bundle bundle = Platform.getBundle(bundleID);	40	Bundle bundle = Platform.getBundle(bundleID);
37	return bundle != null && (bundle.getState() & (Bundle.ACTIVE \| Bundle.STARTING \| Bundle.RESOLVED)) != 0;	41	return bundle != null && (bundle.getState() & (Bundle.ACTIVE \| Bundle.STARTING \| Bundle.RESOLVED)) != 0;
Lines 86-95 Link Here
86	return getDefault().getBundle().getSymbolicName();	90	return getDefault().getBundle().getSymbolicName();
87	}	91	}
88		92
89	public PDERuntimePlugin() {
90	inst = this;
91	}
92
93	private IWorkbenchPage internalGetActivePage() {	93	private IWorkbenchPage internalGetActivePage() {
94	return getWorkbench().getActiveWorkbenchWindow().getActivePage();	94	return getWorkbench().getActiveWorkbenchWindow().getActivePage();
95	}	95	}
Lines 142-148 Link Here
142	platformAdminTracker.close();	142	platformAdminTracker.close();
143	platformAdminTracker = null;	143	platformAdminTracker = null;
144	}	144	}
145	inst = null;
146	}	145	}
147		146
148	}	147	}




package org.eclipse.pde.internal.runtime.registry.model;

import java.io.IOException;
import java.net.URL;
import java.util.*;
import org.eclipse.core.runtime.*;
import org.eclipse.osgi.service.resolver.*;
import org.eclipse.osgi.util.ManifestElement;
import org.eclipse.pde.internal.runtime.*;
import org.osgi.framework.*;
import org.osgi.service.packageadmin.PackageAdmin;

public class LocalRegistryBackend implements IRegistryEventListener, BundleListener, ServiceListener, RegistryBackend {

	private BackendChangeListener listener;
	private RegistryModel model;

	public void setRegistryModel(RegistryModel model) {
		this.model = model;
	}

	public void setRegistryListener(BackendChangeListener listener) {
		this.listener = listener;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.runtime.registry.model.local.RegistryBackend#connect()
	 */
	public void connect() {
		PDERuntimePlugin.getDefault().getBundleContext().addBundleListener(this);
		Platform.getExtensionRegistry().addListener(this);
		PDERuntimePlugin.getDefault().getBundleContext().addServiceListener(this);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.runtime.registry.model.local.RegistryBackend#disconnect()
	 */
	public void disconnect() {
		Platform.getExtensionRegistry().removeListener(this);
		PDERuntimePlugin.getDefault().getBundleContext().removeBundleListener(this);
		PDERuntimePlugin.getDefault().getBundleContext().removeServiceListener(this);
	}

	protected static boolean isRegisteredService(org.osgi.framework.Bundle bundle, ServiceReference ref) {
		return bundle.equals(ref.getBundle());
	}

	protected static boolean isServiceInUse(org.osgi.framework.Bundle bundle, ServiceReference ref) {
		org.osgi.framework.Bundle[] usingBundles = ref.getUsingBundles();
		return (usingBundles != null && Arrays.asList(usingBundles).contains(bundle));
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.runtime.registry.model.local.RegistryBackend#start(org.osgi.framework.Bundle)
	 */
	public void start(Bundle bundle) throws BundleException {
		PDERuntimePlugin.getDefault().getBundleContext().getBundle(bundle.getId().longValue()).start();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.runtime.registry.model.local.RegistryBackend#stop(org.osgi.framework.Bundle)
	 */
	public void stop(Bundle bundle) throws BundleException {
		PDERuntimePlugin.getDefault().getBundleContext().getBundle(bundle.getId().longValue()).stop();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.runtime.registry.model.local.RegistryBackend#diagnose(org.osgi.framework.Bundle)
	 */
	public MultiStatus diagnose(Bundle bundle) {
		PlatformAdmin plaformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
		State state = plaformAdmin.getState(false);

		BundleDescription desc = state.getBundle(bundle.getId().longValue());

		PlatformAdmin platformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
		VersionConstraint[] unsatisfied = platformAdmin.getStateHelper().getUnsatisfiedConstraints(desc);
		ResolverError[] resolverErrors = platformAdmin.getState(false).getResolverErrors(desc);

		MultiStatus problems = new MultiStatus(PDERuntimePlugin.ID, IStatus.INFO, PDERuntimeMessages.RegistryView_found_problems, null);
		for (int i = 0; i < resolverErrors.length; i++) {
			if ((resolverErrors[i].getType() & (ResolverError.MISSING_FRAGMENT_HOST | ResolverError.MISSING_GENERIC_CAPABILITY | ResolverError.MISSING_IMPORT_PACKAGE | ResolverError.MISSING_REQUIRE_BUNDLE)) != 0)
				continue;
			IStatus status = new Status(IStatus.WARNING, PDERuntimePlugin.ID, resolverErrors[i].toString());
			problems.add(status);
		}

		for (int i = 0; i < unsatisfied.length; i++) {
			IStatus status = new Status(IStatus.WARNING, PDERuntimePlugin.ID, MessageHelper.getResolutionFailureMessage(unsatisfied[i]));
			problems.add(status);
		}

		return problems;
	}

	public Map initializeBundles() {
		org.osgi.framework.Bundle[] newBundles = PDERuntimePlugin.getDefault().getBundleContext().getBundles();
		Map tmp = new HashMap(newBundles.length);
		for (int i = 0; i < newBundles.length; i++) {
			if (newBundles[i].getHeaders().get(Constants.FRAGMENT_HOST) == null) {
				Bundle ba = createBundleAdapter(newBundles[i]);
				tmp.put(ba.getId(), ba);
			}
		}
		return tmp;
	}

	public Map initializeExtensionPoints() {
		IExtensionPoint[] extPoints = Platform.getExtensionRegistry().getExtensionPoints();
		Map tmp = new HashMap(extPoints.length);
		for (int i = 0; i < extPoints.length; i++) {
			ExtensionPoint epa = createExtensionPointAdapter(extPoints[i]);
			tmp.put(epa.getUniqueIdentifier(), epa);
		}
		return tmp;
	}

	public Map initializeServices() {
		Map result = new HashMap();

		ServiceReference[] references = null;
		try {
			references = PDERuntimePlugin.getDefault().getBundleContext().getAllServiceReferences(null, null);
		} catch (InvalidSyntaxException e) { // nothing
		}

		if (references == null) {
			return null;
		}

		for (int i = 0; i < references.length; i++) {
			ServiceRegistration service = createServiceReferenceAdapter(references[i]);
			result.put(service.getId(), service);
		}

		return result;
	}

	private Bundle createBundleAdapter(org.osgi.framework.Bundle bundle) {
		String symbolicName = bundle.getSymbolicName();
		String version = (String) bundle.getHeaders().get(org.osgi.framework.Constants.BUNDLE_VERSION);
		int state = bundle.getState();
		Long id = new Long(bundle.getBundleId());
		String location = createLocation(bundle);
		BundlePrerequisite[] imports = (BundlePrerequisite[]) getManifestHeaderArray(bundle, Constants.REQUIRE_BUNDLE);
		BundleLibrary[] libraries = (BundleLibrary[]) getManifestHeaderArray(bundle, Constants.BUNDLE_CLASSPATH);
		boolean isEnabled = getIsEnabled(bundle);

		return new Bundle(model, symbolicName, version, state, id, location, imports, libraries, isEnabled);
	}

	private Extension createExtensionAdapter(IExtension extension) {
		String namespaceIdentifier = extension.getNamespaceIdentifier();
		String label = extension.getLabel();
		String extensionPointUniqueIdentifier = extension.getExtensionPointUniqueIdentifier();
		Long contributor = getBundleId(extension.getContributor().getName());

		IConfigurationElement[] elements = extension.getConfigurationElements();
		ConfigurationElement[] configurationElements = new ConfigurationElement[elements.length];
		for (int i = 0; i < elements.length; i++) {
			configurationElements[i] = createConfigurationElement(elements[i]);
		}
		return new Extension(model, namespaceIdentifier, label, extensionPointUniqueIdentifier, configurationElements, contributor);
	}

	private ConfigurationElement createConfigurationElement(IConfigurationElement config) {
		Attribute[] attributes = createConfigurationElementAttributes(config);
		String name = createName(config);
		return new ConfigurationElement(model, name, attributes);
	}

	private static Long getBundleId(String name) {
		BundleDescription descr = PDERuntimePlugin.getDefault().getPlatformAdmin().getState().getBundle(name, null);
		return new Long(descr.getBundleId());
	}

	private ExtensionPoint createExtensionPointAdapter(IExtensionPoint extensionPoint) {
		String label = extensionPoint.getLabel();
		String uniqueIdentifier = extensionPoint.getUniqueIdentifier();
		String namespaceIdentifier = extensionPoint.getNamespaceIdentifier();
		Long contributor = getBundleId(extensionPoint.getContributor().getName());
		Extension[] extensions = createExtensionAdapters(extensionPoint.getExtensions());
		ExtensionPoint adapter = new ExtensionPoint(model, label, uniqueIdentifier, namespaceIdentifier, contributor);
		adapter.getExtensions().addAll(Arrays.asList(extensions));
		return adapter;
	}

	private ServiceRegistration createServiceReferenceAdapter(ServiceReference ref) {
		Long id = (Long) ref.getProperty(org.osgi.framework.Constants.SERVICE_ID);
		String bundle = ref.getBundle().getSymbolicName();
		org.osgi.framework.Bundle[] usingBundles = ref.getUsingBundles();
		Long[] usingBundlesIds = null;
		if (usingBundles != null) {
			usingBundlesIds = new Long[usingBundles.length];
			for (int i = 0; i < usingBundles.length; i++) {
				usingBundlesIds[i] = new Long(usingBundles[i].getBundleId());
			}
		}
		String[] classes = (String[]) ref.getProperty(org.osgi.framework.Constants.OBJECTCLASS);
		return new ServiceRegistration(model, id, bundle, usingBundlesIds, classes);
	}

	private static boolean getIsEnabled(org.osgi.framework.Bundle bundle) {
		PlatformAdmin plaformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
		State state = plaformAdmin.getState(false);

		BundleDescription description = state.getBundle(bundle.getBundleId());
		return (state.getDisabledInfos(description)).length == 0;
	}

	private static String createLocation(org.osgi.framework.Bundle bundle) {
		URL bundleEntry = bundle.getEntry("/"); //$NON-NLS-1$
		try {
			bundleEntry = FileLocator.resolve(bundleEntry);
		} catch (IOException e) { // do nothing
		}
		IPath path = new Path(bundleEntry.getFile());
		String pathString = path.removeTrailingSeparator().toOSString();
		if (pathString.startsWith("file:")) //$NON-NLS-1$
			pathString = pathString.substring(5);
		if (pathString.endsWith("!")) //$NON-NLS-1$
			pathString = pathString.substring(0, pathString.length() - 1);
		return pathString;
	}

	private Object[] getManifestHeaderArray(org.osgi.framework.Bundle bundle, String headerKey) {
		String libraries = (String) bundle.getHeaders().get(headerKey);
		try {
			ManifestElement[] elements = ManifestElement.parseHeader(headerKey, libraries);
			if (elements == null)
				return null;
			if (headerKey.equals(Constants.BUNDLE_CLASSPATH)) {
				BundleLibrary[] array = new BundleLibrary[elements.length];
				for (int i = 0; i < elements.length; i++)
					array[i] = new BundleLibrary(model, elements[i].getValue());
				return array;
			} else if (headerKey.equals(Constants.REQUIRE_BUNDLE)) {
				BundlePrerequisite[] array = new BundlePrerequisite[elements.length];
				for (int i = 0; i < elements.length; i++) {
					ManifestElement element = elements[i];
					String name = element.getValue();
					String version = element.getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE);

					String visibility = element.getDirective(Constants.VISIBILITY_DIRECTIVE);
					boolean isExported = Constants.VISIBILITY_REEXPORT.equals(visibility);
					array[i] = new BundlePrerequisite(model, name, version, isExported);
				}
				return array;
			}
		} catch (BundleException e) { // do nothing
		}
		return null;
	}

	private Attribute[] createConfigurationElementAttributes(IConfigurationElement config) {
		String[] atts = config.getAttributeNames();

		Attribute[] catts = new Attribute[atts.length];
		for (int i = 0; i < atts.length; i++)
			catts[i] = new Attribute(model, atts[i], config.getAttribute(atts[i]));

		IConfigurationElement[] children = config.getChildren();
		Attribute[] result = new Attribute[children.length + catts.length];
		for (int i = 0; i < children.length; i++) {
			IConfigurationElement child = children[i];
			result[i] = createConfigurationElement(child);
		}
		for (int i = 0; i < catts.length; i++) {
			result[children.length + i] = catts[i];
		}
		return result;
	}

	private static String createName(IConfigurationElement config) {
		String label = config.getAttribute("label"); //$NON-NLS-1$
		if (label == null)
			label = config.getName();

		if (label == null)
			label = config.getAttribute("name"); //$NON-NLS-1$

		if (label == null && config.getAttribute("id") != null) { //$NON-NLS-1$
			String[] labelSplit = config.getAttribute("id").split("\\."); //$NON-NLS-1$ //$NON-NLS-2$
			label = labelSplit.length == 0 ? null : labelSplit[labelSplit.length - 1];
		}

		return label;
	}

	private Extension[] createExtensionAdapters(IExtension[] extensions) {
		Extension[] extensionAdapters = new Extension[extensions.length];
		for (int i = 0; i < extensions.length; i++) {
			extensionAdapters[i] = createExtensionAdapter(extensions[i]);
		}
		return extensionAdapters;
	}

	public void bundleChanged(BundleEvent event) {
		org.osgi.framework.Bundle bundle = event.getBundle();
		Bundle adapter = createBundleAdapter(bundle);

		switch (event.getType()) {
			case BundleEvent.INSTALLED :
				listener.addBundle(adapter);
				break;
			case BundleEvent.UNINSTALLED :
				listener.removeBundle(adapter);
				break;
			case BundleEvent.UPDATED :
				listener.updateBundle(adapter, ModelChangeDelta.UPDATED);
				break;
			case BundleEvent.RESOLVED :
				listener.updateBundle(adapter, ModelChangeDelta.RESOLVED);
				break;
			case BundleEvent.UNRESOLVED :
				listener.updateBundle(adapter, ModelChangeDelta.UNRESOLVED);
				break;
			case BundleEvent.STARTING :
				listener.updateBundle(adapter, ModelChangeDelta.STARTING);
				break;
			case BundleEvent.STARTED :
				listener.updateBundle(adapter, ModelChangeDelta.STARTED);
				break;
			case BundleEvent.STOPPING :
				listener.updateBundle(adapter, ModelChangeDelta.STOPPING);
				break;
			case BundleEvent.STOPPED :
				listener.updateBundle(adapter, ModelChangeDelta.STOPPED);
				break;
			default :
				listener.updateBundle(adapter, ModelChangeDelta.UPDATED);
		}
	}

	public void serviceChanged(ServiceEvent event) {
		ServiceReference ref = event.getServiceReference();
		ServiceRegistration adapter = createServiceReferenceAdapter(ref);

		switch (event.getType()) {
			case ServiceEvent.REGISTERED :
				listener.addService(adapter);
				break;
			case ServiceEvent.UNREGISTERING :
				listener.removeService(adapter);
				break;
			case ServiceEvent.MODIFIED :
			default :
				listener.updateService(adapter);
				break;
		}
	}

	private ExtensionPoint[] createExtensionPointAdapters(IExtensionPoint[] extensionPoints) {
		ExtensionPoint[] result = new ExtensionPoint[extensionPoints.length];
		for (int i = 0; i < extensionPoints.length; i++) {
			result[i] = createExtensionPointAdapter(extensionPoints[i]);
		}
		return result;
	}

	public void added(IExtension[] extensions) {
		listener.addExtensions(createExtensionAdapters(extensions));
	}

	public void removed(IExtension[] extensions) {
		listener.removeExtensions(createExtensionAdapters(extensions));
	}

	public void added(IExtensionPoint[] extensionPoints) {
		listener.addExtensionPoints(createExtensionPointAdapters(extensionPoints));
	}

	public void removed(IExtensionPoint[] extensionPoints) {
		listener.removeExtensionPoints(createExtensionPointAdapters(extensionPoints));
	}

	public void setEnabled(Bundle bundle, boolean enabled) {
		State state = PDERuntimePlugin.getDefault().getState();
		long bundleId = bundle.getId().longValue();
		BundleDescription desc = state.getBundle(bundleId);

		if (enabled) {
			DisabledInfo[] infos = state.getDisabledInfos(desc);
			for (int i = 0; i < infos.length; i++) {
				PlatformAdmin platformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
				platformAdmin.removeDisabledInfo(infos[i]);
			}
		} else {
			DisabledInfo info = new DisabledInfo("org.eclipse.pde.ui", "Disabled via PDE", desc); //$NON-NLS-1$ //$NON-NLS-2$
			PlatformAdmin platformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
			platformAdmin.addDisabledInfo(info);
		}

		org.osgi.framework.Bundle b = PDERuntimePlugin.getDefault().getBundleContext().getBundle(bundleId);
		PackageAdmin packageAdmin = PDERuntimePlugin.getDefault().getPackageAdmin();
		packageAdmin.refreshPackages(new org.osgi.framework.Bundle[] {b});
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.runtime.registry.model.local.RegistryBackend#setEnabled(org.osgi.framework.Bundle, boolean)
	 */
	public void setEnabled(org.osgi.framework.Bundle bundle, boolean enabled) {
		PlatformAdmin plaformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
		State state = plaformAdmin.getState(false);

		BundleDescription desc = state.getBundle(bundle.getBundleId());

		if (enabled) {
			DisabledInfo[] infos = state.getDisabledInfos(desc);
			for (int i = 0; i < infos.length; i++) {
				PlatformAdmin platformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
				platformAdmin.removeDisabledInfo(infos[i]);
			}
		} else {
			DisabledInfo info = new DisabledInfo("org.eclipse.pde.ui", "Disabled via PDE", desc); //$NON-NLS-1$ //$NON-NLS-2$
			PlatformAdmin platformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
			platformAdmin.addDisabledInfo(info);
		}

		PackageAdmin packageAdmin = PDERuntimePlugin.getDefault().getPackageAdmin();
		packageAdmin.refreshPackages(new org.osgi.framework.Bundle[] {bundle});
	}
}




package org.eclipse.pde.internal.runtime.registry.model;

public class Extension extends ModelObject {

	private String namespaceIdentifier;
	private String label;
	private String extensionPointUniqueIdentifier;
	private ConfigurationElement[] configurationElements;
	private Long contributor;

	public Extension(RegistryModel model, String namespaceIdentifier, String label, String extensionPointUniqueIdentifier, ConfigurationElement[] cfg, Long contributor) {
		super(model);
		this.namespaceIdentifier = namespaceIdentifier;
		this.label = label;
		this.extensionPointUniqueIdentifier = extensionPointUniqueIdentifier;
		this.configurationElements = cfg;
		this.contributor = contributor;
	}

	public ConfigurationElement[] getConfigurationElements() {
		return configurationElements;
	}

	public String getExtensionPointUniqueIdentifier() {
		return extensionPointUniqueIdentifier;
	}

	public String getLabel() {
		return label;
	}

	public String getNamespaceIdentifier() {
		return namespaceIdentifier;
	}

	public Long getContributorId() {
		return contributor;
	}

	public boolean equals(Object obj) {
		if (obj instanceof Extension) {
			Extension ext = (Extension) obj;
			return namespaceIdentifier.endsWith(ext.namespaceIdentifier) && label.equals(ext.label) && extensionPointUniqueIdentifier.equals(ext.extensionPointUniqueIdentifier) && contributor.equals(ext.contributor);
		}

		return false;
	}

	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((contributor == null) ? 0 : contributor.hashCode());
		result = prime * result + ((extensionPointUniqueIdentifier == null) ? 0 : extensionPointUniqueIdentifier.hashCode());
		result = prime * result + ((label == null) ? 0 : label.hashCode());
		result = prime * result + ((namespaceIdentifier == null) ? 0 : namespaceIdentifier.hashCode());
		return result;
	}

	public ExtensionPoint getExtensionPoint() {
		return getModel().getExtensionPoint(extensionPointUniqueIdentifier);
	}

	public Bundle getContributor() {
		return getModel().getBundle(contributor);
	}
}




package org.eclipse.pde.internal.runtime.registry.model;

import java.util.ArrayList;
import java.util.List;

public class ExtensionPoint extends ModelObject {

	private String label;
	private String uniqueIdentifier;
	private String namespaceIdentifier;
	private Long contributor;
	private List extensions = new ArrayList();

	public ExtensionPoint(RegistryModel model, String label, String uniqueIdentifier, String namespaceIdentifier, Long contributor) {
		super(model);
		this.label = label;
		this.uniqueIdentifier = uniqueIdentifier;
		this.namespaceIdentifier = namespaceIdentifier;
		this.contributor = contributor;
	}

	public List getExtensions() {
		return extensions;
	}

	public String getLabel() {
		return label;
	}

	public String getUniqueIdentifier() {
		return uniqueIdentifier;
	}

	public String getNamespaceIdentifier() {
		return namespaceIdentifier;
	}

	public Long getContributorId() {
		return contributor;
	}

	public Bundle getContributor() {
		return getModel().getBundle(contributor);
	}

	public boolean equals(Object obj) {
		return (obj instanceof ExtensionPoint) && (uniqueIdentifier.equals(((ExtensionPoint) obj).uniqueIdentifier));
	}

	public int hashCode() {
		return uniqueIdentifier.hashCode();
	}
}




package org.eclipse.pde.internal.runtime.registry;

import org.eclipse.pde.internal.runtime.registry.model.*;

public class RegistryBrowserModelChangeListener implements ModelChangeListener {

	private RegistryBrowser fRegistryBrowser;

	public RegistryBrowserModelChangeListener(RegistryBrowser registryBrowser) {
		fRegistryBrowser = registryBrowser;
	}

	public void modelChanged(final ModelChangeDelta[] delta) {
		fRegistryBrowser.getSite().getWorkbenchWindow().getWorkbench().getDisplay().asyncExec(new Runnable() {
			public void run() {
				update(delta);
			}
		});
	}

	private boolean topLevelElement(Object object) {
		return fRegistryBrowser.showExtensionsOnly() ? object instanceof ExtensionPoint : object instanceof Bundle;
	}

	private Object getTopLevelElement(Object object) {
		if (!fRegistryBrowser.showExtensionsOnly()) { // show bundles
			if (object instanceof Bundle) {
				return object;
			} else if (object instanceof ExtensionPoint) {
				ExtensionPoint ext = (ExtensionPoint) object;
				return ext.getContributor();
			} else if (object instanceof Extension) {
				Extension ext = (Extension) object;
				return ext.getContributor();
			} else if (object instanceof ServiceRegistration) {
				ServiceRegistration reg = (ServiceRegistration) object;
				//return reg.getBundle(); // TODO FIXME
			}
		} else { // show only extensions
			if (object instanceof ExtensionPoint) {
				return object;
			} else if (object instanceof Extension) {
				Extension ext = (Extension) object;
				return ext.getExtensionPoint();
			}
		}

		return null;
	}

	protected void update(ModelChangeDelta[] deltas) {
		for (int i = 0; i < deltas.length; i++) {
			ModelObject object = deltas[i].getModelObject();

			switch (deltas[i].getFlag()) {
				case ModelChangeDelta.ADDED :
					if (topLevelElement(object)) {
						fRegistryBrowser.add(object);
					} else {
						Object topLevelElement = getTopLevelElement(object);
						fRegistryBrowser.refresh(topLevelElement);
					}
					break;
				case ModelChangeDelta.REMOVED :
					if (topLevelElement(object)) {
						fRegistryBrowser.remove(object);
					} else {
						Object topLevelElement = getTopLevelElement(object);
						fRegistryBrowser.refresh(topLevelElement);
					}
					break;
				case ModelChangeDelta.STARTED :
				case ModelChangeDelta.STOPPED :
				case ModelChangeDelta.RESOLVED :
				case ModelChangeDelta.UNRESOLVED :
				case ModelChangeDelta.UPDATED :
					if (topLevelElement(object)) {
						fRegistryBrowser.refresh(object);
					} else {
						Object topLevelElement = getTopLevelElement(object);
						fRegistryBrowser.refresh(topLevelElement);
					}
					break;
			}
		}
	}

}




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry.model;

public class Folder {

	public static final int F_EXTENSIONS = 1;
	public static final int F_EXTENSION_POINTS = 2;
	public static final int F_IMPORTS = 3;
	public static final int F_LIBRARIES = 4;
	public static final int F_REGISTERED_SERVICES = 5;
	public static final int F_SERVICES_IN_USE = 6;

	private int id;
	private Bundle parent;

	public Folder(int id, Bundle parent) {
		this.id = id;
		this.parent = parent;
	}

	public int getId() {
		return id;
	}

	public ModelObject getParent() {
		return parent;
	}

	public ModelObject[] getChildren() {
		switch (id) {
			case F_EXTENSION_POINTS :
				return parent.getExtensionPoints();
			case F_EXTENSIONS :
				return parent.getExtensions();
			case F_IMPORTS :
				return parent.getImports();
			case F_LIBRARIES :
				return parent.getLibraries();
			case F_REGISTERED_SERVICES :
				return parent.getRegisteredServices();
			case F_SERVICES_IN_USE :
				return parent.getServicesInUse();
		}

		return null;
	}

	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + id;
		result = prime * result + ((parent == null) ? 0 : parent.hashCode());
		return result;
	}

	public boolean equals(Object obj) {
		return ((obj instanceof Folder) && (((Folder) obj).id == id) && (((Folder) obj).parent.equals(parent)));
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry.model;

public class BundlePrerequisite extends ModelObject {

	private boolean isExported;
	private String name;
	private String version;

	public BundlePrerequisite(RegistryModel model, String name, String version, boolean isExported) {
		super(model);
		this.name = name;
		this.version = version;
		this.isExported = isExported;
	}

	public boolean isExported() {
		return isExported;
	}

	public String getName() {
		if (version != null) {
			if (Character.isDigit(version.charAt(0)))
				version = '(' + version + ')';
			return name + ' ' + version;
		}

		return name;
	}
}




package org.eclipse.pde.internal.runtime.registry.model;

/**
 * 
 * Delta model objects are of type IBundle, IService, IExtension, IExtensionPoint
 */
public class ModelChangeDelta {

	public static final int ADDED = 0;
	public static final int UPDATED = 1;
	public static final int REMOVED = 2;
	public static final int STARTING = 3;
	public static final int STARTED = 4;
	public static final int STOPPING = 5;
	public static final int STOPPED = 6;
	public static final int RESOLVED = 7;
	public static final int UNRESOLVED = 8;

	private ModelObject fObject;
	private int fFlag;

	public ModelChangeDelta(ModelObject object, int flag) {
		fObject = object;
		fFlag = flag;
	}

	public ModelObject getModelObject() {
		return fObject;
	}

	public int getFlag() {
		return fFlag;
	}
}




package org.eclipse.pde.internal.runtime.registry.model;

public abstract class ModelObject {

	private RegistryModel model;

	public ModelObject(RegistryModel model) {
		this.model = model;
	}

	public RegistryModel getModel() {
		return model;
	}
}




package org.eclipse.pde.internal.runtime.registry.model;

/**
 * Notifies on any changes coming from backend. Usually RegistryModel is only interested in receiving
 * news about that.
 *
 */
public interface BackendChangeListener {

	void addBundle(Bundle adapter);

	void removeBundle(Bundle adapter);

	void updateBundle(Bundle adapter, int updated);

	void addService(ServiceRegistration adapter);

	void removeService(ServiceRegistration adapter);

	void updateService(ServiceRegistration adapter);

	void addExtensions(Extension[] createExtensionAdapters);

	void removeExtensions(Extension[] createExtensionAdapters);

	void addExtensionPoints(ExtensionPoint[] createExtensionPointAdapters);

	void removeExtensionPoints(ExtensionPoint[] createExtensionPointAdapters);
}




package org.eclipse.pde.internal.runtime.registry.model;

import java.util.Map;
import org.eclipse.core.runtime.MultiStatus;
import org.osgi.framework.BundleException;

public interface RegistryBackend {

	public void connect();

	public void disconnect();

	public void setEnabled(Bundle bundle, boolean enabled);

	public void start(Bundle bundle) throws BundleException;

	public void stop(Bundle bundle) throws BundleException;

	public MultiStatus diagnose(Bundle bundle);

	public Map initializeBundles();

	public Map initializeExtensionPoints();

	public void setRegistryListener(BackendChangeListener listener);

	public void setRegistryModel(RegistryModel listener);

	public Map initializeServices();

}

package org.eclipse.pde.internal.runtime.registry.model;

/**
 * Event provides a list of objects that have changed.
 * Possible objects on the list are IBundle, IService, IExtension, IExtensionPoint.
 * This is temporary solution and is subject to future changes.
 * 
 */
public interface ModelChangeListener {

	void modelChanged(ModelChangeDelta[] deltas);
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry.model;

public class Attribute extends ModelObject {
	public static final String F_LOCATION = "Location";

	private String name;
	private String value;

	public Attribute(RegistryModel model, String name, String value) {
		super(model);
		this.name = name;
		this.value = value;
	}

	public String getValue() {
		return value;
	}

	public String getName() {
		return name;
	}
}




package org.eclipse.pde.internal.runtime.registry.model;

public class ConfigurationElement extends Attribute {

	private Attribute[] elements;

	public ConfigurationElement(RegistryModel model, String name, Attribute[] attributes) {
		super(model, name, null);
		elements = attributes;
	}

	public Attribute[] getElements() {
		return elements;
	}
}




package org.eclipse.pde.internal.runtime.registry.model;

public class ServiceRegistration extends ModelObject {

	private Long id;
	private String bundle;
	private Long[] usingBundles;
	private String[] classes;

	public ServiceRegistration(RegistryModel model, Long id, String bundle, Long[] usingBundles, String[] classes) {
		super(model);
		this.id = id;
		this.bundle = bundle;
		this.usingBundles = usingBundles;
		this.classes = classes;
	}

	public Long getId() {
		return id;
	}

	public String[] getClasses() {
		return classes;
	}

	public String getBundle() {
		return bundle;
	}

	public Long[] getUsingBundles() {
		return usingBundles;
	}

	public boolean equals(Object obj) {
		return (obj instanceof ServiceRegistration) && (id.equals(((ServiceRegistration) obj).id));
	}

	public int hashCode() {
		return id.intValue();
	}
}




package org.eclipse.pde.internal.runtime.registry.model;

import java.net.URI;

/**
 * Produces RegistryModels for URLs. Valid URLs:
 * local
 * target
 * remote://host:port
 *
 */
public class RegistryModelFactory {

	/**
	 * 
	 * @param codename
	 * @return never returns null
	 */
	public static RegistryModel getRegistryModel(URI codename) {
		return new RegistryModel(new LocalRegistryBackend());
	}
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.runtime.registry.model;

public class BundleLibrary extends ModelObject {

	private String library;

	public BundleLibrary(RegistryModel model, String library) {
		super(model);
		this.library = library;
	}

	public String getLibrary() {
		return library;
	}
}




package org.eclipse.pde.internal.runtime.registry.model;

import java.util.*;

/**
 * Model entry point for Eclipse runtime. Provides information about runtime bundles, services and extension points.
 *
 */
public class RegistryModel {

	private BackendChangeListener backendListener = new BackendChangeListener() {
		public void addBundle(Bundle adapter) {
			ModelChangeDelta delta = new ModelChangeDelta(adapter, ModelChangeDelta.ADDED);

			bundles.put(adapter.getId(), adapter);

			fireModelChangeEvent(new ModelChangeDelta[] {delta});
		}

		public void removeBundle(Bundle adapter) {
			ModelChangeDelta delta = new ModelChangeDelta(adapter, ModelChangeDelta.REMOVED);

			bundles.remove(adapter.getId());

			fireModelChangeEvent(new ModelChangeDelta[] {delta});
		}

		public void updateBundle(Bundle adapter, int updated) {
			ModelChangeDelta delta = new ModelChangeDelta(adapter, updated);

			bundles.put(adapter.getId(), adapter); // replace old with new one

			fireModelChangeEvent(new ModelChangeDelta[] {delta});
		}

		public void addService(ServiceRegistration adapter) {
			services.put(adapter.getId(), adapter);

			ModelChangeDelta delta = new ModelChangeDelta(adapter, ModelChangeDelta.ADDED);

			fireModelChangeEvent(new ModelChangeDelta[] {delta});
		}

		public void removeService(ServiceRegistration adapter) {
			services.remove(adapter.getId());

			ModelChangeDelta delta = new ModelChangeDelta(adapter, ModelChangeDelta.REMOVED);

			fireModelChangeEvent(new ModelChangeDelta[] {delta});
		}

		public void updateService(ServiceRegistration adapter) {
			services.put(adapter.getId(), adapter);

			ModelChangeDelta delta = new ModelChangeDelta(adapter, ModelChangeDelta.UPDATED);

			fireModelChangeEvent(new ModelChangeDelta[] {delta});
		}

		public void addExtensions(Extension[] extensionAdapters) {
			for (int i = 0; i < extensionAdapters.length; i++) {
				String id = extensionAdapters[i].getExtensionPointUniqueIdentifier();
				ExtensionPoint extPoint = (ExtensionPoint) extensionPoints.get(id);
				extPoint.getExtensions().add(extensionAdapters[i]);
			}

			ModelChangeDelta[] delta = new ModelChangeDelta[extensionAdapters.length];
			for (int i = 0; i < delta.length; i++) {
				delta[i] = new ModelChangeDelta(extensionAdapters[i], ModelChangeDelta.ADDED);
			}
			fireModelChangeEvent(delta);
		}

		public void removeExtensions(Extension[] extensionAdapters) {
			for (int i = 0; i < extensionAdapters.length; i++) {
				String id = extensionAdapters[i].getExtensionPointUniqueIdentifier();
				ExtensionPoint extPoint = (ExtensionPoint) extensionPoints.get(id);
				extPoint.getExtensions().remove(extensionAdapters[i]);
			}

			ModelChangeDelta[] delta = new ModelChangeDelta[extensionAdapters.length];
			for (int i = 0; i < delta.length; i++) {
				delta[i] = new ModelChangeDelta(extensionAdapters[i], ModelChangeDelta.REMOVED);
			}
			fireModelChangeEvent(delta);
		}

		public void addExtensionPoints(ExtensionPoint[] extensionPointAdapters) {
			for (int i = 0; i < extensionPointAdapters.length; i++) {
				extensionPoints.put(extensionPointAdapters[i].getUniqueIdentifier(), extensionPointAdapters[i]);
			}

			ModelChangeDelta[] delta = new ModelChangeDelta[extensionPointAdapters.length];
			for (int i = 0; i < delta.length; i++) {
				delta[i] = new ModelChangeDelta(extensionPointAdapters[i], ModelChangeDelta.ADDED);
			}
			fireModelChangeEvent(delta);
		}

		public void removeExtensionPoints(ExtensionPoint[] extensionPointAdapters) {
			for (int i = 0; i < extensionPointAdapters.length; i++) {
				extensionPoints.remove(extensionPointAdapters[i].getUniqueIdentifier());
			}

			ModelChangeDelta[] delta = new ModelChangeDelta[extensionPointAdapters.length];
			for (int i = 0; i < delta.length; i++) {
				delta[i] = new ModelChangeDelta(extensionPointAdapters[i], ModelChangeDelta.REMOVED);
			}
			fireModelChangeEvent(delta);
		}
	};

	private List listeners = new ArrayList();
	private Map bundles;
	private Map services;
	private Map extensionPoints;
	protected RegistryBackend backend;

	public RegistryModel(RegistryBackend backend) {
		this.backend = backend;
		backend.setRegistryListener(backendListener);
		backend.setRegistryModel(this);
	}

	public void connect() {
		backend.connect();
	}

	public void disconnect() {
		backend.disconnect();
	}

	public Bundle[] getBundles() {
		if (bundles == null) {
			bundles = backend.initializeBundles();
		}

		return (Bundle[]) bundles.values().toArray(new Bundle[bundles.values().size()]);
	}

	public ExtensionPoint[] getExtensionPoints() {
		if (extensionPoints == null) {
			extensionPoints = backend.initializeExtensionPoints();
		}

		return (ExtensionPoint[]) extensionPoints.values().toArray(new ExtensionPoint[extensionPoints.values().size()]);
	}

	public ServiceRegistration[] getServices() {
		if (services == null) {
			services = backend.initializeServices();
		}

		return (ServiceRegistration[]) services.values().toArray(new ServiceRegistration[services.values().size()]);
	}

	public void addModelChangeListener(ModelChangeListener listener) {
		listeners.add(listener);
	}

	public void removeModelChangeListener(ModelChangeListener listener) {
		listeners.remove(listener);
	}

	/**
	 * For received domain types: Bundle, IExtension, IExtensionPoint, ServiceReference,
	 * generates delta with model types: IBundle, IExtensionAdapter, IExtensionPointAdapter, IService
	 *  
	 * @param objects
	 */
	protected void fireModelChangeEvent(ModelChangeDelta[] delta) {
		for (Iterator i = listeners.iterator(); i.hasNext();) {
			ModelChangeListener listener = (ModelChangeListener) i.next();
			listener.modelChanged(delta);
		}
	}

	public Bundle getBundle(Long id) {
		return (Bundle) bundles.get(id);
	}

	public ExtensionPoint getExtensionPoint(String extensionPointUniqueIdentifier) {
		return (ExtensionPoint) extensionPoints.get(extensionPointUniqueIdentifier);
	}

	/*	void setEnabled(Bundle bundle, boolean enabled);

		void start(Bundle bundle) throws BundleException; // XXX Create custom Exception

		void stop(Bundle bundle) throws BundleException;

		MultiStatus diagnose(Bundle bundle);*/

}




package org.eclipse.pde.internal.runtime.registry.model;

import java.util.*;
import org.eclipse.core.runtime.MultiStatus;
import org.osgi.framework.BundleException;

public class Bundle extends ModelObject {

	public static final int ACTIVE = org.osgi.framework.Bundle.ACTIVE;
	public static final int UNINSTALLED = org.osgi.framework.Bundle.UNINSTALLED;
	public static final int INSTALLED = org.osgi.framework.Bundle.INSTALLED;

	private String symbolicName;
	private String location;
	private boolean isEnabled;
	private BundlePrerequisite[] imports;
	private String version;
	private int state;
	private Long id;
	private BundleLibrary[] libraries;

	public Bundle(RegistryModel model, String symbolicName, String version, int state, Long id, String location, BundlePrerequisite[] prereq, BundleLibrary[] libs, boolean isEnabled) {
		super(model);
		this.symbolicName = symbolicName;
		this.version = version;
		this.state = state;
		this.id = id;
		this.location = location;
		this.imports = prereq;
		this.libraries = libs;
		this.isEnabled = isEnabled;
	}

	public String getSymbolicName() {
		return symbolicName;
	}

	public boolean isEnabled() {
		return isEnabled;
	}

	public BundlePrerequisite[] getImports() {
		return imports;
	}

	public BundleLibrary[] getLibraries() {
		return libraries;
	}

	public String getLocation() {
		return location;
	}

	public String getVersion() {
		return version;
	}

	public int getState() {
		return state;
	}

	public Long getId() {
		return id;
	}

	public void start() throws BundleException {
		getModel().backend.start(this);
	}

	public void stop() throws BundleException {
		getModel().backend.stop(this);
	}

	public void setEnabled(boolean enabled) {
		getModel().backend.setEnabled(this, enabled);
	}

	public MultiStatus diagnose() {
		return getModel().backend.diagnose(this);
	}

	public ExtensionPoint[] getExtensionPoints() {
		ExtensionPoint[] extPoints = getModel().getExtensionPoints();
		List result = new ArrayList();

		for (int i = 0; i < extPoints.length; i++) {
			if (id.equals(extPoints[i].getContributorId()))
				result.add(extPoints[i]);
		}
		return (ExtensionPoint[]) result.toArray(new ExtensionPoint[result.size()]);
	}

	public Extension[] getExtensions() {
		ExtensionPoint[] extPoints = getModel().getExtensionPoints();
		List result = new ArrayList();

		for (int i = 0; i < extPoints.length; i++) {
			for (Iterator it = extPoints[i].getExtensions().iterator(); it.hasNext();) {
				Extension a = (Extension) it.next();
				if (id.equals(a.getContributorId()))
					result.add(a);
			}

		}
		return (Extension[]) result.toArray(new Extension[result.size()]);
	}

	public ServiceRegistration[] getRegisteredServices() {
		ServiceRegistration[] services = getModel().getServices();
		List result = new ArrayList();

		for (int i = 0; i < services.length; i++) {
			if (symbolicName.equals(services[i].getBundle()))
				result.add(services[i]);
		}
		return (ServiceRegistration[]) result.toArray(new ServiceRegistration[result.size()]);
	}

	public ServiceRegistration[] getServicesInUse() {
		ServiceRegistration[] services = getModel().getServices();
		List result = new ArrayList();

		for (int i = 0; i < services.length; i++) {
			Long[] usingBundles = services[i].getUsingBundles();
			if (usingBundles != null) {
				for (int j = usingBundles.length; j < usingBundles.length; j++)
					if (id.equals(usingBundles[j]))
						result.add(services[i]);
			}
		}
		return (ServiceRegistration[]) result.toArray(new ServiceRegistration[result.size()]);
	}

	public boolean equals(Object obj) {
		return (obj instanceof Bundle) && (id.equals(((Bundle) obj).id));
	}

	public int hashCode() {
		return id.intValue();
	}

}

Return to bug 243441

Removed Link Here

(-)src/org/eclipse/pde/internal/runtime/registry/ConfigurationAttributeAdapter.java (-23 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.pde.internal.runtime.registry;
12
13	public class ConfigurationAttributeAdapter extends ParentAdapter {
14
15	public ConfigurationAttributeAdapter(Object object) {
16	super(object);
17	}
18
19	protected Object[] createChildren() {
20	return null;
21	}
22
23	}

Removed Link Here

(-)src/org/eclipse/pde/internal/runtime/registry/PluginAdapter.java (-39 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.pde.internal.runtime.registry;
12
13	import org.eclipse.pde.internal.runtime.registry.RegistryBrowserContentProvider.BundleFolder;
14	import org.osgi.framework.Bundle;
15
16	/**
17	* Adapter for bundle objects.
18	*
19	*/
20	public class PluginAdapter extends ParentAdapter {
21
22	public PluginAdapter(Bundle object) {
23	super(object);
24	}
25
26	protected Object[] createChildren() {
27	Bundle bundle = (Bundle) getObject();
28
29	Object[] array = new Object[7];
30	array[0] = new BundleFolder(bundle, IBundleFolder.F_LOCATION);
31	array[1] = new BundleFolder(bundle, IBundleFolder.F_IMPORTS);
32	array[2] = new BundleFolder(bundle, IBundleFolder.F_LIBRARIES);
33	array[3] = new BundleFolder(bundle, IBundleFolder.F_EXTENSION_POINTS);
34	array[4] = new BundleFolder(bundle, IBundleFolder.F_EXTENSIONS);
35	array[5] = new BundleFolder(bundle, IBundleFolder.F_REGISTERED_SERVICES);
36	array[6] = new BundleFolder(bundle, IBundleFolder.F_SERVICES_IN_USE);
37	return array;
38	}
39	}

Removed Link Here

(-)src/org/eclipse/pde/internal/runtime/registry/ParentAdapter.java (-27 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.pde.internal.runtime.registry;
12
13	public abstract class ParentAdapter extends PluginObjectAdapter {
14	Object[] fChildren;
15
16	public ParentAdapter(Object object) {
17	super(object);
18	}
19
20	protected abstract Object[] createChildren();
21
22	public Object[] getChildren() {
23	if (fChildren == null)
24	fChildren = createChildren();
25	return fChildren;
26	}
27	}

Added Link Here

(-)src/org/eclipse/pde/internal/runtime/registry/model/LocalRegistryBackend.java (+423 lines)
1	package org.eclipse.pde.internal.runtime.registry.model;
2
3	import java.io.IOException;
4	import java.net.URL;
5	import java.util.*;
6	import org.eclipse.core.runtime.*;
7	import org.eclipse.osgi.service.resolver.*;
8	import org.eclipse.osgi.util.ManifestElement;
9	import org.eclipse.pde.internal.runtime.*;
10	import org.osgi.framework.*;
11	import org.osgi.service.packageadmin.PackageAdmin;
12
13	public class LocalRegistryBackend implements IRegistryEventListener, BundleListener, ServiceListener, RegistryBackend {
14
15	private BackendChangeListener listener;
16	private RegistryModel model;
17
18	public void setRegistryModel(RegistryModel model) {
19	this.model = model;
20	}
21
22	public void setRegistryListener(BackendChangeListener listener) {
23	this.listener = listener;
24	}
25
26	/* (non-Javadoc)
27	* @see org.eclipse.pde.internal.runtime.registry.model.local.RegistryBackend#connect()
28	*/
29	public void connect() {
30	PDERuntimePlugin.getDefault().getBundleContext().addBundleListener(this);
31	Platform.getExtensionRegistry().addListener(this);
32	PDERuntimePlugin.getDefault().getBundleContext().addServiceListener(this);
33	}
34
35	/* (non-Javadoc)
36	* @see org.eclipse.pde.internal.runtime.registry.model.local.RegistryBackend#disconnect()
37	*/
38	public void disconnect() {
39	Platform.getExtensionRegistry().removeListener(this);
40	PDERuntimePlugin.getDefault().getBundleContext().removeBundleListener(this);
41	PDERuntimePlugin.getDefault().getBundleContext().removeServiceListener(this);
42	}
43
44	protected static boolean isRegisteredService(org.osgi.framework.Bundle bundle, ServiceReference ref) {
45	return bundle.equals(ref.getBundle());
46	}
47
48	protected static boolean isServiceInUse(org.osgi.framework.Bundle bundle, ServiceReference ref) {
49	org.osgi.framework.Bundle[] usingBundles = ref.getUsingBundles();
50	return (usingBundles != null && Arrays.asList(usingBundles).contains(bundle));
51	}
52
53	/* (non-Javadoc)
54	* @see org.eclipse.pde.internal.runtime.registry.model.local.RegistryBackend#start(org.osgi.framework.Bundle)
55	*/
56	public void start(Bundle bundle) throws BundleException {
57	PDERuntimePlugin.getDefault().getBundleContext().getBundle(bundle.getId().longValue()).start();
58	}
59
60	/* (non-Javadoc)
61	* @see org.eclipse.pde.internal.runtime.registry.model.local.RegistryBackend#stop(org.osgi.framework.Bundle)
62	*/
63	public void stop(Bundle bundle) throws BundleException {
64	PDERuntimePlugin.getDefault().getBundleContext().getBundle(bundle.getId().longValue()).stop();
65	}
66
67	/* (non-Javadoc)
68	* @see org.eclipse.pde.internal.runtime.registry.model.local.RegistryBackend#diagnose(org.osgi.framework.Bundle)
69	*/
70	public MultiStatus diagnose(Bundle bundle) {
71	PlatformAdmin plaformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
72	State state = plaformAdmin.getState(false);
73
74	BundleDescription desc = state.getBundle(bundle.getId().longValue());
75
76	PlatformAdmin platformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
77	VersionConstraint[] unsatisfied = platformAdmin.getStateHelper().getUnsatisfiedConstraints(desc);
78	ResolverError[] resolverErrors = platformAdmin.getState(false).getResolverErrors(desc);
79
80	MultiStatus problems = new MultiStatus(PDERuntimePlugin.ID, IStatus.INFO, PDERuntimeMessages.RegistryView_found_problems, null);
81	for (int i = 0; i < resolverErrors.length; i++) {
82	if ((resolverErrors[i].getType() & (ResolverError.MISSING_FRAGMENT_HOST \| ResolverError.MISSING_GENERIC_CAPABILITY \| ResolverError.MISSING_IMPORT_PACKAGE \| ResolverError.MISSING_REQUIRE_BUNDLE)) != 0)
83	continue;
84	IStatus status = new Status(IStatus.WARNING, PDERuntimePlugin.ID, resolverErrors[i].toString());
85	problems.add(status);
86	}
87
88	for (int i = 0; i < unsatisfied.length; i++) {
89	IStatus status = new Status(IStatus.WARNING, PDERuntimePlugin.ID, MessageHelper.getResolutionFailureMessage(unsatisfied[i]));
90	problems.add(status);
91	}
92
93	return problems;
94	}
95
96	public Map initializeBundles() {
97	org.osgi.framework.Bundle[] newBundles = PDERuntimePlugin.getDefault().getBundleContext().getBundles();
98	Map tmp = new HashMap(newBundles.length);
99	for (int i = 0; i < newBundles.length; i++) {
100	if (newBundles[i].getHeaders().get(Constants.FRAGMENT_HOST) == null) {
101	Bundle ba = createBundleAdapter(newBundles[i]);
102	tmp.put(ba.getId(), ba);
103	}
104	}
105	return tmp;
106	}
107
108	public Map initializeExtensionPoints() {
109	IExtensionPoint[] extPoints = Platform.getExtensionRegistry().getExtensionPoints();
110	Map tmp = new HashMap(extPoints.length);
111	for (int i = 0; i < extPoints.length; i++) {
112	ExtensionPoint epa = createExtensionPointAdapter(extPoints[i]);
113	tmp.put(epa.getUniqueIdentifier(), epa);
114	}
115	return tmp;
116	}
117
118	public Map initializeServices() {
119	Map result = new HashMap();
120
121	ServiceReference[] references = null;
122	try {
123	references = PDERuntimePlugin.getDefault().getBundleContext().getAllServiceReferences(null, null);
124	} catch (InvalidSyntaxException e) { // nothing
125	}
126
127	if (references == null) {
128	return null;
129	}
130
131	for (int i = 0; i < references.length; i++) {
132	ServiceRegistration service = createServiceReferenceAdapter(references[i]);
133	result.put(service.getId(), service);
134	}
135
136	return result;
137	}
138
139	private Bundle createBundleAdapter(org.osgi.framework.Bundle bundle) {
140	String symbolicName = bundle.getSymbolicName();
141	String version = (String) bundle.getHeaders().get(org.osgi.framework.Constants.BUNDLE_VERSION);
142	int state = bundle.getState();
143	Long id = new Long(bundle.getBundleId());
144	String location = createLocation(bundle);
145	BundlePrerequisite[] imports = (BundlePrerequisite[]) getManifestHeaderArray(bundle, Constants.REQUIRE_BUNDLE);
146	BundleLibrary[] libraries = (BundleLibrary[]) getManifestHeaderArray(bundle, Constants.BUNDLE_CLASSPATH);
147	boolean isEnabled = getIsEnabled(bundle);
148
149	return new Bundle(model, symbolicName, version, state, id, location, imports, libraries, isEnabled);
150	}
151
152	private Extension createExtensionAdapter(IExtension extension) {
153	String namespaceIdentifier = extension.getNamespaceIdentifier();
154	String label = extension.getLabel();
155	String extensionPointUniqueIdentifier = extension.getExtensionPointUniqueIdentifier();
156	Long contributor = getBundleId(extension.getContributor().getName());
157
158	IConfigurationElement[] elements = extension.getConfigurationElements();
159	ConfigurationElement[] configurationElements = new ConfigurationElement[elements.length];
160	for (int i = 0; i < elements.length; i++) {
161	configurationElements[i] = createConfigurationElement(elements[i]);
162	}
163	return new Extension(model, namespaceIdentifier, label, extensionPointUniqueIdentifier, configurationElements, contributor);
164	}
165
166	private ConfigurationElement createConfigurationElement(IConfigurationElement config) {
167	Attribute[] attributes = createConfigurationElementAttributes(config);
168	String name = createName(config);
169	return new ConfigurationElement(model, name, attributes);
170	}
171
172	private static Long getBundleId(String name) {
173	BundleDescription descr = PDERuntimePlugin.getDefault().getPlatformAdmin().getState().getBundle(name, null);
174	return new Long(descr.getBundleId());
175	}
176
177	private ExtensionPoint createExtensionPointAdapter(IExtensionPoint extensionPoint) {
178	String label = extensionPoint.getLabel();
179	String uniqueIdentifier = extensionPoint.getUniqueIdentifier();
180	String namespaceIdentifier = extensionPoint.getNamespaceIdentifier();
181	Long contributor = getBundleId(extensionPoint.getContributor().getName());
182	Extension[] extensions = createExtensionAdapters(extensionPoint.getExtensions());
183	ExtensionPoint adapter = new ExtensionPoint(model, label, uniqueIdentifier, namespaceIdentifier, contributor);
184	adapter.getExtensions().addAll(Arrays.asList(extensions));
185	return adapter;
186	}
187
188	private ServiceRegistration createServiceReferenceAdapter(ServiceReference ref) {
189	Long id = (Long) ref.getProperty(org.osgi.framework.Constants.SERVICE_ID);
190	String bundle = ref.getBundle().getSymbolicName();
191	org.osgi.framework.Bundle[] usingBundles = ref.getUsingBundles();
192	Long[] usingBundlesIds = null;
193	if (usingBundles != null) {
194	usingBundlesIds = new Long[usingBundles.length];
195	for (int i = 0; i < usingBundles.length; i++) {
196	usingBundlesIds[i] = new Long(usingBundles[i].getBundleId());
197	}
198	}
199	String[] classes = (String[]) ref.getProperty(org.osgi.framework.Constants.OBJECTCLASS);
200	return new ServiceRegistration(model, id, bundle, usingBundlesIds, classes);
201	}
202
203	private static boolean getIsEnabled(org.osgi.framework.Bundle bundle) {
204	PlatformAdmin plaformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
205	State state = plaformAdmin.getState(false);
206
207	BundleDescription description = state.getBundle(bundle.getBundleId());
208	return (state.getDisabledInfos(description)).length == 0;
209	}
210
211	private static String createLocation(org.osgi.framework.Bundle bundle) {
212	URL bundleEntry = bundle.getEntry("/"); //$NON-NLS-1$
213	try {
214	bundleEntry = FileLocator.resolve(bundleEntry);
215	} catch (IOException e) { // do nothing
216	}
217	IPath path = new Path(bundleEntry.getFile());
218	String pathString = path.removeTrailingSeparator().toOSString();
219	if (pathString.startsWith("file:")) //$NON-NLS-1$
220	pathString = pathString.substring(5);
221	if (pathString.endsWith("!")) //$NON-NLS-1$
222	pathString = pathString.substring(0, pathString.length() - 1);
223	return pathString;
224	}
225
226	private Object[] getManifestHeaderArray(org.osgi.framework.Bundle bundle, String headerKey) {
227	String libraries = (String) bundle.getHeaders().get(headerKey);
228	try {
229	ManifestElement[] elements = ManifestElement.parseHeader(headerKey, libraries);
230	if (elements == null)
231	return null;
232	if (headerKey.equals(Constants.BUNDLE_CLASSPATH)) {
233	BundleLibrary[] array = new BundleLibrary[elements.length];
234	for (int i = 0; i < elements.length; i++)
235	array[i] = new BundleLibrary(model, elements[i].getValue());
236	return array;
237	} else if (headerKey.equals(Constants.REQUIRE_BUNDLE)) {
238	BundlePrerequisite[] array = new BundlePrerequisite[elements.length];
239	for (int i = 0; i < elements.length; i++) {
240	ManifestElement element = elements[i];
241	String name = element.getValue();
242	String version = element.getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE);
243
244	String visibility = element.getDirective(Constants.VISIBILITY_DIRECTIVE);
245	boolean isExported = Constants.VISIBILITY_REEXPORT.equals(visibility);
246	array[i] = new BundlePrerequisite(model, name, version, isExported);
247	}
248	return array;
249	}
250	} catch (BundleException e) { // do nothing
251	}
252	return null;
253	}
254
255	private Attribute[] createConfigurationElementAttributes(IConfigurationElement config) {
256	String[] atts = config.getAttributeNames();
257
258	Attribute[] catts = new Attribute[atts.length];
259	for (int i = 0; i < atts.length; i++)
260	catts[i] = new Attribute(model, atts[i], config.getAttribute(atts[i]));
261
262	IConfigurationElement[] children = config.getChildren();
263	Attribute[] result = new Attribute[children.length + catts.length];
264	for (int i = 0; i < children.length; i++) {
265	IConfigurationElement child = children[i];
266	result[i] = createConfigurationElement(child);
267	}
268	for (int i = 0; i < catts.length; i++) {
269	result[children.length + i] = catts[i];
270	}
271	return result;
272	}
273
274	private static String createName(IConfigurationElement config) {
275	String label = config.getAttribute("label"); //$NON-NLS-1$
276	if (label == null)
277	label = config.getName();
278
279	if (label == null)
280	label = config.getAttribute("name"); //$NON-NLS-1$
281
282	if (label == null && config.getAttribute("id") != null) { //$NON-NLS-1$
283	String[] labelSplit = config.getAttribute("id").split("\\."); //$NON-NLS-1$ //$NON-NLS-2$
284	label = labelSplit.length == 0 ? null : labelSplit[labelSplit.length - 1];
285	}
286
287	return label;
288	}
289
290	private Extension[] createExtensionAdapters(IExtension[] extensions) {
291	Extension[] extensionAdapters = new Extension[extensions.length];
292	for (int i = 0; i < extensions.length; i++) {
293	extensionAdapters[i] = createExtensionAdapter(extensions[i]);
294	}
295	return extensionAdapters;
296	}
297
298	public void bundleChanged(BundleEvent event) {
299	org.osgi.framework.Bundle bundle = event.getBundle();
300	Bundle adapter = createBundleAdapter(bundle);
301
302	switch (event.getType()) {
303	case BundleEvent.INSTALLED :
304	listener.addBundle(adapter);
305	break;
306	case BundleEvent.UNINSTALLED :
307	listener.removeBundle(adapter);
308	break;
309	case BundleEvent.UPDATED :
310	listener.updateBundle(adapter, ModelChangeDelta.UPDATED);
311	break;
312	case BundleEvent.RESOLVED :
313	listener.updateBundle(adapter, ModelChangeDelta.RESOLVED);
314	break;
315	case BundleEvent.UNRESOLVED :
316	listener.updateBundle(adapter, ModelChangeDelta.UNRESOLVED);
317	break;
318	case BundleEvent.STARTING :
319	listener.updateBundle(adapter, ModelChangeDelta.STARTING);
320	break;
321	case BundleEvent.STARTED :
322	listener.updateBundle(adapter, ModelChangeDelta.STARTED);
323	break;
324	case BundleEvent.STOPPING :
325	listener.updateBundle(adapter, ModelChangeDelta.STOPPING);
326	break;
327	case BundleEvent.STOPPED :
328	listener.updateBundle(adapter, ModelChangeDelta.STOPPED);
329	break;
330	default :
331	listener.updateBundle(adapter, ModelChangeDelta.UPDATED);
332	}
333	}
334
335	public void serviceChanged(ServiceEvent event) {
336	ServiceReference ref = event.getServiceReference();
337	ServiceRegistration adapter = createServiceReferenceAdapter(ref);
338
339	switch (event.getType()) {
340	case ServiceEvent.REGISTERED :
341	listener.addService(adapter);
342	break;
343	case ServiceEvent.UNREGISTERING :
344	listener.removeService(adapter);
345	break;
346	case ServiceEvent.MODIFIED :
347	default :
348	listener.updateService(adapter);
349	break;
350	}
351	}
352
353	private ExtensionPoint[] createExtensionPointAdapters(IExtensionPoint[] extensionPoints) {
354	ExtensionPoint[] result = new ExtensionPoint[extensionPoints.length];
355	for (int i = 0; i < extensionPoints.length; i++) {
356	result[i] = createExtensionPointAdapter(extensionPoints[i]);
357	}
358	return result;
359	}
360
361	public void added(IExtension[] extensions) {
362	listener.addExtensions(createExtensionAdapters(extensions));
363	}
364
365	public void removed(IExtension[] extensions) {
366	listener.removeExtensions(createExtensionAdapters(extensions));
367	}
368
369	public void added(IExtensionPoint[] extensionPoints) {
370	listener.addExtensionPoints(createExtensionPointAdapters(extensionPoints));
371	}
372
373	public void removed(IExtensionPoint[] extensionPoints) {
374	listener.removeExtensionPoints(createExtensionPointAdapters(extensionPoints));
375	}
376
377	public void setEnabled(Bundle bundle, boolean enabled) {
378	State state = PDERuntimePlugin.getDefault().getState();
379	long bundleId = bundle.getId().longValue();
380	BundleDescription desc = state.getBundle(bundleId);
381
382	if (enabled) {
383	DisabledInfo[] infos = state.getDisabledInfos(desc);
384	for (int i = 0; i < infos.length; i++) {
385	PlatformAdmin platformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
386	platformAdmin.removeDisabledInfo(infos[i]);
387	}
388	} else {
389	DisabledInfo info = new DisabledInfo("org.eclipse.pde.ui", "Disabled via PDE", desc); //$NON-NLS-1$ //$NON-NLS-2$
390	PlatformAdmin platformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
391	platformAdmin.addDisabledInfo(info);
392	}
393
394	org.osgi.framework.Bundle b = PDERuntimePlugin.getDefault().getBundleContext().getBundle(bundleId);
395	PackageAdmin packageAdmin = PDERuntimePlugin.getDefault().getPackageAdmin();
396	packageAdmin.refreshPackages(new org.osgi.framework.Bundle[] {b});
397	}
398
399	/* (non-Javadoc)
400	* @see org.eclipse.pde.internal.runtime.registry.model.local.RegistryBackend#setEnabled(org.osgi.framework.Bundle, boolean)
401	*/
402	public void setEnabled(org.osgi.framework.Bundle bundle, boolean enabled) {
403	PlatformAdmin plaformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
404	State state = plaformAdmin.getState(false);
405
406	BundleDescription desc = state.getBundle(bundle.getBundleId());
407
408	if (enabled) {
409	DisabledInfo[] infos = state.getDisabledInfos(desc);
410	for (int i = 0; i < infos.length; i++) {
411	PlatformAdmin platformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
412	platformAdmin.removeDisabledInfo(infos[i]);
413	}
414	} else {
415	DisabledInfo info = new DisabledInfo("org.eclipse.pde.ui", "Disabled via PDE", desc); //$NON-NLS-1$ //$NON-NLS-2$
416	PlatformAdmin platformAdmin = PDERuntimePlugin.getDefault().getPlatformAdmin();
417	platformAdmin.addDisabledInfo(info);
418	}
419
420	PackageAdmin packageAdmin = PDERuntimePlugin.getDefault().getPackageAdmin();
421	packageAdmin.refreshPackages(new org.osgi.framework.Bundle[] {bundle});
422	}
423	}

Added Link Here

(-)src/org/eclipse/pde/internal/runtime/registry/model/Extension.java (+66 lines)
1	package org.eclipse.pde.internal.runtime.registry.model;
2
3	public class Extension extends ModelObject {
4
5	private String namespaceIdentifier;
6	private String label;
7	private String extensionPointUniqueIdentifier;
8	private ConfigurationElement[] configurationElements;
9	private Long contributor;
10
11	public Extension(RegistryModel model, String namespaceIdentifier, String label, String extensionPointUniqueIdentifier, ConfigurationElement[] cfg, Long contributor) {
12	super(model);
13	this.namespaceIdentifier = namespaceIdentifier;
14	this.label = label;
15	this.extensionPointUniqueIdentifier = extensionPointUniqueIdentifier;
16	this.configurationElements = cfg;
17	this.contributor = contributor;
18	}
19
20	public ConfigurationElement[] getConfigurationElements() {
21	return configurationElements;
22	}
23
24	public String getExtensionPointUniqueIdentifier() {
25	return extensionPointUniqueIdentifier;
26	}
27
28	public String getLabel() {
29	return label;
30	}
31
32	public String getNamespaceIdentifier() {
33	return namespaceIdentifier;
34	}
35
36	public Long getContributorId() {
37	return contributor;
38	}
39
40	public boolean equals(Object obj) {
41	if (obj instanceof Extension) {
42	Extension ext = (Extension) obj;
43	return namespaceIdentifier.endsWith(ext.namespaceIdentifier) && label.equals(ext.label) && extensionPointUniqueIdentifier.equals(ext.extensionPointUniqueIdentifier) && contributor.equals(ext.contributor);
44	}
45
46	return false;
47	}
48
49	public int hashCode() {
50	final int prime = 31;
51	int result = 1;
52	result = prime * result + ((contributor == null) ? 0 : contributor.hashCode());
53	result = prime * result + ((extensionPointUniqueIdentifier == null) ? 0 : extensionPointUniqueIdentifier.hashCode());
54	result = prime * result + ((label == null) ? 0 : label.hashCode());
55	result = prime * result + ((namespaceIdentifier == null) ? 0 : namespaceIdentifier.hashCode());
56	return result;
57	}
58
59	public ExtensionPoint getExtensionPoint() {
60	return getModel().getExtensionPoint(extensionPointUniqueIdentifier);
61	}
62
63	public Bundle getContributor() {
64	return getModel().getBundle(contributor);
65	}
66	}

Added Link Here

(-)src/org/eclipse/pde/internal/runtime/registry/model/ExtensionPoint.java (+53 lines)
1	package org.eclipse.pde.internal.runtime.registry.model;
2
3	import java.util.ArrayList;
4	import java.util.List;
5
6	public class ExtensionPoint extends ModelObject {
7
8	private String label;
9	private String uniqueIdentifier;
10	private String namespaceIdentifier;
11	private Long contributor;
12	private List extensions = new ArrayList();
13
14	public ExtensionPoint(RegistryModel model, String label, String uniqueIdentifier, String namespaceIdentifier, Long contributor) {
15	super(model);
16	this.label = label;
17	this.uniqueIdentifier = uniqueIdentifier;
18	this.namespaceIdentifier = namespaceIdentifier;
19	this.contributor = contributor;
20	}
21
22	public List getExtensions() {
23	return extensions;
24	}
25
26	public String getLabel() {
27	return label;
28	}
29
30	public String getUniqueIdentifier() {
31	return uniqueIdentifier;
32	}
33
34	public String getNamespaceIdentifier() {
35	return namespaceIdentifier;
36	}
37
38	public Long getContributorId() {
39	return contributor;
40	}
41
42	public Bundle getContributor() {
43	return getModel().getBundle(contributor);
44	}
45
46	public boolean equals(Object obj) {
47	return (obj instanceof ExtensionPoint) && (uniqueIdentifier.equals(((ExtensionPoint) obj).uniqueIdentifier));
48	}
49
50	public int hashCode() {
51	return uniqueIdentifier.hashCode();
52	}
53	}

Added Link Here

(-)src/org/eclipse/pde/internal/runtime/registry/model/ModelChangeDelta.java (+34 lines)
1	package org.eclipse.pde.internal.runtime.registry.model;
2
3	/**
4	*
5	* Delta model objects are of type IBundle, IService, IExtension, IExtensionPoint
6	*/
7	public class ModelChangeDelta {
8
9	public static final int ADDED = 0;
10	public static final int UPDATED = 1;
11	public static final int REMOVED = 2;
12	public static final int STARTING = 3;
13	public static final int STARTED = 4;
14	public static final int STOPPING = 5;
15	public static final int STOPPED = 6;
16	public static final int RESOLVED = 7;
17	public static final int UNRESOLVED = 8;
18
19	private ModelObject fObject;
20	private int fFlag;
21
22	public ModelChangeDelta(ModelObject object, int flag) {
23	fObject = object;
24	fFlag = flag;
25	}
26
27	public ModelObject getModelObject() {
28	return fObject;
29	}
30
31	public int getFlag() {
32	return fFlag;
33	}
34	}

Added Link Here

(-)src/org/eclipse/pde/internal/runtime/registry/model/ModelObject.java (+14 lines)
1	package org.eclipse.pde.internal.runtime.registry.model;
2
3	public abstract class ModelObject {
4
5	private RegistryModel model;
6
7	public ModelObject(RegistryModel model) {
8	this.model = model;
9	}
10
11	public RegistryModel getModel() {
12	return model;
13	}
14	}

Added Link Here

(-)src/org/eclipse/pde/internal/runtime/registry/model/BackendChangeListener.java (+29 lines)
1	package org.eclipse.pde.internal.runtime.registry.model;
2
3	/**
4	* Notifies on any changes coming from backend. Usually RegistryModel is only interested in receiving
5	* news about that.
6	*
7	*/
8	public interface BackendChangeListener {
9
10	void addBundle(Bundle adapter);
11
12	void removeBundle(Bundle adapter);
13
14	void updateBundle(Bundle adapter, int updated);
15
16	void addService(ServiceRegistration adapter);
17
18	void removeService(ServiceRegistration adapter);
19
20	void updateService(ServiceRegistration adapter);
21
22	void addExtensions(Extension[] createExtensionAdapters);
23
24	void removeExtensions(Extension[] createExtensionAdapters);
25
26	void addExtensionPoints(ExtensionPoint[] createExtensionPointAdapters);
27
28	void removeExtensionPoints(ExtensionPoint[] createExtensionPointAdapters);
29	}

Added Link Here

(-)src/org/eclipse/pde/internal/runtime/registry/model/RegistryBackend.java (+43 lines)
1	package org.eclipse.pde.internal.runtime.registry.model;
2
3	import java.util.Map;
4	import org.eclipse.core.runtime.MultiStatus;
5	import org.osgi.framework.BundleException;
6
7	public interface RegistryBackend {
8
9	public void connect();
10
11	public void disconnect();
12
13	public void setEnabled(Bundle bundle, boolean enabled);
14
15	public void start(Bundle bundle) throws BundleException;
16
17	public void stop(Bundle bundle) throws BundleException;
18
19	public MultiStatus diagnose(Bundle bundle);
20
21	public Map initializeBundles();
22
23	public Map initializeExtensionPoints();
24
25	public void setRegistryListener(BackendChangeListener listener);
26
27	public void setRegistryModel(RegistryModel listener);
28
29	public Map initializeServices();
30
31	}
Added Link Here
1	package org.eclipse.pde.internal.runtime.registry.model;
2
3	/**
4	* Event provides a list of objects that have changed.
5	* Possible objects on the list are IBundle, IService, IExtension, IExtensionPoint.
6	* This is temporary solution and is subject to future changes.
7	*
8	*/
9	public interface ModelChangeListener {
10
11	void modelChanged(ModelChangeDelta[] deltas);
12	}

Added Link Here

(-)src/org/eclipse/pde/internal/runtime/registry/model/ConfigurationElement.java (+15 lines)
1	package org.eclipse.pde.internal.runtime.registry.model;
2
3	public class ConfigurationElement extends Attribute {
4
5	private Attribute[] elements;
6
7	public ConfigurationElement(RegistryModel model, String name, Attribute[] attributes) {
8	super(model, name, null);
9	elements = attributes;
10	}
11
12	public Attribute[] getElements() {
13	return elements;
14	}
15	}

Added Link Here

(-)src/org/eclipse/pde/internal/runtime/registry/model/ServiceRegistration.java (+41 lines)
1	package org.eclipse.pde.internal.runtime.registry.model;
2
3	public class ServiceRegistration extends ModelObject {
4
5	private Long id;
6	private String bundle;
7	private Long[] usingBundles;
8	private String[] classes;
9
10	public ServiceRegistration(RegistryModel model, Long id, String bundle, Long[] usingBundles, String[] classes) {
11	super(model);
12	this.id = id;
13	this.bundle = bundle;
14	this.usingBundles = usingBundles;
15	this.classes = classes;
16	}
17
18	public Long getId() {
19	return id;
20	}
21
22	public String[] getClasses() {
23	return classes;
24	}
25
26	public String getBundle() {
27	return bundle;
28	}
29
30	public Long[] getUsingBundles() {
31	return usingBundles;
32	}
33
34	public boolean equals(Object obj) {
35	return (obj instanceof ServiceRegistration) && (id.equals(((ServiceRegistration) obj).id));
36	}
37
38	public int hashCode() {
39	return id.intValue();
40	}
41	}