public void mouseMoved(MouseEvent e) {
int k = html.viewToModel(e.getPoint());
if (html.hasFocus() && html.getSelectionStart() <= k && k < html.getSelectionEnd()) {
setMessage("(on selection)", MOVE);
return;
}
String s = text.getText(); // "";
int m = s.length(); // html.getDocument().getLength();
/*try {
s = html.getText(0, m);
} catch (BadLocationException x) {
setMessage("BadLocation "+m, TEXT); return;
} */
if (!Character.isLetter(s.charAt(k))) {
setMessage("(not a letter)", TEXT);
return;
}
selB = k;
selE = k + 1;
while (!Character.isWhitespace(s.charAt(selB - 1))) selB--;
while (!Character.isWhitespace(s.charAt(selE))) selE++;
setMessage(selB + "-" + selE, HAND);
word = "";
for (int i = selB; i < selE; i++) if (Character.isLetter(s.charAt(i))) word += s.charAt(i);
html.setToolTipText(word);
}
String cleanupSource(String source) {
if (source.isEmpty()) {
return source.concat("\n");
}
int lastChIdx = source.length() - 1;
if (source.charAt(lastChIdx) != '\n') {
// Append a newline at the end
source = source.concat("\n");
} else {
// Remove all newlines at the end but one
while (lastChIdx >= 1) {
Character ch1 = source.charAt(lastChIdx);
if (ch1 == '\n' || Character.isWhitespace(ch1)) {
source = source.substring(0, lastChIdx--);
} else {
break;
}
}
source = source.concat("\n");
}
return source;
}
/**
* This is the write() method of the stream. All Writer subclasses implement this. All other
* versions of write() are variants of this one
*/
public void write(char[] buffer, int index, int len) {
synchronized (this.lock) {
// Loop through all the characters passed to us
for (int i = index; i < index + len; i++) {
// If we haven't begun a page (or a new page), do that now.
if (page == null) newpage();
// If the character is a line terminator, then begin new line,
// unless it is a \n immediately after a \r.
if (buffer[i] == '\n') {
if (!last_char_was_return) newline();
continue;
}
if (buffer[i] == '\r') {
newline();
last_char_was_return = true;
continue;
} else last_char_was_return = false;
// If it some other non-printing character, ignore it.
if (Character.isWhitespace(buffer[i])
&& !Character.isSpaceChar(buffer[i])
&& (buffer[i] != '\t')) continue;
// If no more characters will fit on the line, start a new line.
if (charnum >= chars_per_line) {
newline();
if (page == null) newpage(); // and start a new page, if necessary
}
// Now print the character:
// If it is a space, skip one space, without output.
// If it is a tab, skip the necessary number of spaces.
// Otherwise, print the character.
// It is inefficient to draw only one character at a time, but
// because our FontMetrics don't match up exactly to what the
// printer uses we need to position each character individually.
if (Character.isSpaceChar(buffer[i])) charnum++;
else if (buffer[i] == '\t') charnum += 8 - (charnum % 8);
else {
page.drawChars(
buffer, i, 1, x0 + charnum * charwidth, y0 + (linenum * lineheight) + lineascent);
charnum++;
}
}
}
}
protected static String parsePhrase(final String lineText) {
boolean overloading = false;
{ // Check if we can provide suggestions for this phrase ending
String trimmedLineText = lineText.trim();
if (trimmedLineText.length() == 0) return null;
char lastChar = trimmedLineText.charAt(trimmedLineText.length() - 1);
if (lastChar == '.') {
trimmedLineText = trimmedLineText.substring(0, trimmedLineText.length() - 1).trim();
if (trimmedLineText.length() == 0) return null;
lastChar = trimmedLineText.charAt(trimmedLineText.length() - 1);
switch (lastChar) {
case ')':
case ']':
case '"':
break; // We can suggest for these
default:
if (!Character.isJavaIdentifierPart(lastChar)) {
return null; // Not something we can suggest
}
break;
}
} else if (lastChar == '(') {
overloading = true; // We can suggest overloaded methods
} else if (!Character.isJavaIdentifierPart(lastChar)) {
return null; // Not something we can suggest
}
}
final int currentCharIndex = lineText.length() - 1;
{ // Check if the caret is in the comment
int commentStart = lineText.indexOf("//", 0);
if (commentStart >= 0 && currentCharIndex > commentStart) {
return null;
}
}
// Index the line
BitSet isInLiteral = new BitSet(lineText.length());
BitSet isInBrackets = new BitSet(lineText.length());
{ // Mark parts in literals
boolean inString = false;
boolean inChar = false;
boolean inEscaped = false;
for (int i = 0; i < lineText.length(); i++) {
if (!inEscaped) {
switch (lineText.charAt(i)) {
case '\"':
if (!inChar) inString = !inString;
break;
case '\'':
if (!inString) inChar = !inChar;
break;
case '\\':
if (inString || inChar) {
inEscaped = true;
}
break;
}
} else {
inEscaped = false;
}
isInLiteral.set(i, inString || inChar);
}
}
if (isInLiteral.get(currentCharIndex)) return null;
{ // Mark parts in top level brackets
int depth = overloading ? 1 : 0;
int bracketStart = overloading ? lineText.length() : 0;
int squareDepth = 0;
int squareBracketStart = 0;
bracketLoop:
for (int i = lineText.length() - 1; i >= 0; i--) {
if (!isInLiteral.get(i)) {
switch (lineText.charAt(i)) {
case ')':
if (depth == 0) bracketStart = i;
depth++;
break;
case '(':
depth--;
if (depth == 0) {
isInBrackets.set(i, bracketStart);
} else if (depth < 0) {
break bracketLoop;
}
break;
case ']':
if (squareDepth == 0) squareBracketStart = i;
squareDepth++;
break;
case '[':
squareDepth--;
if (squareDepth == 0) {
isInBrackets.set(i, squareBracketStart);
} else if (squareDepth < 0) {
break bracketLoop;
}
break;
}
}
}
if (depth > 0) isInBrackets.set(0, bracketStart);
if (squareDepth > 0) isInBrackets.set(0, squareBracketStart);
}
// Walk the line from the end while it makes sense
int position = currentCharIndex;
parseLoop:
while (position >= 0) {
int currChar = lineText.charAt(position);
switch (currChar) {
case '.': // Grab it
position--;
break;
case '[':
break parseLoop; // End of scope
case ']': // Grab the whole region in square brackets
position = isInBrackets.previousClearBit(position - 1);
break;
case '(':
if (isInBrackets.get(position)) {
position--; // This checks for first bracket while overloading
break;
}
break parseLoop; // End of scope
case ')': // Grab the whole region in brackets
position = isInBrackets.previousClearBit(position - 1);
break;
case '"': // Grab the whole literal and quit
position = isInLiteral.previousClearBit(position - 1);
break parseLoop;
default:
if (Character.isJavaIdentifierPart(currChar)) {
position--; // Grab the identifier
} else if (Character.isWhitespace(currChar)) {
position--; // Grab whitespace too
} else {
break parseLoop; // Got a char ending the phrase
}
break;
}
}
position++;
// Extract phrase
String phrase = lineText.substring(position, lineText.length()).trim();
Messages.log(phrase);
if (phrase.length() == 0 || Character.isDigit(phrase.charAt(0))) {
return null; // Can't suggest for numbers or empty phrases
}
return phrase;
}
public void keyTyped(KeyEvent e) {
if (debug) {
System.out.println(
"--- RecordingModule: key typed = "
+ e
+ "\n > Key char->int = "
+ (int) e.getKeyChar());
System.out.println(" -- isActionKey() = " + e.isActionKey());
System.out.println(" -- isISOControl() = " + Character.isISOControl(e.getKeyChar()));
System.out.println(" -- isWhitespace() = " + Character.isWhitespace(e.getKeyChar()));
}
if (isKeyReserved(e)) {
return;
}
if (enabled && !readOnly && lastKeyPressEvent != null) {
if (enableKeyboard) {
boolean replace = false;
String text = "";
if (isControl(e)) {
if (lastKeyPressEvent.getKeyCode() == KeyEvent.VK_ENTER) {
// Change the Type cmd prior to Typeline if the delay from the last type key is less
// than 1 sec
if (useTypeline && e.getModifiers() == 0 && lastElement != null) {
String s = DocumentUtils.getElementText(lastElement);
if (s.startsWith("Type ")
&& (System.currentTimeMillis() - lastInsertTime) < typelineDelay) {
replace = true;
text = s.replaceFirst("Type", "Typeline");
}
}
}
if ("".equals(text)) {
int count = 1;
KeyEvent e2;
long lastEventTime = e.getWhen();
// We go through the vector of events and check whether there are events corresponding
// to a typed text.
for (int i = 0; i < events.size() && events.get(i) instanceof KeyEvent; i++) {
e2 = (KeyEvent) events.get(i);
if (e.getID() == e2.getID()
&& e.getKeyChar() == e2.getKeyChar()
&& e.getKeyCode() == e2.getKeyCode()
&& e.getModifiers() == e2.getModifiers()
&& (lastEventTime - e2.getWhen() < keyMutiDelay)) {
count++;
replace = true;
lastEventTime = e2.getWhen();
} else {
break;
}
}
text = "Press ";
// String modifiers = KeyEvent.getKeyModifiersText(e.getModifiers());
String modifiers = parser.modifiersToString(e.getModifiers());
if (!"".equals(modifiers)) {
text += modifiers + "+";
}
String charText = KeyEvent.getKeyText(lastKeyPressEvent.getKeyCode());
if (charText == null) {
charText = "<unknown>";
}
text += charText;
if (count > 1) {
text += " " + PressCommand.PARAM_COUNT + "=" + count;
}
if (debug) {
System.out.println("--- RecordingModule: Inserting '" + text + "'");
}
}
} else {
text = "" + e.getKeyChar();
KeyEvent e2;
// We go through the vector of events and check whether there are events corresponding to
// a typed text.
for (int i = 0; i < events.size() && events.get(i) instanceof KeyEvent; i++) {
e2 = (KeyEvent) events.get(i);
if (!isControl(e2) && !e2.isActionKey()) {
text = e2.getKeyChar() + text;
replace = true;
} else {
break;
}
}
text = "Type \"" + Utils.escapeUnescapedDoubleQuotes(text) + "\"";
}
// Insert the command to the current editor
insertLine(text, replace, true, false);
}
insertEvent(e);
}
}