下面列出了javax.swing.text.JTextComponent#getDocument ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private Document getNextDocument() {
// Initially documentIndex == -1
if (documentIndex == documents.size() - 1) { // Check adding
if (documentSet.isEmpty()) { // documents list not inited yet -> add 'doc'
documentSet.put(doc, Boolean.TRUE);
}
for (JTextComponent tc : EditorRegistry.componentList()) {
Document d = tc.getDocument();
if (!documentSet.containsKey(d)) {
documentSet.put(d, Boolean.TRUE);
documents.add(new WeakReference<Document>(d));
}
}
}
Document retDoc = null;
while (documentIndex < documents.size() - 1) {
documentIndex++;
retDoc = documents.get(documentIndex).get();
if (retDoc != null) {
break;
}
}
return retDoc;
}
static int nextCamelCasePosition(JTextComponent textComponent) {
int offset = textComponent.getCaretPosition();
Document doc = textComponent.getDocument();
// Are we at the end of the document?
if (offset == doc.getLength()) {
return -1;
}
KeystrokeHandler bc = UiUtils.getBracketCompletion(doc, offset);
if (bc != null) {
int nextOffset = bc.getNextWordOffset(doc, offset, false);
if (nextOffset != -1) {
return nextOffset;
}
}
try {
return Utilities.getNextWord(textComponent, offset);
} catch (BadLocationException ble) {
// something went wrong :(
ErrorManager.getDefault().notify(ble);
}
return -1;
}
private static void setHighlight(JTextComponent jtc, String pattern) {
Highlighter highlighter = jtc.getHighlighter();
highlighter.removeAllHighlights();
try {
Document doc = jtc.getDocument();
String text = doc.getText(0, doc.getLength());
Matcher matcher = Pattern.compile(pattern).matcher(text);
int pos = 0;
while (matcher.find(pos) && !matcher.group().isEmpty()) {
pos = matcher.end();
highlighter.addHighlight(matcher.start(), pos, HIGHLIGHT);
}
// while ((pos = text.indexOf(pattern, pos)) >= 0) {
// highlighter.addHighlight(pos, pos + pattern.length(), HIGHLIGHT);
// pos += pattern.length();
// }
} catch (BadLocationException | PatternSyntaxException ex) {
UIManager.getLookAndFeel().provideErrorFeedback(jtc);
}
}
/**
* Return the lines that span the selection (split as an array of Strings)
* if there is no selection then current line is returned.
*
* Note that the strings returned will not contain the terminating line feeds
*
* The text component will then have the full lines set as selection
* @param target
* @return String[] of lines spanning selection / or Dot
*/
public static String[] getSelectedLines(JTextComponent target) {
String[] lines = null;
try {
PlainDocument pDoc = (PlainDocument) target.getDocument();
int start = pDoc.getParagraphElement(target.getSelectionStart()).getStartOffset();
int end;
if (target.getSelectionStart() == target.getSelectionEnd()) {
end = pDoc.getParagraphElement(target.getSelectionEnd()).getEndOffset();
} else {
// if more than one line is selected, we need to subtract one from the end
// so that we do not select the line with the caret and no selection in it
end = pDoc.getParagraphElement(target.getSelectionEnd() - 1).getEndOffset();
}
target.select(start, end);
lines = pDoc.getText(start, end - start).split("\n");
target.select(start, end);
} catch (BadLocationException ex) {
Logger.getLogger(ActionUtils.class.getName()).log(Level.SEVERE, null, ex);
lines = EMPTY_STRING_ARRAY;
}
return lines;
}
@Override
public void defaultAction(JTextComponent component) {
super.defaultAction(component);
final BaseDocument doc = (BaseDocument) component.getDocument();
doc.runAtomic(new Runnable() {
@Override
public void run() {
try {
doc.insertString(Util.findPositionForJspDirective(doc),
"<%@ taglib prefix=\"" //NOI18N
+ tagLibPrefix + "\" uri=\"" //NOI18N
+ tagLibURI + "\" %>\n", null); //NOI18N
} catch (BadLocationException ex) {
Exceptions.printStackTrace(ex);
}
}
});
}
@Override
public void actionPerformed(ActionEvent evt, JTextComponent target) {
final AtomicBoolean processedHere = new AtomicBoolean(false);
if (target != null) {
if (!target.isEditable() || !target.isEnabled() || !(target.getDocument() instanceof BaseDocument)) {
target.getToolkit().beep();
return;
}
final Positions positions = Positions.create(target);
final BaseDocument doc = (BaseDocument) target.getDocument();
doc.runAtomic(new Runnable() {
@Override
public void run() {
performCustomAction(doc, positions, processedHere);
}
});
if (!processedHere.get()) {
performDefaultAction(evt, target);
}
}
}
@Override
public void actionPerformed(ActionEvent e) {
JTextComponent target = getTextComponent(e);
boolean beep = true;
if ((target != null) && (target.isEditable())) {
try {
Document doc = target.getDocument();
int ss = 0;
int se = doc.getLength();
if (ss != se) {
doc.remove(ss, se - ss);
beep = false;
}
} catch (BadLocationException bl) {
}
}
if (beep) {
UIManager.getLookAndFeel().provideErrorFeedback(target);
}
}
public void processKeyEvent (KeyEvent evt) {
if (evt.getID() == KeyEvent.KEY_TYPED) {
char c = evt.getKeyChar();
JTextComponent component = (JTextComponent)evt.getSource();
if (confirmChars == null) {
confirmChars = getConfirmChars(component);
}
if (confirmChars.indexOf(c) != -1) {
if (c != '.') {
Completion.get().hideDocumentation();
Completion.get().hideCompletion();
}
NbEditorDocument doc = (NbEditorDocument) component.getDocument ();
try {
defaultAction(component);
doc.insertString(processKeyEventOffset, Character.toString(c), null);
} catch (BadLocationException e) {
}
if (c == '.')
Completion.get().showCompletion();
evt.consume();
} // if
} // if
}
/**
* If the selection is multi lined, then the full lines are selected,
* otherwise, nothing is done.
* @param target
* @return true if the selection is multi-line, or a whole line
*/
public static boolean selectLines(JTextComponent target) {
if (target.getSelectionStart() == target.getSelectionEnd()) {
return false;
}
PlainDocument pDoc = (PlainDocument) target.getDocument();
Element es = pDoc.getParagraphElement(target.getSelectionStart());
// if more than one line is selected, we need to subtract one from the end
// so that we do not select the line with the caret and no selection in it
Element ee = pDoc.getParagraphElement(target.getSelectionEnd() - 1);
if (es.equals(ee) && ee.getEndOffset() != target.getSelectionEnd()) {
return false;
}
int start = es.getStartOffset();
int end = ee.getEndOffset();
target.select(start, end - 1);
return true;
}
@Override
protected boolean canFilter(JTextComponent component) {
try {
if (component.getCaret() == null || component.getCaretPosition() < anchor) {
return false;
}
Document doc = component.getDocument();
int offset = component.getCaretPosition();
String prefix = doc.getText(anchor, offset - anchor);
//check the items
for (CompletionItem item : items) {
if (item instanceof HtmlCompletionItem) {
String itemText = ((HtmlCompletionItem) item).getItemText();
if(itemText != null) { //http://netbeans.org/bugzilla/show_bug.cgi?id=222234
if (startsWithIgnoreCase(itemText, prefix)) {
return true; //at least one item will remain
}
} else {
LOG.log(Level.WARNING, "CompletionItem {0} returned null from getItemText()!", item);
}
}
}
} catch (BadLocationException ex) {
Exceptions.printStackTrace(ex);
}
return false;
}
/** Creates a new instance of CaretSelectionLayer */
protected CaretBasedBlockHighlighting(JTextComponent component, String coloringName, boolean extendsEOL, boolean extendsEmptyLine) {
// Determine the mime type
String mimeType = BlockHighlighting.getMimeType(component);
this.mimePath = mimeType == null ? MimePath.EMPTY : MimePath.parse(mimeType);
this.coloringName = coloringName;
this.extendsEOL = extendsEOL;
this.extendsEmptyLine = extendsEmptyLine;
// Hook up the component
this.component = component;
selectionsBag = new PositionsBag(component.getDocument(), false);
}
/**
* Gets the Line Number at the give position of the editor component.
* The first line number is ZERO
* @param editor
* @param pos
* @return line number
* @throws javax.swing.text.BadLocationException
*/
public static int getLineNumber(JTextComponent editor, int pos)
throws BadLocationException {
if (getSyntaxDocument(editor) != null) {
SyntaxDocument sdoc = getSyntaxDocument(editor);
return sdoc.getLineNumberAt(pos);
} else {
Document doc = editor.getDocument();
return doc.getDefaultRootElement().getElementIndex(pos);
}
}
/**
* Resets the JTextComponent to <code>editor</code>. This will update
* the tree accordingly.
*/
public void setEditor(JTextComponent editor) {
if (this.editor == editor) {
return;
}
if (this.editor != null) {
Document oldDoc = this.editor.getDocument();
oldDoc.removeDocumentListener(this);
this.editor.removePropertyChangeListener(this);
this.editor.removeCaretListener(this);
}
this.editor = editor;
if (editor == null) {
treeModel = null;
tree.setModel(null);
} else {
Document newDoc = editor.getDocument();
newDoc.addDocumentListener(this);
editor.addPropertyChangeListener(this);
editor.addCaretListener(this);
treeModel = new ElementTreeModel(newDoc);
tree.setModel(treeModel);
}
}
/** Get the identifier around the given position or null if there's no identifier
* around the given position. The identifier is not verified against SyntaxSupport.isIdentifier().
* @param c JTextComponent to work on
* @param offset position in document - usually the caret.getDot()
* @return the block (starting and ending position) enclosing the identifier
* or null if no identifier was found
*/
public static int[] getIdentifierBlock(JTextComponent c, int offset)
throws BadLocationException {
CharSequence id = null;
int[] ret = null;
Document doc = c.getDocument();
int idStart = javax.swing.text.Utilities.getWordStart(c, offset);
if (idStart >= 0) {
int idEnd = javax.swing.text.Utilities.getWordEnd(c, idStart);
if (idEnd >= 0) {
id = DocumentUtilities.getText(doc, idStart, idEnd - idStart);
ret = new int[] { idStart, idEnd };
CharSequence trim = CharSequenceUtilities.trim(id);
if (trim.length() == 0 || (trim.length() == 1 && !Character.isJavaIdentifierPart(trim.charAt(0)))) {
int prevWordStart = javax.swing.text.Utilities.getPreviousWord(c, offset);
if (offset == javax.swing.text.Utilities.getWordEnd(c,prevWordStart )){
ret = new int[] { prevWordStart, offset };
} else {
return null;
}
} else if ((id != null) && (id.length() != 0) && (CharSequenceUtilities.indexOf(id, '.') != -1)){ //NOI18N
int index = offset - idStart;
int begin = CharSequenceUtilities.lastIndexOf(id.subSequence(0, index), '.');
begin = (begin == -1) ? 0 : begin + 1; //first index after the dot, if exists
int end = CharSequenceUtilities.indexOf(id, '.', index);
end = (end == -1) ? id.length() : end;
ret = new int[] { idStart+begin, idStart+end };
}
}
}
return ret;
}
public synchronized void propertyChange(PropertyChangeEvent evt) {
JTextComponent jtc = EditorRegistry.focusedComponent();
if (jtc == null) return;
Document active = jtc.getDocument();
Object sourceProperty = active.getProperty(Document.StreamDescriptionProperty);
if (!(sourceProperty instanceof DataObject)) return;
FileObject activeFile = ((DataObject)sourceProperty).getPrimaryFile();
TimesCollectorPeer.getDefault().select(activeFile);
}
/**
* Extend rectangular selection either by char in a specified selection
* or by word (if ctrl is pressed).
*
* @param toRight true for right or false for left.
* @param ctrl
*/
public void extendRectangularSelection(boolean toRight, boolean ctrl) {
JTextComponent c = component;
Document doc = c.getDocument();
int dotOffset = getDot();
Element lineRoot = doc.getDefaultRootElement();
int lineIndex = lineRoot.getElementIndex(dotOffset);
Element lineElement = lineRoot.getElement(lineIndex);
float charWidth;
LockedViewHierarchy lvh = ViewHierarchy.get(c).lock();
try {
charWidth = lvh.getDefaultCharWidth();
} finally {
lvh.unlock();
}
int newDotOffset = -1;
try {
int newlineOffset = lineElement.getEndOffset() - 1;
Rectangle newlineRect = c.modelToView(newlineOffset);
if (!ctrl) {
if (toRight) {
if (rsDotRect.x < newlineRect.x) {
newDotOffset = dotOffset + 1;
} else {
rsDotRect.x += charWidth;
}
} else { // toLeft
if (rsDotRect.x > newlineRect.x) {
rsDotRect.x -= charWidth;
if (rsDotRect.x < newlineRect.x) { // Fix on rsDotRect
newDotOffset = newlineOffset;
}
} else {
newDotOffset = Math.max(dotOffset - 1, lineElement.getStartOffset());
}
}
} else { // With Ctrl
int numVirtualChars = 8; // Number of virtual characters per one Ctrl+Shift+Arrow press
if (toRight) {
if (rsDotRect.x < newlineRect.x) {
newDotOffset = Math.min(Utilities.getNextWord(c, dotOffset), lineElement.getEndOffset() - 1);
} else { // Extend virtually
rsDotRect.x += numVirtualChars * charWidth;
}
} else { // toLeft
if (rsDotRect.x > newlineRect.x) { // Virtually extended
rsDotRect.x -= numVirtualChars * charWidth;
if (rsDotRect.x < newlineRect.x) {
newDotOffset = newlineOffset;
}
} else {
newDotOffset = Math.max(Utilities.getPreviousWord(c, dotOffset), lineElement.getStartOffset());
}
}
}
if (newDotOffset != -1) {
rsDotRect = c.modelToView(newDotOffset);
moveDot(newDotOffset); // updates rs and fires state change
} else {
updateRectangularSelectionPaintRect();
fireStateChanged();
}
} catch (BadLocationException ex) {
// Leave selection as is
}
}
private boolean doHandleTransfer(final JTextComponent targetComponent) {
final Document targetDoc = targetComponent.getDocument();
final FileObject targetSource = NbEditorUtilities.getFileObject(targetDoc);
Project targetProject = FileOwnerQuery.getOwner(targetSource);
Method m = method.getWadlMethod();
if(m == null)
Exceptions.printStackTrace(new IOException("Wadl method not found"));
final String displayName = m.getName();
targetFO = getTargetFile(targetDoc);
if (targetFO == null) {
return false;
}
final List<Exception> errors = new ArrayList<Exception>();
final ProgressDialog dialog = new ProgressDialog(
NbBundle.getMessage(RestClientEditorDrop.class, "LBL_CodeGenProgress",
displayName));
generatorTask = RequestProcessor.getDefault().create(new Runnable() {
public void run() {
try {
SaasClientCodeGenerator codegen = (SaasClientCodeGenerator)
SaasClientCodeGenerationManager.lookup(method, targetDoc);
codegen.init(method, targetDoc);
codegen.setDropLocation(targetComponent);
RestClientSaasBean bean = (RestClientSaasBean) codegen.getBean();
List<ParameterInfo> allParams = bean.filterParametersByAuth(
bean.filterParameters(new ParamFilter[]{ParamFilter.FIXED}));
boolean response = Util.showDialog(displayName, allParams, targetDoc);
if(response)
Util.doGenerateCode(codegen, dialog, errors);
} catch (Exception ioe) {
if(Constants.UNSUPPORTED_DROP.equals(ioe.getMessage())) {
Util.showUnsupportedDropMessage(new Object[] {
targetSource.getNameExt(), "Java Client"});
return;
}
errors.add(ioe);
} finally {
dialog.close();
}
}
});
generatorTask.schedule(50);
dialog.open();
if (errors.size() > 0) {
Exceptions.printStackTrace(errors.get(0));
return false;
}
return true;
}
private String getConfirmChars (JTextComponent component) {
NbEditorDocument doc = (NbEditorDocument) component.getDocument ();
StringBuffer buf = new StringBuffer();
int offset = component.getCaret ().getDot ();
try {
TokenHierarchy tokenHierarchy = TokenHierarchy.get (doc);
if (doc instanceof NbEditorDocument) {
((NbEditorDocument) doc).readLock ();
}
try {
TokenSequence sequence = tokenHierarchy.tokenSequence ();
if (sequence.isEmpty()) {
return ""; // NOI18N
}
//find most embedded token sequence on the specified offset
while(true) {
sequence.move (offset - 1);
if (!sequence.moveNext()) {
return ""; // NOI18N
}
TokenSequence embedded = sequence.embedded ();
if (embedded == null) break;
sequence = embedded;
}
Token token = sequence.token ();
String tokenType = token.id ().name ();
String mimeType = sequence.language ().mimeType ();
Language l = LanguagesManager.getDefault ().getLanguage (mimeType);
List<Feature> features = l.getFeatureList ().getFeatures (CompletionProviderImpl.COMPLETION, tokenType);
Iterator<Feature> it = features.iterator ();
while (it.hasNext ()) {
Feature feature = it.next ();
String confChars = (String) feature.getValue("confirmChars"); // NOI18N
if (confChars != null) {
buf.append(confChars);
}
}
} finally {
if (doc instanceof NbEditorDocument)
((NbEditorDocument) doc).readUnlock ();
}
} catch (LanguageDefinitionNotFoundException ex) {
}
return buf.toString();
}
@Override
public void actionPerformed (final ActionEvent evt, final JTextComponent target) {
if (target != null) {
if (!target.isEditable() || !target.isEnabled()) {
target.getToolkit().beep();
return;
}
final BaseDocument doc = (BaseDocument) target.getDocument();
if (doc instanceof GuardedDocument && ((GuardedDocument) doc).isPosGuarded(target.getCaretPosition())) {
target.getToolkit().beep();
return;
}
doc.runAtomicAsUser (new Runnable () {
@Override
public void run () {
DocumentUtilities.setTypingModification(doc, true);
try {
Element rootElement = doc.getDefaultRootElement();
Caret caret = target.getCaret();
boolean selection = false;
boolean backwardSelection = false;
int start = target.getCaretPosition();
int end = start;
// check if there is a selection
if (Utilities.isSelectionShowing(caret)) {
int selStart = caret.getDot();
int selEnd = caret.getMark();
start = Math.min(selStart, selEnd);
end = Math.max(selStart, selEnd) - 1;
selection = true;
backwardSelection = (selStart >= selEnd);
}
int zeroBaseStartLineNumber = rootElement.getElementIndex(start);
int zeroBaseEndLineNumber = rootElement.getElementIndex(end);
if (zeroBaseEndLineNumber == -1) {
// could not get line number
target.getToolkit().beep();
} else {
try {
// get line text
Element startLineElement = rootElement.getElement(zeroBaseStartLineNumber);
int startLineStartOffset = startLineElement.getStartOffset();
Element endLineElement = rootElement.getElement(zeroBaseEndLineNumber);
int endLineEndOffset = endLineElement.getEndOffset();
if (endLineEndOffset > doc.getLength()) {
return;
}
String linesText = doc.getText(startLineStartOffset, (endLineEndOffset - startLineStartOffset));
Element nextLineElement = rootElement.getElement(zeroBaseEndLineNumber + 1);
int nextLineEndOffset = nextLineElement.getEndOffset();
int column = start - startLineStartOffset;
// insert it after next line
if (nextLineEndOffset > doc.getLength()) {
doc.insertString(doc.getLength(), "\n" + linesText.substring(0, linesText.length()-1), null);
} else {
doc.insertString(nextLineEndOffset, linesText, null);
}
// remove original line
removeLineByLine(doc, startLineStartOffset, (endLineEndOffset - startLineStartOffset));
if (selection) {
// select moved lines
if (backwardSelection) {
if (doc.getLength() < nextLineEndOffset) {
caret.setDot(doc.getLength() - (endLineEndOffset - startLineStartOffset) + column + 1);
caret.moveDot(doc.getLength());
} else {
caret.setDot(nextLineEndOffset - (endLineEndOffset - startLineStartOffset) + column);
caret.moveDot(nextLineEndOffset - (endLineEndOffset - end - 1));
}
} else {
caret.setDot(nextLineEndOffset - (endLineEndOffset - end - 1));
caret.moveDot(nextLineEndOffset - (endLineEndOffset - startLineStartOffset) + column);
}
} else {
// set caret position
target.setCaretPosition(Math.min(doc.getLength(), nextLineEndOffset + column - (endLineEndOffset - startLineStartOffset)));
}
} catch (BadLocationException ex) {
target.getToolkit().beep();
}
}
} finally {
DocumentUtilities.setTypingModification(doc, false);
}
}
});
}
}
@SuppressWarnings("LeakingThisInConstructor")
public ElementTreePanel(JTextComponent editor) {
this.editor = editor;
Document document = editor.getDocument();
// Create the tree.
treeModel = new ElementTreeModel(document);
tree = new JTree(treeModel) {
@Override
public String convertValueToText(Object value, boolean selected,
boolean expanded, boolean leaf,
int row, boolean hasFocus) {
// Should only happen for the root
if (!(value instanceof Element)) {
return value.toString();
}
Element e = (Element) value;
AttributeSet as = e.getAttributes().copyAttributes();
String asString;
if (as != null) {
StringBuilder retBuffer = new StringBuilder("[");
Enumeration names = as.getAttributeNames();
while (names.hasMoreElements()) {
Object nextName = names.nextElement();
if (nextName != StyleConstants.ResolveAttribute) {
retBuffer.append(" ");
retBuffer.append(nextName);
retBuffer.append("=");
retBuffer.append(as.getAttribute(nextName));
}
}
retBuffer.append(" ]");
asString = retBuffer.toString();
} else {
asString = "[ ]";
}
if (e.isLeaf()) {
return e.getName() + " [" + e.getStartOffset() + ", " + e.
getEndOffset() + "] Attributes: " + asString;
}
return e.getName() + " [" + e.getStartOffset() + ", " + e.
getEndOffset() + "] Attributes: " + asString;
}
};
tree.addTreeSelectionListener(this);
tree.setDragEnabled(true);
// Don't show the root, it is fake.
tree.setRootVisible(false);
// Since the display value of every node after the insertion point
// changes every time the text changes and we don't generate a change
// event for all those nodes the display value can become off.
// This can be seen as '...' instead of the complete string value.
// This is a temporary workaround, increase the needed size by 15,
// hoping that will be enough.
tree.setCellRenderer(new DefaultTreeCellRenderer() {
@Override
public Dimension getPreferredSize() {
Dimension retValue = super.getPreferredSize();
if (retValue != null) {
retValue.width += 15;
}
return retValue;
}
});
// become a listener on the document to update the tree.
document.addDocumentListener(this);
// become a PropertyChangeListener to know when the Document has
// changed.
editor.addPropertyChangeListener(this);
// Become a CaretListener
editor.addCaretListener(this);
// configure the panel and frame containing it.
setLayout(new BorderLayout());
add(new JScrollPane(tree), BorderLayout.CENTER);
// Add a label above tree to describe what is being shown
JLabel label = new JLabel("Elements that make up the current document",
SwingConstants.CENTER);
label.setFont(new Font("Dialog", Font.BOLD, 14));
add(label, BorderLayout.NORTH);
setPreferredSize(new Dimension(400, 400));
}