diff -r ed1c9f64298a -r 5b9d4d8641ce trace/traceviewer/com.nokia.traceviewer/src/com/nokia/traceviewer/dialog/FilterAdvancedParser.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/trace/traceviewer/com.nokia.traceviewer/src/com/nokia/traceviewer/dialog/FilterAdvancedParser.java Wed Jun 23 14:49:59 2010 +0300 @@ -0,0 +1,1066 @@ +/* + * Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * + * Parses the rule text field for validity + * + */ +package com.nokia.traceviewer.dialog; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.custom.StyleRange; +import org.eclipse.swt.custom.StyledText; +import org.eclipse.swt.events.FocusEvent; +import org.eclipse.swt.events.FocusListener; +import org.eclipse.swt.events.KeyEvent; +import org.eclipse.swt.events.KeyListener; +import org.eclipse.swt.events.MouseEvent; +import org.eclipse.swt.events.MouseListener; +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.widgets.TreeItem; + +import com.nokia.traceviewer.engine.TraceViewerGlobals; +import com.nokia.traceviewer.engine.dataprocessor.FilterRuleSet.LogicalOperator; + +/** + * Parses the rule text field for validity + */ +public final class FilterAdvancedParser implements FocusListener, KeyListener, + MouseListener { + + /** + * Indicates the max number of brackets in a rule. Used to shut down while + * loop if there is something wrong + */ + private static final int MAX_NUMBER_OF_BRACKETS = 50; + + /** + * AND String + */ + public static final String AND = "AND"; //$NON-NLS-1$ + + /** + * OR String + */ + public static final String OR = "OR"; //$NON-NLS-1$ + + /** + * NOT String + */ + public static final String NOT = "NOT"; //$NON-NLS-1$ + + /** + * Start bracket + */ + private static final char START_BRACKET = '('; + + /** + * Start bracket String + */ + public static final String START_BRACKET_STR = "("; //$NON-NLS-1$ + + /** + * End bracket + */ + private static final char END_BRACKET = ')'; + + /** + * End bracket String + */ + public static final String END_BRACKET_STR = ")"; //$NON-NLS-1$ + + /** + * Space + */ + public static final char SPACE = ' '; + + /** + * Space String + */ + public static final String SPACE_STR = " "; //$NON-NLS-1$ + + /** + * Empty String + */ + private static final String EMPTY = ""; //$NON-NLS-1$ + + /** + * Text field to validate + */ + private final StyledText textField; + + /** + * Rule items + */ + private final TreeItem[] items; + + /** + * Blue color + */ + private final Color blue; + + /** + * Gray color + */ + private final Color gray; + + /** + * Constructor + * + * @param ruleTextfield + * rule text field + * @param items + * rule items + */ + public FilterAdvancedParser(StyledText ruleTextfield, TreeItem[] items) { + textField = ruleTextfield; + this.items = items; + blue = textField.getDisplay().getSystemColor(SWT.COLOR_BLUE); + gray = textField.getDisplay().getSystemColor(SWT.COLOR_GRAY); + } + + /* + * (non-Javadoc) + * + * @see + * org.eclipse.swt.events.KeyListener#keyPressed(org.eclipse.swt.events. + * KeyEvent) + */ + public void keyPressed(KeyEvent e) { + if (e.keyCode != SWT.CTRL) { + validate(); + + // Set button states + TraceViewerGlobals.getTraceViewer().getDataProcessorAccess() + .getFilterProcessor().getFilterDialog().getAdvancedDialog() + .setButtonStates(); + } + } + + /* + * (non-Javadoc) + * + * @seeorg.eclipse.swt.events.MouseListener#mouseUp(org.eclipse.swt.events. + * MouseEvent) + */ + public void mouseUp(MouseEvent e) { + if (textField.getText().length() > 1) { + Point selection = null; + if (textField.getSelectionRange().y > 0) { + selection = textField.getSelection(); + } + validate(); + // Set button states + TraceViewerGlobals.getTraceViewer().getDataProcessorAccess() + .getFilterProcessor().getFilterDialog().getAdvancedDialog() + .setButtonStates(); + if (selection != null) { + textField.setSelection(selection); + } + } + } + + /** + * Validates the text field + */ + void validate() { + textField.getCaret().setVisible(false); + String text = textField.getText(); + // Change logical operations to upper case + text = text.replace(" and ", SPACE + AND + SPACE); //$NON-NLS-1$ + text = text.replace(" or ", SPACE + OR + SPACE); //$NON-NLS-1$ + text = text.replace(" not ", SPACE + NOT + SPACE); //$NON-NLS-1$ + + StringBuffer newText = new StringBuffer(text); + int caretPos = textField.getCaretOffset(); + + int removedBeforeCaret = removeDoubleSpaces(newText, caretPos); + caretPos -= removedBeforeCaret; + + // Empty, add one space + if (newText.length() == 0) { + newText.append(SPACE); + caretPos = 1; + + } + + // Insert the text and color the caret + textField.setText(newText.toString()); + textField.setCaretOffset(caretPos); + colorCaretAndRules(); + textField.getCaret().setVisible(true); + } + + /** + * Removes double spaces + * + * @param newText + * StringBuffer to use + * @param caretPos + * old caret position + * @return number of chars removed before caret position + */ + private int removeDoubleSpaces(StringBuffer newText, int caretPos) { + int charsRemoved = 0; + boolean lastCharSpace = false; + for (int i = 0; i < newText.length(); i++) { + if (newText.charAt(i) == SPACE) { + if (lastCharSpace) { + newText.deleteCharAt(i); + if (i < caretPos) { + charsRemoved++; + } + i--; + } + lastCharSpace = true; + } else { + lastCharSpace = false; + } + } + return charsRemoved; + } + + /** + * Counts occurrences of a character from a string + * + * @param text + * text to find from + * @param c + * the character + * @return number of occurrences in the string + */ + private int countOccurrences(String text, char c) { + int occ = 0; + for (int i = 0; i < text.length(); i++) { + if (text.charAt(i) == c) { + occ++; + } + } + return occ; + } + + /** + * Colors the caret and the rules + */ + private void colorCaretAndRules() { + List ranges = new ArrayList(); + int caretPos = textField.getCaretOffset(); + + // Color the rules + if (items != null) { + String text = textField.getText(); + text = text.replace(START_BRACKET, SPACE); + text = text.replace(END_BRACKET, SPACE); + StringBuffer buf = new StringBuffer(); + ArrayList words = new ArrayList(); + ArrayList offsets = new ArrayList(); + + // Gather the words + for (int i = 0; i < text.length(); i++) { + char c = text.charAt(i); + if (c == SPACE) { + // If the buffer is not empty, it's a word and should be + // added to the list + if (!buf.toString().replace(SPACE_STR, EMPTY).equals(EMPTY)) { + words.add(buf.toString()); + offsets.add(Integer.valueOf(i - buf.length())); + } + buf.setLength(0); + } else { + buf.append(c); + } + } + + // Create the style ranges for the basic rules found + for (int j = 0; j < words.size(); j++) { + if (isBasicRule(words.get(j))) { + ranges.add(new StyleRange(offsets.get(j).intValue(), words + .get(j).length(), blue, null)); + } + } + } + + // Color the caret if not focused + if (!textField.isFocusControl()) { + if (caretPos > textField.getCharCount()) { + caretPos = textField.getCharCount(); + } + ranges.add(new StyleRange(caretPos - 1, 1, gray, gray)); + } + // Sort and set the ranges + ranges = sortColorRanges(ranges); + textField.setStyleRanges(ranges.toArray(new StyleRange[ranges.size()])); + } + + /** + * Sorts color ranges + * + * @param ranges + * color ranges + * @return ordered list + */ + private List sortColorRanges(List ranges) { + Collections.sort(ranges, new Comparator() { + + public int compare(StyleRange o1, StyleRange o2) { + int id1 = o1.start; + int id2 = o2.start; + return id1 > id2 ? 1 : id1 < id2 ? -1 : 0; + } + + }); + return ranges; + } + + /** + * Finds and returns a set from caret pos + * + * @param text + * text to search from + * @param caretOffset + * caret offset + * @return the set where the caret is on + */ + private String findSet(String text, int caretOffset) { + String set = null; + if (text.length() > 0) { + + // Get counts for the brackets + int startCount = countOccurrences(text.substring(0, caretOffset), + START_BRACKET); + int endCount = countOccurrences(text.substring(0, caretOffset), + END_BRACKET); + + // Full sets before the caret, start from last end bracket + if (startCount == endCount) { + // Get indices for the nearest brackets + int startIdx = getNearestChar(text, caretOffset, START_BRACKET, + true); + int endIdx = getNearestChar(text, caretOffset, END_BRACKET, + false); + if (startIdx == -1) { + startIdx = text.length(); + } + if (endIdx == -1) { + endIdx = 0; + } else { + endIdx++; + } + set = text.substring(endIdx, startIdx); + } else { + // Get indices for the nearest brackets + int startIdx = getNearestChar(text, caretOffset, START_BRACKET, + false); + int endIdx = getNearestChar(text, caretOffset, END_BRACKET, + true); + if (startIdx == -1) { + startIdx = 0; + } else { + startIdx++; + } + if (endIdx == -1) { + endIdx = text.length(); + } + set = text.substring(startIdx, endIdx); + } + } + return set; + } + + /** + * Gets nearest char from a string + * + * @param text + * text to search from + * @param caretOffset + * caret offset + * @param c + * character to search for + * @param forward + * forward or backward search + * @return offset of nearest character. -1 if not found + */ + private int getNearestChar(String text, int caretOffset, char c, + boolean forward) { + int idx = -1; + // Searching forwards + if (forward) { + idx = text.indexOf(c, caretOffset); + + // Searching backwards + } else if (text.length() > 0) { + for (int i = caretOffset - 1; i >= 0; i--) { + if (text.charAt(i) == c) { + idx = i; + break; + } + } + } + return idx; + } + + /** + * Tells if a set is open + * + * @return true if set is open + */ + boolean isSetOpen() { + boolean setOpen = false; + int startCount = countOccurrences(textField.getText(), START_BRACKET); + int endCount = countOccurrences(textField.getText(), END_BRACKET); + if (startCount > endCount) { + setOpen = true; + } + return setOpen; + } + + /** + * Check if AND can be inserted to current pos + * + * @return true if AND can be inserted + */ + boolean canAndBeInserted() { + boolean canBeInserted = true; + String set = findSet(textField.getText(), textField.getCaretOffset()); + // If there is OR + if (set != null && set.contains(OR)) { + canBeInserted = false; + } else if (set != null && !containsFilterRule(set, items) + && !isSetOpen() + && !containsFilterRule(textField.getText(), items)) { + canBeInserted = false; + } else if (set != null && !containsFilterRule(set, items) + && isSetOpen()) { + canBeInserted = false; + } else if (set == null) { + canBeInserted = false; + } + + return canBeInserted; + } + + /** + * Check if OR can be inserted to current pos + * + * @return true if OR can be inserted + */ + boolean canOrBeInserted() { + boolean canBeInserted = true; + String set = findSet(textField.getText(), textField.getCaretOffset()); + // If there is AND + if (set != null && set.contains(AND)) { + canBeInserted = false; + } else if (set != null && !containsFilterRule(set, items) + && !isSetOpen() + && !containsFilterRule(textField.getText(), items)) { + canBeInserted = false; + } else if (set != null && !containsFilterRule(set, items) + && isSetOpen()) { + canBeInserted = false; + } else if (set == null) { + canBeInserted = false; + } + + return canBeInserted; + } + + /** + * Check if new set can be started to current pos + * + * @return true if new set can be started + */ + boolean canNewSetBeStarted() { + boolean canBeStarted = false; + String text = textField.getText(); + int caretPos = textField.getCaretOffset(); + boolean ready = false; + StringBuffer buf = new StringBuffer(); + + // Text has to contain at least one rule + if (containsFilterRule(text, items) && caretPos > 1) { + + // Go backwards and check the previous word + for (int i = caretPos - 1; i > 0; i--) { + char c = text.charAt(i); + // Space, do nothing + if (c == SPACE) { + if (ready) { + // Remove NOT + if (buf.toString().equals(NOT)) { + buf.setLength(0); + ready = false; + } else { + break; + } + } + } else { + buf.insert(0, c); + ready = true; + } + } + + String word = buf.toString(); + if (word.contains(OR) || word.contains(AND)) { + canBeStarted = true; + } + } else { + canBeStarted = true; + } + return canBeStarted; + } + + /** + * Check if a set can be ended here + * + * @return true if a set can be ended here + */ + boolean canSetBeEnded() { + boolean canBeEnded = false; + String text = textField.getText(); + int caretPos = textField.getCaretOffset(); + boolean ready = false; + StringBuffer buf = new StringBuffer(); + + // Text has to contain at least one rule + if (containsFilterRule(text, items) && isSetOpen()) { + // Go backwards and check the previous word + for (int i = caretPos - 1; i > 0; i--) { + char c = text.charAt(i); + // Space, do nothing + if (c == SPACE) { + if (ready) { + break; + } + } else { + buf.insert(0, c); + ready = true; + } + } + + String word = buf.toString(); + if (!word.contains(OR) && !word.contains(AND)) { + canBeEnded = true; + } + } + return canBeEnded; + } + + /** + * Check if apply can be clicked + * + * @return true if apply can be clicked + */ + boolean canApplyBeClicked() { + boolean canBeClicked = false; + if (!isSetOpen()) { + String text = textField.getText(); + + // Length bigger than one and contains at least one rule + if (text.length() > 1 && containsFilterRule(text, items)) { + int nrOfRules = 0; + // Check that after every rule there cannot be another rule + text = text.replace(START_BRACKET_STR, SPACE_STR); + text = text.replace(END_BRACKET_STR, SPACE_STR); + String[] words = text.split(SPACE_STR); + boolean lastWasRule = false; + for (int i = 0; i < words.length; i++) { + if (containsFilterRule(words[i], items)) { + nrOfRules++; + canBeClicked = true; + if (lastWasRule) { + canBeClicked = false; + break; + } + lastWasRule = true; + } else { + lastWasRule = false; + } + + } + // If more than one rule, there has to be logical operator too + if (canBeClicked && nrOfRules > 1) { + // All good + if (text.contains(AND) || text.contains(OR)) { + // Not good + } else { + canBeClicked = false; + } + } + + // Check that logical operators have a rule in both sides + if (canBeClicked) { + text = text.replace(START_BRACKET_STR, EMPTY); + text = text.replace(END_BRACKET_STR, EMPTY); + text = text.replace(NOT, EMPTY); + + // Remove double spaces + StringBuffer buf = new StringBuffer(text); + removeDoubleSpaces(buf, 0); + text = buf.toString(); + + canBeClicked = checkLogicalOperatorValidity(canBeClicked, + text, AND); + if (canBeClicked) { + canBeClicked = checkLogicalOperatorValidity( + canBeClicked, text, OR); + } + } + + // Length is 0 or 1 + } else if (text.length() <= 1) { + canBeClicked = true; + } + } + return canBeClicked; + } + + /** + * Checks that logical operators have filter rule in both sides + * + * @param canBeClicked + * variable indicating if apply can be clicked + * @param text + * text to process + * @param operator + * logical operator as string + * @return true if logical operators are ok + */ + private boolean checkLogicalOperatorValidity(boolean canBeClicked, + String text, String operator) { + StringBuffer buf = new StringBuffer(); + int pos = text.indexOf(operator); + // Loop while next operator is found + while (pos != -1) { + // Check backwards + for (int i = pos - 2; i > -1; i--) { + char c = text.charAt(i); + if (c == SPACE) { + break; + } + buf.insert(0, c); + } + if (!ruleInItems(buf.toString(), items)) { + canBeClicked = false; + } + buf.setLength(0); + + // Check forwards + for (int i = pos + operator.length() + 1; canBeClicked + && i < text.length(); i++) { + char c = text.charAt(i); + if (c == SPACE) { + break; + } + buf.append(c); + } + if (!ruleInItems(buf.toString(), items)) { + canBeClicked = false; + } + buf.setLength(0); + + pos = text.indexOf(operator, pos + 1); + } + + return canBeClicked; + } + + /** + * Checks if a string contains filter rule from the tree + * + * @param text + * text to search from + * @param items + * items to go through + * @return true if at least one rule can be found from the string + */ + boolean containsFilterRule(String text, TreeItem[] items) { + boolean found = false; + if (text != null && items != null) { + for (int i = 0; i < items.length && !found; i++) { + + // Contains children, recurse + if (items[i].getItemCount() > 0) { + found = containsFilterRule(text, items[i].getItems()); + + // Check item + } else if (text.contains(items[i].getText())) { + found = true; + } + } + } + return found; + } + + /** + * Gets logical operator from a text + * + * @param text + * text to get logical operator from + * @return logical operator of this set. Returns OR if this is a basic rule. + * Null if both operators are found. + */ + LogicalOperator getLogicalOperator(String text) { + LogicalOperator op = LogicalOperator.OR; + String mainLevel = getMainLevelOfRule(text); + + // Contains AND but no OR + if (mainLevel.contains(AND) && !mainLevel.contains(OR)) { + op = LogicalOperator.AND; + // Contains OR but no AND + } else if (mainLevel.contains(OR) && !mainLevel.contains(AND)) { + op = LogicalOperator.OR; + // Contains either both or not any + } else if ((mainLevel.contains(AND) && mainLevel.contains(OR)) + || (!mainLevel.contains(AND) && !mainLevel.contains(OR))) { + String newText = removeStartAndEndBracket(text); + if (newText != null) { + text = newText; + } + text = text.replace(NOT, EMPTY); + text = text.trim(); + if (!isBasicRule(text)) { + // Is not basic rule + op = null; + } + } + return op; + } + + /** + * Gets the main level of the rule + * + * @param text + * rule text to process + * @return main level of the rule + */ + private String getMainLevelOfRule(String text) { + int safeCounter = 0; + String mainLevel = removeTextBetweenBrackets(text); + if (mainLevel != null && mainLevel.indexOf(OR) == -1 + && mainLevel.indexOf(AND) == -1) { + mainLevel = text; + } + while (mainLevel != null && mainLevel.indexOf(OR) == -1 + && mainLevel.indexOf(AND) == -1 && mainLevel.length() > 0 + && safeCounter < MAX_NUMBER_OF_BRACKETS) { + safeCounter++; + mainLevel = removeStartAndEndBracket(mainLevel); + mainLevel = removeTextBetweenBrackets(mainLevel); + } + return mainLevel; + } + + /** + * Removes all text between brackets (including brackets) + * + * @param text + * text to be processed + * @return text without information inside brackets + */ + private String removeTextBetweenBrackets(String text) { + StringBuffer str = new StringBuffer(); + if (text != null && text.length() > 0) { + int nrOfStartBrackets = 0; + for (int i = 0; i < text.length(); i++) { + char c = text.charAt(i); + if (c == START_BRACKET) { + nrOfStartBrackets++; + } else if (c == END_BRACKET) { + nrOfStartBrackets--; + } else if (nrOfStartBrackets == 0) { + str.append(c); + } + } + } + return str.toString(); + } + + /** + * Removes first start and last end bracket + * + * @param text + * text to process + * @return text without first start and last end bracket. Null if cannot + * find both brackets + */ + private String removeStartAndEndBracket(String text) { + String ret = null; + int startPos = text.indexOf(START_BRACKET); + int endPos = text.lastIndexOf(END_BRACKET); + if (startPos != -1 && endPos != -1 && startPos + 1 < endPos) { + ret = text.substring(startPos + 1, endPos); + } + return ret; + } + + /** + * Tells if the String given is a basic rule + * + * @param text + * String to search from + * @return true if the String given is a basic rule + */ + boolean isBasicRule(String text) { + boolean basicRule = false; + + // Find rule from the tree items + if (text.length() > 0 && !text.equals(SPACE_STR)) { + if (ruleInItems(text, items)) { + basicRule = true; + } + } + return basicRule; + } + + /** + * Checks if rule is contained in the items + * + * @param text + * rule text + * @param items + * items array + * @return true if rule is found from the items + */ + private boolean ruleInItems(String text, TreeItem[] items) { + boolean found = false; + for (int i = 0; i < items.length; i++) { + + // Contains children, recurse + if ((items[i].getItemCount() > 0)) { + found = ruleInItems(text, items[i].getItems()); + + // Check item + } else if (text.equals(items[i].getText())) { + found = true; + break; + } + } + return found; + } + + /** + * Gets children rule sets from a String + * + * @param text + * String to split to rule sets + * @return array of children + */ + String[] getChildren(String text) { + // Add space before start and after end brackets and to both sides of + // each logical operator + text = text.replace(START_BRACKET_STR, SPACE_STR + START_BRACKET_STR); + text = text.replace(END_BRACKET_STR, END_BRACKET_STR + SPACE_STR); + text = text.replace(AND, SPACE_STR + AND + SPACE_STR); + text = text.replace(OR, SPACE_STR + OR + SPACE_STR); + text = text.replace(NOT, SPACE_STR + NOT + SPACE_STR); + + String[] strings; + int nrOfStartBrackets = 0; + ArrayList children = new ArrayList(); + StringBuffer buf = new StringBuffer(); + + // Go through every character + for (int i = 0; i < text.length(); i++) { + char c = text.charAt(i); + if (c == START_BRACKET) { + nrOfStartBrackets++; + } else if (c == END_BRACKET) { + nrOfStartBrackets--; + + // When brackets are processed, create a child from the + // buffer + if (nrOfStartBrackets == 0) { + addBufferToChildList(children, buf); + } + } else if (nrOfStartBrackets > 0) { + buf.append(c); + + // Nr of start brackets is zero + } else { + // Character is space + if (c == SPACE) { + if (buf.length() > 0) { + addBufferToChildList(children, buf); + } + } else { + buf.append(c); + // If processing the last character, add child + if (i == text.length() - 1) { + addBufferToChildList(children, buf); + } + } + } + } + + // Insert the strings to a array + strings = new String[children.size()]; + for (int j = 0; j < children.size(); j++) { + strings[j] = children.get(j); + } + + return strings; + } + + /** + * Adds buffer contents to child list and empties the buffer + * + * @param children + * children list + * @param buf + * buffer + */ + private void addBufferToChildList(List children, StringBuffer buf) { + // AND and OR cannot be children + if (!buf.toString().trim().equals(AND) + && !buf.toString().trim().equals(OR)) { + // Add child to the list + children.add(buf.toString()); + } + buf.setLength(0); + } + + /** + * Checks written rules + * + * @param text + * text to check + * @return true if text field contains only valid rules and operations + */ + boolean checkWrittenRules(String text) { + // Replace brackets and logical operations with spaces + text = text.replace(START_BRACKET_STR, SPACE_STR); + text = text.replace(END_BRACKET_STR, SPACE_STR); + text = text.replace(AND, SPACE_STR); + text = text.replace(OR, SPACE_STR); + text = text.replace(NOT, SPACE_STR); + + // Add space to start and end and then remove filter rules + StringBuffer buf = new StringBuffer(text); + buf.insert(0, SPACE); + buf.append(SPACE); + text = removeFilterRules(buf.toString(), items); + + // Remove spaces + text = text.replace(SPACE_STR, EMPTY); + + // Text should now be empty + boolean empty = text.length() == 0; + return empty; + } + + /** + * Removes filter rules from the text + * + * @param text + * the text + * @param items + * tree items + * @return original text without filter rules + */ + private String removeFilterRules(String text, TreeItem[] items) { + for (int i = 0; i < items.length; i++) { + + // Has children, recurse + if (items[i].getItemCount() > 0) { + text = removeFilterRules(text, items[i].getItems()); + + // Remove the rule from the text. + } else { + text = text.replace(items[i].getText() + SPACE_STR, EMPTY); + } + } + return text; + } + + /** + * Gets previous word from the text field + * + * @param text + * text to search from + * @param pos + * position where to read + * @return previous word + */ + String getPreviousWord(String text, int pos) { + StringBuffer buf = new StringBuffer(); + for (int i = pos; i >= 0; i--) { + char c = text.charAt(i); + + // Space, break + if ((c == SPACE) && (i < pos - 1)) { + break; + } + buf.insert(0, c); + } + return buf.toString().trim(); + } + + /* + * (non-Javadoc) + * + * @see + * org.eclipse.swt.events.FocusListener#focusGained(org.eclipse.swt.events + * .FocusEvent) + */ + public void focusGained(FocusEvent e) { + colorCaretAndRules(); + } + + /* + * (non-Javadoc) + * + * @see + * org.eclipse.swt.events.FocusListener#focusLost(org.eclipse.swt.events + * .FocusEvent) + */ + public void focusLost(FocusEvent e) { + colorCaretAndRules(); + } + + /* + * (non-Javadoc) + * + * @see + * org.eclipse.swt.events.KeyListener#keyReleased(org.eclipse.swt.events + * .KeyEvent) + */ + public void keyReleased(KeyEvent e) { + } + + /* + * (non-Javadoc) + * + * @see + * org.eclipse.swt.events.MouseListener#mouseDoubleClick(org.eclipse.swt + * .events.MouseEvent) + */ + public void mouseDoubleClick(MouseEvent e) { + } + + /* + * (non-Javadoc) + * + * @see + * org.eclipse.swt.events.MouseListener#mouseDown(org.eclipse.swt.events + * .MouseEvent) + */ + public void mouseDown(MouseEvent e) { + } +}