Пример #1
0
  /**
   * Tells whether the given marker can be treated as a Java annotation which will later be update
   * by JDT Core problems.
   *
   * @param marker the marker
   * @return <code>true</code> if the marker can be treated as a Java annotation
   * @since 3.3.2
   */
  public static final boolean isJavaAnnotation(IMarker marker) {
    // Performance
    String markerType = MarkerUtilities.getMarkerType(marker);
    if (IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER.equals(markerType)
        || IJavaModelMarker.TASK_MARKER.equals(markerType)
        || IJavaModelMarker.TRANSIENT_PROBLEM.equals(markerType)
        || IJavaModelMarker.BUILDPATH_PROBLEM_MARKER.equals(markerType)) return true;

    return MarkerUtilities.isMarkerType(marker, IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER);
  }
 /**
  * Corrects the {@link IMarker#CHAR_START} and {@link IMarker#CHAR_END} values as needed
  *
  * @param document
  * @param marker
  * @param line
  * @throws BadLocationException
  */
 void ensureRanges(IDocument document, IMarker marker, int line) throws BadLocationException {
   if (line < 0 || line > document.getNumberOfLines()) {
     return;
   }
   IRegion region = document.getLineInformation(line - 1);
   int charstart = region.getOffset();
   int charend = charstart + region.getLength();
   MarkerUtilities.setCharStart(marker, charstart);
   MarkerUtilities.setCharEnd(marker, charend);
 }
Пример #3
0
  /**
   * Adds a new quickmark in the active editor. If the same quickmark number already exists (in the
   * workspace), the existing quickmark is replaced with the new (i.e. the quickmark is moved). If
   * the same quickmark already exists in the same location, the quickmark is removed.
   *
   * @param quickmarkNumber
   */
  private void addBookmark(int quickmarkNumber) {
    ITextEditor editor = getActiveEditor();
    if (editor != null) {
      Integer key = new Integer(quickmarkNumber);

      Map attributes = new HashMap();
      ITextSelection selection = (ITextSelection) editor.getSelectionProvider().getSelection();

      int charStart = selection.getOffset();
      int charEnd = charStart;
      MarkerUtilities.setCharStart(attributes, charStart);
      MarkerUtilities.setCharEnd(attributes, charEnd);

      IFile file = getActiveFile();

      String message =
          MessageFormat.format(
              Messages.getString("SetQuickmarkAction.quickmarkMessage"),
              new Object[] {key}); // $NON-NLS-1$
      MarkerUtilities.setMessage(attributes, message);
      attributes.put(QuickmarksPlugin.NUMBER, key);
      attributes.put(QuickmarksPlugin.FILE, file);

      boolean OK = true;
      Map markers = getMarkers();
      if (markers.containsKey(key)) {
        IMarker marker = (IMarker) markers.get(key);
        try {
          Integer markerCharStart = (Integer) marker.getAttribute(IMarker.CHAR_START);
          Integer markerCharEnd = (Integer) marker.getAttribute(IMarker.CHAR_END);
          if (markerCharStart != null
              && markerCharStart.intValue() == charStart
              && markerCharEnd != null
              && markerCharEnd.intValue() == charEnd) {
            OK = false;
          }
          marker.delete();
        } catch (CoreException e) {
          QuickmarksPlugin.debug(e);
        }
      }

      if (OK) {
        try {
          MarkerUtilities.createMarker(file, attributes, getMarkerType());
        } catch (Exception e) {
          QuickmarksPlugin.log(e);
        }
      }
    }
  }
Пример #4
0
 private void assertNoErrors(final IFile file) {
   try {
     final IMarker[] findMarkers =
         file.findMarkers(IMarker.PROBLEM, true, IResource.DEPTH_INFINITE);
     for (final IMarker iMarker : findMarkers) {
       String _message = MarkerUtilities.getMessage(iMarker);
       int _severity = MarkerUtilities.getSeverity(iMarker);
       boolean _equals = (_severity == IMarker.SEVERITY_ERROR);
       Assert.assertFalse(_message, _equals);
     }
   } catch (Throwable _e) {
     throw Exceptions.sneakyThrow(_e);
   }
 }
 private static boolean internalHasResolutions(IMarker marker) {
   ErrorCode id = new DartMarkerAnnotation(marker).getId();
   CompilationUnit cu = getCompilationUnit(marker);
   return cu != null
       && DartCorrectionProcessor_OLD.hasCorrections(
           cu, id, MarkerUtilities.getMarkerType(marker));
 }
