Java NbDocument.findLineOffset方法代码示例

import org.openide.text.NbDocument; //导入方法依赖的package包/类
static int[] computeLineSpan(Document doc, int lineNumber) throws BadLocationException {
    lineNumber = Math.min(lineNumber, NbDocument.findLineRootElement((StyledDocument) doc).getElementCount());
    
    int lineStartOffset = NbDocument.findLineOffset((StyledDocument) doc, Math.max(0, lineNumber - 1));
    int lineEndOffset;
    
    if (doc instanceof BaseDocument) {
        lineEndOffset = Utilities.getRowEnd((BaseDocument) doc, lineStartOffset);
    } else {
        //XXX: performance:
        String lineText = doc.getText(lineStartOffset, doc.getLength() - lineStartOffset);
        
        lineText = lineText.indexOf('\n') != (-1) ? lineText.substring(0, lineText.indexOf('\n')) : lineText;
        lineEndOffset = lineStartOffset + lineText.length();
    }
    
    int[] span = new int[] {lineStartOffset, lineEndOffset};
    
    computeLineSpan(doc, span);
    
    return span;
}
 

import org.openide.text.NbDocument; //导入方法依赖的package包/类
private static boolean openFileAtOffset(DataObject dataObject, int offset) throws IOException {
    EditorCookie ec = dataObject.getCookie(EditorCookie.class);
    LineCookie lc = dataObject.getCookie(LineCookie.class);
    if (ec != null && lc != null) {
        StyledDocument doc = ec.openDocument();
        if (doc != null) {
            int lineNumber = NbDocument.findLineNumber(doc, offset);
            if (lineNumber != -1) {
                Line line = lc.getLineSet().getCurrent(lineNumber);
                if (line != null) {
                    int lineOffset = NbDocument.findLineOffset(doc, lineNumber);
                    int column = offset - lineOffset;
                    line.show(ShowOpenType.OPEN, ShowVisibilityType.FOCUS, column);
                    return true;
                }
            }
        }
    }
    return false;
}
 

import org.openide.text.NbDocument; //导入方法依赖的package包/类
public String toString () {
        int offset = next (1) == null ?
            doc.getLength () : next (1).getOffset ();
        int lineNumber = NbDocument.findLineNumber (doc, offset);
        return (String) doc.getProperty ("title") + ":" + 
            (lineNumber + 1) + "," + 
            (offset - NbDocument.findLineOffset (doc, lineNumber) + 1);
//        StringBuffer sb = new StringBuffer ();
//        TokenItem t = next;
//        int i = 0;
//        while (i < 10) {
//            if (t == null) break;
//            EditorToken et = (EditorToken) t.getTokenID ();
//            sb.append (Token.create (
//                et.getMimeType (),
//                et.getType (),
//                t.getImage (),
//                null
//            ));
//            t = t.getNext ();
//            i++;
//        }
//        return sb.toString ();
    }
 

import org.openide.text.NbDocument; //导入方法依赖的package包/类
private static boolean isEmpty (
    int                     ln,
    StyledDocument          document,
    Set<Integer>            whitespaces
) throws BadLocationException {
    int start = NbDocument.findLineOffset (document, ln);
    int end = document.getLength ();
    try {
        end = NbDocument.findLineOffset (document, ln + 1) - 1;
    } catch (IndexOutOfBoundsException ex) {
    }
    TokenSequence ts = Utils.getTokenSequence (document, start);
    if (ts.token () == null) return true;
    while (whitespaces.contains (ts.token ().id ().ordinal ())) {
        if (!ts.moveNext ()) return true;
        if (ts.offset () > end) return true;
    }
    return false;
}
 

