org.eclipse.mylyn.context.core;bundle-version="[3.0,4.0.0)",

 org.eclipse.mylyn.context.ui;bundle-version="[3.0,4.0.0)",

Bundle-Activator: org.eclipse.mylyn.internal.wikitext.tasks.ui.WikiTextTasksUiPlugin

         point="org.eclipse.mylyn.context.core.bridges">

      <structureBridge

            class="org.eclipse.mylyn.internal.wikitext.tasks.ui.WikiTextContextStructureBridge"

            name="WikiText Structure Bridge"

            parentContentType="resource">

      </structureBridge>

   </extension>

   <extension

         point="org.eclipse.mylyn.context.ui.bridges">

      <uiBridge

            class="org.eclipse.mylyn.internal.wikitext.tasks.ui.WikiTextContextUiBridge"

            contentType="org.eclipse.mylyn.wikitext"

            name="WikiText Context UI Bridge">

      </uiBridge>

   </extension>

   <extension

/*******************************************************************************

 * Copyright (c) 2009 David Green 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:

 *     David Green - initial API and implementation

 *******************************************************************************/

package org.eclipse.mylyn.internal.wikitext.tasks.ui;

import java.io.BufferedInputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.io.StringWriter;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IMarker;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.content.IContentDescription;

import org.eclipse.core.runtime.content.IContentType;

import org.eclipse.mylyn.context.core.AbstractContextStructureBridge;

import org.eclipse.mylyn.wikitext.core.WikiText;

import org.eclipse.mylyn.wikitext.core.parser.markup.MarkupLanguage;

import org.eclipse.mylyn.wikitext.core.parser.outline.OutlineItem;

import org.eclipse.mylyn.wikitext.core.parser.outline.OutlineParser;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.PlatformUI;

/**

 * A Mylyn {@link AbstractContextStructureBridge context structure bridge} for wikitext files.

 * 

 * @author David Green

 */

public class WikiTextContextStructureBridge extends AbstractContextStructureBridge {

	private static final char HANDLE_FILE_SEPARATOR = ';';

	public static final String CONTENT_TYPE = WikiText.CONTENT_TYPE;

	public WikiTextContextStructureBridge() {

	}

	@Override

	public boolean acceptsObject(Object object) {

		if (object instanceof OutlineItem) {

			return true;

		} else if (object instanceof IFile) {

			IFile file = (IFile) object;

			try {

				IContentDescription description = file.getContentDescription();

				if (description != null) {

					IContentType contentType = description.getContentType();

					if (contentType != null) {

						if (isWikiText(contentType)) {

							return true;

						}

					}

				}

			} catch (CoreException e) {

				// ignore

			}

			String languageName = WikiText.getMarkupLanguageNameForFilename(file.getName());

			return languageName != null;

		}

		return false;

	}

	private boolean isWikiText(IContentType contentType) {

		if (WikiText.CONTENT_TYPE.equals(contentType.getId())) {

			return true;

		}

		IContentType baseType = contentType.getBaseType();

		if (baseType != null) {

			return isWikiText(baseType);

		}

		return false;

	}

	@Override

	public boolean canBeLandmark(String handle) {

		if (handle == null) {

			return false;

		} else {

			return handle.indexOf(HANDLE_FILE_SEPARATOR) != -1;

		}

	}

	@Override

	public boolean canFilter(Object element) {

		return true;

	}

	@Override

	public List<String> getChildHandles(String handle) {

		Object object = getObjectForHandle(handle);

		if (object instanceof OutlineItem) {

			OutlineItem item = (OutlineItem) object;

			if (!item.getChildren().isEmpty()) {

				List<String> handles = new ArrayList<String>(item.getChildren().size());

				for (OutlineItem child : item.getChildren()) {

					handles.add(getHandleIdentifier(child));

				}

				return handles;

			}

		}

		return Collections.emptyList();

	}

	@Override

	public String getContentType() {

		return CONTENT_TYPE;

	}

