@Override
protected Transferable createTransferable(JComponent c) {
JTextPane aTextPane = (JTextPane) c;
HTMLEditorKit kit = ((HTMLEditorKit) aTextPane.getEditorKit());
StyledDocument sdoc = aTextPane.getStyledDocument();
int sel_start = aTextPane.getSelectionStart();
int sel_end = aTextPane.getSelectionEnd();
int i = sel_start;
StringBuilder output = new StringBuilder();
while (i < sel_end) {
Element e = sdoc.getCharacterElement(i);
Object nameAttr = e.getAttributes().getAttribute(StyleConstants.NameAttribute);
int start = e.getStartOffset(), end = e.getEndOffset();
if (nameAttr == HTML.Tag.BR) {
output.append("\n");
} else if (nameAttr == HTML.Tag.CONTENT) {
if (start < sel_start) {
start = sel_start;
}
if (end > sel_end) {
end = sel_end;
}
try {
String str = sdoc.getText(start, end - start);
output.append(str);
} catch (BadLocationException ble) {
Debug.error(me + "Copy-paste problem!\n%s", ble.getMessage());
}
}
i = end;
}
return new StringSelection(output.toString());
}
private void updateTemplateFromEditor(PrintfTemplate template) {
ArrayList params = new ArrayList();
String format = null;
int text_length = editorPane.getDocument().getLength();
try {
format = editorPane.getDocument().getText(0, text_length);
} catch (BadLocationException ex1) {
}
Element section_el = editorPane.getDocument().getDefaultRootElement();
// Get number of paragraphs.
int num_para = section_el.getElementCount();
for (int p_count = 0; p_count < num_para; p_count++) {
Element para_el = section_el.getElement(p_count);
// Enumerate the content elements
int num_cont = para_el.getElementCount();
for (int c_count = 0; c_count < num_cont; c_count++) {
Element content_el = para_el.getElement(c_count);
AttributeSet attr = content_el.getAttributes();
// Get the name of the style applied to this content element; may be null
String sn = (String) attr.getAttribute(StyleConstants.NameAttribute);
// Check if style name match
if (sn != null && sn.startsWith("Parameter")) {
// we extract the label.
JLabel l = (JLabel) StyleConstants.getComponent(attr);
if (l != null) {
params.add(l.getName());
}
}
}
}
template.setFormat(format);
template.setTokens(params);
}
// TODO: make this a method of SikuliDocument, no need to pass document as argument
private void changeIndentation(DefaultStyledDocument doc, int linenum, int columns)
throws BadLocationException {
PreferencesUser pref = PreferencesUser.getInstance();
boolean expandTab = pref.getExpandTab();
int tabWidth = pref.getTabWidth();
if (linenum < 0) {
throw new BadLocationException("Negative line", -1);
}
Element map = doc.getDefaultRootElement();
if (linenum >= map.getElementCount()) {
throw new BadLocationException("No such line", doc.getLength() + 1);
}
if (columns == 0) {
return;
}
Element lineElem = map.getElement(linenum);
int lineStart = lineElem.getStartOffset();
int lineLength = lineElem.getEndOffset() - lineStart;
String line = doc.getText(lineStart, lineLength);
// determine current indentation and number of whitespace characters
int wsChars;
int indentation = 0;
for (wsChars = 0; wsChars < line.length(); wsChars++) {
char c = line.charAt(wsChars);
if (c == ' ') {
indentation++;
} else if (c == '\t') {
indentation += tabWidth;
} else {
break;
}
}
int newIndentation = indentation + columns;
if (newIndentation <= 0) {
doc.remove(lineStart, wsChars);
return;
}
// build whitespace string for new indentation
StringBuilder newWs = new StringBuilder(newIndentation / tabWidth + tabWidth - 1);
int ind = 0;
if (!expandTab) {
for (; ind + tabWidth <= newIndentation; ind += tabWidth) {
newWs.append('\t');
}
}
for (; ind < newIndentation; ind++) {
newWs.append(' ');
}
doc.replace(lineStart, wsChars, newWs.toString(), null);
}
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 static int getNSVisualPosition(EditorPane txt, int pos, int direction) {
Element root = txt.getDocument().getDefaultRootElement();
int numLines = root.getElementIndex(txt.getDocument().getLength() - 1) + 1;
int line = root.getElementIndex(pos) + 1;
int tarLine = direction == SwingConstants.NORTH ? line - 1 : line + 1;
try {
if (tarLine <= 0) {
return 0;
}
if (tarLine > numLines) {
return txt.getDocument().getLength();
}
Rectangle curRect = txt.modelToView(pos);
Rectangle tarEndRect;
if (tarLine < numLines) {
tarEndRect = txt.modelToView(txt.getLineStartOffset(tarLine) - 1);
} else {
tarEndRect = txt.modelToView(txt.getDocument().getLength() - 1);
}
Debug.log(9, "curRect: " + curRect + ", tarEnd: " + tarEndRect);
if (curRect.x > tarEndRect.x) {
pos = txt.viewToModel(new Point(tarEndRect.x, tarEndRect.y));
} else {
pos = txt.viewToModel(new Point(curRect.x, tarEndRect.y));
}
} catch (BadLocationException e) {
Debug.error(me + "Problem getting next visual position\n%s", e.getMessage());
}
return pos;
}
/*
* We need to know if the caret is currently positioned on the line we
* are about to paint so the line number can be highlighted.
*/
private boolean isCurrentLine(int rowStartOffset) {
int caretPosition = component.getCaretPosition();
Element root = component.getDocument().getDefaultRootElement();
if (root.getElementIndex(rowStartOffset) == root.getElementIndex(caretPosition)) return true;
else return false;
}
@Override
public void mouseClicked(MouseEvent me) {
Element el = doc.getCharacterElement(viewToModel(me.getPoint()));
if (el == null) return;
AttributeSet as = el.getAttributes();
if (as.isDefined("ip")) {
String ip = (String) as.getAttribute("ip");
ScriptException se = (ScriptException) as.getAttribute("exception");
Node node = net.getAtIP(ip);
if (node == null) {
Utility.displayError("Error", "Computer does not exist");
return;
}
String errorString =
"--ERROR--\n"
+ "Error at line number "
+ se.getLineNumber()
+ " and column number "
+ se.getColumnNumber()
+ "\n"
+ se.getMessage();
new ScriptDialog(
parentFrame,
str -> {
if (str != null) {
node.setScript(str);
}
},
node.getScript(),
errorString)
.setVisible(true);
}
}
/*
* Get the line number to be drawn. The empty string will be returned
* when a line of text has wrapped.
*/
protected String getTextLineNumber(int rowStartOffset) {
Element root = component.getDocument().getDefaultRootElement();
int index = root.getElementIndex(rowStartOffset);
Element line = root.getElement(index);
if (line.getStartOffset() == rowStartOffset) return String.valueOf(index + 1);
else return "";
}
public synchronized List<Element> getRestriccionColored() {
List<Element> resp = new ArrayList();
for (Element e : restriccion) {
if (!e.getCol().equals(WHITE)) {
resp.add(e);
}
}
return resp;
}
/** Invoked when an action occurs. */
public static BoxItem createNewElement(String className, int posX, int posY) {
BoxItem ret = null;
Element elem = null;
try {
if (debug) System.out.println("Creating new element '" + className + "'");
elem = Element.newInstance(className);
if (elem == null) {
if (debug) System.out.println("Element '" + className + "' not found");
return null;
}
ret = elem.getDesignerBox();
ret.setBounds(
(posX / DesignEventHandler.ELEM_STEP) * DesignEventHandler.ELEM_STEP,
(posY / DesignEventHandler.ELEM_STEP) * DesignEventHandler.ELEM_STEP,
ConfigurableSystemSettings.getDesignerElementWidth(),
ConfigurableSystemSettings.getDesignerElementHeight());
Main.app.designFrame.addElement(ret);
Item.highlighted.clear();
Item.highlighted.add(ret);
Main.app.processor.add(elem);
// elem.setActive(false);
Main.app.designFrame.panel.repaint();
if (elem instanceof Display) {
Chart chart = ((Display) elem).newChart();
((Display) elem).setChart(chart);
chart.setAtTopLayer();
// System.out.println("c1 " + chart.getBounds());
Main.app.runtimeFrame.addChart(chart);
// Main.app.runtimeFrame.show();
Main.app.runtimeFrame.setVisible();
// Main.app.runtimeFrame.repaint();
// Change runtime to edit mode if not now
if (!Main.app.runtimeFrame.framedCharts) {
Main.app.runtimeFrame.framedCharts = true;
try {
Main.app.runtimeFrame.reload();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
elem.reinit();
} catch (Exception e) {
if (elem != null) elem.disactivate(e);
System.out.println("New element error: " + e);
// e.printStackTrace();
} catch (Throwable e) {
System.out.println("Critical error occurred while creating new element: " + e);
e.printStackTrace();
}
return ret;
}
@Override
public void mouseMoved(MouseEvent me) {
Element el = doc.getCharacterElement(viewToModel(me.getPoint()));
if (el == null) return;
AttributeSet as = el.getAttributes();
if (as.isDefined("ip")) {
setCursor(handCursor);
} else {
setCursor(defaultCursor);
}
}
public int getLineStartOffset(int line) throws BadLocationException {
// line starting from 0
Element map = getDocument().getDefaultRootElement();
if (line < 0) {
throw new BadLocationException("Negative line", -1);
} else if (line >= map.getElementCount()) {
throw new BadLocationException("No such line", getDocument().getLength() + 1);
} else {
Element lineElem = map.getElement(line);
return lineElem.getStartOffset();
}
}
public Element getLineAtPoint(MouseEvent me) {
Point p = me.getLocationOnScreen();
Point pp = getLocationOnScreen();
p.translate(-pp.x, -pp.y);
int pos = viewToModel(p);
Element root = getDocument().getDefaultRootElement();
int e = root.getElementIndex(pos);
if (e == -1) {
return null;
}
return root.getElement(e);
}
public File reparseBefore() {
Element e = this.getDocument().getDefaultRootElement();
if (e.getEndOffset() - e.getStartOffset() == 1) {
return null;
}
File temp = FileManager.createTempFile("reparse");
try {
writeFile(temp.getAbsolutePath());
return temp;
} catch (IOException ex) {
}
return null;
}
private void handleDecreaseIndent(int line, Element elem, StyledDocument doc)
throws BadLocationException {
int start = elem.getStartOffset();
int end = elem.getEndOffset() - 1;
doc.getText(start, end - start, segLine);
int i = segLine.offset;
end = i + segLine.count;
if (end > i) {
String leadingWS = PythonIndentation.getLeadingWhitespace(doc, start, end - start);
int toRemove = indentationLogic.checkDedent(leadingWS, line + 1);
doc.remove(start, toRemove);
}
}
// <editor-fold defaultstate="collapsed" desc="replace text patterns with image buttons">
public boolean reparse() {
File temp = null;
Element e = this.getDocument().getDefaultRootElement();
if (e.getEndOffset() - e.getStartOffset() == 1) {
return true;
}
if ((temp = reparseBefore()) != null) {
if (reparseAfter(temp)) {
updateDocumentListeners();
return true;
}
}
return false;
}
public void caretUpdate(CaretEvent e) {
// when the cursor moves on _textView
// this method will be called. Then, we
// must determine what the line number is
// and update the line number view
Element root = textView.getDocument().getDefaultRootElement();
int line = root.getElementIndex(e.getDot());
root = root.getElement(line);
int col = root.getElementIndex(e.getDot());
lineNumberView.setText(line + ":" + col);
// if text is selected then enable copy and cut
boolean isSelection = e.getDot() != e.getMark();
copyAction.setEnabled(isSelection);
cutAction.setEnabled(isSelection);
}
//
// Implement CaretListener interface
//
@Override
public void caretUpdate(CaretEvent e) {
// Get the line the caret is positioned on
int caretPosition = component.getCaretPosition();
Element root = component.getDocument().getDefaultRootElement();
int currentLine = root.getElementIndex(caretPosition);
// Need to repaint so the correct line number can be highlighted
if (lastLine != currentLine) {
repaint();
lastLine = currentLine;
}
}
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();
}
void editorPane_keyPressed(KeyEvent e) {
StyledDocument doc = editorPane.getStyledDocument();
int pos = editorPane.getCaretPosition();
int code = e.getKeyCode();
Element el;
switch (code) {
case KeyEvent.VK_BACK_SPACE:
case KeyEvent.VK_DELETE:
case KeyEvent.VK_LEFT:
case KeyEvent.VK_KP_LEFT:
if (pos == 0) return;
// we want to get the element to the left of position.
el = doc.getCharacterElement(pos - 1);
break;
case KeyEvent.VK_RIGHT:
case KeyEvent.VK_KP_RIGHT:
// we want to get the element to the right of position.
el = doc.getCharacterElement(pos + 1);
break;
default:
return; // bail we don't handle it.
}
AttributeSet attr = el.getAttributes();
String el_name = (String) attr.getAttribute(StyleConstants.NameAttribute);
int el_range = el.getEndOffset() - el.getStartOffset() - 1;
if (el_name.startsWith("Parameter") && StyleConstants.getComponent(attr) != null) {
try {
switch (code) {
case KeyEvent.VK_BACK_SPACE:
case KeyEvent.VK_DELETE:
doc.remove(el.getStartOffset(), el_range);
break;
case KeyEvent.VK_LEFT:
case KeyEvent.VK_KP_LEFT:
editorPane.setCaretPosition(pos - el_range);
break;
case KeyEvent.VK_RIGHT:
case KeyEvent.VK_KP_RIGHT:
editorPane.setCaretPosition(pos + (el_range));
break;
}
} catch (BadLocationException ex) {
}
}
}
/** Calculate the width needed to display the maximum line number */
private void setPreferredWidth() {
Element root = component.getDocument().getDefaultRootElement();
int lines = root.getElementCount();
int digits = Math.max(String.valueOf(lines).length(), minimumDisplayDigits);
// Update sizes when number of digits in the line number changes
if (lastDigits != digits) {
lastDigits = digits;
FontMetrics fontMetrics = getFontMetrics(getFont());
int width = fontMetrics.charWidth('0') * digits;
Insets insets = getInsets();
int preferredWidth = insets.left + insets.right + width;
Dimension d = getPreferredSize();
d.setSize(preferredWidth, HEIGHT);
setPreferredSize(d);
setSize(d);
}
}
public Element getLineAtCaret(int caretPosition) {
Element root = getDocument().getDefaultRootElement();
if (caretPosition == -1) {
return root.getElement(root.getElementIndex(getCaretPosition()));
} else {
return root.getElement(root.getElementIndex(root.getElementIndex(caretPosition)));
}
}
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 StructureType assignStructureType(Element structure) throws VisualizerLoadException {
String name = structure.getName().toLowerCase();
if (name.compareTo("graph") == 0) {
if (structure.getAttributeValue("weighted").compareTo("true") == 0)
return new Graph_Network("NETWORK");
else return new Graph_Network("GRAPH");
} else if (name.equals("array")) return new MD_Array();
else if (name.equals("no3darray")) return new No3darray();
else if (name.equals("linkedlist")) return new VisLinkedList();
else if (name.equals("no3dlinkedlist")) return new No3dLinkedList();
else if (name.equals("linkedlistnonull")) return new VisLinkedListNoNull();
else if (name.equals("bargraph")) return new BarScat("BAR");
else if (name.equals("scattergraph"))
return new BarScat(
"SCAT"); // not implemented in xml dtd, and does not have a load-from-xml method defined
else if (name.equals("stack")) return new Stack();
else if (name.equals("queue")) return new Queue();
else if (name.equals("tree")) {
if (structure.getChild("binary_node") != null) return new BinaryTree();
else return new GeneralTree();
} else if (name.equals("text")) return new TextStructure();
// if the XML element name is different from your structure's name, you can do something like
// this:
// else if( name.equalsIgnoreCase("node"))
// return new Node();
else if (name.equals("legend")) return new LegendofColors();
else {
// try dynamic typing
try {
return assignStructureType(name);
} catch (Exception e) {
throw new VisualizerLoadException(
"Unable to instantiate class \"" + name + "\":\n" + e.getMessage());
}
}
}
/** Returns the offset where the selection ends on the specified line. */
public int getSelectionEnd(int line) {
if (line == selectionEndLine) return selectionEnd;
else if (rectSelect) {
Element map = document.getDefaultRootElement();
int end = selectionEnd - map.getElement(selectionEndLine).getStartOffset();
Element lineElement = map.getElement(line);
int lineStart = lineElement.getStartOffset();
int lineEnd = lineElement.getEndOffset() - 1;
return Math.min(lineEnd, lineStart + end);
} else return getLineEndOffset(line) - 1;
}
/*
* Determine the Y offset for the current row
*/
private int getOffsetY(int rowStartOffset, FontMetrics fontMetrics) throws BadLocationException {
// Get the bounding rectangle of the row
Rectangle r = component.modelToView(rowStartOffset);
int lineHeight = fontMetrics.getHeight();
int y = r.y + r.height;
int descent = 0;
// The text needs to be positioned above the bottom of the bounding
// rectangle based on the descent of the font(s) contained on the row.
if (r.height == lineHeight) // default font is being used
{
descent = fontMetrics.getDescent();
} else // We need to check all the attributes for font changes
{
if (fonts == null) fonts = new HashMap<String, FontMetrics>();
Element root = component.getDocument().getDefaultRootElement();
int index = root.getElementIndex(rowStartOffset);
Element line = root.getElement(index);
for (int i = 0; i < line.getElementCount(); i++) {
Element child = line.getElement(i);
AttributeSet as = child.getAttributes();
String fontFamily = (String) as.getAttribute(StyleConstants.FontFamily);
Integer fontSize = (Integer) as.getAttribute(StyleConstants.FontSize);
String key = fontFamily + fontSize;
FontMetrics fm = fonts.get(key);
if (fm == null) {
Font font = new Font(fontFamily, Font.PLAIN, fontSize);
fm = component.getFontMetrics(font);
fonts.put(key, fm);
}
descent = Math.max(descent, fm.getDescent());
}
}
return y - descent;
}
private void parse(Element node) {
if (!showThumbs) {
// do not show any thumbnails
return;
}
int count = node.getElementCount();
for (int i = 0; i < count; i++) {
Element elm = node.getElement(i);
Debug.log(8, elm.toString());
if (elm.isLeaf()) {
int start = elm.getStartOffset(), end = elm.getEndOffset();
parseRange(start, end);
} else {
parse(elm);
}
}
}
/**
* @param path_ret where the file will be saved
* @param a getting the information of current status of the editor
* @param cnc_a getting the information of current status of the editor
* @throws ParserConfigurationException
* @throws IOException
*/
public void save(String tempPath, counts a, connections cnc_a)
throws ParserConfigurationException, IOException {
try {
DocumentBuilderFactory dbf = DocumentBuilderFactoryImpl.newInstance();
// get an instance of builder
DocumentBuilder db = dbf.newDocumentBuilder();
// create an instance of DOM
Document dom = db.newDocument();
Element el_root = dom.createElement("circuit");
dom.appendChild(el_root);
// Root of the components
Element cmp_root = dom.createElement("components");
el_root.appendChild(cmp_root);
for (component x : a.getComponent_list()) {
Element cmpEle = this.createCmpEle(x, dom);
cmp_root.appendChild(cmpEle);
}
// Root of the components
Element wire_root = dom.createElement("wires");
el_root.appendChild(wire_root);
for (line x : cnc_a.getLine_logs()) {
Element wireEle = null;
if (x.getId() > 0) {
wireEle = this.createWireEle(x, dom);
wire_root.appendChild(wireEle);
}
}
OutputFormat format = new OutputFormat();
XMLSerializer serializer =
new XMLSerializer(new FileOutputStream(new File(tempPath)), format);
serializer.serialize(dom);
this.changeTitle(new File(tempPath).getName());
this.setSaved(true);
this.setPath(tempPath);
taskbar.setText("File is saved successfully.");
} catch (FileNotFoundException ex) {
Logger.getLogger(Pad_Draw.class.getName()).log(Level.SEVERE, null, ex);
}
}
public void actionPerformed(JTextComponent text) {
indentationLogic = ((EditorPane) text).getIndentationLogic();
StyledDocument doc = (StyledDocument) text.getDocument();
Element map = doc.getDefaultRootElement();
Caret c = text.getCaret();
int dot = c.getDot();
int mark = c.getMark();
int line1 = map.getElementIndex(dot);
if (dot != mark) {
int line2 = map.getElementIndex(mark);
int begin = Math.min(line1, line2);
int end = Math.max(line1, line2);
Element elem;
try {
for (line1 = begin; line1 < end; line1++) {
elem = map.getElement(line1);
handleDecreaseIndent(line1, elem, doc);
}
elem = map.getElement(end);
int start = elem.getStartOffset();
if (Math.max(c.getDot(), c.getMark()) != start) {
handleDecreaseIndent(end, elem, doc);
}
} catch (BadLocationException ble) {
Debug.error(me + "Problem while de-indenting line\n%s", ble.getMessage());
UIManager.getLookAndFeel().provideErrorFeedback(text);
}
} else {
Element elem = map.getElement(line1);
try {
handleDecreaseIndent(line1, elem, doc);
} catch (BadLocationException ble) {
Debug.error(me + "Problem while de-indenting line\n%s", ble.getMessage());
UIManager.getLookAndFeel().provideErrorFeedback(text);
}
}
}
/** Returns the selected text, or null if no selection is active. */
public final String getSelectedText() {
if (selectionStart == selectionEnd) return null;
if (rectSelect) {
// Return each row of the selection on a new line
Element map = document.getDefaultRootElement();
int start = selectionStart - map.getElement(selectionStartLine).getStartOffset();
int end = selectionEnd - map.getElement(selectionEndLine).getStartOffset();
// Certain rectangles satisfy this condition...
if (end < start) {
int tmp = end;
end = start;
start = tmp;
}
StringBuffer buf = new StringBuffer();
Segment seg = new Segment();
for (int i = selectionStartLine; i <= selectionEndLine; i++) {
Element lineElement = map.getElement(i);
int lineStart = lineElement.getStartOffset();
int lineEnd = lineElement.getEndOffset() - 1;
int lineLen = lineEnd - lineStart;
lineStart = Math.min(lineStart + start, lineEnd);
lineLen = Math.min(end - start, lineEnd - lineStart);
getText(lineStart, lineLen, seg);
buf.append(seg.array, seg.offset, seg.count);
if (i != selectionEndLine) buf.append('\n');
}
return buf.toString();
} else {
return getText(selectionStart, selectionEnd - selectionStart);
}
}