@Override

    public ValidationResult validate(IResource resource, int kind, ValidationState state, IProgressMonitor monitor) {

        if (ProjectUtils.isPlist(resource)) {

            return validatePlist((IFile) resource);

        } else if (isProject(resource)) {

            return validateProject((IProject) resource);

        } else {

            return null;

        }

    }

    private ValidationResult validateProject(IProject resource) {

        ValidationResult result = new ValidationResult();

        try {

            isPlistPresent(resource, result);

        } catch (CoreException e) {

            Activator.log(e);

        }

        return result;

    }

    private boolean isProject(IResource resource) {

        return resource.getType() == IResource.PROJECT && ProjectUtils.hasWrtNature(resource.getProject());

    }

    private ValidationResult validatePlist(IFile resource) {

        ValidationResult result = new ValidationResult();

        IStructuredModel structuredModel;

        try {

            structuredModel = StructuredModelManager.getModelManager().getModelForRead(resource);

            try {

                if (structuredModel instanceof IDOMModel) {

                    IDOMModel model = (IDOMModel) structuredModel;

                    validateElement((IDOMElement) model.getDocument().getDocumentElement(), result, resource);

                    checkHtml(model, resource, result);

                    checkPlistValues(model, resource, result);

                }

            } finally {

                if (structuredModel != null) {

                    structuredModel.releaseFromRead();

                }

            }

        } catch (IOException e) {

            Activator.log(e);

        } catch (CoreException e) {

            Activator.log(e);

        }

        return result;

    }

    private void validateElement(IDOMElement element, ValidationResult result, IResource resource) {

        // showData("");

        boolean isValidElement = false;

            if (validElement.toString().equalsIgnoreCase(element.getNodeName().trim())) {

                isValidElement = true;

                break;

            }

            continue;

        }

        if (!isValidElement) {

            Object[] arguments = { "   ", element.getNodeName().trim() };

            String message = MessageFormat.format(ValidatorPropMessages.getString("plist.element.not.supported")

                    + "{0}" + "{1}", arguments);

            result.add(createMessage(resource, message, element.getStartOffset(), element.getEndOffset()));

        }

        NodeList childNodes = element.getChildNodes();

        for (int i = 0; i < childNodes.getLength(); i++) {

            Node item = childNodes.item(i);

            if (item.getNodeType() == Node.ELEMENT_NODE) {

                validateElement((IDOMElement) item, result, resource);

            }

        }

    }

    private ValidatorMessage createMessage(IResource resource, String message, int startOffset, int endOffset) {

        ValidatorMessage msg = ValidatorMessage.create(message, resource);

        msg.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);

        msg.setAttribute(IMarker.CHAR_START, startOffset);

        msg.setAttribute(IMarker.CHAR_END, endOffset);

        return msg;

    }

    private boolean checkHtml(IDOMModel model, IFile plist, ValidationResult result) {

        String text = model.getStructuredDocument().get();

        IRegion region = CoreUtil.getIndexFileNameRegion(text);

        boolean checkHtml = false;

        if (region != null) {

            String htmlName = text.substring(region.getOffset(), region.getOffset() + region.getLength());

            IFile htmlFile = null;

            try {

                htmlFile = getFile(plist.getProject(), new Path(htmlName), 0, "html", "htm");

            } catch (CoreException e) {

                Activator.log(e);

            }

            if (htmlFile == null) {

                Object[] arguments = { htmlName, "<>", htmlName };

                String message = MessageFormat.format(ValidatorPropMessages.getString("plist.html.element.mismatch")

                        + "{0}" + "{1}" + "{2}", arguments);

                result.add(createMessage(plist, message, region.getOffset(), region.getOffset() + region.getLength()));

            }

        } else {

            String message = ValidatorPropMessages.getString("plist.html.element.mailHtml.missing");

            ValidatorMessage msg = createMessage(plist, message, 0, 0);

            setMessageOnRootElement(msg, model);

            result.add(msg);

        }

        return checkHtml;

    }

    private void setMessageOnRootElement(ValidatorMessage msg, IDOMModel model) {

        Element element = model.getDocument().getDocumentElement();

        int begin = 0, end = 0;

        if (element instanceof IDOMNode) {

            IDOMNode node = (IDOMNode) element;

            begin = node.getStartOffset();

            end = node.getFirstStructuredDocumentRegion().getEnd();

        }

        msg.setAttribute(IMarker.CHAR_START, begin);

        msg.setAttribute(IMarker.CHAR_END, end);

    }

    private IFile getFile(IContainer container, IPath path, int segment, String... extensions) throws CoreException {

        if (segment + 1 == path.segmentCount()) {

            return getFile(container, path.lastSegment(), extensions);

        } else {

            String name = path.segment(segment).toLowerCase();

            IResource[] members = container.members();

            for (IResource resource : members) {

                if (resource.getName().toLowerCase().equals(name)) {

                    if (resource.getType() == IResource.FOLDER) {

                        return getFile((IContainer) resource, path, segment + 1, extensions);

                    }

                }

            }

        }

        return null;

    }

    private IFile getFile(IContainer container, String lastSegment, String[] extensions) throws CoreException {

        final Set<String> names = new TreeSet<String>();

        names.add(lastSegment.toLowerCase());

        for (String extension : extensions) {

            names.add(lastSegment.concat(".").concat(extension).toLowerCase());

        }

        IResource[] members = container.members();

        for (IResource resource : members) {

            if (resource.getType() == IResource.FILE && names.contains(resource.getName().toLowerCase())

                    && resource.isAccessible()) {

                return (IFile) resource;

            }

        }

        return null;

    }

    private void checkPlistValues(IDOMModel model, IResource plist, ValidationResult result) {

        String source = model.getStructuredDocument().get();

        if (!hasAttributeValue(source, "DisplayName")) {

            Object[] arguments = { " 'Display Name'  ", ValidatorPropMessages.getString("not.in.plist.file") };

            String message = MessageFormat.format(ValidatorPropMessages.getString("plist.mankey.mising") + "{0}"

                    + "{1}", arguments);

            ValidatorMessage msg = createMessage(plist, message, 0, 0);

            setMessageOnRootElement(msg, model);

            result.add(msg);

        } else { /* validating Widget name (Display name) */

            Matcher matcher = CoreUtil.getPropertyLookupPattern("DisplayName").matcher(source);

            if (matcher.find()) {

                String strError = Util.validateWidgetName(matcher.group(1));

                if (strError != null) {

                    Object[] arguments = { " 'Display Name'  ",

                            ValidatorPropMessages.getString("contains.invalid.character") };

                    String message = MessageFormat.format(ValidatorPropMessages.getString("plist.mankey.mising")

                            + "{0}" + "{1}", arguments);

                    ValidatorMessage msg = createMessage(plist, message, matcher.start(), matcher.end());

                    result.add(msg);

                }

            }

        }

        if (!hasAttributeValue(source, "MainHTML")) {

            Object[] arguments = { " 'MainHTML '  ", ValidatorPropMessages.getString("not.in.plist.file") };

            String message = MessageFormat.format(ValidatorPropMessages.getString("plist.mankey.mising") + "{0}"

                    + "{1}", arguments);

            ValidatorMessage msg = createMessage(plist, message, 0, 0);

            setMessageOnRootElement(msg, model);

            result.add(msg);

        }

        if (!hasAttributeValue(source, "Identifier")) {

            Object[] arguments = { " 'Identifier '  ", ValidatorPropMessages.getString("not.in.plist.file") };

            String message = MessageFormat.format(ValidatorPropMessages.getString("plist.mankey.mising") + "{0}"

                    + "{1}", arguments);

            ValidatorMessage msg = createMessage(plist, message, 0, 0);

            setMessageOnRootElement(msg, model);

            result.add(msg);

        } else { /* validating Widget Idenfier (UID) */

            Matcher matcher = CoreUtil.getPropertyLookupPattern("Identifier").matcher(source);

            if (matcher.find()) {

                String strError = Util.validateWidgetID(matcher.group(1));

                if (strError != null) {

                    Object[] arguments = { " 'Identifier'  ",

                            ValidatorPropMessages.getString("contains.invalid.character") };

                    String message = MessageFormat.format(ValidatorPropMessages.getString("plist.mankey.mising")

                            + "{0}" + "{1}", arguments);

                    ValidatorMessage msg = createMessage(plist, message, matcher.start(1), matcher.end(1));

                    result.add(msg);

                }

            }

        }

    }

    private boolean hasAttributeValue(String source, String propertyName) {

        Pattern pattern = CoreUtil.getPropertyLookupPattern(propertyName);

        boolean hasAttr = true;

        Matcher matcher = pattern.matcher(source);

        if (!matcher.find()) {

            hasAttr = false;

        } else {

            hasAttr = matcher.group(1).trim().length() > 0;

        }

        return hasAttr;

    }

    private void isPlistPresent(IProject project, ValidationResult result) throws CoreException {

        IResource[] members = project.members();

        for (IResource resource : members) {

            if (ProjectUtils.isPlist(resource)) {

                return;

            }

        }

        ValidatorMessage msg = ValidatorMessage.create(ValidatorPropMessages.getString("plist.File.Not.Present"),

                project);

        msg.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);

        result.add(msg);

    }