	@Override

	public String getContentType(String elementHandle) {

		if (elementHandle.indexOf(HANDLE_FILE_SEPARATOR) == -1) {

			return parentContentType;

		}

		return CONTENT_TYPE;

	}

	@Override

	public String getHandleForOffsetInObject(Object object, int offset) {

		IResource resource = null;

		try {

			if (object instanceof IResource) {

				resource = (IResource) object;

			} else if (object instanceof IMarker) {

				resource = ((IMarker) object).getResource();

			} else {

				try {

					// works with ConcreteMarker without creating a compile-time dependency on internals

					IMarker marker = (IMarker) object.getClass().getMethod("getMarker").invoke(object); //$NON-NLS-1$

					resource = marker.getResource();

				} catch (Exception e) {

					// ignore

				}

			}

		} catch (Exception e) {

			return null;

		}

		if (resource instanceof IFile) {

			IFile file = (IFile) resource;

			if (acceptsObject(file)) {

				OutlineItem outline = getOutline(file);

				if (outline != null) {

					OutlineItem item = outline.findNearestMatchingOffset(offset);

					if (item != null) {

						return getHandleIdentifier(item);

					}

				}

			}

		}

		return null;

	}

	@Override

	public String getLabel(Object object) {

		if (object instanceof OutlineItem) {

			OutlineItem item = (OutlineItem) object;

			if (item.getParent() == null) {

				return getFile(item).getName();

			} else {

				return item.getLabel();

			}

		}

		return ""; //$NON-NLS-1$

	}

	@Override

	public Object getObjectForHandle(String handle) {

		if (handle == null) {

			return null;

		}

		int idxOfSeparator = handle.indexOf(HANDLE_FILE_SEPARATOR);

		String filename = handle;

		if (idxOfSeparator != -1) {

			filename = handle.substring(0, idxOfSeparator);

		}

		IFile file;

		try {

			file = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(filename));

		} catch (Exception e) {

			// be error-tolerant since we don't know much about the handle at this point

			return null;

		}

		if (file != null) {

			if (idxOfSeparator != -1) {

				String headingId = handle.substring(idxOfSeparator + 1);

				OutlineItem outline = getOutline(file);

				if (outline != null) {

					OutlineItem item = outline.findItemById(headingId);

					return item;

				}

			} else {

				return file;

			}

		}

		return null;

	}

	@Override

	public String getParentHandle(String handle) {

		Object object = getObjectForHandle(handle);

		if (object instanceof OutlineItem) {

			OutlineItem item = (OutlineItem) object;

			if (item.getParent() != null) {

				return getHandleIdentifier(item.getParent());

			}

		}

		return null;

	}

	@Override

	public boolean isDocument(String handle) {

		Object object = getObjectForHandle(handle);

		if (object instanceof OutlineItem) {

			OutlineItem item = (OutlineItem) object;

			return item.getParent() == null;

		}

		return false;

	}

	@Override

	public String getHandleIdentifier(Object object) {

		if (object instanceof OutlineItem) {

			OutlineItem item = (OutlineItem) object;

			return item.getResourcePath() + HANDLE_FILE_SEPARATOR + item.getId();

		} else if (object instanceof IFile && acceptsObject(object)) {

			return ((IFile) object).getFullPath().toString();

		}

		return null;

	}

	private IPath getFullPath(OutlineItem item) {

		String resourcePath = item.getResourcePath();

		return resourcePath == null ? null : new Path(resourcePath);

	}

	private OutlineItem getOutline(IFile file) {

		// FIXME: is editor integration the way to go?? we probably need some kind of core model

		IEditorPart editorPart = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();

		if (editorPart != null) {

			OutlineItem outline = (OutlineItem) editorPart.getAdapter(OutlineItem.class);

			if (outline != null) {

				return outline;

			}

		}

		MarkupLanguage markupLanguage = WikiText.getMarkupLanguageForFilename(file.getName());

		if (markupLanguage != null) {

			OutlineParser parser = new OutlineParser(markupLanguage);

			try {

				String contents = getContents(file);

				OutlineItem outline = parser.parse(contents);

				outline.setResourcePath(file.getFullPath().toString());

				return outline;

			} catch (Exception e) {

				// ignore

				return null;

			}

		}

		return null;

	}

	private String getContents(IFile file) throws Exception {

		String charset = file.getCharset();

		StringWriter writer = new StringWriter();

		Reader reader = new InputStreamReader(new BufferedInputStream(file.getContents()), charset);

		int i;

		while ((i = reader.read()) != -1) {

			writer.write(i);

		}

		return writer.toString();

	}

	IFile getFile(OutlineItem item) {

		IPath fullPath = getFullPath(item);

		return fullPath == null ? null : ResourcesPlugin.getWorkspace().getRoot().getFile(fullPath);

	}

}