import org.openide.text.NbDocument; //导入方法依赖的package包/类
public static HighlightImpl parse(StyledDocument doc, String line) throws ParseException, BadLocationException {
    MessageFormat f = new MessageFormat("[{0}], {1,number,integer}:{2,number,integer}-{3,number,integer}:{4,number,integer}");
    Object[] args = f.parse(line);
    
    String attributesString = (String) args[0];
    int    lineStart  = ((Long) args[1]).intValue();
    int    columnStart  = ((Long) args[2]).intValue();
    int    lineEnd  = ((Long) args[3]).intValue();
    int    columnEnd  = ((Long) args[4]).intValue();
    
    String[] attrElements = attributesString.split(",");
    List<ColoringAttributes> attributes = new ArrayList<ColoringAttributes>();
    
    for (String a : attrElements) {
        a = a.trim();
        
        attributes.add(ColoringAttributes.valueOf(a));
    }
    
    if (attributes.contains(null))
        throw new NullPointerException();
    
    int offsetStart = NbDocument.findLineOffset(doc, lineStart) + columnStart;
    int offsetEnd = NbDocument.findLineOffset(doc, lineEnd) + columnEnd;
    
    return new HighlightImpl(doc, offsetStart, offsetEnd, attributes);
}
 

import org.openide.text.NbDocument; //导入方法依赖的package包/类
/**
 * Locates AnnotateLine associated with given line. The
 * line is translated to Element that is used as map lookup key.
 * The map is initially filled up with Elements sampled on
 * annotate() method.
 *
 * <p>Key trick is that Element's identity is maintained
 * until line removal (and is restored on undo).
 *
 * @param line
 * @return found AnnotateLine or <code>null</code>
 */
private VcsAnnotation getAnnotateLine(int line) {
    StyledDocument sd = (StyledDocument) doc;
    int lineOffset = NbDocument.findLineOffset(sd, line);
    Element element = sd.getParagraphElement(lineOffset);
    VcsAnnotation al = elementAnnotations.get(element);

    if (al != null) {
        int startOffset = element.getStartOffset();
        int endOffset = element.getEndOffset();
        try {
            int len = endOffset - startOffset;
            String text = doc.getText(startOffset, len -1);
            String content = al.getDocumentText();
            if (text.equals(content)) {
                return al;
            }
        } catch (BadLocationException e) {
            ErrorManager err = ErrorManager.getDefault();
            err.annotate(e, "CVS.AB: can not locate line annotation."); // NOI18N
            err.notify(ErrorManager.INFORMATIONAL, e);
        }
    }

    return null;
}
 

import org.openide.text.NbDocument; //导入方法依赖的package包/类
/** return the offset of the first non-whitespace character on the line,
           or -1 when the line does not exist
 */
private static int findLineOffset(StyledDocument doc, int lineNumber) {
    int offset;
    try {
        offset = NbDocument.findLineOffset (doc, lineNumber - 1);
        int offset2 = NbDocument.findLineOffset (doc, lineNumber);
        try {
            String lineStr = doc.getText(offset, offset2 - offset);
            for (int i = 0; i < lineStr.length(); i++) {
                if (!Character.isWhitespace(lineStr.charAt(i))) {
                    offset += i;
                    break;
                }
            }
        } catch (BadLocationException ex) {
            // ignore
        }
    } catch (IndexOutOfBoundsException ioobex) {
        return -1;
    }
    return offset;
}
 

import org.openide.text.NbDocument; //导入方法依赖的package包/类
/**
 * Locates AnnotateLine associated with given line. The
 * line is translated to Element that is used as map lookup key.
 * The map is initially filled up with Elements sampled on
 * annotate() method.
 *
 * <p>Key trick is that Element's identity is maintained
 * until line removal (and is restored on undo).
 *
 * @param line
 * @return found AnnotateLine or <code>null</code>
 */
private AnnotateLine getAnnotateLine(int line) {
    StyledDocument sd = (StyledDocument) doc;
    int lineOffset = NbDocument.findLineOffset(sd, line);
    Element element = sd.getParagraphElement(lineOffset);
    AnnotateLine al = elementAnnotations.get(element);

    if (al != null) {
        int startOffset = element.getStartOffset();
        int endOffset = element.getEndOffset();
        try {
            int len = endOffset - startOffset;
            String text = doc.getText(startOffset, len -1);
            String content = al.getContent();
            if (text.equals(content)) {
                return al;
            }
        } catch (BadLocationException e) {
            Mercurial.LOG.log(Level.INFO, "HG.AB: can not locate line annotation.");  // NOI18N
        }
    }

    return null;
}
 

