Java Code Examples for org.eclipse.core.resources.IResource#deleteMarkers()

protected boolean doDeleteProjectMarkers(String markerType, IOperationMonitor parentOM) 
		throws OperationCancellation {
	
	try(IOperationSubMonitor om = parentOM.enterSubTask(LangCoreMessages.BUILD_ClearingProblemMarkers)) {
		
		ArrayList2<IResource> resources = ResourceUtils.getResourcesAt(location);
		for (IResource container : resources) {
		try {
			IMarker[] findMarkers = container.findMarkers(markerType, true, IResource.DEPTH_INFINITE);
			parentOM.checkCancellation();
			if(findMarkers.length != 0) {
				container.deleteMarkers(markerType, true, IResource.DEPTH_INFINITE);
				return true;
			}
		} catch (CoreException ce) {
			EclipseCore.logStatus(ce);
		}
		}
	}
	return false;
}
 

/**
 * Delete all error markers from the currently open file.
 * 
 * @param editor The editor to clear the markers from
 */
public void clearErrorMarkers(ITextEditor editor) {
	// talk about ugly code...
    // TODO if this case occurs, then the user has probably not correctly created a project
    // -> we should somehow inform the user
    IResource resource = (IResource) editor.getEditorInput().getAdapter(IResource.class);
    if (resource == null) return;

    try {
        // TODO what should we clear and when?
        // regular problems == parsing errors
        resource.deleteMarkers(IMarker.PROBLEM, false, IResource.DEPTH_INFINITE);
        // builder markers == build problems (don't clean them)
        //resource.deleteMarkers(TexlipseBuilder.MARKER_TYPE, false, IResource.DEPTH_INFINITE);
        // don't clear spelling errors
    } catch (CoreException e) {
        TexlipsePlugin.log("Deleting error markers", e);
    }
}
 

/**
* @generated
*/
public static void deleteMarkers(IResource resource) {
	try {
		resource.deleteMarkers(MARKER_TYPE, true, IResource.DEPTH_ZERO);
	} catch (CoreException e) {
		CrossflowDiagramEditorPlugin.getInstance().logError("Failed to delete validation markers", e); //$NON-NLS-1$
	}
}
 

/**
* @generated
*/
public static void deleteMarkers(IResource resource) {
	try {
		resource.deleteMarkers(MARKER_TYPE, true, IResource.DEPTH_ZERO);
	} catch (CoreException e) {
		ProcessDiagramEditorPlugin.getInstance().logError("Failed to delete validation markers", e); //$NON-NLS-1$
	}
}
 

private static void removeProblemsAndTasksFor(IResource resource)
{
	try
	{
		if (resource != null && resource.isAccessible())
		{
			resource.deleteMarkers(IMarkerConstants.PROBLEM_MARKER, true, IResource.DEPTH_INFINITE);
			resource.deleteMarkers(IMarkerConstants.TASK_MARKER, true, IResource.DEPTH_INFINITE);
		}
	}
	catch (CoreException e)
	{
		// assume there were no problems
	}
}
 

/**
 * This function will remove the markers related to errors.
 * @param resource the file that should have the markers removed
 * @throws CoreException
 */
public static void deleteErrorMarkers(IResource resource) throws CoreException {
    IMarker[] markers = resource.findMarkers(IMarker.PROBLEM, false, IResource.DEPTH_ZERO);
    if (markers.length > 0) {
        resource.deleteMarkers(IMarker.PROBLEM, false, IResource.DEPTH_ZERO);
    }
}
 

public void deleteMarkers(IResource file, boolean isRecursive)
		throws CoreException {
	final int depth;
	if (isRecursive) {
		depth = IResource.DEPTH_INFINITE;
	} else {
		depth = IResource.DEPTH_ZERO;
	}
	file.deleteMarkers(CHECKER_MARKER_TYPE, true, depth);
}
 

/**
 * Removes all status markers from the module.
 */
