/**
* Determines the preferred span for this view along an axis.
*
* @param axis may be either View.X_AXIS or View.Y_AXIS
* @return the span the view would like to be rendered into >= 0. Typically the view is told to
* render into the span that is returned, although there is no guarantee. The parent may
* choose to resize or break the view.
*/
public float getPreferredSpan(int axis) {
switch (axis) {
case View.X_AXIS:
Segment buff = SegmentCache.getSharedSegment();
Document doc = getDocument();
int width;
try {
FontMetrics fm = getFontMetrics();
doc.getText(0, doc.getLength(), buff);
width = Utilities.getTabbedTextWidth(buff, fm, 0, this, 0);
if (buff.count > 0) {
Component c = getContainer();
firstLineOffset =
sun.swing.SwingUtilities2.getLeftSideBearing(
(c instanceof JComponent) ? (JComponent) c : null, fm, buff.array[buff.offset]);
firstLineOffset = Math.max(0, -firstLineOffset);
} else {
firstLineOffset = 0;
}
} catch (BadLocationException bl) {
width = 0;
}
SegmentCache.releaseSharedSegment(buff);
return width + firstLineOffset;
default:
return super.getPreferredSpan(axis);
}
}
/**
* Updates the AttributedCharacterIterator by invoking <code>formatToCharacterIterator</code> on
* the <code>Format</code>. If this is successful, <code>updateMask(AttributedCharacterIterator)
* </code> is then invoked to update the internal bitmask.
*/
void updateMask() {
if (getFormat() != null) {
Document doc = getFormattedTextField().getDocument();
validMask = false;
if (doc != null) {
try {
string = doc.getText(0, doc.getLength());
} catch (BadLocationException ble) {
string = null;
}
if (string != null) {
try {
Object value = stringToValue(string);
AttributedCharacterIterator iterator = getFormat().formatToCharacterIterator(value);
updateMask(iterator);
} catch (ParseException pe) {
} catch (IllegalArgumentException iae) {
} catch (NullPointerException npe) {
}
}
}
}
}
private boolean replaceWithImage(int startOff, int endOff, Pattern ptn)
throws BadLocationException {
Document doc = getDocument();
String imgStr = doc.getText(startOff, endOff - startOff);
JComponent comp = null;
if (ptn == patPatternStr || ptn == patPngStr) {
if (pref.getPrefMoreImageThumbs()) {
comp = EditorPatternButton.createFromString(this, imgStr, null);
} else {
comp = EditorPatternLabel.labelFromString(this, imgStr);
}
} else if (ptn == patRegionStr) {
if (pref.getPrefMoreImageThumbs()) {
comp = EditorRegionButton.createFromString(this, imgStr);
} else {
comp = EditorRegionLabel.labelFromString(this, imgStr);
}
} else if (ptn == patCaptureBtn) {
comp = EditorPatternLabel.labelFromString(this, "");
}
if (comp != null) {
this.select(startOff, endOff);
this.insertComponent(comp);
return true;
}
return false;
}
private void analyseDocument(Document document, int lineNum, PythonIndentation indentationLogic)
throws BadLocationException {
Element map = document.getDefaultRootElement();
int endPos = map.getElement(lineNum).getEndOffset();
indentationLogic.reset();
indentationLogic.addText(document.getText(0, endPos));
}
private void initGuardedBlocks(Place shreds) {
int origOffset = -1;
int curOffset = 0;
for (PsiLanguageInjectionHost.Shred shred : shreds) {
Segment hostRangeMarker = shred.getHostRangeMarker();
int start = shred.getRange().getStartOffset() + shred.getPrefix().length();
int end = shred.getRange().getEndOffset() - shred.getSuffix().length();
if (curOffset < start) {
RangeMarker guard = myNewDocument.createGuardedBlock(curOffset, start);
if (curOffset == 0 && shred == shreds.get(0)) guard.setGreedyToLeft(true);
String padding =
origOffset < 0
? ""
: myOrigDocument.getText().substring(origOffset, hostRangeMarker.getStartOffset());
guard.putUserData(REPLACEMENT_KEY, fixQuotes(padding));
}
curOffset = end;
origOffset = hostRangeMarker.getEndOffset();
}
if (curOffset < myNewDocument.getTextLength()) {
RangeMarker guard =
myNewDocument.createGuardedBlock(curOffset, myNewDocument.getTextLength());
guard.setGreedyToRight(true);
guard.putUserData(REPLACEMENT_KEY, "");
}
}
private void altCommitToOriginal(@NotNull DocumentEvent e) {
final PsiFile origPsiFile =
PsiDocumentManager.getInstance(myProject).getPsiFile(myOrigDocument);
String newText = myNewDocument.getText();
// prepare guarded blocks
LinkedHashMap<String, String> replacementMap = new LinkedHashMap<String, String>();
int count = 0;
for (RangeMarker o : ContainerUtil.reverse(((DocumentEx) myNewDocument).getGuardedBlocks())) {
String replacement = o.getUserData(REPLACEMENT_KEY);
String tempText = "REPLACE" + (count++) + Long.toHexString(StringHash.calc(replacement));
newText =
newText.substring(0, o.getStartOffset()) + tempText + newText.substring(o.getEndOffset());
replacementMap.put(tempText, replacement);
}
// run preformat processors
final int hostStartOffset = myAltFullRange.getStartOffset();
myEditor.getCaretModel().moveToOffset(hostStartOffset);
for (CopyPastePreProcessor preProcessor :
Extensions.getExtensions(CopyPastePreProcessor.EP_NAME)) {
newText = preProcessor.preprocessOnPaste(myProject, origPsiFile, myEditor, newText, null);
}
myOrigDocument.replaceString(hostStartOffset, myAltFullRange.getEndOffset(), newText);
// replace temp strings for guarded blocks
for (String tempText : replacementMap.keySet()) {
int idx =
CharArrayUtil.indexOf(
myOrigDocument.getCharsSequence(),
tempText,
hostStartOffset,
myAltFullRange.getEndOffset());
myOrigDocument.replaceString(idx, idx + tempText.length(), replacementMap.get(tempText));
}
// JAVA: fix occasional char literal concatenation
fixDocumentQuotes(myOrigDocument, hostStartOffset - 1);
fixDocumentQuotes(myOrigDocument, myAltFullRange.getEndOffset());
// reformat
PsiDocumentManager.getInstance(myProject).commitDocument(myOrigDocument);
Runnable task =
() -> {
try {
CodeStyleManager.getInstance(myProject)
.reformatRange(origPsiFile, hostStartOffset, myAltFullRange.getEndOffset(), true);
} catch (IncorrectOperationException e1) {
// LOG.error(e);
}
};
DocumentUtil.executeInBulk(myOrigDocument, true, task);
PsiElement newInjected =
InjectedLanguageManager.getInstance(myProject)
.findInjectedElementAt(origPsiFile, hostStartOffset);
DocumentWindow documentWindow =
newInjected == null ? null : InjectedLanguageUtil.getDocumentWindow(newInjected);
if (documentWindow != null) {
myEditor.getCaretModel().moveToOffset(documentWindow.injectedToHost(e.getOffset()));
myEditor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE);
}
}
public void insertUpdate(DocumentEvent e) {
Document doc = e.getDocument();
try {
prop.set(doc.getText(0, doc.getLength()));
} catch (BadLocationException b) {
// Once again, no idea what this is supposed to be.
// I don't think I like this interface much :-(.
System.out.println(b);
}
}
private void commitToOriginalInner() {
final String text = myNewDocument.getText();
final Map<
PsiLanguageInjectionHost,
Set<Trinity<RangeMarker, RangeMarker, SmartPsiElementPointer>>>
map =
ContainerUtil.classify(
myMarkers.iterator(),
new Convertor<
Trinity<RangeMarker, RangeMarker, SmartPsiElementPointer>,
PsiLanguageInjectionHost>() {
@Override
public PsiLanguageInjectionHost convert(
final Trinity<RangeMarker, RangeMarker, SmartPsiElementPointer> o) {
final PsiElement element = o.third.getElement();
return (PsiLanguageInjectionHost) element;
}
});
PsiDocumentManager documentManager = PsiDocumentManager.getInstance(myProject);
documentManager.commitDocument(myOrigDocument); // commit here and after each manipulator update
int localInsideFileCursor = 0;
for (PsiLanguageInjectionHost host : map.keySet()) {
if (host == null) continue;
String hostText = host.getText();
ProperTextRange insideHost = null;
StringBuilder sb = new StringBuilder();
for (Trinity<RangeMarker, RangeMarker, SmartPsiElementPointer> entry : map.get(host)) {
RangeMarker origMarker = entry.first; // check for validity?
int hostOffset = host.getTextRange().getStartOffset();
ProperTextRange localInsideHost =
new ProperTextRange(
origMarker.getStartOffset() - hostOffset, origMarker.getEndOffset() - hostOffset);
RangeMarker rangeMarker = entry.second;
ProperTextRange localInsideFile =
new ProperTextRange(
Math.max(localInsideFileCursor, rangeMarker.getStartOffset()),
rangeMarker.getEndOffset());
if (insideHost != null) {
// append unchanged inter-markers fragment
sb.append(
hostText.substring(insideHost.getEndOffset(), localInsideHost.getStartOffset()));
}
sb.append(
localInsideFile.getEndOffset() <= text.length() && !localInsideFile.isEmpty()
? localInsideFile.substring(text)
: "");
localInsideFileCursor = localInsideFile.getEndOffset();
insideHost = insideHost == null ? localInsideHost : insideHost.union(localInsideHost);
}
assert insideHost != null;
ElementManipulators.getManipulator(host).handleContentChange(host, insideHost, sb.toString());
documentManager.commitDocument(myOrigDocument);
}
}
private void updateBoard(DocumentEvent e) throws BadLocationException {
Document doc = e.getDocument();
int index = (int) doc.getProperty("index");
String valueString = doc.getText(0, doc.getLength());
if (doc.getLength() == 0) valueString = "0";
int value = Integer.parseInt(valueString);
gameBoard.changeCellAt(index, value);
// gameBoard.out();
if (gameBoard.checkGameOver()) {
JOptionPane.showMessageDialog(frame, "NUMBRIX COMPLETED!!!");
}
}
/*
* public int search(String str){
* return search(str, true);
* }
*/
public int search(String str, int pos, boolean forward) {
boolean isCaseSensitive = true;
String toSearch = str;
if (str.startsWith("!")) {
str = str.substring(1).toUpperCase();
isCaseSensitive = false;
}
int ret = -1;
Document doc = getDocument();
Debug.log(9, "search caret: " + pos + ", " + doc.getLength());
try {
String body;
int begin;
if (forward) {
int len = doc.getLength() - pos;
body = doc.getText(pos, len > 0 ? len : 0);
begin = pos;
} else {
body = doc.getText(0, pos);
begin = 0;
}
if (!isCaseSensitive) {
body = body.toUpperCase();
}
Pattern pattern = Pattern.compile(Pattern.quote(str));
Matcher matcher = pattern.matcher(body);
ret = continueSearch(matcher, begin, forward);
if (ret < 0) {
if (forward && pos != 0) {
return search(toSearch, 0, forward);
}
if (!forward && pos != doc.getLength()) {
return search(toSearch, doc.getLength(), forward);
}
}
} catch (BadLocationException e) {
Debug.log(7, "search caret: " + pos + ", " + doc.getLength() + e.getStackTrace());
}
return ret;
}
@Override
@SuppressWarnings("SleepWhileHoldingLock")
public void run() {
try {
// initialize the statusbar
status.removeAll();
JProgressBar progress = new JProgressBar();
progress.setMinimum(0);
progress.setMaximum(doc.getLength());
status.add(progress);
status.revalidate();
// start writing
Writer out = new FileWriter(f);
Segment text = new Segment();
text.setPartialReturn(true);
int charsLeft = doc.getLength();
int offset = 0;
while (charsLeft > 0) {
doc.getText(offset, Math.min(4096, charsLeft), text);
out.write(text.array, text.offset, text.count);
charsLeft -= text.count;
offset += text.count;
progress.setValue(offset);
try {
Thread.sleep(10);
} catch (InterruptedException e) {
Logger.getLogger(FileSaver.class.getName()).log(Level.SEVERE, null, e);
}
}
out.flush();
out.close();
} catch (IOException e) {
final String msg = e.getMessage();
SwingUtilities.invokeLater(
new Runnable() {
public void run() {
JOptionPane.showMessageDialog(
getFrame(),
"Could not save file: " + msg,
"Error saving file",
JOptionPane.ERROR_MESSAGE);
}
});
} catch (BadLocationException e) {
System.err.println(e.getMessage());
}
// we are done... get rid of progressbar
status.removeAll();
status.revalidate();
}
/**
* This function inserts or replaces the user's input in a string buffer, to create the text
* which would be on screen if we allowed it. We declare to throw bad location due to
* doc.getText, but since the paramters are coming from the farmework, that should never
* happen.... in theory. If insert is true we insert, if false we replace. Length parameter only
* used when replacing.
*/
private StringBuffer getTextPrototype(
boolean insert, FilterBypass fb, int offs, String str, int length)
throws BadLocationException {
Document doc = fb.getDocument();
String text = doc.getText(0, doc.getLength());
StringBuffer sb = new StringBuffer(text);
if (insert) {
sb.insert(offs, str);
} else {
sb.replace(offs, offs + length, str);
}
return sb;
} // end of getTextPrototype
public String getCurrentWordBeforeCursor() {
Document doc = getDocument();
if (doc == null) return null;
int charsToLookBack = 10;
int docLength = doc.getLength();
if (docLength < charsToLookBack) charsToLookBack = docLength - 1;
String allTextBeforeCaretPosition = null;
String oldContent = null;
String charsSinceLastWhitespace = null;
try {
allTextBeforeCaretPosition = doc.getText(0, getCaretPosition());
LastWhitespaceInfo info = findLastWhitespaceLocation(allTextBeforeCaretPosition);
if (info.lastWhitespaceLocation > 0 && doc.getLength() > (charsToLookBack - 1)) {
// get caret position
int caretPosition = getCaretPosition();
// look at last 10 characters
int scanBackPosition = caretPosition - charsToLookBack;
if (scanBackPosition <= 0) return null;
String recentChars = doc.getText(scanBackPosition, charsToLookBack);
// if any characters are blanks, get the characters since the last blank
int lastWhitespacePosition = recentChars.lastIndexOf(info.lastWhitespaceString);
if (lastWhitespacePosition <= 0) return null;
charsSinceLastWhitespace =
recentChars.substring(lastWhitespacePosition + 1, charsToLookBack);
return charsSinceLastWhitespace;
} else {
return null;
}
} catch (BadLocationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
}
}
private void checkCompletion(java.awt.event.KeyEvent ke) throws BadLocationException {
Document doc = getDocument();
Element root = doc.getDefaultRootElement();
int pos = getCaretPosition();
int lineIdx = root.getElementIndex(pos);
Element line = root.getElement(lineIdx);
int start = line.getStartOffset(), len = line.getEndOffset() - start;
String strLine = doc.getText(start, len - 1);
Debug.log(9, "[" + strLine + "]");
if (strLine.endsWith("find") && ke.getKeyChar() == '(') {
ke.consume();
doc.insertString(pos, "(", null);
ButtonCapture btnCapture = new ButtonCapture(this, line);
insertComponent(btnCapture);
doc.insertString(pos + 2, ")", null);
}
}
private String addWhiteSpace(Document doc, int offset) throws BadLocationException {
StringBuilder whiteSpace = new StringBuilder("\n");
Element rootElement = doc.getDefaultRootElement();
int line = rootElement.getElementIndex(offset);
int i = rootElement.getElement(line).getStartOffset();
while (true) {
String temp = doc.getText(i, 1);
if (temp.equals(" ") || temp.equals("\t")) {
whiteSpace.append(temp);
i++;
} else break;
}
return whiteSpace.toString();
}
/**
* Updates the shared value instance if updateValue is true. Always forces the redraw of
* everything.
*/
protected void doValueUpdate(FilterBypass fb) throws BadLocationException {
Document doc = fb.getDocument();
String text = doc.getText(0, doc.getLength());
if (text.isEmpty()) {
text = "0";
}
if (updateValue == true) {
try {
Double value = new Double(text);
double newValue = multiplier.getValueToBeSet(value.doubleValue());
cValue.setValue(newValue);
} catch (NumberFormatException e) {
// do nothing, since we allow '-'
}
}
topContainer.forceRedraw();
}
private int getFunctionStartOffset(String func, Element node) throws BadLocationException {
Document doc = getDocument();
int count = node.getElementCount();
Pattern patDef = Pattern.compile("def\\s+" + func + "\\s*\\(");
for (int i = 0; i < count; i++) {
Element elm = node.getElement(i);
if (elm.isLeaf()) {
int start = elm.getStartOffset(), end = elm.getEndOffset();
String line = doc.getText(start, end - start);
Matcher matcher = patDef.matcher(line);
if (matcher.find()) {
return start;
}
} else {
int p = getFunctionStartOffset(func, elm);
if (p >= 0) {
return p;
}
}
}
return -1;
}
@Override
public void replace(
DocumentFilter.FilterBypass fp, int offset, int length, String string, AttributeSet aset)
throws BadLocationException {
Document doc = fp.getDocument();
String oldText = doc.getText(0, doc.getLength());
StringBuilder sb = new StringBuilder(oldText);
sb.replace(offset, offset + length, oldText);
int len = string.length();
boolean isValidInteger = true;
for (int i = 0; i < len; i++) {
if (!Character.isDigit(string.charAt(i))) {
isValidInteger = false;
break;
}
}
if (isValidInteger && verifyText(sb.toString())) {
super.replace(fp, offset, length, string, aset);
} else Toolkit.getDefaultToolkit().beep();
}
public void write(Writer out, Document doc, int pos, int len, Map<String, String> copiedImgs)
throws IOException, BadLocationException {
Debug.log(9, "SikuliEditorKit.write %d %d", pos, len);
DefaultStyledDocument sdoc = (DefaultStyledDocument) doc;
int i = pos;
String absPath;
while (i < pos + len) {
Element e = sdoc.getCharacterElement(i);
int start = e.getStartOffset(), end = e.getEndOffset();
if (e.getName().equals(StyleConstants.ComponentElementName)) {
// A image argument to be filled
AttributeSet attr = e.getAttributes();
Component com = StyleConstants.getComponent(attr);
out.write(com.toString());
if (copiedImgs != null
&& (com instanceof EditorPatternButton || com instanceof EditorPatternLabel)) {
if (com instanceof EditorPatternButton) {
absPath = ((EditorPatternButton) com).getFilename();
} else {
absPath = ((EditorPatternLabel) com).getFile();
}
String fname = (new File(absPath)).getName();
copiedImgs.put(fname, absPath);
Debug.log(3, "save image for copy&paste: " + fname + " -> " + absPath);
}
} else {
if (start < pos) {
start = pos;
}
if (end > pos + len) {
end = pos + len;
}
out.write(doc.getText(start, end - start));
}
i = end;
}
out.close();
}
private int parseLine(int startOff, int endOff, Pattern ptn) throws BadLocationException {
if (endOff <= startOff) {
return endOff;
}
Document doc = getDocument();
while (true) {
String line = doc.getText(startOff, endOff - startOff);
Matcher m = ptn.matcher(line);
// System.out.println("["+line+"]");
if (m.find()) {
int len = m.end() - m.start();
if (replaceWithImage(startOff + m.start(), startOff + m.end(), ptn)) {
startOff += m.start() + 1;
endOff -= len - 1;
} else {
startOff += m.end() + 1;
}
} else {
break;
}
}
return endOff;
}
void updateTheLabel(DocumentEvent e) {
Document doc = (Document) e.getDocument();
String text = null;
try {
text = doc.getText(0, doc.getLength());
doc = null;
} catch (BadLocationException ex) {
text = null;
}
if (text != null) {
try {
double number = Double.parseDouble(text);
if (number > 1) {
label.setText(labelPair.getPlural());
} else {
label.setText(labelPair.getSingular());
}
} catch (NumberFormatException ex) {
// Do nothing
} finally {
text = null;
}
}
}
private void reparsePsiFile() {
myVirtualFile.setContent(myEditorDocument, myEditorDocument.getText(), false);
FileContentUtil.reparseFiles(
myProject, Collections.<VirtualFile>singletonList(myVirtualFile), false);
myFile = ObjectUtils.assertNotNull(PsiManager.getInstance(myProject).findFile(myVirtualFile));
}