/*******************************************************************************

 * Copyright (c) 2007, 2008 David Green 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:

 *     David Green - initial API and implementation

 *******************************************************************************/

package org.eclipse.mylyn.internal.wikitext.tasks.ui;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.ILog;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.ui.plugin.AbstractUIPlugin;

import org.osgi.framework.BundleContext;

public class WikiTextTasksUiPlugin extends AbstractUIPlugin {

	private static WikiTextTasksUiPlugin plugin;

	public WikiTextTasksUiPlugin() {

		plugin = this;

	}

	@Override

	public void start(BundleContext context) throws Exception {

		super.start(context);

	}

	@Override

	public void stop(BundleContext context) throws Exception {

		plugin = null;

		super.stop(context);

	}

	public static WikiTextTasksUiPlugin getDefault() {

		return plugin;

	}

	public void log(Throwable ce) {

		if (ce instanceof CoreException) {

			getLog().log(((CoreException) ce).getStatus());

		} else {

			log(IStatus.ERROR, ce.getMessage(), ce);

		}

	}

	public void log(int severity, String message, Throwable exception) {

		if (message == null) {

			message = ""; //$NON-NLS-1$

		}

		ILog log = getLog();

		IStatus status = null;

		if (exception instanceof CoreException) {

			status = ((CoreException) exception).getStatus();

		}

		if (status == null) {

			status = new Status(severity, getPluginId(), severity, message, exception);

		}

		log.log(status);

	}

	public String getPluginId() {

		return getBundle().getSymbolicName();

	}

	public IStatus createStatus(int statusCode, Throwable exception) {

		return createStatus(null, statusCode, exception);

	}

	public IStatus createStatus(String message, int statusCode, Throwable exception) {

		if (message == null && exception != null) {

			message = exception.getClass().getName() + ": " + exception.getMessage(); //$NON-NLS-1$

		}

		Status status = new Status(statusCode, getPluginId(), statusCode, message, exception);

		return status;

	}

}

/*******************************************************************************

 * Copyright (c) 2007, 2008 David Green 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:

 *     David Green - initial API and implementation

 *******************************************************************************/

package org.eclipse.mylyn.internal.wikitext.tasks.ui;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.core.resources.IFile;

import org.eclipse.jface.text.TextSelection;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.mylyn.context.core.AbstractContextStructureBridge;

import org.eclipse.mylyn.context.core.ContextCore;

import org.eclipse.mylyn.context.core.IInteractionElement;

import org.eclipse.mylyn.context.ui.AbstractContextUiBridge;

import org.eclipse.mylyn.wikitext.core.parser.outline.OutlineItem;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.IEditorReference;

import org.eclipse.ui.IFileEditorInput;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.part.FileEditorInput;

import org.eclipse.ui.part.IShowInTarget;

import org.eclipse.ui.part.ShowInContext;

import org.eclipse.ui.views.contentoutline.ContentOutlinePage;

import org.eclipse.ui.views.contentoutline.IContentOutlinePage;

/**

 * a UI context bridge for WikiText.

 * 

 * @author David Green

 */

