private String getCaseCorrectedLookupString(LookupElement item) {
String lookupString = item.getLookupString();
if (item.isCaseSensitive()) {
return lookupString;
}
final String prefix = itemPattern(item);
final int length = prefix.length();
if (length == 0 || !itemMatcher(item).prefixMatches(prefix)) return lookupString;
boolean isAllLower = true;
boolean isAllUpper = true;
boolean sameCase = true;
for (int i = 0; i < length && (isAllLower || isAllUpper || sameCase); i++) {
final char c = prefix.charAt(i);
boolean isLower = Character.isLowerCase(c);
boolean isUpper = Character.isUpperCase(c);
// do not take this kind of symbols into account ('_', '@', etc.)
if (!isLower && !isUpper) continue;
isAllLower = isAllLower && isLower;
isAllUpper = isAllUpper && isUpper;
sameCase = sameCase && isLower == Character.isLowerCase(lookupString.charAt(i));
}
if (sameCase) return lookupString;
if (isAllLower) return lookupString.toLowerCase();
if (isAllUpper) return StringUtil.toUpperCase(lookupString);
return lookupString;
}
private static boolean containsOnlyUppercaseLetters(String s) {
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c != '*' && c != ' ' && !Character.isUpperCase(c)) return false;
}
return true;
}
private static char solutionAlgorithm(char maxKey, int maxValue, int valuesCounter) {
// Probably can play with this to make more efficient algorithm
if (valuesCounter >= LETTERS_NEEDED_TO_DETECT_SPACE) return ' ';
else if (maxValue >= 3) return Character.toLowerCase(maxKey);
else if (valuesCounter == maxValue && Character.isUpperCase(maxKey))
return Character.toLowerCase(maxKey);
else return UNKNOWN_CHAR;
}
public static boolean containsUpperCase(@NotNull String text) {
for (int i = 0; i < text.length(); i++) {
if (Character.isUpperCase(text.charAt(i)) && (i == 0 || text.charAt(i - 1) == '\\')) {
return true;
}
}
return false;
}
private static Map<Character, Integer> createValuesMap(int col) {
Map<Character, Integer> valuesMap = new HashMap<Character, Integer>();
for (char[] textRow : possibleLetters) {
char currCh = textRow[col];
if (Character.isUpperCase(currCh))
if (!valuesMap.containsKey(currCh)) valuesMap.put(currCh, 1);
else valuesMap.put(currCh, valuesMap.get(currCh) + 1);
}
return valuesMap;
}
/**
* Set the fields from the ProjectionClass
*
* @param projClass projection class to use
*/
private void setFieldsWithClassParams(ProjectionClass projClass) {
// set the projection in the JComboBox
String want = projClass.toString();
for (int i = 0; i < projClassCB.getItemCount(); i++) {
ProjectionClass pc = (ProjectionClass) projClassCB.getItemAt(i);
if (pc.toString().equals(want)) {
projClassCB.setSelectedItem((Object) pc);
break;
}
}
// set the parameter fields
paramPanel.removeAll();
paramPanel.setVisible(0 < projClass.paramList.size());
List widgets = new ArrayList();
for (int i = 0; i < projClass.paramList.size(); i++) {
ProjectionParam pp = (ProjectionParam) projClass.paramList.get(i);
// construct the label
String name = pp.name;
String text = "";
// Create a decent looking label
for (int cIdx = 0; cIdx < name.length(); cIdx++) {
char c = name.charAt(cIdx);
if (cIdx == 0) {
c = Character.toUpperCase(c);
} else {
if (Character.isUpperCase(c)) {
text += " ";
c = Character.toLowerCase(c);
}
}
text += c;
}
widgets.add(GuiUtils.rLabel(text + ": "));
// text input field
JTextField tf = new JTextField();
pp.setTextField(tf);
tf.setColumns(12);
widgets.add(tf);
}
GuiUtils.tmpInsets = new Insets(4, 4, 4, 4);
JPanel widgetPanel = GuiUtils.doLayout(widgets, 2, GuiUtils.WT_N, GuiUtils.WT_N);
paramPanel.add("North", widgetPanel);
paramPanel.add("Center", GuiUtils.filler());
}
public void keyTyped(char ch) {
if (this.emuSys != null) {
if (this.emuSys.getSwapKeyCharCase()) {
if (Character.isUpperCase(ch)) {
ch = Character.toLowerCase(ch);
} else if (Character.isLowerCase(ch)) {
ch = Character.toUpperCase(ch);
}
}
if (this.emuSys.getConvertKeyCharToISO646DE()) {
this.emuSys.keyTyped(TextUtil.toISO646DE(ch));
} else {
this.emuSys.keyTyped(ch);
}
}
}
@NotNull
private Pattern getPattern(String pattern) {
if (!Comparing.strEqual(pattern, myPattern)) {
myCompiledPattern = null;
myPattern = pattern;
}
if (myCompiledPattern == null) {
boolean allowToLower = true;
final int eol = pattern.indexOf('\n');
if (eol != -1) {
pattern = pattern.substring(0, eol);
}
if (pattern.length() >= 80) {
pattern = pattern.substring(0, 80);
}
final @NonNls StringBuffer buffer = new StringBuffer();
if (containsOnlyUppercaseLetters(pattern)) {
allowToLower = false;
}
if (allowToLower) {
buffer.append(".*");
}
boolean firstIdentifierLetter = true;
for (int i = 0; i < pattern.length(); i++) {
final char c = pattern.charAt(i);
if (Character.isLetterOrDigit(c)) {
// This logic allows to use uppercase letters only to catch the name like PDM for
// PsiDocumentManager
if (Character.isUpperCase(c) || Character.isDigit(c)) {
if (!firstIdentifierLetter) {
buffer.append("[^A-Z]*");
}
buffer.append("[");
buffer.append(c);
if (allowToLower || i == 0) {
buffer.append('|');
buffer.append(Character.toLowerCase(c));
}
buffer.append("]");
} else if (Character.isLowerCase(c)) {
buffer.append('[');
buffer.append(c);
buffer.append('|');
buffer.append(Character.toUpperCase(c));
buffer.append(']');
} else {
buffer.append(c);
}
firstIdentifierLetter = false;
} else if (c == '*') {
buffer.append(".*");
firstIdentifierLetter = true;
} else if (c == '.') {
buffer.append("\\.");
firstIdentifierLetter = true;
} else if (c == ' ') {
buffer.append("[^A-Z]*\\ ");
firstIdentifierLetter = true;
} else {
firstIdentifierLetter = true;
// for standard RegExp engine
// buffer.append("\\u");
// buffer.append(Integer.toHexString(c + 0x20000).substring(1));
// for OROMATCHER RegExp engine
buffer.append("\\x");
buffer.append(Integer.toHexString(c + 0x20000).substring(3));
}
}
buffer.append(".*");
try {
myCompiledPattern = new Perl5Compiler().compile(buffer.toString());
} catch (MalformedPatternException e) {
// do nothing
}
}
return myCompiledPattern;
}