import org.openide.text.NbDocument; //导入方法依赖的package包/类
private static boolean openAtLine(CompilationController controller, Document doc, String methodName, int line) {
    try {
        if (line > -1) {
            DataObject od = DataObject.find(controller.getFileObject());
            int offset = NbDocument.findLineOffset((StyledDocument) doc, line);
            ExecutableElement parentMethod = controller.getTreeUtilities().scopeFor(offset).getEnclosingMethod();
            if (parentMethod != null) {
                String offsetMethodName = parentMethod.getSimpleName().toString();
                if (methodName.equals(offsetMethodName)) {
                    LineCookie lc = od.getLookup().lookup(LineCookie.class);
                    if (lc != null) {
                        final Line l = lc.getLineSet().getCurrent(line - 1);

                        if (l != null) {
                            CommonUtils.runInEventDispatchThread(new Runnable() {
                                @Override
                                public void run() {
                                    l.show(Line.ShowOpenType.OPEN, Line.ShowVisibilityType.FOCUS);
                                }
                            });
                            return true;
                        }
                    }
                }
            }
        }
    } catch (DataObjectNotFoundException e) {
        LOG.log(Level.WARNING, "Error accessing dataobject", e);
    }
    return false;
}
 

import org.openide.text.NbDocument; //导入方法依赖的package包/类
static String getText (Line l) throws Exception {
    EditorCookie ec = (EditorCookie) l.getDataObject ().
        getCookie (EditorCookie.class);
    StyledDocument doc = ec.openDocument ();
    if (doc == null) return "";
    int off = NbDocument.findLineOffset (doc, l.getLineNumber ());
    int len = NbDocument.findLineOffset (doc, l.getLineNumber () + 1) - 
        off - 1;
    return doc.getText (off, len);
}
 

import org.openide.text.NbDocument; //导入方法依赖的package包/类
/** Returns offset of the beginning of a line.
 * @param lineNumber number of line (starts at 1)
 * @return offset offset of line from the beginning of a file
 */
private int getLineOffset(int lineNumber) {
    try {
        StyledDocument doc = (StyledDocument) txtEditorPane().getDocument();
        return NbDocument.findLineOffset(doc, lineNumber - 1);
    } catch (IndexOutOfBoundsException e) {
        throw new JemmyException("Invalid line number " + lineNumber, e);
    }
}
 

