Ejemplo n.º 1
0
  /**
   * @param file the file to get the model for
   * @return the file's XMLModel
   */
  protected IDOMModel getModelForResource(IFile file) {
    IStructuredModel model = null;
    IModelManager manager = StructuredModelManager.getModelManager();

    try {
      model = manager.getModelForRead(file);
      // TODO.. HTML validator tries again to get a model a 2nd way
    } catch (Exception e) {
      // e.printStackTrace();
    }
    return model instanceof IDOMModel ? (IDOMModel) model : null;
  }
  /** Be sure to release any models obtained from this method. */
  IStructuredModel getTestModel() throws IOException, CoreException {

    IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(fProjectName);
    IFile iFile = (IFile) project.findMember("/files/simple.xml");
    // fProjectName + "/files/simple.xml"

    IStructuredModel model = null;
    IModelManager modelManager = StructuredModelManager.getModelManager();

    model = modelManager.getModelForEdit(iFile);

    return model;
  }
Ejemplo n.º 3
0
      @Override
      public IStructuredModel getModelForRead() {
        IModelManager mm = StructuredModelManager.getModelManager();
        if (mm != null) {
          try {
            return mm.getModelForRead(mFile);
          } catch (Exception e) {
            fail(e.toString());
          }
        }

        return null;
      }
  private boolean addXmlFileChanges(IFile file, CompositeChange changes, boolean isManifest) {
    IModelManager modelManager = StructuredModelManager.getModelManager();
    IStructuredModel model = null;
    try {
      model = modelManager.getExistingModelForRead(file);
      if (model == null) {
        model = modelManager.getModelForRead(file);
      }
      if (model != null) {
        IStructuredDocument document = model.getStructuredDocument();
        if (model instanceof IDOMModel) {
          IDOMModel domModel = (IDOMModel) model;
          Element root = domModel.getDocument().getDocumentElement();
          if (root != null) {
            List<TextEdit> edits = new ArrayList<TextEdit>();
            if (isManifest) {
              addManifestReplacements(edits, root, document);
            } else {
              addLayoutReplacements(edits, root, document);
            }
            if (!edits.isEmpty()) {
              MultiTextEdit rootEdit = new MultiTextEdit();
              rootEdit.addChildren(edits.toArray(new TextEdit[edits.size()]));
              TextFileChange change = new TextFileChange(file.getName(), file);
              change.setTextType(EXT_XML);
              change.setEdit(rootEdit);
              changes.add(change);
            }
          }
        } else {
          return false;
        }
      }

      return true;
    } catch (IOException e) {
      AdtPlugin.log(e, null);
    } catch (CoreException e) {
      AdtPlugin.log(e, null);
    } finally {
      if (model != null) {
        model.releaseFromRead();
      }
    }

    return false;
  }