public class WikiTextContextUiBridge extends AbstractContextUiBridge {

	public WikiTextContextUiBridge() {

	}

	@Override

	public boolean acceptsEditor(IEditorPart editorPart) {

		return editorPart.getAdapter(OutlineItem.class) != null;

	}

	@Override

	public List<TreeViewer> getContentOutlineViewers(IEditorPart editorPart) {

		List<TreeViewer> viewers = new ArrayList<TreeViewer>();

		if (acceptsEditor(editorPart)) {

			try {

				IContentOutlinePage outlinePage = (IContentOutlinePage) editorPart.getAdapter(IContentOutlinePage.class);

				if (outlinePage != null) {

					Method method = ContentOutlinePage.class.getDeclaredMethod("getTreeViewer", new Class[] {}); //$NON-NLS-1$

					method.setAccessible(true);

					viewers.add((TreeViewer) method.invoke(outlinePage, new Object[] {}));

				}

			} catch (Exception e) {

				// ignore

			}

		}

		return viewers;

	}

	@Override

	public String getContentType() {

		return WikiTextContextStructureBridge.CONTENT_TYPE;

	}

	@Override

	public Object getObjectForTextSelection(TextSelection selection, IEditorPart editor) {

		OutlineItem outline = (OutlineItem) editor.getAdapter(OutlineItem.class);

		if (outline != null && selection != null) {

			return outline.findNearestMatchingOffset(selection.getOffset());

		}

		return outline;

	}

	@Override

	public IInteractionElement getElement(IEditorInput input) {

		Object adapter = input.getAdapter(OutlineItem.class);

		if (adapter != null) {

			String handle = ContextCore.getStructureBridge(adapter).getHandleIdentifier(adapter);

			return ContextCore.getContextManager().getElement(handle);

		}

		return null;

	}

	@Override

	public void open(IInteractionElement element) {

		AbstractContextStructureBridge structureBridge = ContextCore.getStructureBridge(WikiTextContextStructureBridge.CONTENT_TYPE);

		if (structureBridge instanceof WikiTextContextStructureBridge) {

			Object object = structureBridge.getObjectForHandle(element.getHandleIdentifier());

			OutlineItem item = null;

			if (object instanceof OutlineItem) {

				item = (OutlineItem) object;

				object = ((WikiTextContextStructureBridge) structureBridge).getFile(item);

			}

			if (object instanceof IFile) {

				FileEditorInput editorInput = new FileEditorInput((IFile) object);

				try {

					IEditorPart editor = PlatformUI.getWorkbench()

							.getActiveWorkbenchWindow()

							.getActivePage()

							.openEditor(editorInput, "org.eclipse.mylyn.wikitext.ui.editor.markupEditor"); //$NON-NLS-1$

					if (item != null && editor instanceof IShowInTarget) {

						((IShowInTarget) editor).show(new ShowInContext(editorInput, new StructuredSelection(item)));

					}

				} catch (PartInitException e) {

					WikiTextTasksUiPlugin.getDefault().log(e);

				}

			}

		}

	}

	@Override

	public void close(IInteractionElement element) {

		try {

			IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();

			if (page != null) {

				List<IEditorReference> editors = new ArrayList<IEditorReference>(4);

				for (IEditorReference reference : page.getEditorReferences()) {

					try {

						if (reference.getEditorInput() instanceof IFileEditorInput) {

							IFileEditorInput input = (IFileEditorInput) reference.getEditorInput();

							if (input.getFile().getFullPath().toString().equals(element.getHandleIdentifier())) {

								editors.add(reference);

							}

						}

					} catch (PartInitException e) {

						// ignore

					}

				}

				if (!editors.isEmpty()) {

					page.closeEditors(editors.toArray(new IEditorReference[editors.size()]), true);

				}

			}

		} catch (Throwable t) {

			WikiTextTasksUiPlugin.getDefault().log(t);

		}

	}

}