public static void removeStatusFromModule(IResource module)
{
    try
    {
        module.deleteMarkers(STEP_STATUS_MARKER, true, IResource.DEPTH_ZERO);
    } catch (CoreException e)
    {
        ProverUIActivator.getDefault().logError("Error removing status markers from module " + module, e);
    }
}
 

/**
 * Removes all markers indicating obligation information on  a resource. Does
 * nothing if the resource does not exist. It deletes these markers only at one level
 * under the resource. That is, if the resource is a directory, it deletes markers
 * on its children.
 * 
 * @param resource
 * @throws CoreException 
 */
public static void clearObligationMarkers(IResource resource) throws CoreException
{
    if (resource.exists())
    {
        /*
         * Obligation markers should only be on files directly in the project folder, so we
         * only need to delete markers to depth one. Depth infinite would search any
         * checkpoint folders, which can be slow if there are many files.
         */
        resource.deleteMarkers(OBLIGATION_MARKER, false, IResource.DEPTH_ONE);
    }
}
 

/** 
 * This method is called when the spec is parsed, as well as on other occasions
 * that don't interest us.  It deletes the Show Use markers if the user's preference
 * is to do so and if we can find any to delete.
 */
public boolean eventOccured(SpecEvent event)
{

    if (event.getType() != SpecEvent.TYPE_PARSE)
    {
        return true;
    }

    // Check if user preference is to remove use markers on parse.
    if (!Activator.getDefault().getPreferenceStore().getBoolean(
            EditorPreferencePage.CLEAR_DECLARATION_USE_MARKERS_ON_PARSE)) {
        return true;
    }
    
    // User wants to remove markers.  Remove them if there are any.
    Spec spec = event.getSpec();
    String moduleName = spec.getModuleToShow();
    if (moduleName == null)
    {
        return true;
    }
    IResource resource = ResourceHelper.getResourceByModuleName(moduleName);
    if (resource == null)
    {
        return true;
    }
    try
    {
        resource.deleteMarkers(ShowUsesHandler.SHOW_USE_MARKER_TYPE, false, 99);
    } catch (CoreException e)
    {
        // I don't know why this should ever fail, but there's nothing to be done 
        // if marker deletion fails except to hope that it's because there 
        // weren't any.
    }
    
    return true;

}
 

/**
 * Transitively deletes the given marker type on all modules (including the root
 * module) of the spec.
 */
public void deleteMarker(final String markerType) throws CoreException {
	getRootFile().deleteMarkers(markerType, true, IResource.DEPTH_INFINITE);
	for (IResource r : getModuleResources()) {
		r.deleteMarkers(markerType, true, IResource.DEPTH_INFINITE);
	}
}
 

/**
 * Delete all the problem markers related with current resource
 * 
 * @param resource
 * @throws CoreException
 */
public static void clear( IResource resource ) throws CoreException
{
	if ( resource != null )
	{
		resource.deleteMarkers( PROBLEMS_MARKER_ID, true,
				IResource.DEPTH_INFINITE );
	}
}
 

/**
 * @param original
 * @param pydevCoverageMarker
 */
public static void removeMarkers(IResource resource, String markerType) {
    if (resource == null) {
        return;
    }
    try {
        resource.deleteMarkers(markerType, false, IResource.DEPTH_ZERO);
    } catch (Exception e) {
        Log.log(e);
    }
}
 

/**
 * Clears the task markers
 * 
 * @param editor The editor to clear the markers from
 */
public void clearTaskMarkers(ITextEditor editor) {
    IResource resource = (IResource) editor.getEditorInput().getAdapter(IResource.class);
    if (resource == null) return;
    try {
        resource.deleteMarkers(IMarker.TASK, false, IResource.DEPTH_INFINITE);
    } catch (CoreException e) {
        TexlipsePlugin.log("Deleting task markers", e);
    }
}
 

/**
 * Clears the problem markers (such as parsing errors)
 * 
 * @param resource The resource whose markers to clear
 */