import org.openide.text.NbDocument; //导入方法依赖的package包/类
public void reindent () throws BadLocationException {
    //S ystem.out.println("SCHLIEMAN reformat !\n  " + context.document() + "\n  " + context.isIndent() + "\n  " + context.startOffset () + "\n  " + context.endOffset());
    StyledDocument document = (StyledDocument) context.document ();
    try {
        MimePath mimePath = MimePath.parse (context.mimePath ());
        String mimeType = mimePath.getMimeType (mimePath.size () - 1);
        Language l = LanguagesManager.getDefault ().getLanguage (mimeType);
        Object indentValue = getIndentProperties (l);
        if (indentValue == null) return;
        
        if (indentValue instanceof Feature) {
            Feature m = (Feature) indentValue;
            m.getValue (Context.create (document, context.startOffset ()));
            return;
        }
        Object[] params = (Object[]) indentValue;
        
        TokenHierarchy tokenHierarchy = TokenHierarchy.get (document);
        LanguagePath languagePath = LanguagePath.get (org.netbeans.api.lexer.Language.find (mimePath.getMimeType (0)));
        for (int i = 1; i < mimePath.size(); i++)
            languagePath = languagePath.embedded (org.netbeans.api.lexer.Language.find (mimePath.getMimeType (i)));
        List<TokenSequence> tokenSequences = tokenHierarchy.tokenSequenceList (languagePath, context.startOffset (), context.endOffset ());
        
        Set<Integer> whitespaces = l.getAnalyser().getSkipTokenTypes ();
        
        Iterator<Region> it = context.indentRegions ().iterator ();
        while (it.hasNext ()) {
            Region region = it.next ();
            Map<Position,Integer> indentMap = new HashMap<Position,Integer> ();
            int ln = NbDocument.findLineNumber (document, region.getStartOffset ());
            int endLineNumber = NbDocument.findLineNumber (document, region.getEndOffset ());
            if (!Utils.getTokenSequence (document, context.lineStartOffset (region.getStartOffset ())).language ().mimeType ().equals (mimeType)) 
                ln++;
            int indent = 0;
            if (ln > 0) {
                int offset = NbDocument.findLineOffset (document, ln - 1);
                indent = context.lineIndent (offset);
                if (!Utils.getTokenSequence (document, offset).language ().mimeType ().equals (mimeType))
                    indent += IndentUtils.indentLevelSize (document); 
            }
            while (ln <= endLineNumber) {
                if (ln == endLineNumber && 
                    isEmpty (ln, document, whitespaces) &&
                    !Utils.getTokenSequence (document, region.getEndOffset ()).language ().mimeType ().equals (mimeType)
                ) break;
                indent = indent (context, document, params, ln++, indent, indentMap, whitespaces);
            }

            Iterator<Position> it2 = indentMap.keySet ().iterator ();
            while (it2.hasNext ()) {
                Position position = it2.next ();
                context.modifyIndent (position.getOffset (), indentMap.get (position));
            }
        }
    } catch (LanguageDefinitionNotFoundException ldnfe) {
        //no language found - this might happen when some of the embedded languages are not schliemann based,
        //so just ignore and do nothing - no indent
    } catch (Exception ex) {
        ErrorManager.getDefault ().notify (ex);
    }
}
 

import org.openide.text.NbDocument; //导入方法依赖的package包/类
private Position[] getLine0(Error d, final Document doc, int startOffset, int endOffset) {
    StyledDocument sdoc = (StyledDocument) doc;
    int lineNumber = NbDocument.findLineNumber(sdoc, startOffset);
    int lineOffset = NbDocument.findLineOffset(sdoc, lineNumber);
    String text = DataLoadersBridge.getDefault().getLine(doc, lineNumber);
    if (text == null) {
        return new Position[2];
    }
    
    if (d.isLineError()) {
        int column = 0;
        int length = text.length();
        
        while (column < text.length() && Character.isWhitespace(text.charAt(column))) {
            column++;
        }
        
        while (length > 0 && Character.isWhitespace(text.charAt(length - 1))) {
            length--;
        }
        
        startOffset = lineOffset + column;
        endOffset = lineOffset + length;
        if (startOffset > endOffset) {
            // Space only on the line
            startOffset = lineOffset;
        }
    }
    
    if (LOG.isLoggable(Level.FINE)) {
        LOG.log(Level.FINE, "startOffset = " + startOffset );
        LOG.log(Level.FINE, "endOffset = " + endOffset );
    }
    
    final int startOffsetFinal = startOffset;
    final int endOffsetFinal = endOffset;
    final Position[] result = new Position[2];
    
    int len = doc.getLength();

    if (startOffsetFinal > len || endOffsetFinal > len) {
        if (!cancel.isCancelled() && LOG.isLoggable(Level.WARNING)) {
            LOG.log(Level.WARNING, "document changed, but not canceled?" );
            LOG.log(Level.WARNING, "len = " + len );
            LOG.log(Level.WARNING, "startOffset = " + startOffsetFinal );
            LOG.log(Level.WARNING, "endOffset = " + endOffsetFinal );
        }
        cancel();

        return result;
    }

    try {
        result[0] = NbDocument.createPosition(doc, startOffsetFinal, Bias.Forward);
        result[1] = NbDocument.createPosition(doc, endOffsetFinal, Bias.Backward);
    } catch (BadLocationException e) {
        LOG.log(Level.WARNING, null, e);
    }
    
    return result;
}
 