Пример #6
0
 /*
  * (non-Javadoc)
  *
  * @see
  * org.eclipse.ui.texteditor.IMarkerUpdater#updateMarker(org.eclipse.core
  * .resources.IMarker, org.eclipse.jface.text.IDocument,
  * org.eclipse.jface.text.Position)
  */
 public boolean updateMarker(
     final IMarker marker, final IDocument document, final Position position) {
   if (position.isDeleted()) {
     return false;
   }
   try {
     final int line = MarkerUtilities.getLineNumber(marker);
     final int newLine = document.getLineOfOffset(position.getOffset()) + 1;
     if (line == newLine) {
       return true;
     }
     final IBreakpointManager manager = DebugPlugin.getDefault().getBreakpointManager();
     final IBreakpoint breakpoint = manager.getBreakpoint(marker);
     if (breakpoint == null) {
       return false;
     }
     if (breakpoint instanceof ErlangLineBreakpoint) {
       final ErlangLineBreakpoint erlangLineBreakpoint = (ErlangLineBreakpoint) breakpoint;
       final ErlangDebugTarget target = erlangLineBreakpoint.getTarget();
       erlangLineBreakpoint.remove(target);
       MarkerUtilities.setLineNumber(marker, newLine);
       erlangLineBreakpoint.install(target);
       return true;
     }
     // if there exists a breakpoint on the line remove this one
     if (isLineBreakpointMarker(marker)) {
       ensureRanges(document, marker, line);
       return lineBreakpointExists(marker.getResource(), line, marker) == null;
     }
     // if the line info is a valid location with an invalid line
     // number,
     // a line breakpoint must be removed
     if (isLineBreakpointMarker(marker) && line == -1) {
       return false;
     }
     MarkerUtilities.setLineNumber(marker, line);
     if (isLineBreakpointMarker(marker)) {
       ensureRanges(document, marker, line);
     }
     return true;
   } catch (final BadLocationException e) {
     ErlLogger.error(e);
   } catch (final CoreException e) {
     ErlLogger.error(e);
   }
   return false;
 }
    @Override
    public boolean select(Viewer viewer, Object parentElem, Object elem) {
      IMarker marker = (IMarker) elem;

      if (MarkerUtilities.getSeverity(marker) == severityToPermit)
        return ErrorWarningFilterAction.this.isChecked(); // Allow only if button pushed
      else return true; // We're not interested in this marker; let another filter handle it
    }
Пример #8
0
 private void createCustomMarkerOnResource(IResource resource, int severenity)
     throws CoreException {
   HashMap<String, Object> attributes = new HashMap<String, Object>();
   attributes.put(IMarker.MESSAGE, CUSTOM_MARKER_TEST_MESSAGE);
   attributes.put(IMarker.LINE_NUMBER, 1);
   attributes.put(IMarker.LOCATION, resource.getFullPath().toPortableString());
   attributes.put(IMarker.SEVERITY, severenity);
   MarkerUtilities.createMarker(resource, attributes, CUSTOM_MARKER_ID);
 }
 @Override
 public void executeCommand() throws BadLocationException, CoreException {
   List<IMarker> bookmarks = getCurrentEditorBookmarks();
   if (bookmarks.isEmpty()) {
     setTimedErrorMessage("There are no bookmarks in File to delete!");
     return;
   }
   for (IMarker marker : bookmarks) {
     getEditor().getDeleteLine(MarkerUtilities.getLineNumber(marker) - 1);
     marker.delete();
   }
 }
 /* (non-Javadoc)
  * @see org.eclipse.ui.texteditor.IMarkerUpdater#updateMarker(org.eclipse.core.resources.IMarker, org.eclipse.jface.text.IDocument, org.eclipse.jface.text.Position)
  */
 public boolean updateMarker(IMarker marker, IDocument document, Position position) {
   if (position.isDeleted()) {
     return false;
   }
   IBreakpointManager manager = DebugPlugin.getDefault().getBreakpointManager();
   IBreakpoint breakpoint = manager.getBreakpoint(marker);
   if (breakpoint == null) {
     return false;
   }
   IFile file = (IFile) marker.getResource();
   if (JavaScriptCore.isJavaScriptLikeFileName(file.getName())) {
     IJavaScriptUnit unit = JavaScriptCore.createCompilationUnitFrom(file);
     if (unit == null) {
       return false;
     }
     JavaScriptUnit jsunit =
         JavaScriptPlugin.getDefault().getASTProvider().getAST(unit, ASTProvider.WAIT_YES, null);
     try {
       BreakpointLocationFinder finder =
           new BreakpointLocationFinder(
               jsunit, document.getLineOfOffset(position.getOffset()) + 1, true);
       jsunit.accept(finder);
       if (finder.getLocation() == BreakpointLocationFinder.UNKNOWN) {
         return false;
       }
       int line = finder.getLineNumber();
       if (MarkerUtilities.getLineNumber(marker) == line) {
         // if there exists a breakpoint on the line remove this one
         if (isLineBreakpoint(marker)) {
           ensureRanges(document, marker, line);
           return lineBreakpointExists(
                   marker.getResource(),
                   ((IJavaScriptLineBreakpoint) breakpoint).getScriptPath(),
                   line,
                   marker,
                   true)
               == null;
         }
         return true;
       }
       if (isLineBreakpoint(marker) & line == -1) {
         return false;
       }
       if (lineBreakpointExists(
               marker.getResource(),
               ((IJavaScriptLineBreakpoint) breakpoint).getScriptPath(),
               line,
               marker,
               false)
           != null) {
         return false;
       }
       MarkerUtilities.setLineNumber(marker, line);
       if (isLineBreakpoint(marker)) {
         ensureRanges(document, marker, line);
       }
       return true;
     } catch (BadLocationException ble) {
       JavaScriptDebugUIPlugin.log(ble);
     } catch (CoreException e) {
       JavaScriptDebugUIPlugin.log(e);
     }
   }
   return true;
 }
 /**
  * Returns if the given marker is of the type {@link IJavaScriptLineBreakpoint#MARKER_ID}
  *
  * @param marker
  * @return true if the marker is a {@link IJavaScriptLineBreakpoint} marker
  */
 boolean isLineBreakpoint(IMarker marker) {
   return MarkerUtilities.isMarkerType(marker, IJavaScriptLineBreakpoint.MARKER_ID);
 }
Пример #12
0
  /*
   * @see org.eclipse.jdt.internal.ui.javaeditor.IJavaAnnotation#getMarkerType()
   */
  public String getMarkerType() {
    IMarker marker = getMarker();
    if (marker == null || !marker.exists()) return null;

    return MarkerUtilities.getMarkerType(getMarker());
  }