public List collectJSONNodes(IStructuredModel model, int start, int length) {
    List nodes = new ArrayList();

    IndexedRegion startNode = model.getIndexedRegion(start);
    IndexedRegion endNode = model.getIndexedRegion(start + length - 1);

    if (startNode == null || endNode == null) {
      return nodes;
    }

    if (model instanceof IJSONModel
        && startNode instanceof IJSONNode
        && endNode instanceof IJSONNode) {
      // JSON model
      IJSONNode ca = getCommonAncestor((IJSONNode) startNode, (IJSONNode) endNode);
      if (ca != null) {
        for (IJSONNode node = ca.getFirstChild();
            node != null && start + length < ((IndexedRegion) node).getStartOffset();
            node = node.getNextSibling()) {
          if (start < ((IndexedRegion) node).getEndOffset()) {
            nodes.add(node);
          }
        }
      }
    }
    return nodes;
  }
Ejemplo n.º 2
0
 /**
  * To see whether the textSelection start and end are on the same.
  *
  * @param model
  * @param textSelection
  * @return the node
  */
 static boolean isSame(IStructuredModel model, TextSelection textSelection) {
   if (model != null && textSelection != null) {
     int t1 = textSelection.getOffset();
     int t2 = textSelection.getLength() + t1;
     return model.getIndexedRegion(t1) == model.getIndexedRegion(t2);
   }
   return false;
 }
 protected IndexedRegion getCorrespondingNode(IStructuredDocumentRegion sdRegion) {
   IStructuredModel sModel =
       StructuredModelManager.getModelManager().getExistingModelForRead(fDocument);
   IndexedRegion indexedRegion = null;
   try {
     if (sModel != null) indexedRegion = sModel.getIndexedRegion(sdRegion.getStart());
   } finally {
     if (sModel != null) sModel.releaseFromRead();
   }
   return indexedRegion;
 }
 public void testGetIndexedRegion() throws IOException, CoreException {
   IStructuredModel model = getTestModel();
   try {
     model.getIndexedRegion(0);
     assertTrue(true);
   } finally {
     if (model != null) {
       model.releaseFromEdit();
     }
   }
 }
Ejemplo n.º 5
0
 /**
  * Get node at indexed position.
  *
  * @param model
  * @param position
  * @return the node at position
  */
 static Node getNodeAt(IStructuredModel model, int position) {
   try {
     IndexedRegion region = model.getIndexedRegion(position);
     if (region instanceof Node) {
       return (Node) region;
     }
     return null;
   } catch (Exception e) {
     // "Error in region node creation"
     _log.error("Error.EditModelQuery.1", e); // $NON-NLS-1$
     return null;
   }
 }
  /**
   * Returns the closest IndexedRegion for the offset and viewer allowing for differences between
   * viewer offsets and model positions. note: this method returns an IndexedRegion for read only
   *
   * @param viewer the viewer whose document is used to compute the proposals
   * @param documentOffset an offset within the document for which completions should be computed
   * @return an IndexedRegion
   */
  public static IndexedRegion getNodeAt(ITextViewer viewer, int documentOffset) {

    if (viewer == null) return null;

    IndexedRegion node = null;
    IModelManager mm = StructuredModelManager.getModelManager();
    IStructuredModel model = null;
    if (mm != null) model = mm.getExistingModelForRead(viewer.getDocument());
    try {
      if (model != null) {
        int lastOffset = documentOffset;
        node = model.getIndexedRegion(documentOffset);
        while (node == null && lastOffset >= 0) {
          lastOffset--;
          node = model.getIndexedRegion(lastOffset);
        }
      }
    } finally {
      if (model != null) model.releaseFromRead();
    }
    return node;
  }
