/** * Finds a word by specified offset and returns the region of word. * * @param source * @param offset * @return the region of found word */ public static IRegion findWord(IDocument document, int offset) { int start = -2; int end = -1; try { int pos = offset; char c; while (pos > 0 && pos < document.getLength()) { c = document.getChar(pos); if (Character.isWhitespace(c) && !Character.isLetter(c)) break; --pos; } start = pos; pos = offset; int length = document.getLength(); while (pos < length - 1) { c = document.getChar(pos); if (!Character.isJavaIdentifierPart(c)) break; ++pos; } end = pos; } catch (BadLocationException x) { } if (start >= -1 && end > -1) { return new Region(start, end - start); } return null; }
/* * @see org.eclipse.jdt.internal.ui.text.java.LazyJavaCompletionProposal#apply(org.eclipse.jface.text.IDocument, char, int) */ @Override public void apply(IDocument document, char trigger, int offset) { try { boolean insertClosingParenthesis = trigger == '(' && autocloseBrackets(); if (insertClosingParenthesis) { StringBuffer replacement = new StringBuffer(getReplacementString()); updateReplacementWithParentheses(replacement); setReplacementString(replacement.toString()); trigger = '\0'; } super.apply(document, trigger, offset); if (fImportRewrite != null && fImportRewrite.hasRecordedChanges()) { int oldLen = document.getLength(); fImportRewrite .rewriteImports(new NullProgressMonitor()) .apply(document, TextEdit.UPDATE_REGIONS); setReplacementOffset(getReplacementOffset() + document.getLength() - oldLen); } if (insertClosingParenthesis) setUpLinkedMode(document, ')'); rememberSelection(); } catch (CoreException e) { JavaPlugin.log(e); } catch (BadLocationException e) { JavaPlugin.log(e); } }
/** * @return the current token and its initial offset for this token * @param the chars to be considered separators (note that whitespace chars are always considered * separators and don't need to be in this set). * @throws BadLocationException */ public Tuple<String, Integer> getCurrToken(Set<Character> separatorChars) throws BadLocationException { int offset = getAbsoluteCursorOffset(); int i = offset; if (i > doc.getLength()) { return new Tuple<String, Integer>("", doc.getLength()); // $NON-NLS-1$ } while (i > 0) { char ch = doc.getChar(i - 1); if (separatorChars.contains(ch) || Character.isWhitespace(ch)) { break; } i--; } Tuple<String, Integer> tup = new Tuple<String, Integer>(doc.get(i, offset - i), offset); String prefix = tup.o1; // ok, now, get the rest of the token, as we already have its prefix int start = tup.o2 - prefix.length(); int end = start; while (doc.getLength() - 1 >= end) { char ch = doc.getChar(end); if (separatorChars.contains(ch) || Character.isWhitespace(ch)) { break; } end++; } String post = doc.get(tup.o2, end - tup.o2); return new Tuple<String, Integer>(prefix + post, start); }
/** * This function gets the activation token from the document given the current cursor position. * * @param document this is the document we want info on * @param offset this is the cursor position * @param getFullQualifier if true we get the full qualifier (even if it passes the current cursor * location) * @return a tuple with the activation token and the cursor offset (may change if we need to get * the full qualifier, otherwise, it is the same offset passed as a parameter). */ public static Tuple<String, Integer> extractActivationToken( IDocument document, int offset, boolean getFullQualifier) { try { if (getFullQualifier) { // if we have to get the full qualifier, we'll have to walk the offset (cursor) forward while (offset < document.getLength()) { char ch = document.getChar(offset); if (Character.isJavaIdentifierPart(ch)) { offset++; } else { break; } } } int i = offset; if (i > document.getLength()) { return new Tuple<String, Integer>("", document.getLength()); // $NON-NLS-1$ } while (i > 0) { char ch = document.getChar(i - 1); if (!Character.isJavaIdentifierPart(ch)) { break; } i--; } return new Tuple<String, Integer>(document.get(i, offset - i), offset); } catch (BadLocationException e) { return new Tuple<String, Integer>("", offset); // $NON-NLS-1$ } }
/** This method should be called after all the lines received were processed. */ private void onAfterAllLinesHandled( final String finalText, final boolean finalAddedParen, final int finalStart, final int finalOffset, final boolean finalAddedCloseParen, final String finalIndentString, final int finalNewDeltaCaretPosition) { boolean shiftsCaret = true; String newText = finalText.substring(finalStart, finalText.length()); if (finalAddedParen) { String cmdLine = getCommandLine(); Document parenDoc = new Document(cmdLine + newText); int currentOffset = cmdLine.length() + 1; DocCmd docCmd = new DocCmd(currentOffset, 0, "("); docCmd.shiftsCaret = true; try { strategy.customizeParenthesis(parenDoc, docCmd); } catch (BadLocationException e) { Log.log(e); } newText = docCmd.text + newText.substring(1); if (!docCmd.shiftsCaret) { shiftsCaret = false; setCaretOffset(finalOffset + (docCmd.caretOffset - currentOffset)); } } else if (finalAddedCloseParen) { String cmdLine = getCommandLine(); String existingDoc = cmdLine + finalText.substring(1); int cmdLineOffset = cmdLine.length(); if (existingDoc.length() > cmdLineOffset) { Document parenDoc = new Document(existingDoc); DocCmd docCmd = new DocCmd(cmdLineOffset, 0, ")"); docCmd.shiftsCaret = true; boolean canSkipOpenParenthesis; try { canSkipOpenParenthesis = strategy.canSkipCloseParenthesis(parenDoc, docCmd); } catch (BadLocationException e) { canSkipOpenParenthesis = false; Log.log(e); } if (canSkipOpenParenthesis) { shiftsCaret = false; setCaretOffset(finalOffset + 1); newText = newText.substring(1); } } } // and now add the last line (without actually handling it). String cmd = finalIndentString + newText; cmd = convertTabs(cmd); applyStyleToUserAddedText(cmd, doc.getLength()); appendText(cmd); if (shiftsCaret) { setCaretOffset(doc.getLength() - finalNewDeltaCaretPosition); } history.update(getCommandLine()); }
protected void copyIndentation(final IDocument d, final DocumentCommand c) { // CODE KOPIERT AUS SUPER-KLASSE DA DORT PRIVATE // == DefaultIndentLineAutoEditStrategy.autoIndentAfterNewLine(IDocument d, DocumentCommand c) if (c.offset == -1 || d.getLength() == 0) return; try { // find start of line int p = (c.offset == d.getLength() ? c.offset - 1 : c.offset); IRegion info = d.getLineInformationOfOffset(p); int start = info.getOffset(); // find white spaces int end = findEndOfWhiteSpace(d, start, c.offset); StringBuffer buf = new StringBuffer(c.text); if (end > start) { // append to input buf.append(d.get(start, end - start)); } c.text = buf.toString(); } catch (BadLocationException excp) { // stop work } }
protected void endProcessing() { super.endProcessing(); ValidatorStrategy validatorStrategy = getValidatorStrategy(); if (validatorStrategy != null) { validatorStrategy.endProcessing(); } /* single spell-check for everything to ensure that SpellingProblem offsets are correct */ IReconcilingStrategy spellingStrategy = getSpellcheckStrategy(); IDocument document = getDocument(); if (spellingStrategy != null && document != null) { spellingStrategy.reconcile(new Region(0, document.getLength())); } IReconcilingStrategy semanticHighlightingStrategy = getSemanticHighlightingStrategy(); if (semanticHighlightingStrategy != null && document != null) { semanticHighlightingStrategy.reconcile(new Region(0, document.getLength())); } if ((getTextViewer() instanceof ISourceViewer)) { ISourceViewer sourceViewer = (ISourceViewer) getTextViewer(); IAnnotationModel annotationModel = sourceViewer.getAnnotationModel(); for (int i = 0; i < fReconcileListeners.length; i++) { fReconcileListeners[i].reconciled( document, annotationModel, false, new NullProgressMonitor()); } } }
private void smartIndentAfterClosingBracket(IDocument d, DocumentCommand c) { if (c.offset == -1 || d.getLength() == 0) return; try { int p = (c.offset == d.getLength() ? c.offset - 1 : c.offset); int line = d.getLineOfOffset(p); int start = d.getLineOffset(line); int whiteend = findEndOfWhiteSpace(d, start, c.offset); JavaHeuristicScanner scanner = new JavaHeuristicScanner(d); JavaIndenter indenter = new JavaIndenter(d, scanner, fProject); // shift only when line does not contain any text up to the closing bracket if (whiteend == c.offset) { // evaluate the line with the opening bracket that matches out closing bracket int reference = indenter.findReferencePosition(c.offset, false, true, false, false); int indLine = d.getLineOfOffset(reference); if (indLine != -1 && indLine != line) { // take the indent of the found line StringBuffer replaceText = new StringBuffer(getIndentOfLine(d, indLine)); // add the rest of the current line including the just added close bracket replaceText.append(d.get(whiteend, c.offset - whiteend)); replaceText.append(c.text); // modify document command c.length += c.offset - start; c.offset = start; c.text = replaceText.toString(); } } } catch (BadLocationException e) { JavaPlugin.log(e); } }
protected void setEntireDocumentDirty(IDocument document) { super.setEntireDocumentDirty(document); // make the entire document dirty // this also happens on a "save as" if (document != null && isInstalled() && fLastPartitions != null && document.getLength() == 0) { /** * https://bugs.eclipse.org/bugs/show_bug.cgi?id=199053 * * <p>Process the strategies for the last known-good partitions. */ for (int i = 0; i < fLastPartitions.length; i++) { ValidatorStrategy validatorStrategy = getValidatorStrategy(); if (validatorStrategy != null) { validatorStrategy.reconcile( fLastPartitions[i], createDirtyRegion(fLastPartitions[i], DirtyRegion.REMOVE)); } } IReconcilingStrategy spellingStrategy = getSpellcheckStrategy(); if (spellingStrategy != null) { spellingStrategy.reconcile(new Region(0, document.getLength())); } // if there is a folding strategy then reconcile it if (getFoldingStrategy() != null) { getFoldingStrategy().reconcile(new Region(0, document.getLength())); } } }
/** * Provide the initialization of the listeners additions. The Window, Part, and Document Listener * are added. Note that sensor shell should be instantiated before this method is called because * <code>processActivity()</code> method uses sensor shell instance. */ private void registerListeners() { IWorkbench workbench = EclipseSensorPlugin.getInstance().getWorkbench(); // :RESOLVED: JULY 1, 2003 // Supports the multiple window for sensor collection. IWorkbenchWindow[] activeWindows = workbench.getWorkbenchWindows(); // Check if window listener is not added yet. Otherwise multi instances are notified. if (this.windowListener == null) { this.windowListener = new WindowListenerAdapter(); workbench.addWindowListener(new WindowListenerAdapter()); } for (int i = 0; i < activeWindows.length; i++) { IWorkbenchPage activePage = activeWindows[i].getActivePage(); activePage.addPartListener(new PartListenerAdapter()); IEditorPart activeEditorPart = activePage.getActiveEditor(); // Adds this EclipseSensorPlugin instance to IDocumentListener // only when activeEditorPart is the instance of ITextEditor // so that null case is also ignored. if (activeEditorPart instanceof ITextEditor) { // Sets activeTextEditor. Otherwise a first activated file would not be recorded. this.activeTextEditor = (ITextEditor) activeEditorPart; // Gets opened file since the initial opened file is not notified from IPartListener. URI fileResource = EclipseSensor.this.getFileResource(this.activeTextEditor); Map<String, String> keyValueMap = new HashMap<String, String>(); keyValueMap.put(EclipseSensorConstants.SUBTYPE, "Open"); keyValueMap.put(EclipseSensorConstants.UNIT_TYPE, EclipseSensorConstants.FILE); keyValueMap.put( EclipseSensorConstants.UNIT_NAME, EclipseSensor.this.extractFileName(fileResource)); this.addDevEvent( EclipseSensorConstants.DEVEVENT_EDIT, fileResource, keyValueMap, "Opened " + fileResource.toString()); IDocumentProvider provider = this.activeTextEditor.getDocumentProvider(); IDocument document = provider.getDocument(activeEditorPart.getEditorInput()); // Initially sets active buffer and threshold buffer. // Otherwise a first activated buffer would not be recorded. this.activeBufferSize = document.getLength(); this.thresholdBufferSize = document.getLength(); document.addDocumentListener(new DocumentListenerAdapter()); } } // Handles breakpoint set/unset event. IBreakpointManager bpManager = DebugPlugin.getDefault().getBreakpointManager(); bpManager.addBreakpointListener(new BreakPointerSensor(this)); // Listens to debug event. DebugPlugin.getDefault().addDebugEventListener(new DebugSensor(this)); // Creates instance to handle build error. this.buildErrorSensor = new BuildErrorSensor(this); }
public ParamRegion findEnclosingPeerCharacters(IDocument document, int offset, int length) { if (document == null || offset < 0 || offset > document.getLength()) return null; try { DocumentAccessor doc = new DocumentAccessor(document); return findEnclosingPeers(document, doc, offset, length, 0, document.getLength()); } catch (BadLocationException ble) { return null; } }
protected String getSurroundingText(IDocument document, int offset, int context) { int start = (offset - context < 0) ? 0 : offset - context; int end = (offset + context > document.getLength() - 1) ? document.getLength() - 1 : offset + context; try { return document.get(start, offset - start) + "|" + document.get(offset, end - (offset + 1)); } catch (BadLocationException e) { return StringUtil.EMPTY; } }
@Override public void documentChanged(DocumentEvent event) { IDocument newDoc = event.getDocument(); if (docLines != newDoc.getNumberOfLines()) { updateAnnotations(false); docLines = newDoc.getNumberOfLines(); docLength = newDoc.getLength(); } else { changeAnnotations(event.getOffset(), newDoc.getLength()); } }
/** Shows the prompt for the user (e.g.: >>>) */ protected void appendInvitation(boolean async) { int start = doc.getLength(); String promptStr = prompt.toString(); IConsoleStyleProvider styleProvider = viewer.getStyleProvider(); if (styleProvider != null) { ScriptStyleRange style = styleProvider.createPromptStyle(promptStr, start); if (style != null) { addToPartitioner(style); } } appendText(promptStr); // caret already updated setCaretOffset(doc.getLength(), async); revealEndOfDocument(); }
public void testLiterateSequences() throws CoreException { IDocument document = createDocument("A\\begin{code}B\\end{code}C\n"); // scanner should not know about literate stuff ITokenScanner scanner = new HaskellCodeScanner(false); scanner.setRange(document, 0, document.getLength()); assertColor(scanner.nextToken(), ColorProvider.DEFAULT_OTHER); // scanner should recognize literate sequences as comments scanner = new HaskellCodeScanner(true); scanner.setRange(document, 0, document.getLength()); assertColor(scanner.nextToken(), ColorProvider.DEFAULT_OTHER); assertColor(scanner.nextToken(), ColorProvider.DEFAULT_COMMENT); assertColor(scanner.nextToken(), ColorProvider.DEFAULT_OTHER); assertColor(scanner.nextToken(), ColorProvider.DEFAULT_COMMENT); assertColor(scanner.nextToken(), ColorProvider.DEFAULT_OTHER); }
/** * Indents a line with a given indentation level. * * @param document the document being processed. * @param lineStart the offset at which the target line starts * @param indentationLevel the indentation level to use * @exception BadLocationException if the offset is invalid in this document */ private void setIndentLevel( final IDocument document, final int lineStart, final int indentationLevel) throws BadLocationException { int lastWhiteSpace = lineStart; char c; while (lastWhiteSpace < document.getLength()) { c = document.getChar(lastWhiteSpace); if (c == ' ' || c == '\t') { lastWhiteSpace++; } else { break; } } for (int i = indentArray.size() - 1; i < indentationLevel; i++) { indentArray.add(indentArray.get(i) + IndentationSupport.getIndentString()); } if (!document .get(lineStart, lastWhiteSpace - lineStart) .equals(indentArray.get(indentationLevel))) { multiEdit.addChild( new ReplaceEdit( lineStart, lastWhiteSpace - lineStart, indentArray.get(indentationLevel))); } }
@Override public boolean performFinish() { IFile resultFile = page.getResultFile(); if (resultFile != null) { ABSEditor editor = UtilityFunctions.openABSEditorForFile(resultFile.getLocation(), resultFile.getProject()); IDocument document = editor.getDocumentProvider().getDocument(editor.getEditorInput()); // modules are always added the the end of the document final int off = document.getLength(); try { document.replace(off, 0, insertType.getInsertionString(page.getResult())); final int insertOffset = insertType.getInsertOffset(page.getResult()); WizardUtil.saveEditorAndGotoOffset(editor, insertOffset); return true; } catch (BadLocationException e) { MessageDialog.openError( getShell(), "Error", "Fatal error: The insertion position for the new module does not longer exist. Please save the target file and try again."); e.printStackTrace(); return false; } } else { MessageDialog.openError( getShell(), "Error", "Fatal error: No file reference was passed by the wizard. Please try again to use the wizard and select a valid file."); return false; } }
/** Select the word at the current selection. Return true if successful, false otherwise. */ protected boolean matchWord() { IDocument doc = fText.getDocument(); try { int pos = fPos; char c; while (pos >= 0) { c = doc.getChar(pos); if (!Character.isJavaIdentifierPart(c)) break; --pos; } fStartPos = pos; pos = fPos; int length = doc.getLength(); while (pos < length) { c = doc.getChar(pos); if (!Character.isJavaIdentifierPart(c)) break; ++pos; } fEndPos = pos; return true; } catch (BadLocationException x) { } return false; }
private ITypedRegion getPartition(IDocument doc, int offset) throws BadLocationException { ITypedRegion part = TextUtilities.getPartition( doc, IPropertiesFilePartitions.PROPERTIES_FILE_PARTITIONING, offset, true); if (part.getType() == IDocument.DEFAULT_CONTENT_TYPE && part.getLength() == 0 && offset == doc.getLength() && offset > 0) { // A special case because when cursor at end of document and just after a '=' sign, then we // get a DEFAULT content type // with a empty region. We rather would get the non-empty 'Value' partition just before that // (which has the assignment in it. char assign = doc.getChar(offset - 1); if (isAssign(assign)) { return new TypedRegion(offset - 1, 1, IPropertiesFilePartitions.PROPERTY_VALUE); } else { // For a similar case but where there's extra spaces after the '=' ITypedRegion previousPart = TextUtilities.getPartition( doc, IPropertiesFilePartitions.PROPERTIES_FILE_PARTITIONING, offset - 1, true); int previousEnd = previousPart.getOffset() + previousPart.getLength(); if (previousEnd == offset) { // prefer this over a 0 length partition ending at the same location return previousPart; } } } return part; }
private int findChangeLogPattern(IDocument changelog_doc, int startOffset) { // find the "pattern" of a changelog entry. Not a specific one, // but one that "looks" like an entry int nextEntry = startOffset; int line_length = 0; String entry = ""; // $NON-NLS-1$ while (nextEntry < changelog_doc.getLength()) { try { // Get the line of interest in the changelog document line_length = changelog_doc.getLineOfOffset(nextEntry); entry = changelog_doc.get(nextEntry, changelog_doc.getLineLength(line_length)); // Attempt to find date pattern on line if (matchDatePattern(entry)) { // nextDate -= entry.length()+1; break; } // If no date matches, move to the next line nextEntry += changelog_doc.getLineLength(line_length); } catch (BadLocationException e) { ChangelogPlugin.getDefault() .getLog() .log( new Status( IStatus.ERROR, ChangelogPlugin.PLUGIN_ID, IStatus.ERROR, e.getMessage(), e)); } } return nextEntry; }
/* * @see org.eclipse.cdt.core.dom.ast.ASTVisitor#leave(org.eclipse.cdt.core.dom.ast.IASTTranslationUnit) */ @Override public int leave(IASTTranslationUnit tu) { super.leave(tu); assert getCurrentContainer().getTypeCode() == ICElement.C_UNIT; pop(fDocument.getLength()); return PROCESS_SKIP; }
/** * If you found an opening peer, you'll want to look for a closing peer. * * @param offset * @param openingPeer * @param closingPeer * @param document * @return the offset of the closing peer * @throws IOException */ public int searchForClosingPeer( int offset, char openingPeer, char closingPeer, IDocument document) { try { fReader.configureForwardReader(document, offset + 1, document.getLength(), true, true, true); int stack = 1; int c = fReader.read(); while (c != PythonCodeReader.EOF) { if (c == openingPeer && c != closingPeer) stack++; else if (c == closingPeer) stack--; if (stack <= 0) { // <= 0 because if we have a closing peer without an opening one, we'll return // it. return fReader.getOffset(); } c = fReader.read(); } return -1; } catch (Exception e) { throw new RuntimeException(e); } }
protected List<IRegion> getAttributeValueRegions(ITextViewer viewer) { List<IRegion> regions = new ArrayList<IRegion>(); IDocument document = viewer.getDocument(); int startOffset = 0; int endOffset = document.getLength(); IStructuredDocumentRegion sdRegion = null; while (startOffset < endOffset && (sdRegion = ContentAssistUtils.getStructuredDocumentRegion(viewer, startOffset)) != null) { ITextRegionList list = sdRegion.getRegions(); for (int i = 0; list != null && i < list.size(); i++) { ITextRegion region = list.get(i); if (region.getType() == DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE) { final int regionOffset = sdRegion.getStartOffset() + region.getStart(); final int regionLength = region.getTextLength(); regions.add(new Region(regionOffset, regionLength)); } } startOffset += sdRegion.getLength(); } return regions; }
/** * Checks whether the content of <code>document</code> in the range (<code>offset</code>, <code> * length</code>) contains the <code>new</code> keyword. * * @param document the document being modified * @param offset the first character position in <code>document</code> to be considered * @param length the length of the character range to be considered * @param partitioning the document partitioning * @return <code>true</code> if the specified character range contains a <code>new</code> keyword, * <code>false</code> otherwise. */ private static boolean isNewMatch( IDocument document, int offset, int length, String partitioning) { Assert.isTrue(length >= 0); Assert.isTrue(offset >= 0); Assert.isTrue(offset + length < document.getLength() + 1); try { String text = document.get(offset, length); int pos = text.indexOf("new"); // $NON-NLS-1$ while (pos != -1 && !isDefaultPartition(document, pos + offset, partitioning)) pos = text.indexOf("new", pos + 2); // $NON-NLS-1$ if (pos < 0) return false; if (pos != 0 && Character.isJavaIdentifierPart(text.charAt(pos - 1))) return false; if (pos + 3 < length && Character.isJavaIdentifierPart(text.charAt(pos + 3))) return false; return true; } catch (BadLocationException e) { } return false; }
private final void processNode(SemanticToken token, DartNode node) { token.update(node); token.attachSource(fSourceViewer.getDocument()); // sometimes node has wrong source range; log problem if (token.getSource() == null) { IDocument document = fSourceViewer.getDocument(); if (node != null && document != null) { SourceInfo sourceInfo = node.getSourceInfo(); if (sourceInfo != null) { DartToolsPlugin.log( "Bad node: " + node.getClass().getName() + " offset:" + sourceInfo.getOffset() + " len:" + sourceInfo.getLength() + " in document: " + document.getLength()); } } return; } // try SemanticHighlighting instances for (int i = 0, n = fJobSemanticHighlightings.length; i < n; i++) { if (fJobHighlightings[i].isEnabled()) { SemanticHighlighting semanticHighlighting = fJobSemanticHighlightings[i]; // try multiple positions { List<SourceRange> ranges = semanticHighlighting.consumesMulti(token); if (ranges != null) { for (SourceRange range : ranges) { int offset = range.getOffset(); int length = range.getLength(); if (offset > -1 && length > 0) { fCollector.addPosition(offset, length, fJobHighlightings[i]); } } break; } } // try single position boolean consumes; if (node instanceof DartIdentifier) { consumes = semanticHighlighting.consumesIdentifier(token); } else { consumes = semanticHighlighting.consumes(token); } if (consumes) { int offset = node.getSourceInfo().getOffset(); int length = node.getSourceInfo().getLength(); if (offset > -1 && length > 0) { fCollector.addPosition(offset, length, fJobHighlightings[i]); } break; } } } token.clear(); }
private void appendContent( IDocument text, int startOffset, int endOffset, StringBuilder buf, boolean surroundLinesOnly) { try { int startLine = text.getLineOfOffset(startOffset); int endLine = text.getLineOfOffset(endOffset); boolean dotsAdded = false; if (surroundLinesOnly && startOffset == 0) { // No surround lines for the top no-change range startLine = Math.max(endLine - surroundLines, 0); buf.append("...<br>"); // $NON-NLS-1$ dotsAdded = true; } for (int i = startLine; i <= endLine; i++) { if (surroundLinesOnly) { if ((i - startLine > surroundLines) && (endLine - i > surroundLines)) { if (!dotsAdded) { buf.append("...<br>"); // $NON-NLS-1$ dotsAdded = true; } else if (endOffset == text.getLength()) { return; // No surround lines for the bottom no-change range } continue; } } IRegion lineInfo = text.getLineInformation(i); int start = lineInfo.getOffset(); int end = start + lineInfo.getLength(); int from = Math.max(start, startOffset); int to = Math.min(end, endOffset); String content = text.get(from, to - from); if (surroundLinesOnly && from == start && Strings.containsOnlyWhitespaces(content)) { continue; // Ignore empty lines except when range started in the middle of a line } for (int k = 0; k < content.length(); k++) { char ch = content.charAt(k); if (ch == '<') { buf.append("<"); // $NON-NLS-1$ } else if (ch == '>') { buf.append(">"); // $NON-NLS-1$ } else { buf.append(ch); } } if (to == end && to != endOffset) { // New line when at the end of the line, and not end of range buf.append("<br>"); // $NON-NLS-1$ } } } catch (BadLocationException e) { // Ignore. } }
private static boolean isBeforeCloseBrace(IDocument document, int offset, int endLineOffset) throws BadLocationException { int nonEmptyOffset = findEndOfWhiteSpaceAfter(document, offset, endLineOffset); if (nonEmptyOffset == document.getLength()) { nonEmptyOffset--; } return document.getChar(nonEmptyOffset) == CLOSING_BRACE_CHAR; }
/** * Appends some text at the end of the document. * * @param text the text to be added. */ protected void appendText(String text) { int initialOffset = doc.getLength(); try { doc.replace(initialOffset, 0, text); } catch (BadLocationException e) { Log.log(e); } }
/** * Creates a JavaNode for a CU. It represents the root of a JavaNode tree, so its parent is null. * * @param document the document which contains the Java element */ public JavaNode(IDocument document) { super( CU, JavaCompareUtilities.buildID(CU, "root"), document, 0, document.getLength()); // $NON-NLS-1$ }
public boolean openHyperLink() { String localiz = getLocalization(); if (localiz == null) { return false; } else if (fBase.getUnderlyingResource() == null) { return false; } else if (fElement.length() == 0 || fElement.charAt(0) != '%') { return false; } IProject proj = fBase.getUnderlyingResource().getProject(); IFile file = proj.getFile(localiz + ".properties"); // $NON-NLS-1$ if (!file.exists()) return false; try { IEditorPart editor = IDE.openEditor(PDEPlugin.getActivePage(), file); if (!(editor instanceof TextEditor)) return false; TextEditor tEditor = (TextEditor) editor; IDocument doc = tEditor.getDocumentProvider().getDocument(tEditor.getEditorInput()); if (doc == null) return false; try { String key = fElement.substring(1); int keyLen = key.length(); int length = doc.getLength(); int start = 0; IRegion region = null; FindReplaceDocumentAdapter docSearch = new FindReplaceDocumentAdapter(doc); while ((region = docSearch.find(start, key, true, false, false, false)) != null) { int offset = region.getOffset(); if (offset > 0) { // check for newline before char c = doc.getChar(offset - 1); if (c != '\n' && c != '\r') { start += keyLen; continue; } } if (offset + keyLen < length) { // check for whitespace / assign symbol after char c = doc.getChar(offset + keyLen); if (!Character.isWhitespace(c) && c != '=' && c != ':') { start += keyLen; continue; } } tEditor.selectAndReveal(offset, keyLen); break; } } catch (BadLocationException e) { PDEPlugin.log(e); } } catch (PartInitException e) { return false; } return true; }