| /******************************************************************************* |
| * Copyright (c) 2001, 2004 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 |
| * Jens Lukowski/Innoopract - initial renaming/restructuring |
| * |
| *******************************************************************************/ |
| package org.eclipse.wst.sse.ui.internal.debug; |
| |
| import java.util.ArrayList; |
| 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.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.debug.core.DebugPlugin; |
| import org.eclipse.debug.core.IBreakpointManager; |
| import org.eclipse.debug.core.model.IBreakpoint; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.text.BadLocationException; |
| import org.eclipse.jface.text.IDocument; |
| import org.eclipse.jface.text.Position; |
| import org.eclipse.jface.text.source.IAnnotationModel; |
| import org.eclipse.jface.text.source.IVerticalRulerInfo; |
| import org.eclipse.swt.events.MouseEvent; |
| import org.eclipse.swt.events.MouseListener; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IFileEditorInput; |
| import org.eclipse.ui.IPartService; |
| import org.eclipse.ui.IStorageEditorInput; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.texteditor.AbstractMarkerAnnotationModel; |
| import org.eclipse.ui.texteditor.IDocumentProvider; |
| import org.eclipse.ui.texteditor.ITextEditor; |
| import org.eclipse.ui.texteditor.IUpdate; |
| import org.eclipse.wst.sse.core.IStructuredModel; |
| import org.eclipse.wst.sse.core.StructuredModelManager; |
| import org.eclipse.wst.sse.ui.extensions.breakpoint.IBreakpointProvider; |
| import org.eclipse.wst.sse.ui.internal.Logger; |
| import org.eclipse.wst.sse.ui.internal.SSEUIPlugin; |
| import org.eclipse.wst.sse.ui.internal.extension.BreakpointProviderBuilder; |
| |
| |
| public abstract class BreakpointRulerAction extends Action implements IUpdate { |
| |
| protected class MouseUpdater implements MouseListener { |
| public void mouseDoubleClick(MouseEvent e) { |
| // do nothing (here) |
| } |
| |
| public void mouseDown(MouseEvent e) { |
| update(); |
| } |
| |
| public void mouseUp(MouseEvent e) { |
| // do nothing |
| } |
| } |
| |
| public static final String getFileExtension(IEditorInput input) { |
| IPath path = null; |
| if (input instanceof IStorageEditorInput) { |
| try { |
| path = ((IStorageEditorInput) input).getStorage().getFullPath(); |
| } catch (CoreException e) { |
| Logger.logException(e); |
| } |
| } |
| if (path != null) { |
| return path.getFileExtension(); |
| } |
| String name = input.getName(); |
| int index = name.lastIndexOf('.'); |
| if (index == -1) |
| return null; |
| if (index == (name.length() - 1)) |
| return ""; //$NON-NLS-1$ |
| return name.substring(index + 1); |
| } |
| |
| public static final IResource getResource(IEditorInput input) { |
| IResource resource = null; |
| |
| if (input instanceof IFileEditorInput) |
| resource = ((IFileEditorInput) input).getFile(); |
| if (resource == null) |
| resource = (IResource) input.getAdapter(IFile.class); |
| if (resource == null) |
| resource = (IResource) input.getAdapter(IResource.class); |
| |
| IEditorPart editorPart = null; |
| if (resource == null) { |
| IWorkbench workbench = SSEUIPlugin.getDefault().getWorkbench(); |
| if (workbench != null) { |
| IWorkbenchWindow window = workbench.getActiveWorkbenchWindow(); |
| if (window != null) { |
| IPartService service = window.getPartService(); |
| if (service != null) { |
| Object part = service.getActivePart(); |
| if (part != null && part instanceof IEditorPart) { |
| editorPart = (IEditorPart) part; |
| if (editorPart != null) { |
| IStructuredModel model = null; |
| ITextEditor textEditor = null; |
| try { |
| if (editorPart instanceof ITextEditor) { |
| textEditor = (ITextEditor) editorPart; |
| } |
| if (textEditor == null) { |
| textEditor = (ITextEditor) editorPart.getAdapter(ITextEditor.class); |
| } |
| if (textEditor != null) { |
| IDocument textDocument = textEditor.getDocumentProvider().getDocument(input); |
| model = StructuredModelManager.getModelManager().getExistingModelForRead(textDocument); |
| if (model != null) { |
| resource = BreakpointProviderBuilder.getInstance().getResource(input, model.getContentTypeIdentifier(), getFileExtension(input)); |
| } |
| } |
| if (resource == null) { |
| IBreakpointProvider[] providers = BreakpointProviderBuilder.getInstance().getBreakpointProviders(editorPart, null, getFileExtension(input)); |
| for (int i = 0; i < providers.length && resource == null; i++) { |
| resource = providers[i].getResource(input); |
| } |
| } |
| } catch (Exception e) { |
| Logger.logException(e); |
| } finally { |
| if (model != null) { |
| model.releaseFromRead(); |
| } |
| } |
| } |
| |
| } |
| } |
| } |
| |
| } |
| } |
| return resource; |
| } |
| |
| protected MouseListener fMouseListener = null; |
| |
| protected IVerticalRulerInfo fRulerInfo = null; |
| protected ITextEditor fTextEditor = null; |
| |
| public BreakpointRulerAction(ITextEditor editor, IVerticalRulerInfo rulerInfo) { |
| super(); |
| fTextEditor = editor; |
| if(rulerInfo != null) { |
| fRulerInfo = rulerInfo; |
| fMouseListener = new MouseUpdater(); |
| rulerInfo.getControl().addMouseListener(fMouseListener); |
| } |
| } |
| |
| /** |
| * Returns the <code>AbstractMarkerAnnotationModel</code> of the |
| * editor's input. |
| * |
| * @return the marker annotation model |
| */ |
| protected AbstractMarkerAnnotationModel getAnnotationModel() { |
| IDocumentProvider provider = fTextEditor.getDocumentProvider(); |
| IAnnotationModel model = provider.getAnnotationModel(fTextEditor.getEditorInput()); |
| if (model instanceof AbstractMarkerAnnotationModel) |
| return (AbstractMarkerAnnotationModel) model; |
| return null; |
| } |
| |
| protected IBreakpoint[] getBreakpoints(IMarker[] markers) { |
| IBreakpointManager manager = DebugPlugin.getDefault().getBreakpointManager(); |
| List breakpoints = new ArrayList(markers.length); |
| for (int i = 0; i < markers.length; i++) { |
| IBreakpoint breakpoint = manager.getBreakpoint(markers[i]); |
| if (breakpoint != null) { |
| breakpoints.add(breakpoint); |
| } |
| } |
| return (IBreakpoint[]) breakpoints.toArray(new IBreakpoint[0]); |
| } |
| |
| /** |
| * Returns the <code>IDocument</code> of the editor's input. |
| * |
| * @return the document of the editor's input |
| */ |
| protected IDocument getDocument() { |
| IDocumentProvider provider = fTextEditor.getDocumentProvider(); |
| return provider.getDocument(fTextEditor.getEditorInput()); |
| } |
| |
| /** |
| * Returns all markers which include the ruler's line of activity. |
| * |
| * @return an array of markers which include the ruler's line of activity |
| */ |
| protected IMarker[] getMarkers() { |
| List markers = new ArrayList(); |
| |
| IResource resource = getResource(); |
| IDocument document = getDocument(); |
| AbstractMarkerAnnotationModel annotationModel = getAnnotationModel(); |
| |
| if (resource != null && annotationModel != null && resource.exists()) { |
| try { |
| IMarker[] allMarkers = resource.findMarkers(IBreakpoint.BREAKPOINT_MARKER, true, IResource.DEPTH_ZERO); |
| if (allMarkers != null) { |
| for (int i = 0; i < allMarkers.length; i++) { |
| if (includesRulerLine(annotationModel.getMarkerPosition(allMarkers[i]), document)) { |
| markers.add(allMarkers[i]); |
| } |
| } |
| } |
| } catch (CoreException x) { |
| // |
| } |
| } |
| |
| return (IMarker[]) markers.toArray(new IMarker[0]); |
| } |
| |
| protected IResource getResource() { |
| IEditorInput input = getTextEditor().getEditorInput(); |
| IResource resource = getResource(input); |
| return resource; |
| } |
| |
| /** |
| * @return Returns the rulerInfo. |
| */ |
| public IVerticalRulerInfo getRulerInfo() { |
| return fRulerInfo; |
| } |
| |
| /** |
| * @return Returns the textEditor. |
| */ |
| public ITextEditor getTextEditor() { |
| return fTextEditor; |
| } |
| |
| protected boolean hasMarkers() { |
| IResource resource = getResource(); |
| IDocument document = getDocument(); |
| AbstractMarkerAnnotationModel model = getAnnotationModel(); |
| |
| if (resource != null && model != null && resource.exists()) { |
| try { |
| IMarker[] allMarkers = resource.findMarkers(IBreakpoint.LINE_BREAKPOINT_MARKER, true, IResource.DEPTH_ZERO); |
| if (allMarkers != null) { |
| for (int i = 0; i < allMarkers.length; i++) { |
| if (includesRulerLine(model.getMarkerPosition(allMarkers[i]), document)) { |
| return true; |
| } |
| } |
| } |
| } catch (CoreException x) { |
| // |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Checks whether a position includes the ruler's line of activity. |
| * |
| * @param position |
| * the position to be checked |
| * @param document |
| * the document the position refers to |
| * @return <code>true</code> if the line is included by the given |
| * position |
| */ |
| protected boolean includesRulerLine(Position position, IDocument document) { |
| if (position != null && fRulerInfo != null) { |
| try { |
| int markerLine = document.getLineOfOffset(position.getOffset()); |
| int line = getRulerInfo().getLineOfLastMouseButtonActivity(); |
| if (line == markerLine) |
| return true; |
| // commented because of "1GEUOZ9: ITPJUI:ALL - Confusing UI |
| // for |
| // multiline Bookmarks and Tasks" |
| // return (markerLine <= line && line <= |
| // document.getLineOfOffset(position.getOffset() + |
| // position.getLength())); |
| } catch (BadLocationException x) { |
| // |
| } |
| } |
| return false; |
| } |
| } |