Ejemplo n.º 7
0
 /**
  * originally copied from org.eclipse.wst.xml.ui.internal.hyperlink.XMLHyperlinkDetector this
  * method grabs the IDOMModel for the IDocument, performs the passed operation on the node at the
  * offset and then releases the IDOMModel operation's Node value is also an instance of
  * IndexedRegion
  *
  * @param offset
  */
 public static void performOnCurrentElement(
     IDocument document, int offset, NodeOperation<Node> operation) {
   assert document != null;
   assert operation != null;
   // get the current node at the offset (returns either: element,
   // doctype, text)
   IStructuredModel sModel = null;
   try {
     sModel = StructuredModelManager.getModelManager().getExistingModelForRead(document);
     if (sModel != null) {
       IndexedRegion inode = sModel.getIndexedRegion(offset);
       if (inode == null) {
         inode = sModel.getIndexedRegion(offset - 1);
       }
       if (inode instanceof Node) {
         operation.process((Node) inode, sModel.getStructuredDocument());
       }
     }
   } finally {
     if (sModel != null) {
       sModel.releaseFromRead();
     }
   }
 }
Ejemplo n.º 8
0
 /**
  * To see if the range and text selection covered the same range.
  *
  * @param model
  * @param range
  * @param textSelection
  * @return true if same
  */
 static boolean isSame(IStructuredModel model, DesignRange range, TextSelection textSelection) {
   if (model != null && range != null && textSelection != null) {
     int t1 = textSelection.getOffset();
     int t2 = textSelection.getLength() + t1;
     int r1 = getIndexedRegionLocation(DOMRangeHelper.toDOMRange(range).getStartPosition());
     int r2 = getIndexedRegionLocation(DOMRangeHelper.toDOMRange(range).getEndPosition());
     return (model.getIndexedRegion(t1) == model.getIndexedRegion(r1)
             && //
             model.getIndexedRegion(t2) == model.getIndexedRegion(r2))
         || (model.getIndexedRegion(t2) == model.getIndexedRegion(r1)
             && //
             model.getIndexedRegion(t1) == model.getIndexedRegion(r2));
   }
   return false;
 }
  /**
   * This validate call is for the ISourceValidator partial document validation approach
   *
   * @param dirtyRegion
   * @param helper
   * @param reporter
   * @see org.eclipse.wst.sse.ui.internal.reconcile.validator.ISourceValidator
   */
  public void validate(IRegion dirtyRegion, IValidationContext helper, IReporter reporter) {
    if (helper == null || fDocument == null || !fEnableSourceValidation) return;

    if ((reporter != null) && (reporter.isCancelled() == true)) {
      throw new OperationCanceledException();
    }

    IStructuredModel model =
        StructuredModelManager.getModelManager().getExistingModelForRead(fDocument);
    if (model == null) return; // error

    try {

      IDOMDocument document = null;
      if (model instanceof IDOMModel) {
        document = ((IDOMModel) model).getDocument();
      }

      if (document == null || !hasHTMLFeature(document)) return; // ignore

      ITextFileBuffer fb = FileBufferModelManager.getInstance().getBuffer(fDocument);
      if (fb == null) return;

      IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(fb.getLocation());
      if (file == null || !file.exists()) return;

      // this will be the wrong region if it's Text (instead of Element)
      // we don't know how to validate Text
      IndexedRegion ir =
          getCoveringNode(dirtyRegion); // model.getIndexedRegion(dirtyRegion.getOffset());
      if (ir instanceof Text) {
        while (ir != null && ir instanceof Text) {
          // it's assumed that this gets the IndexedRegion to
          // the right of the end offset
          ir = model.getIndexedRegion(ir.getEndOffset());
        }
      }

      if (ir instanceof INodeNotifier) {

        INodeAdapterFactory factory = HTMLValidationAdapterFactory.getInstance();
        ValidationAdapter adapter = (ValidationAdapter) factory.adapt((INodeNotifier) ir);
        if (adapter == null) return; // error

        if (reporter != null) {
          HTMLValidationReporter rep = null;
          rep = getReporter(reporter, file, (IDOMModel) model);
          rep.clear();
          adapter.setReporter(rep);

          Message mess =
              new LocalizedMessage(
                  IMessage.LOW_SEVERITY, file.getFullPath().toString().substring(1));
          reporter.displaySubtask(this, mess);
        }
        adapter.validate(ir);
      }
    } finally {
      if (model != null) model.releaseFromRead();
    }
  }
  /*
   * Search the RegionContainer's regions looking for JSP content. If valid
   * content is found, return the position >= 0 If no valid content is
   * found, return NO_VALID_CONTENT. If a region starts after the line's
   * endOffset, return END_OF_LINE.
   */
  private static int getValidRegionPosition(
      IStructuredModel model,
      ITextRegionCollection regionContainer,
      int startOffset,
      int endOffset) {

    ITextRegionList regions = regionContainer.getRegions();
    for (int i = 0; i < regions.size(); i++) {
      ITextRegion region = regions.get(i);
      if (region instanceof ITextRegionCollection) {
        int validPosition =
            getValidRegionPosition(model, (ITextRegionCollection) region, startOffset, endOffset);
        if (validPosition == END_OF_LINE || validPosition >= 0) return validPosition;
      } else {
        // region must be at least partially on selected line
        if (regionContainer.getEndOffset(region) > startOffset) {

          int regionStartOffset = regionContainer.getStartOffset(region);
          // if region starts after line's endOffset, we're done
          // searching
          if (regionStartOffset > endOffset) return END_OF_LINE;

          // If region is JSP content, make sure the language is
          // Java not Javascript by
          // checking the content assist adapter's type.
          if (region.getType().equals(DOMJSPRegionContexts.JSP_CONTENT)) {
            // DWM: this logic is not incorrect ... given changes
            // to adapters, etc.
            // but probably don't need anything here, since both
            // Java and JavaScript
            // are supported in V5.

            // nsd_TODO: verify this!!!

            // INodeNotifier notifier =
            // (INodeNotifier)model.getNode(region.getStartOffset());
            // IAdapterFactory factory =
            // model.getFactoryRegistry().getFactoryFor(ContentAssistAdapter.class);
            // if(factory instanceof
            // HTMLContentAssistAdapterFactory) {
            // INodeAdapter adapter =
            // ((HTMLContentAssistAdapterFactory)factory).createAdapter(notifier,
            // region);
            // if(adapter != null && adapter instanceof
            // JSPJavaContentAssistAdapter)

            if (regionStartOffset > startOffset) return regionStartOffset;
            else return startOffset;
            // }
          }
          // a custom tag, jsp:useBean, getproperty or setproperty
          // statement is also a valid breakpoint location
          else if (region.getType().equals(DOMRegionContext.XML_TAG_NAME)
              && (isCustomTagRegion(model.getIndexedRegion(regionStartOffset))
                  || regionContainer.getText(region).equals(JSP12Namespace.ElementName.USEBEAN)
                  || regionContainer.getText(region).equals(JSP12Namespace.ElementName.GETPROPERTY)
                  || regionContainer
                      .getText(region)
                      .equals(JSP12Namespace.ElementName.SETPROPERTY))) {

            if (regionStartOffset > startOffset) return regionStartOffset;
            else return startOffset;
          } else {
            // Defect #241090, the Text Nodes inside of JSP
            // scriptlets, expressions, and declarations are valid
            // breakpoint-able locations
            boolean isCodeNode = false;
            IndexedRegion node = model.getIndexedRegion(regionStartOffset);
            if (node != null && node instanceof Node) {
              Node domNode = (Node) node;
              Node root = domNode.getOwnerDocument().getDocumentElement();
              if (root != null
                  && root.getNodeName().equals(JSP12Namespace.ElementName.ROOT)
                  && domNode.getNodeType() == Node.TEXT_NODE
                  && domNode.getParentNode() != null) {
                String parentName = domNode.getParentNode().getNodeName();
                isCodeNode =
                    parentName.equals(JSP12Namespace.ElementName.SCRIPTLET)
                        || parentName.equals(JSP12Namespace.ElementName.EXPRESSION)
                        || parentName.equals(JSP12Namespace.ElementName.DECLARATION);
              }
            }
            if (isCodeNode) {
              if (regionStartOffset > startOffset) return regionStartOffset;
              else return startOffset;
            }
          }
        }
      }
    }
    return NO_VALID_CONTENT;
  }
Ejemplo n.º 11
0
 /**
  * Get a node that is at Indexed position 'pos' in 'model'.
  *
  * @param model
  * @param pos
  * @return the
  */
 IndexedRegion getPosNode(IStructuredModel model, int pos) {
   IndexedRegion inode = model.getIndexedRegion(pos);
   return inode;
 }