public void clearProblemMarkers(IResource resource) {
    try {
        resource.deleteMarkers(IMarker.PROBLEM, false, IResource.DEPTH_INFINITE);
    } catch (CoreException e) {
        TexlipsePlugin.log("Deleting error markers", e);
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {

  for (IResource resource : mResourcesToClear) {
    if (resource.isAccessible()) {
      resource.deleteMarkers(CheckstyleMarker.MARKER_ID, true, IResource.DEPTH_INFINITE);
    }
  }

  return Status.OK_STATUS;
}
 

public static void deleteTscMarker(IResource resource) throws CoreException {
	resource.deleteMarkers(TSC_MARKER_TYPE, true, IResource.DEPTH_INFINITE);
}
 

/**
 * Deletes existed problem markers and adds new markers
 * 
 * @throws CoreException
 */
public void refreshMarkers( IEditorInput input ) throws CoreException
{
	IResource file = getFile( input );
	if ( file != null )
	{
		// Deletes existed markers
		file.deleteMarkers( ProblemMarkID, true, IResource.DEPTH_INFINITE );

		// Adds markers
		ModuleHandle reportDesignHandle = getModel( );
		if ( reportDesignHandle == null )
		{
			return;
		}

		// Model said that should checkReport( ) before getting error and
		// warning list.
		reportDesignHandle.checkReportIfNecessary( );
		List list = reportDesignHandle.getErrorList( );
		int errorListSize = list.size( );
		list.addAll( reportDesignHandle.getWarningList( ) );

		for ( int i = 0, m = list.size( ); i < m; i++ )
		{
			ErrorDetail errorDetail = (ErrorDetail) list.get( i );
			IMarker marker = file.createMarker( ProblemMarkID );

			Map<String, Object> attrib = new HashMap<String, Object>( );

			// The first part is from error list, the other is from warning
			// list
			if ( i < errorListSize )
			{
				attrib.put( IMarker.SEVERITY, IMarker.SEVERITY_ERROR );
			}
			else
			{
				attrib.put( IMarker.SEVERITY, IMarker.SEVERITY_WARNING );
			}

			attrib.put( IMarker.MESSAGE, errorDetail.getMessage( ) );
			attrib.put( IMarker.LINE_NUMBER, errorDetail.getLineNo( ) );
			attrib.put( IMarker.LOCATION, errorDetail.getTagName( ) );

			if ( errorDetail.getElement( ) != null
					&& errorDetail.getElement( ).getID( ) != 0 )
			{
				attrib.put( ELEMENT_ID,
						Integer.valueOf( (int) errorDetail.getElement( )
								.getID( ) ) );
			}

			// set all attributes together to reduce notification events
			marker.setAttributes( attrib );
		}
	}
}
 

/**
 * Removes all SANY step markers on the module.
 * See {@link ProverHelper#SANY_MARKER} for a description of
 * these markers.
 * 
 * @param module
 * @throws CoreException 
 */
public static void removeSANYStepMarkers(IResource module) throws CoreException
{
    module.deleteMarkers(SANY_MARKER, false, IResource.DEPTH_ZERO);
}
 

/**
 *  Deletes xds build markers on given resource, and, 
 * optionally, deletes such markers from its children.  If <code>includeSubtypes</code>
 * is <code>false</code>, only markers whose type exactly matches 
 * the given type are deleted.  
 * <p/>
 * @param resource where to delete markers
 * @param includeSubtypes whether or not to consider sub-types of the given type
 * @param depth how far to recurse (see <code>IResource.DEPTH_* </code>)
 * @throws CoreException
 */
public static void deleteBuildProblemMarkers(IResource resource, boolean isIncludeSubtypes, int depth) throws CoreException {
	resource.deleteMarkers(XdsMarkerConstants.BUILD_PROBLEM_MARKER_TYPE, isIncludeSubtypes, depth);
}