From 3577769f43a09c672a64dd7f6ee4c8179fa6433e Mon Sep 17 00:00:00 2001 From: David Dykstal Date: Fri, 18 May 2007 18:31:07 +0000 Subject: [PATCH] [cleanup] formating in preparation for bug fixing --- .../UI/org/eclipse/rse/ui/Mnemonics.java | 559 ++++++++---------- 1 file changed, 248 insertions(+), 311 deletions(-) diff --git a/rse/plugins/org.eclipse.rse.ui/UI/org/eclipse/rse/ui/Mnemonics.java b/rse/plugins/org.eclipse.rse.ui/UI/org/eclipse/rse/ui/Mnemonics.java index 39f46624f76..dbd8c56bad8 100644 --- a/rse/plugins/org.eclipse.rse.ui/UI/org/eclipse/rse/ui/Mnemonics.java +++ b/rse/plugins/org.eclipse.rse.ui/UI/org/eclipse/rse/ui/Mnemonics.java @@ -15,6 +15,7 @@ ********************************************************************************/ package org.eclipse.rse.ui; + import org.eclipse.jface.dialogs.IDialogConstants; import org.eclipse.jface.resource.JFaceResources; import org.eclipse.rse.ui.widgets.InheritableEntryField; @@ -29,70 +30,64 @@ import org.eclipse.swt.widgets.Menu; import org.eclipse.swt.widgets.MenuItem; import org.eclipse.swt.widgets.Text; - - /** * A class for creating unique mnemonics per control per window. */ -public class Mnemonics -{ - private static final String[] TransparentEndings = { // endings that should appear after a mnemonic - "...", // ellipsis //$NON-NLS-1$ - ">>", // standard "more" //$NON-NLS-1$ - "<<", // standard "less" //$NON-NLS-1$ - ">", // "more" -- non-standard usage, must appear in list after >> //$NON-NLS-1$ - "<", // "less" -- non-standard usage, must appear in list after << //$NON-NLS-1$ - ":", // colon //$NON-NLS-1$ - "\uff0e\uff0e\uff0e", // wide ellipsis //$NON-NLS-1$ - "\uff1e\uff1e", // wide standard "more" //$NON-NLS-1$ - "\uff1c\uff1c", // wide standard "less" //$NON-NLS-1$ - "\uff1e", // wide non-standard "more" //$NON-NLS-1$ - "\uff1c", // wide non-standard "less" //$NON-NLS-1$ - "\uff1a" // wide colon //$NON-NLS-1$ +public class Mnemonics { + private static final String[] TransparentEndings = { // endings that should appear after a mnemonic if one is added + "...", // ellipsis //$NON-NLS-1$ + ">>", // standard "more" //$NON-NLS-1$ + "<<", // standard "less" //$NON-NLS-1$ + ">", // "more" -- non-standard usage, must appear in list after >> //$NON-NLS-1$ + "<", // "less" -- non-standard usage, must appear in list after << //$NON-NLS-1$ + ":", // colon //$NON-NLS-1$ + "\uff0e\uff0e\uff0e", // wide ellipsis //$NON-NLS-1$ + "\uff1e\uff1e", // wide standard "more" //$NON-NLS-1$ + "\uff1c\uff1c", // wide standard "less" //$NON-NLS-1$ + "\uff1e", // wide non-standard "more" //$NON-NLS-1$ + "\uff1c", // wide non-standard "less" //$NON-NLS-1$ + "\uff1a" // wide colon //$NON-NLS-1$ }; - + private StringBuffer mnemonics = new StringBuffer(); // mnemonics used so far private static final String candidateChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; //$NON-NLS-1$ - private String preferencePageMnemonics = null; // mnemonics used by Eclipse on preference pages - private String wizardPageMnemonics = null; // mnemonics used by Eclipse on wizard pages - // private static String preferencePageMnemonics = "AD"; // mnemonics used by Eclipse on preference pages - // private static String wizardPageMnemonics = "FBN"; // mnemonics used by Eclipse on wizard pages + private String preferencePageMnemonics = null; // mnemonics used by Eclipse on preference pages + private String wizardPageMnemonics = null; // mnemonics used by Eclipse on wizard pages public static final char MNEMONIC_CHAR = '&'; private boolean onPrefPage = false; private boolean onWizardPage = false; private boolean applyMnemonicsToPrecedingLabels = true; - - /** - * Clear the list for re-use - */ - public void clear() - { - mnemonics = new StringBuffer(); - } - - /** - * Inserts an added mnemonic of the form (&x) into a StringBuffer at the correct point. - * Checks for transparent endings and trailing spaces. - * @param label the label to check - */ - private static void insertMnemonic(StringBuffer label, String mnemonic) { - int p = label.length(); + + /** + * Clear the list for re-use + */ + public void clear() { + mnemonics = new StringBuffer(); + } + + /** + * Inserts an added mnemonic of the form (&x) into a StringBuffer at the correct point. + * Checks for transparent endings and trailing spaces. + * @param label the label to check + */ + private static void insertMnemonic(StringBuffer label, String mnemonic) { + int p = label.length(); // check for trailing spaces #1 while (p > 0 && label.charAt(p - 1) == ' ') { p--; } // check for transparent endings - for (int i = 0; i < TransparentEndings.length; i++) { - String transparentEnding = TransparentEndings[i]; - int l = transparentEnding.length(); - int n = p - l; - if (n >= 0) { + for (int i = 0; i < TransparentEndings.length; i++) { + String transparentEnding = TransparentEndings[i]; + int l = transparentEnding.length(); + int n = p - l; + if (n >= 0) { String labelEnding = label.substring(n, n + l); if (labelEnding.equals(transparentEnding)) { p = n; break; } - } + } } // check for trailing spaces #2 while (p > 0 && label.charAt(p - 1) == ' ') { @@ -102,8 +97,8 @@ public class Mnemonics if (p > 0) { label.insert(p, mnemonic); } - } - + } + /** * Given a string, this starts at the first character and iterates until * it finds a character not previously used as a mnemonic on this page. @@ -112,40 +107,36 @@ public class Mnemonics * @param label String to which to generate and apply the mnemonic * @return input String with '&' inserted in front of the unique character */ - public String setUniqueMnemonic(String label) - { - + public String setUniqueMnemonic(String label) { // Kludge for now // If there is already a mnemonic, remove it label = removeMnemonic(label); //int iMnemonic = label.indexOf( MNEMONIC_CHAR ); //if( iMnemonic >= 0 && iMnemonic < label.length() - 1 ){ - //mnemonics.append( label.charAt( iMnemonic + 1 ) ); - //return label; + //mnemonics.append( label.charAt( iMnemonic + 1 ) ); + //return label; //} - int labelLen = label.length(); if (labelLen == 0) - return label; + return label; else if ((labelLen == 1) && label.equals("?")) //$NON-NLS-1$ - return label; - StringBuffer newLabel = new StringBuffer(label); - int mcharPos = findUniqueMnemonic(label); + return label; + StringBuffer newLabel = new StringBuffer(label); + int mcharPos = findUniqueMnemonic(label); if (mcharPos != -1) - newLabel.insert(mcharPos,MNEMONIC_CHAR); + newLabel.insert(mcharPos, MNEMONIC_CHAR); // if no unique character found, then // find a new arbitrary one from the alphabet... - else - { - mcharPos = findUniqueMnemonic(candidateChars); - if (mcharPos != -1) - { - String addedMnemonic = "(" + MNEMONIC_CHAR + candidateChars.charAt(mcharPos) + ")"; //$NON-NLS-1$ //$NON-NLS-2$ - insertMnemonic(newLabel, addedMnemonic); - } + else { + mcharPos = findUniqueMnemonic(candidateChars); + if (mcharPos != -1) { + String addedMnemonic = "(" + MNEMONIC_CHAR + candidateChars.charAt(mcharPos) + ")"; //$NON-NLS-1$ //$NON-NLS-2$ + insertMnemonic(newLabel, addedMnemonic); + } } return newLabel.toString(); } // end getUniqueMnemonic + /** * Given a label and mnemonic, this applies that mnemonic to the label. * Not normally called from other classes, but rather by the setUniqueMnemonic @@ -154,98 +145,86 @@ public class Mnemonics * @param mnemonicChar the character that is to be the mnemonic character * @return input String with '&' inserted in front of the given character */ - public static String applyMnemonic(String label, char mnemonicChar) - { + public static String applyMnemonic(String label, char mnemonicChar) { int labelLen = label.length(); - if (labelLen == 0) - return label; - StringBuffer newLabel = new StringBuffer(label); + if (labelLen == 0) return label; + StringBuffer newLabel = new StringBuffer(label); int mcharPos = findCharPos(label, mnemonicChar); if (mcharPos != -1) - newLabel.insert(mcharPos,MNEMONIC_CHAR); - else - { - String addedMnemonic = new String("("+MNEMONIC_CHAR + mnemonicChar + ")"); //$NON-NLS-1$ //$NON-NLS-2$ + newLabel.insert(mcharPos, MNEMONIC_CHAR); + else { + String addedMnemonic = new String("(" + MNEMONIC_CHAR + mnemonicChar + ")"); //$NON-NLS-1$ //$NON-NLS-2$ insertMnemonic(newLabel, addedMnemonic); } return newLabel.toString(); } // end getUniqueMnemonic + /** * Given a char, find its position in the given string */ - private static int findCharPos(String label, char charToFind) - { + private static int findCharPos(String label, char charToFind) { int pos = -1; - for (int idx=0; (pos==-1) && (idx 0)) - button.setText(setUniqueMnemonic(text)); + if ((text != null) && (text.trim().length() > 0)) button.setText(setUniqueMnemonic(text)); } + /** * If a button is removed from a dialog window, call this method to remove its mnemonic from the list for this dialog. * This frees it up for another button to use. */ - public void removeMnemonic(Button button) - { + public void removeMnemonic(Button button) { String text = button.getText(); - if (text == null) - return; + if (text == null) return; int idx = text.indexOf(MNEMONIC_CHAR); - if (idx >= 0) - { - StringBuffer buffer = new StringBuffer(text); - char mchar = buffer.charAt(idx+1); // the char after the & - buffer.deleteCharAt(idx); // delete the & - boolean found = false; - for (int mdx=0; !found && (mdx < mnemonics.length()); mdx++) - if (mnemonics.charAt(mdx) == mchar) - { - found = true; - mnemonics.deleteCharAt(mdx); - } - - button.setText(buffer.toString()); + if (idx >= 0) { + StringBuffer buffer = new StringBuffer(text); + char mchar = buffer.charAt(idx + 1); // the char after the & + buffer.deleteCharAt(idx); // delete the & + boolean found = false; + for (int mdx = 0; !found && (mdx < mnemonics.length()); mdx++) + if (mnemonics.charAt(mdx) == mchar) { + found = true; + mnemonics.deleteCharAt(mdx); + } + + button.setText(buffer.toString()); } } + /** * Helper method to strip the mnemonic from a string. * Useful if using Eclipse supplied labels */ - public static String removeMnemonic(String text) - { + public static String removeMnemonic(String text) { int idx = text.indexOf(MNEMONIC_CHAR); - if (idx >= 0) - { - StringBuffer buffer = new StringBuffer(text); - buffer.deleteCharAt(idx); // delete the & - - // in case of already appended (&X), remove the remaining (X) - if ( buffer.length() > (1 + idx) && idx > 1 && buffer.charAt(idx+1) == ')' && buffer.charAt(idx-1) == '(' ) - buffer.delete(idx - 1, idx + 2); - return buffer.toString(); - } - else - return text; + if (idx >= 0) { + StringBuffer buffer = new StringBuffer(text); + buffer.deleteCharAt(idx); // delete the & + + // in case of already appended (&X), remove the remaining (X) + if (buffer.length() > (1 + idx) && idx > 1 && buffer.charAt(idx + 1) == ')' && buffer.charAt(idx - 1) == '(') buffer.delete(idx - 1, idx + 2); + return buffer.toString(); + } else + return text; } + /** * Remove and free up mnemonic */ - public String removeAndFreeMnemonic(String text) - { + public String removeAndFreeMnemonic(String text) { int idx = text.indexOf(MNEMONIC_CHAR); - if (idx >= 0) - { - StringBuffer buffer = new StringBuffer(text); - char mchar = buffer.charAt(idx+1); // the char after the & - buffer.deleteCharAt(idx); // delete the & - boolean found = false; - for (int mdx=0; !found && (mdx < mnemonics.length()); mdx++) - if (mnemonics.charAt(mdx) == mchar) - { - found = true; - mnemonics.deleteCharAt(mdx); - } - return buffer.toString(); - } - else - return text; + if (idx >= 0) { + StringBuffer buffer = new StringBuffer(text); + char mchar = buffer.charAt(idx + 1); // the char after the & + buffer.deleteCharAt(idx); // delete the & + boolean found = false; + for (int mdx = 0; !found && (mdx < mnemonics.length()); mdx++) + if (mnemonics.charAt(mdx) == mchar) { + found = true; + mnemonics.deleteCharAt(mdx); + } + return buffer.toString(); + } else + return text; } - + /** * Helper method to return the mnemonic from a string. * Helpful when it is necessary to know the mnemonic assigned so it can be reassigned, * such as is necessary for buttons which toggle their text. * @return the mnemonic if assigned, else a blank character. */ - public static char getMnemonic(String text) - { + public static char getMnemonic(String text) { int idx = text.indexOf(MNEMONIC_CHAR); if (idx >= 0) - return text.charAt(idx+1); + return text.charAt(idx + 1); else - return ' '; + return ' '; } - + /** * Given a Composite, this method walks all the children recursively and * and sets the mnemonics uniquely for each child control where a @@ -389,50 +352,41 @@ public class Mnemonics * per Window. * Call this after populating your controls. */ - public void setMnemonics(Composite parent) - { - Control children[] = parent.getChildren(); - if (children != null) - { - Control currChild = null; - boolean bSetText = false; - for (int idx=0; idx < children.length; idx++) - { - currChild = children[idx]; - // composite? Recurse - // d54732: but do not recurse if it is a combo! For a combo, we want to check - // if there is a preceding label. It's meaningless for a combo to - // have children anyway (KM) - if ((currChild instanceof Composite) && - (!applyMnemonicsToPrecedingLabels || (applyMnemonicsToPrecedingLabels && - !(currChild instanceof Combo) && !(currChild instanceof InheritableEntryField)))) - setMnemonics((Composite)currChild); - // button? select and apply unique mnemonic... - else if (currChild instanceof Button) - { - Button currButton = (Button)currChild; - String text = currButton.getText(); - if ((text!=null) && (text.trim().length()>0)) - { - currButton.setText(setUniqueMnemonic(text)); - bSetText = true; - } - } - // entry field or combo box? select and apply unique mnemonic to preceding label... - else if (applyMnemonicsToPrecedingLabels && (idx>0) && ((currChild instanceof Text) || (currChild instanceof Combo) || (currChild instanceof InheritableEntryField)) && - (children[idx-1] instanceof Label)) - { - Label currLabel = (Label)children[idx-1]; - String text = currLabel.getText(); - if ((text!=null) && (text.trim().length()>0)) - { - currLabel.setText(setUniqueMnemonic(text)); - bSetText = true; - } + public void setMnemonics(Composite parent) { + Control children[] = parent.getChildren(); + if (children != null) { + Control currChild = null; + boolean bSetText = false; + for (int idx = 0; idx < children.length; idx++) { + currChild = children[idx]; + // composite? Recurse + // d54732: but do not recurse if it is a combo! For a combo, we want to check + // if there is a preceding label. It's meaningless for a combo to + // have children anyway (KM) + if ((currChild instanceof Composite) && + (!applyMnemonicsToPrecedingLabels || (applyMnemonicsToPrecedingLabels && !(currChild instanceof Combo) && !(currChild instanceof InheritableEntryField)))) + setMnemonics((Composite) currChild); + // button? select and apply unique mnemonic... + else if (currChild instanceof Button) { + Button currButton = (Button) currChild; + String text = currButton.getText(); + if ((text != null) && (text.trim().length() > 0)) { + currButton.setText(setUniqueMnemonic(text)); + bSetText = true; + } + } + // entry field or combo box? select and apply unique mnemonic to preceding label... + else if (applyMnemonicsToPrecedingLabels && (idx > 0) && ((currChild instanceof Text) || (currChild instanceof Combo) || (currChild instanceof InheritableEntryField)) && + (children[idx - 1] instanceof Label)) { + Label currLabel = (Label) children[idx - 1]; + String text = currLabel.getText(); + if ((text != null) && (text.trim().length() > 0)) { + currLabel.setText(setUniqueMnemonic(text)); + bSetText = true; + } + } } - } - if ( bSetText == true ) - parent.layout(true); // in case a (x) was appended, we need to layout the controls again + if (bSetText == true) parent.layout(true); // in case a (x) was appended, we need to layout the controls again } } @@ -441,27 +395,22 @@ public class Mnemonics * memnonic. Also handles casdading submenus. * Call this after populating the menu. */ - public void setMnemonics(Menu menu) - { - MenuItem[] children = menu.getItems(); - if ((children != null) && (children.length>0)) - { - MenuItem currChild = null; - for (int idx=0; idx < children.length; idx++) - { - currChild = children[idx]; - String text = currChild.getText(); - if ((text!=null)&&(text.length()>0)) - { - if (text.indexOf(MNEMONIC_CHAR) < 0) // bad things happen when setting mnemonics twice! - { - Image image = currChild.getImage(); - currChild.setText(setUniqueMnemonic(text)); - if (image != null) - currChild.setImage(image); - } - } - } + public void setMnemonics(Menu menu) { + MenuItem[] children = menu.getItems(); + if ((children != null) && (children.length > 0)) { + MenuItem currChild = null; + for (int idx = 0; idx < children.length; idx++) { + currChild = children[idx]; + String text = currChild.getText(); + if ((text != null) && (text.length() > 0)) { + if (text.indexOf(MNEMONIC_CHAR) < 0) // bad things happen when setting mnemonics twice! + { + Image image = currChild.getImage(); + currChild.setText(setUniqueMnemonic(text)); + if (image != null) currChild.setImage(image); + } + } + } } } @@ -476,64 +425,54 @@ public class Mnemonics *

* Call this after populating the menu. */ - public void setMnemonicsAndArmListener(Menu menu, ArmListener listener) - { - MenuItem[] children = menu.getItems(); - if ((children != null) && (children.length>0)) - { - MenuItem currChild = null; - for (int idx=0; idx < children.length; idx++) - { - currChild = children[idx]; - String text = currChild.getText(); - if ((text!=null)&&(text.length()>0)) - { - int mnemonicIndex = text.indexOf(MNEMONIC_CHAR); - if (mnemonicIndex < 0) // bad things happen when setting mnemonics twice! - { - Image image = currChild.getImage(); - currChild.setText(setUniqueMnemonic(text)); - if (image != null) - currChild.setImage(image); - currChild.addArmListener(listener); - } - else - // hmm, already has a mnemonic char. Either it is an Eclipse/BP-supplied action, or we have been here before. - // The distinction is important as want to add an Arm listener, but only once! - { - // for now we do the brute force ugly thing... - Image image = currChild.getImage(); - - // need to adjust any action that already has this mnemonic - char c = text.charAt(mnemonicIndex + 1); - - // anything already have this? - if (!isUniqueMnemonic(c)) - { - // if so, we need to adjust existing action - for (int n = 0; n < idx; n++) - { - MenuItem oChild = children[n]; - String oText = oChild.getText(); - char oldN = getMnemonic(oText); - if (oldN == c) - { - // this one now needs to change - String cleanText = removeMnemonic(oText); - oChild.setText(setUniqueMnemonic(cleanText)); - } - } - } - - text = removeAndFreeMnemonic(text); - currChild.setText(setUniqueMnemonic(text)); - if (image != null) - currChild.setImage(image); - currChild.removeArmListener(listener); // just in case - currChild.addArmListener(listener); - } - } - } + public void setMnemonicsAndArmListener(Menu menu, ArmListener listener) { + MenuItem[] children = menu.getItems(); + if ((children != null) && (children.length > 0)) { + MenuItem currChild = null; + for (int idx = 0; idx < children.length; idx++) { + currChild = children[idx]; + String text = currChild.getText(); + if ((text != null) && (text.length() > 0)) { + int mnemonicIndex = text.indexOf(MNEMONIC_CHAR); + if (mnemonicIndex < 0) // bad things happen when setting mnemonics twice! + { + Image image = currChild.getImage(); + currChild.setText(setUniqueMnemonic(text)); + if (image != null) currChild.setImage(image); + currChild.addArmListener(listener); + } else + // hmm, already has a mnemonic char. Either it is an Eclipse/BP-supplied action, or we have been here before. + // The distinction is important as want to add an Arm listener, but only once! + { + // for now we do the brute force ugly thing... + Image image = currChild.getImage(); + + // need to adjust any action that already has this mnemonic + char c = text.charAt(mnemonicIndex + 1); + + // anything already have this? + if (!isUniqueMnemonic(c)) { + // if so, we need to adjust existing action + for (int n = 0; n < idx; n++) { + MenuItem oChild = children[n]; + String oText = oChild.getText(); + char oldN = getMnemonic(oText); + if (oldN == c) { + // this one now needs to change + String cleanText = removeMnemonic(oText); + oChild.setText(setUniqueMnemonic(cleanText)); + } + } + } + + text = removeAndFreeMnemonic(text); + currChild.setText(setUniqueMnemonic(text)); + if (image != null) currChild.setImage(image); + currChild.removeArmListener(listener); // just in case + currChild.addArmListener(listener); + } + } + } } } @@ -542,8 +481,7 @@ public class Mnemonics * Preference pages already have a few buttons with mnemonics set by Eclipse * We have to make sure we do not use the ones they use */ - public Mnemonics setOnPreferencePage(boolean page) - { + public Mnemonics setOnPreferencePage(boolean page) { this.onPrefPage = page; return this; } @@ -553,12 +491,11 @@ public class Mnemonics * Wizard pages already have a few buttons with mnemonics set by Eclipse * We have to make sure we do not use the ones they use */ - public Mnemonics setOnWizardPage(boolean page) - { + public Mnemonics setOnWizardPage(boolean page) { this.onWizardPage = page; return this; } - + /** * Set whether to apply mnemonics to labels preceding text fields, combos and inheritable entry fields. * This is for consistency with Eclipse. Only set to false if it does not work @@ -571,5 +508,5 @@ public class Mnemonics this.applyMnemonicsToPrecedingLabels = apply; return this; } - + } \ No newline at end of file