import org.openide.text.NbDocument; //导入方法依赖的package包/类
/**
 * Get a list of MIME types of languages found on a line.
 * @param line The line to search for the MIME types.
 * @return A set of MIME types.
 * @since 2.50
 */
public Set<String> getMIMETypesOnLine(Line line) {
    EditorCookie editorCookie = line.getLookup().lookup(EditorCookie.class);
    if (editorCookie == null) {
        DataObject dobj = line.getLookup().lookup(DataObject.class);
        if (dobj != null) {
            editorCookie = dobj.getLookup().lookup(EditorCookie.class);
        }
        if (editorCookie == null) {
            return Collections.emptySet();
        }
    }
    StyledDocument document = editorCookie.getDocument();
    if (document == null) {
        return Collections.emptySet();
    }
    Set<String> mimeTypes = null;
    ((AbstractDocument) document).readLock();
    try {
        TokenHierarchy<Document> th = TokenHierarchy.get((Document) document);
        int ln = line.getLineNumber();
        int offset = NbDocument.findLineOffset(document, ln);
        int maxOffset = document.getLength() - 1;
        int maxLine = NbDocument.findLineNumber(document, maxOffset);
        int offset2;
        if (ln + 1 > maxLine) {
            offset2 = maxOffset;
        } else {
            offset2 = NbDocument.findLineOffset(document, ln+1) - 1;
        }
        // The line has offsets <offset, offset2>
        Set<LanguagePath> languagePaths = th.languagePaths();
        for (LanguagePath lp : languagePaths) {
            List<TokenSequence<?>> tsl = th.tokenSequenceList(lp, offset, offset2);
            for (TokenSequence ts : tsl) {
                if (ts.moveNext()) {
                    //int to = ts.offset();
                    //if (!(offset <= to && to < offset2)) {
                    //    continue;
                    //}
                    String mimeType = ts.language().mimeType();
                    if (mimeType != null) {
                        if (mimeTypes == null) {
                            mimeTypes = Collections.singleton(mimeType);
                        } else {
                            if (mimeTypes.size() == 1) {
                                mimeTypes = new HashSet<String>(mimeTypes);
                            }
                            mimeTypes.add(mimeType);
                        }
                    }
                }
            }
        }
    } finally {
        ((AbstractDocument) document).readUnlock();
    }
    return (mimeTypes != null) ? mimeTypes : Collections.<String>emptySet();
    
}
 

import org.openide.text.NbDocument; //导入方法依赖的package包/类
private static boolean doOpen(FileObject fo, int offset) {
    try {
        DataObject od = DataObject.find(fo);
        EditorCookie ec = od.getLookup().lookup(EditorCookie.class);
        LineCookie lc = od.getLookup().lookup(LineCookie.class);
        
        if (ec != null && lc != null && offset != -1) {
            StyledDocument doc = null;
            try {
                doc = ec.openDocument();
            } catch (UserQuestionException uqe) {
                final Object value = DialogDisplayer.getDefault().notify(
                        new NotifyDescriptor.Confirmation(uqe.getLocalizedMessage(),
                        NbBundle.getMessage(UiUtils.class, "TXT_Question"),
                        NotifyDescriptor.YES_NO_OPTION));
                if (value != NotifyDescriptor.YES_OPTION) {
                    return false;
                }
                uqe.confirmed();
                doc = ec.openDocument();
            }
            if (doc != null) {
                int line = NbDocument.findLineNumber(doc, offset);
                int lineOffset = NbDocument.findLineOffset(doc, line);
                int column = offset - lineOffset;
                
                if (line != -1) {
                    Line l = lc.getLineSet().getCurrent(line);
                    
                    if (l != null) {
                        doShow( l, column);
                        return true;
                    }
                }
            }
        }
        
        OpenCookie oc = od.getLookup().lookup(OpenCookie.class);
        
        if (oc != null) {
            doOpen(oc);
            return true;
        }
    } catch (IOException e) {
        if (log.isLoggable(Level.INFO))
            log.log(Level.INFO, e.getMessage(), e);
    }
    
    return false;
}