Ejemplo n.º 5
0
    /**
     * Returns the content type of document
     *
     * @param document - assumes document is not null
     * @return String content type of given document
     */
    private String getContentType() {
      String type = null;

      IModelManager mgr = StructuredModelManager.getModelManager();
      IStructuredModel model = null;
      try {
        model = mgr.getExistingModelForRead(document);
        if (model != null) {
          type = model.getContentTypeIdentifier();
        }
      } finally {
        if (model != null) {
          model.releaseFromRead();
        }
      }
      return type;
    }
  /**
   * Method validateEdit.
   *
   * @param file org.eclipse.core.resources.IFile
   * @param context org.eclipse.swt.widgets.Shell
   * @return IStatus
   */
  private static IStatus validateEdit(IFile file, Shell context) {
    if (file == null || !file.exists()) return STATUS_ERROR;
    if (!(file.isReadOnly())) return STATUS_OK;

    IPath location = file.getLocation();

    final long beforeModifiedFromJavaIO =
        (location != null) ? location.toFile().lastModified() : IResource.NULL_STAMP;
    final long beforeModifiedFromIFile = file.getModificationStamp();

    IStatus status = ResourcesPlugin.getWorkspace().validateEdit(new IFile[] {file}, context);
    if (!status.isOK()) return status;

    final long afterModifiedFromJavaIO =
        (location != null) ? location.toFile().lastModified() : IResource.NULL_STAMP;
    final long afterModifiedFromIFile = file.getModificationStamp();

    if (beforeModifiedFromJavaIO != afterModifiedFromJavaIO
        || beforeModifiedFromIFile != afterModifiedFromIFile) {
      IModelManager manager = StructuredModelManager.getModelManager();
      IStructuredModel model = manager.getExistingModelForRead(file);
      if (model != null) {
        if (!model.isDirty()) {
          try {
            file.refreshLocal(IResource.DEPTH_ONE, null);
          } catch (CoreException e) {
            return STATUS_ERROR;
          } finally {
            model.releaseFromRead();
          }
        } else {
          model.releaseFromRead();
        }
      }
    }

    if ((beforeModifiedFromJavaIO != afterModifiedFromJavaIO)
        || (beforeModifiedFromIFile != afterModifiedFromIFile)) {
      // the file is replaced. Modification cannot be
      // applied.
      return STATUS_ERROR;
    }
    return STATUS_OK;
  }
  /**
   * 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;
  }
  public void customizeDocumentCommand(IDocument document, DocumentCommand c) {
    if (!isSmartInsertMode()) {
      return;
    }

    if (!(document instanceof IStructuredDocument)) {
      // This shouldn't happen unless this strategy is used on an invalid document
      return;
    }
    IStructuredDocument doc = (IStructuredDocument) document;

    // Handle newlines/indentation
    if (c.length == 0
        && c.text != null
        && TextUtilities.endsWith(doc.getLegalLineDelimiters(), c.text) != -1) {

      IModelManager modelManager = StructuredModelManager.getModelManager();
      IStructuredModel model = modelManager.getModelForRead(doc);
      if (model != null) {
        try {
          final int offset = c.offset;
          int lineStart = findLineStart(doc, offset);
          int textStart = findTextStart(doc, lineStart, offset);

          IStructuredDocumentRegion region = doc.getRegionAtCharacterOffset(textStart);
          if (region != null && region.getType().equals(XML_TAG_NAME)) {
            Pair<Integer, Integer> balance = getBalance(doc, textStart, offset);
            int tagBalance = balance.getFirst();
            int bracketBalance = balance.getSecond();

            String lineIndent = ""; // $NON-NLS-1$
            if (textStart > lineStart) {
              lineIndent = doc.get(lineStart, textStart - lineStart);
            }

            // We only care if tag or bracket balance is greater than 0;
            // we never *dedent* on negative balances
            boolean addIndent = false;
            if (bracketBalance < 0) {
              // Handle
              //    <foo
              //        ></foo>^
              // and
              //    <foo
              //        />^
              ITextRegion left = getRegionAt(doc, offset, true /*biasLeft*/);
              if (left != null
                  && (left.getType().equals(XML_TAG_CLOSE)
                      || left.getType().equals(XML_EMPTY_TAG_CLOSE))) {

                // Find the corresponding open tag...
                // The org.eclipse.wst.xml.ui.gotoMatchingTag frequently
                // doesn't work, it just says "No matching brace found"
                // (or I would use that here).

                int targetBalance = 0;
                ITextRegion right = getRegionAt(doc, offset, false /*biasLeft*/);
                if (right != null && right.getType().equals(XML_END_TAG_OPEN)) {
                  targetBalance = -1;
                }
                int openTag =
                    AndroidXmlCharacterMatcher.findTagBackwards(doc, offset, targetBalance);
                if (openTag != -1) {
                  // Look up the indentation of the given line
                  lineIndent = AndroidXmlEditor.getIndentAtOffset(doc, openTag);
                }
              }
            } else if (tagBalance > 0 || bracketBalance > 0) {
              // Add indentation
              addIndent = true;
            }

            StringBuilder sb = new StringBuilder(c.text);
            sb.append(lineIndent);
            String oneIndentUnit = XmlFormatPreferences.create().getOneIndentUnit();
            if (addIndent) {
              sb.append(oneIndentUnit);
            }

            // Handle
            //     <foo>^</foo>
            // turning into
            //     <foo>
            //         ^
            //     </foo>
            ITextRegion left = getRegionAt(doc, offset, true /*biasLeft*/);
            ITextRegion right = getRegionAt(doc, offset, false /*biasLeft*/);
            if (left != null
                && right != null
                && left.getType().equals(XML_TAG_CLOSE)
                && right.getType().equals(XML_END_TAG_OPEN)) {
              // Move end tag
              if (tagBalance > 0 && bracketBalance < 0) {
                sb.append(oneIndentUnit);
              }
              c.caretOffset = offset + sb.length();
              c.shiftsCaret = false;
              sb.append(TextUtilities.getDefaultLineDelimiter(doc));
              sb.append(lineIndent);
            }
            c.text = sb.toString();
          } else if (region != null && region.getType().equals(XML_CONTENT)) {
            // Indenting in text content. If you're in the middle of editing
            // text, just copy the current line indentation.
            // However, if you're editing in leading whitespace (e.g. you press
            // newline on a blank line following say an element) then figure
            // out the indentation as if the newline had been pressed at the
            // end of the element, and insert that amount of indentation.
            // In this case we need to also make sure to subtract any existing
            // whitespace on the current line such that if we have
            //
            // <foo>
            // ^   <bar/>
            // </foo>
            //
            // you end up with
            //
            // <foo>
            //
            //    ^<bar/>
            // </foo>
            //
            String text = region.getText();
            int regionStart = region.getStartOffset();
            int delta = offset - regionStart;
            boolean inWhitespacePrefix = true;
            for (int i = 0, n = Math.min(delta, text.length()); i < n; i++) {
              char ch = text.charAt(i);
              if (!Character.isWhitespace(ch)) {
                inWhitespacePrefix = false;
                break;
              }
            }
            if (inWhitespacePrefix) {
              IStructuredDocumentRegion previous = region.getPrevious();
              if (previous != null && previous.getType() == XML_TAG_NAME) {
                ITextRegionList subRegions = previous.getRegions();
                ITextRegion last = subRegions.get(subRegions.size() - 1);
                if (last.getType() == XML_TAG_CLOSE || last.getType() == XML_EMPTY_TAG_CLOSE) {
                  int begin =
                      AndroidXmlCharacterMatcher.findTagBackwards(
                          doc, previous.getStartOffset() + last.getStart(), 0);
                  int prevLineStart = findLineStart(doc, begin);
                  int prevTextStart = findTextStart(doc, prevLineStart, begin);

                  String lineIndent = ""; // $NON-NLS-1$
                  if (prevTextStart > prevLineStart) {
                    lineIndent = doc.get(prevLineStart, prevTextStart - prevLineStart);
                  }
                  StringBuilder sb = new StringBuilder(c.text);
                  sb.append(lineIndent);
                  String oneIndentUnit = XmlFormatPreferences.create().getOneIndentUnit();

                  // See if there is whitespace on the insert line that
                  // we should also remove
                  for (int i = delta, n = text.length(); i < n; i++) {
                    char ch = text.charAt(i);
                    if (ch == ' ') {
                      c.length++;
                    } else {
                      break;
                    }
                  }
                  boolean onClosingTagLine = false;
                  if (text.indexOf('\n', delta) == -1) {
                    IStructuredDocumentRegion next = region.getNext();
                    if (next != null && next.getType() == XML_TAG_NAME) {
                      String nextType = next.getRegions().get(0).getType();
                      if (nextType == XML_END_TAG_OPEN) {
                        onClosingTagLine = true;
                      }
                    }
                  }

                  boolean addIndent = (last.getType() == XML_TAG_CLOSE) && !onClosingTagLine;
                  if (addIndent) {
                    sb.append(oneIndentUnit);
                  }
                  c.text = sb.toString();

                  return;
                }
              }
            }
            copyPreviousLineIndentation(doc, c);
          } else {
            copyPreviousLineIndentation(doc, c);
          }
        } catch (BadLocationException e) {
          AdtPlugin.log(e, null);
        } finally {
          model.releaseFromRead();
        }
      }
    }
  }
  @Override
  protected void configureJBossAppXml() {
    IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(earProjectName);
    IVirtualComponent component = ComponentCore.createComponent(project);
    IVirtualFolder folder = component.getRootFolder();
    IFolder rootFolder = (IFolder) folder.getUnderlyingFolder();
    IResource jbossAppXml = rootFolder.findMember("META-INF/jboss-app.xml");
    if (jbossAppXml == null || !(jbossAppXml instanceof IFile) || !jbossAppXml.exists()) {
      return;
    }

    IModelManager manager = StructuredModelManager.getModelManager();
    if (manager == null) {
      return;
    }
    IStructuredModel model = null;
    try {
      model = manager.getModelForEdit((IFile) jbossAppXml);
      if (model instanceof IDOMModel) {
        IDOMModel domModel = (IDOMModel) model;
        IDOMDocument document = domModel.getDocument();
        Element root = document.getDocumentElement();
        if (root == null) {
          return;
        }
        NodeList children = root.getChildNodes();
        boolean strictAdded = false;
        Node firstChild = null;
        for (int i = 0; i < children.getLength(); i++) {
          Node currentNode = children.item(i);
          if (Node.ELEMENT_NODE == currentNode.getNodeType() && firstChild == null) {
            firstChild = currentNode;
          }
          if (Node.ELEMENT_NODE == currentNode.getNodeType()
              && MODULE_ORDER.equals(currentNode.getNodeName())) {
            setValue(document, currentNode, STRICT);
            strictAdded = true;
          }
        }
        if (!strictAdded) {
          Element moduleOrder = document.createElement(MODULE_ORDER);
          setValue(document, moduleOrder, STRICT);
          if (firstChild != null) {
            root.insertBefore(moduleOrder, firstChild);
          } else {
            root.appendChild(moduleOrder);
          }
        }
        model.save();
      }
    } catch (CoreException e) {
      SeamCorePlugin.getDefault().logError(e);
    } catch (IOException e) {
      SeamCorePlugin.getDefault().logError(e);
    } finally {
      if (model != null) {
        model.releaseFromEdit();
      }
    }
    try {
      new FormatProcessorXML().formatFile((IFile) jbossAppXml);
    } catch (IOException e) {
      SeamCorePlugin.getDefault().logError(e);
    } catch (CoreException e) {
      SeamCorePlugin.getDefault().logError(e);
    }
  }
  /**
   * must release model (from edit) after
   *
   * @param filename relative to this class (TestStructuredPartitioner)
   */
  private IStructuredModel getModelForEdit(final String filename) {

    IStructuredModel model = null;
    try {
      IModelManager modelManager = StructuredModelManager.getModelManager();
      InputStream inStream = getClass().getResourceAsStream(filename);
      if (inStream == null)
        throw new FileNotFoundException("Can't file resource stream " + filename);
      final String baseFile = getClass().getResource(filename).toString();
      model =
          modelManager.getModelForEdit(
              baseFile,
              inStream,
              new URIResolver() {

                String fBase = baseFile;

                public String getFileBaseLocation() {
                  return fBase;
                }

                public String getLocationByURI(String uri) {
                  return getLocationByURI(uri, fBase);
                }

                public String getLocationByURI(String uri, boolean resolveCrossProjectLinks) {
                  return getLocationByURI(uri);
                }

                public String getLocationByURI(String uri, String baseReference) {
                  int lastSlash = baseReference.lastIndexOf("/");
                  if (lastSlash > 0) return baseReference.substring(0, lastSlash + 1) + uri;
                  return baseReference;
                }

                public String getLocationByURI(
                    String uri, String baseReference, boolean resolveCrossProjectLinks) {
                  return getLocationByURI(uri, baseReference);
                }

                public IProject getProject() {
                  return null;
                }

                public IContainer getRootLocation() {
                  return null;
                }

                public InputStream getURIStream(String uri) {
                  return getClass().getResourceAsStream(getLocationByURI(uri));
                }

                public void setFileBaseLocation(String newLocation) {
                  this.fBase = newLocation;
                }

                public void setProject(IProject newProject) {}
              });
    } catch (IOException ex) {
      ex.printStackTrace();
    }
    return model;
  }