mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-07-26 10:25:32 +02:00
Code Issues Wiki Activity

[cleanup] formating in preparation for bug fixing

Browse source
This commit is contained in:
David Dykstal 2007-05-18 18:31:07 +00:00
parent 0c5a08d8ce
commit 3577769f43
1 changed files with 248 additions and 311 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

559
rse/plugins/org.eclipse.rse.ui/UI/org/eclipse/rse/ui/Mnemonics.java
View file

@ -15,6 +15,7 @@
********************************************************************************/ ********************************************************************************/
package org.eclipse.rse.ui; package org.eclipse.rse.ui;
import org.eclipse.jface.dialogs.IDialogConstants; import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.resource.JFaceResources; import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.rse.ui.widgets.InheritableEntryField; 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.MenuItem;
import org.eclipse.swt.widgets.Text; import org.eclipse.swt.widgets.Text;
/** /**
* A class for creating unique mnemonics per control per window. * A class for creating unique mnemonics per control per window.
*/ */
public class Mnemonics public class Mnemonics {
{ private static final String[] TransparentEndings = { // endings that should appear after a mnemonic if one is added
private static final String[] TransparentEndings = { // endings that should appear after a mnemonic "...", // ellipsis //$NON-NLS-1$
"...", // ellipsis //$NON-NLS-1$ ">>", // standard "more" //$NON-NLS-1$
">>", // standard "more" //$NON-NLS-1$ "<<", // standard "less" //$NON-NLS-1$
"<<", // standard "less" //$NON-NLS-1$ ">", // "more" -- non-standard usage, must appear in list after >> //$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$
"<", // "less" -- non-standard usage, must appear in list after << //$NON-NLS-1$ ":", // colon //$NON-NLS-1$
":", // colon //$NON-NLS-1$ "\uff0e\uff0e\uff0e", // wide ellipsis //$NON-NLS-1$
"\uff0e\uff0e\uff0e", // wide ellipsis //$NON-NLS-1$ "\uff1e\uff1e", // wide standard "more" //$NON-NLS-1$
"\uff1e\uff1e", // wide standard "more" //$NON-NLS-1$ "\uff1c\uff1c", // wide standard "less" //$NON-NLS-1$
"\uff1c\uff1c", // wide standard "less" //$NON-NLS-1$ "\uff1e", // wide non-standard "more" //$NON-NLS-1$
"\uff1e", // wide non-standard "more" //$NON-NLS-1$ "\uff1c", // wide non-standard "less" //$NON-NLS-1$
"\uff1c", // wide non-standard "less" //$NON-NLS-1$ "\uff1a" // wide colon //$NON-NLS-1$
"\uff1a" // wide colon //$NON-NLS-1$
}; };
private StringBuffer mnemonics = new StringBuffer(); // mnemonics used so far private StringBuffer mnemonics = new StringBuffer(); // mnemonics used so far
private static final String candidateChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; //$NON-NLS-1$ private static final String candidateChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; //$NON-NLS-1$
private String preferencePageMnemonics = null; // mnemonics used by Eclipse on preference pages private String preferencePageMnemonics = null; // mnemonics used by Eclipse on preference pages
private String wizardPageMnemonics = null; // mnemonics used by Eclipse on wizard 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
public static final char MNEMONIC_CHAR = '&'; public static final char MNEMONIC_CHAR = '&';
private boolean onPrefPage = false; private boolean onPrefPage = false;
private boolean onWizardPage = false; private boolean onWizardPage = false;
private boolean applyMnemonicsToPrecedingLabels = true; private boolean applyMnemonicsToPrecedingLabels = true;
/** /**
* Clear the list for re-use * Clear the list for re-use
*/ */
public void clear() public void clear() {
{ mnemonics = new StringBuffer();
mnemonics = new StringBuffer(); }
}
/**
/** * Inserts an added mnemonic of the form (&x) into a StringBuffer at the correct point.
* Inserts an added mnemonic of the form (&x) into a StringBuffer at the correct point. * Checks for transparent endings and trailing spaces.
* Checks for transparent endings and trailing spaces. * @param label the label to check
* @param label the label to check */
*/ private static void insertMnemonic(StringBuffer label, String mnemonic) {
private static void insertMnemonic(StringBuffer label, String mnemonic) { int p = label.length();
int p = label.length();
// check for trailing spaces #1 // check for trailing spaces #1
while (p > 0 && label.charAt(p - 1) == ' ') { while (p > 0 && label.charAt(p - 1) == ' ') {
p--; p--;
} }
// check for transparent endings // check for transparent endings
for (int i = 0; i < TransparentEndings.length; i++) { for (int i = 0; i < TransparentEndings.length; i++) {
String transparentEnding = TransparentEndings[i]; String transparentEnding = TransparentEndings[i];
int l = transparentEnding.length(); int l = transparentEnding.length();
int n = p - l; int n = p - l;
if (n >= 0) { if (n >= 0) {
String labelEnding = label.substring(n, n + l); String labelEnding = label.substring(n, n + l);
if (labelEnding.equals(transparentEnding)) { if (labelEnding.equals(transparentEnding)) {
p = n; p = n;
break; break;
} }
} }
} }
// check for trailing spaces #2 // check for trailing spaces #2
while (p > 0 && label.charAt(p - 1) == ' ') { while (p > 0 && label.charAt(p - 1) == ' ') {
@ -102,8 +97,8 @@ public class Mnemonics
if (p > 0) { if (p > 0) {
label.insert(p, mnemonic); label.insert(p, mnemonic);
} }
} }
/** /**
* Given a string, this starts at the first character and iterates until * 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. * 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 * @param label String to which to generate and apply the mnemonic
* @return input String with '&' inserted in front of the unique character * @return input String with '&' inserted in front of the unique character
*/ */
public String setUniqueMnemonic(String label) public String setUniqueMnemonic(String label) {
{
// Kludge for now // Kludge for now
// If there is already a mnemonic, remove it // If there is already a mnemonic, remove it
label = removeMnemonic(label); label = removeMnemonic(label);
//int iMnemonic = label.indexOf( MNEMONIC_CHAR ); //int iMnemonic = label.indexOf( MNEMONIC_CHAR );
//if( iMnemonic >= 0 && iMnemonic < label.length() - 1 ){ //if( iMnemonic >= 0 && iMnemonic < label.length() - 1 ){
//mnemonics.append( label.charAt( iMnemonic + 1 ) ); //mnemonics.append( label.charAt( iMnemonic + 1 ) );
//return label; //return label;
//} //}
int labelLen = label.length(); int labelLen = label.length();
if (labelLen == 0) if (labelLen == 0)
return label; return label;
else if ((labelLen == 1) && label.equals("?")) //$NON-NLS-1$ else if ((labelLen == 1) && label.equals("?")) //$NON-NLS-1$
return label; return label;
StringBuffer newLabel = new StringBuffer(label); StringBuffer newLabel = new StringBuffer(label);
int mcharPos = findUniqueMnemonic(label); int mcharPos = findUniqueMnemonic(label);
if (mcharPos != -1) if (mcharPos != -1)
newLabel.insert(mcharPos,MNEMONIC_CHAR); newLabel.insert(mcharPos, MNEMONIC_CHAR);
// if no unique character found, then // if no unique character found, then
// find a new arbitrary one from the alphabet... // find a new arbitrary one from the alphabet...
else else {
{ mcharPos = findUniqueMnemonic(candidateChars);
mcharPos = findUniqueMnemonic(candidateChars); if (mcharPos != -1) {
if (mcharPos != -1) String addedMnemonic = "(" + MNEMONIC_CHAR + candidateChars.charAt(mcharPos) + ")"; //$NON-NLS-1$ //$NON-NLS-2$
{ insertMnemonic(newLabel, addedMnemonic);
String addedMnemonic = "(" + MNEMONIC_CHAR + candidateChars.charAt(mcharPos) + ")"; //$NON-NLS-1$ //$NON-NLS-2$ }
insertMnemonic(newLabel, addedMnemonic);
}
} }
return newLabel.toString(); return newLabel.toString();
} // end getUniqueMnemonic } // end getUniqueMnemonic
/** /**
* Given a label and mnemonic, this applies that mnemonic to the label. * Given a label and mnemonic, this applies that mnemonic to the label.
* Not normally called from other classes, but rather by the setUniqueMnemonic * 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 * @param mnemonicChar the character that is to be the mnemonic character
* @return input String with '&' inserted in front of the given 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(); int labelLen = label.length();
if (labelLen == 0) if (labelLen == 0) return label;
return label; StringBuffer newLabel = new StringBuffer(label);
StringBuffer newLabel = new StringBuffer(label);
int mcharPos = findCharPos(label, mnemonicChar); int mcharPos = findCharPos(label, mnemonicChar);
if (mcharPos != -1) if (mcharPos != -1)
newLabel.insert(mcharPos,MNEMONIC_CHAR); newLabel.insert(mcharPos, MNEMONIC_CHAR);
else else {
{ String addedMnemonic = new String("(" + MNEMONIC_CHAR + mnemonicChar + ")"); //$NON-NLS-1$ //$NON-NLS-2$
String addedMnemonic = new String("("+MNEMONIC_CHAR + mnemonicChar + ")"); //$NON-NLS-1$ //$NON-NLS-2$
insertMnemonic(newLabel, addedMnemonic); insertMnemonic(newLabel, addedMnemonic);
} }
return newLabel.toString(); return newLabel.toString();
} // end getUniqueMnemonic } // end getUniqueMnemonic
/** /**
* Given a char, find its position in the given string * 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; int pos = -1;
for (int idx=0; (pos==-1) && (idx<label.length()); idx++) for (int idx = 0; (pos == -1) && (idx < label.length()); idx++)
if (label.charAt(idx) == charToFind) if (label.charAt(idx) == charToFind) pos = idx;
pos = idx; return pos;
return pos;
} }
/** /**
* Determine if given char is a unique mnemonic * Determine if given char is a unique mnemonic
*/ */
public boolean isUniqueMnemonic(char currchar) public boolean isUniqueMnemonic(char currchar) {
{ boolean isUnique = true;
boolean isUnique = true; for (int idx = 0; isUnique && (idx < mnemonics.length()); idx++)
for (int idx=0; isUnique && (idx < mnemonics.length()); idx++) if (mnemonics.charAt(idx) == currchar) isUnique = false;
if (mnemonics.charAt(idx) == currchar) return isUnique;
isUnique = false;
return isUnique;
} }
/** /**
* Find a uniqe mnemonic char in given string. * Find a uniqe mnemonic char in given string.
* Note if one is found, it is added to the list of currently used mnemonics! * Note if one is found, it is added to the list of currently used mnemonics!
* *
* @return index position of unique character in input string, or -1 if none found. * @return index position of unique character in input string, or -1 if none found.
*/ */
public int findUniqueMnemonic(String label) public int findUniqueMnemonic(String label) {
{
int labelLen = label.length(); int labelLen = label.length();
if (labelLen == 0) if (labelLen == 0) return -1;
return -1; int retcharPos = -1;
int retcharPos = -1;
label = label.toUpperCase(); label = label.toUpperCase();
char currchar = label.charAt(0); char currchar = label.charAt(0);
boolean isUnique = false; boolean isUnique = false;
// if we're on a preference page, get the preference page mnemonics // if we're on a preference page, get the preference page mnemonics
if (onPrefPage) { if (onPrefPage) {
if (preferencePageMnemonics == null) { if (preferencePageMnemonics == null) {
preferencePageMnemonics = getPreferencePageMnemonics(); preferencePageMnemonics = getPreferencePageMnemonics();
} }
} }
// if we're on a wizard page, get the wizard page mnemonics // if we're on a wizard page, get the wizard page mnemonics
if (onWizardPage) { if (onWizardPage) {
if (wizardPageMnemonics == null) { if (wizardPageMnemonics == null) {
wizardPageMnemonics = getWizardPageMnemonics(); wizardPageMnemonics = getWizardPageMnemonics();
} }
} }
// attempt to find the first character in the given // attempt to find the first character in the given
// string that has not already been used as a mnemonic // string that has not already been used as a mnemonic
for (int idx=0; (idx<labelLen) && (retcharPos==-1); idx++) for (int idx = 0; (idx < labelLen) && (retcharPos == -1); idx++) {
{ currchar = label.charAt(idx);
currchar = label.charAt(idx);
if (!(onPrefPage && preferencePageMnemonics.indexOf(currchar) != -1) && !(onWizardPage && wizardPageMnemonics.indexOf(currchar) != -1) && candidateChars.indexOf(currchar) != -1) {
if ( !(onPrefPage && preferencePageMnemonics.indexOf( currchar ) != -1) isUnique = isUniqueMnemonic(currchar);
&& !(onWizardPage && wizardPageMnemonics.indexOf( currchar ) != -1) if (isUnique) {
&& candidateChars.indexOf( currchar ) != -1 ) mnemonics.append(currchar);
{ retcharPos = idx;
isUnique = isUniqueMnemonic(currchar); }
if (isUnique) }
{
mnemonics.append(currchar);
retcharPos = idx;
}
}
} }
return retcharPos; return retcharPos;
} }
/** /**
* Returns a string containing the mnemonics for a preference page. * Returns a string containing the mnemonics for a preference page.
* @return the mnemonics. * @return the mnemonics.
@ -254,132 +233,116 @@ public class Mnemonics
String[] labels = JFaceResources.getStrings(new String[] { "defaults", "apply" }); //$NON-NLS-1$ //$NON-NLS-2$ String[] labels = JFaceResources.getStrings(new String[] { "defaults", "apply" }); //$NON-NLS-1$ //$NON-NLS-2$
return getMnemonicsFromStrings(labels).toUpperCase(); return getMnemonicsFromStrings(labels).toUpperCase();
} }
/** /**
* Returns a string containing the mnemonics for a wizard page. * Returns a string containing the mnemonics for a wizard page.
* @return the mnemonics. * @return the mnemonics.
*/ */
private String getWizardPageMnemonics() { private String getWizardPageMnemonics() {
String[] labels = new String[] {IDialogConstants.BACK_LABEL, IDialogConstants.NEXT_LABEL, IDialogConstants.FINISH_LABEL}; String[] labels = new String[] { IDialogConstants.BACK_LABEL, IDialogConstants.NEXT_LABEL, IDialogConstants.FINISH_LABEL };
return getMnemonicsFromStrings(labels).toUpperCase(); return getMnemonicsFromStrings(labels).toUpperCase();
} }
/** /**
* Returns a string with the mnemonics for a given array of strings. * Returns a string with the mnemonics for a given array of strings.
* @param strings the array of strings. * @param strings the array of strings.
* @return a string containing the mnemonics. * @return a string containing the mnemonics.
*/ */
private String getMnemonicsFromStrings(String[] strings) { private String getMnemonicsFromStrings(String[] strings) {
StringBuffer result = new StringBuffer(); StringBuffer result = new StringBuffer();
for (int i = 0; i < strings.length; i++) { for (int i = 0; i < strings.length; i++) {
int idx = strings[i].indexOf(MNEMONIC_CHAR); int idx = strings[i].indexOf(MNEMONIC_CHAR);
if (idx != -1) { if (idx != -1) {
result.append(strings[i].charAt(idx+1)); result.append(strings[i].charAt(idx + 1));
} }
} }
return result.toString(); return result.toString();
} }
/** /**
* Adds a mnemonic to an SWT Button such that the user can select it via Ctrl/Alt+mnemonic. * Adds a mnemonic to an SWT Button such that the user can select it via Ctrl/Alt+mnemonic.
* Note a mnemonic unique to this window is chosen * Note a mnemonic unique to this window is chosen
*/ */
public void setMnemonic(Button button) public void setMnemonic(Button button) {
{
removeMnemonic(button); // just in case it already has a mnemonic removeMnemonic(button); // just in case it already has a mnemonic
String text = button.getText(); String text = button.getText();
if ((text != null) && (text.trim().length() > 0)) if ((text != null) && (text.trim().length() > 0)) button.setText(setUniqueMnemonic(text));
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. * 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. * This frees it up for another button to use.
*/ */
public void removeMnemonic(Button button) public void removeMnemonic(Button button) {
{
String text = button.getText(); String text = button.getText();
if (text == null) if (text == null) return;
return;
int idx = text.indexOf(MNEMONIC_CHAR); int idx = text.indexOf(MNEMONIC_CHAR);
if (idx >= 0) if (idx >= 0) {
{ StringBuffer buffer = new StringBuffer(text);
StringBuffer buffer = new StringBuffer(text); char mchar = buffer.charAt(idx + 1); // the char after the &
char mchar = buffer.charAt(idx+1); // the char after the & buffer.deleteCharAt(idx); // delete the &
buffer.deleteCharAt(idx); // delete the & boolean found = false;
boolean found = false; for (int mdx = 0; !found && (mdx < mnemonics.length()); mdx++)
for (int mdx=0; !found && (mdx < mnemonics.length()); mdx++) if (mnemonics.charAt(mdx) == mchar) {
if (mnemonics.charAt(mdx) == mchar) found = true;
{ mnemonics.deleteCharAt(mdx);
found = true; }
mnemonics.deleteCharAt(mdx);
} button.setText(buffer.toString());
button.setText(buffer.toString());
} }
} }
/** /**
* Helper method to strip the mnemonic from a string. * Helper method to strip the mnemonic from a string.
* Useful if using Eclipse supplied labels * Useful if using Eclipse supplied labels
*/ */
public static String removeMnemonic(String text) public static String removeMnemonic(String text) {
{
int idx = text.indexOf(MNEMONIC_CHAR); int idx = text.indexOf(MNEMONIC_CHAR);
if (idx >= 0) if (idx >= 0) {
{ StringBuffer buffer = new StringBuffer(text);
StringBuffer buffer = new StringBuffer(text); buffer.deleteCharAt(idx); // delete the &
buffer.deleteCharAt(idx); // delete the &
// in case of already appended (&X), remove the remaining (X)
// 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);
if ( buffer.length() > (1 + idx) && idx > 1 && buffer.charAt(idx+1) == ')' && buffer.charAt(idx-1) == '(' ) return buffer.toString();
buffer.delete(idx - 1, idx + 2); } else
return buffer.toString(); return text;
}
else
return text;
} }
/** /**
* Remove and free up mnemonic * Remove and free up mnemonic
*/ */
public String removeAndFreeMnemonic(String text) public String removeAndFreeMnemonic(String text) {
{
int idx = text.indexOf(MNEMONIC_CHAR); int idx = text.indexOf(MNEMONIC_CHAR);
if (idx >= 0) if (idx >= 0) {
{ StringBuffer buffer = new StringBuffer(text);
StringBuffer buffer = new StringBuffer(text); char mchar = buffer.charAt(idx + 1); // the char after the &
char mchar = buffer.charAt(idx+1); // the char after the & buffer.deleteCharAt(idx); // delete the &
buffer.deleteCharAt(idx); // delete the & boolean found = false;
boolean found = false; for (int mdx = 0; !found && (mdx < mnemonics.length()); mdx++)
for (int mdx=0; !found && (mdx < mnemonics.length()); mdx++) if (mnemonics.charAt(mdx) == mchar) {
if (mnemonics.charAt(mdx) == mchar) found = true;
{ mnemonics.deleteCharAt(mdx);
found = true; }
mnemonics.deleteCharAt(mdx); return buffer.toString();
} } else
return buffer.toString(); return text;
}
else
return text;
} }
/** /**
* Helper method to return the mnemonic from a string. * Helper method to return the mnemonic from a string.
* Helpful when it is necessary to know the mnemonic assigned so it can be reassigned, * 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. * such as is necessary for buttons which toggle their text.
* @return the mnemonic if assigned, else a blank character. * @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); int idx = text.indexOf(MNEMONIC_CHAR);
if (idx >= 0) if (idx >= 0)
return text.charAt(idx+1); return text.charAt(idx + 1);
else else
return ' '; return ' ';
} }
/** /**
* Given a Composite, this method walks all the children recursively and * Given a Composite, this method walks all the children recursively and
* and sets the mnemonics uniquely for each child control where a * and sets the mnemonics uniquely for each child control where a
@ -389,50 +352,41 @@ public class Mnemonics
* per Window. * per Window.
* Call this after populating your controls. * Call this after populating your controls.
*/ */
public void setMnemonics(Composite parent) public void setMnemonics(Composite parent) {
{ Control children[] = parent.getChildren();
Control children[] = parent.getChildren(); if (children != null) {
if (children != null) Control currChild = null;
{ boolean bSetText = false;
Control currChild = null; for (int idx = 0; idx < children.length; idx++) {
boolean bSetText = false; currChild = children[idx];
for (int idx=0; idx < children.length; idx++) // composite? Recurse
{ // d54732: but do not recurse if it is a combo! For a combo, we want to check
currChild = children[idx]; // if there is a preceding label. It's meaningless for a combo to
// composite? Recurse // have children anyway (KM)
// d54732: but do not recurse if it is a combo! For a combo, we want to check if ((currChild instanceof Composite) &&
// if there is a preceding label. It's meaningless for a combo to (!applyMnemonicsToPrecedingLabels || (applyMnemonicsToPrecedingLabels && !(currChild instanceof Combo) && !(currChild instanceof InheritableEntryField))))
// have children anyway (KM) setMnemonics((Composite) currChild);
if ((currChild instanceof Composite) && // button? select and apply unique mnemonic...
(!applyMnemonicsToPrecedingLabels || (applyMnemonicsToPrecedingLabels && else if (currChild instanceof Button) {
!(currChild instanceof Combo) && !(currChild instanceof InheritableEntryField)))) Button currButton = (Button) currChild;
setMnemonics((Composite)currChild); String text = currButton.getText();
// button? select and apply unique mnemonic... if ((text != null) && (text.trim().length() > 0)) {
else if (currChild instanceof Button) currButton.setText(setUniqueMnemonic(text));
{ bSetText = true;
Button currButton = (Button)currChild; }
String text = currButton.getText(); }
if ((text!=null) && (text.trim().length()>0)) // 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)) &&
currButton.setText(setUniqueMnemonic(text)); (children[idx - 1] instanceof Label)) {
bSetText = true; Label currLabel = (Label) children[idx - 1];
} String text = currLabel.getText();
} if ((text != null) && (text.trim().length() > 0)) {
// entry field or combo box? select and apply unique mnemonic to preceding label... currLabel.setText(setUniqueMnemonic(text));
else if (applyMnemonicsToPrecedingLabels && (idx>0) && ((currChild instanceof Text) || (currChild instanceof Combo) || (currChild instanceof InheritableEntryField)) && bSetText = true;
(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. * memnonic. Also handles casdading submenus.
* Call this after populating the menu. * Call this after populating the menu.
*/ */
public void setMnemonics(Menu menu) public void setMnemonics(Menu menu) {
{ MenuItem[] children = menu.getItems();
MenuItem[] children = menu.getItems(); if ((children != null) && (children.length > 0)) {
if ((children != null) && (children.length>0)) MenuItem currChild = null;
{ for (int idx = 0; idx < children.length; idx++) {
MenuItem currChild = null; currChild = children[idx];
for (int idx=0; idx < children.length; idx++) String text = currChild.getText();
{ if ((text != null) && (text.length() > 0)) {
currChild = children[idx]; if (text.indexOf(MNEMONIC_CHAR) < 0) // bad things happen when setting mnemonics twice!
String text = currChild.getText(); {
if ((text!=null)&&(text.length()>0)) Image image = currChild.getImage();
{ currChild.setText(setUniqueMnemonic(text));
if (text.indexOf(MNEMONIC_CHAR) < 0) // bad things happen when setting mnemonics twice! if (image != null) currChild.setImage(image);
{ }
Image image = currChild.getImage(); }
currChild.setText(setUniqueMnemonic(text)); }
if (image != null)
currChild.setImage(image);
}
}
}
} }
} }
@ -476,64 +425,54 @@ public class Mnemonics
* <p> * <p>
* Call this after populating the menu. * Call this after populating the menu.
*/ */
public void setMnemonicsAndArmListener(Menu menu, ArmListener listener) public void setMnemonicsAndArmListener(Menu menu, ArmListener listener) {
{ MenuItem[] children = menu.getItems();
MenuItem[] children = menu.getItems(); if ((children != null) && (children.length > 0)) {
if ((children != null) && (children.length>0)) MenuItem currChild = null;
{ for (int idx = 0; idx < children.length; idx++) {
MenuItem currChild = null; currChild = children[idx];
for (int idx=0; idx < children.length; idx++) String text = currChild.getText();
{ if ((text != null) && (text.length() > 0)) {
currChild = children[idx]; int mnemonicIndex = text.indexOf(MNEMONIC_CHAR);
String text = currChild.getText(); if (mnemonicIndex < 0) // bad things happen when setting mnemonics twice!
if ((text!=null)&&(text.length()>0)) {
{ Image image = currChild.getImage();
int mnemonicIndex = text.indexOf(MNEMONIC_CHAR); currChild.setText(setUniqueMnemonic(text));
if (mnemonicIndex < 0) // bad things happen when setting mnemonics twice! if (image != null) currChild.setImage(image);
{ currChild.addArmListener(listener);
Image image = currChild.getImage(); } else
currChild.setText(setUniqueMnemonic(text)); // hmm, already has a mnemonic char. Either it is an Eclipse/BP-supplied action, or we have been here before.
if (image != null) // The distinction is important as want to add an Arm listener, but only once!
currChild.setImage(image); {
currChild.addArmListener(listener); // for now we do the brute force ugly thing...
} Image image = currChild.getImage();
else
// hmm, already has a mnemonic char. Either it is an Eclipse/BP-supplied action, or we have been here before. // need to adjust any action that already has this mnemonic
// The distinction is important as want to add an Arm listener, but only once! char c = text.charAt(mnemonicIndex + 1);
{
// for now we do the brute force ugly thing... // anything already have this?
Image image = currChild.getImage(); if (!isUniqueMnemonic(c)) {
// if so, we need to adjust existing action
// need to adjust any action that already has this mnemonic for (int n = 0; n < idx; n++) {
char c = text.charAt(mnemonicIndex + 1); MenuItem oChild = children[n];
String oText = oChild.getText();
// anything already have this? char oldN = getMnemonic(oText);
if (!isUniqueMnemonic(c)) if (oldN == c) {
{ // this one now needs to change
// if so, we need to adjust existing action String cleanText = removeMnemonic(oText);
for (int n = 0; n < idx; n++) oChild.setText(setUniqueMnemonic(cleanText));
{ }
MenuItem oChild = children[n]; }
String oText = oChild.getText(); }
char oldN = getMnemonic(oText);
if (oldN == c) text = removeAndFreeMnemonic(text);
{ currChild.setText(setUniqueMnemonic(text));
// this one now needs to change if (image != null) currChild.setImage(image);
String cleanText = removeMnemonic(oText); currChild.removeArmListener(listener); // just in case
oChild.setText(setUniqueMnemonic(cleanText)); currChild.addArmListener(listener);
} }
} }
} }
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 * 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 * 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; this.onPrefPage = page;
return this; return this;
} }
@ -553,12 +491,11 @@ public class Mnemonics
* Wizard pages already have a few buttons with mnemonics set by Eclipse * 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 * 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; this.onWizardPage = page;
return this; return this;
} }
/** /**
* Set whether to apply mnemonics to labels preceding text fields, combos and inheritable entry fields. * Set whether to apply mnemonics to labels preceding text fields, combos and inheritable entry fields.
* This is for consistency with Eclipse. Only set to <code>false</code> if it does not work * This is for consistency with Eclipse. Only set to <code>false</code> if it does not work
@ -571,5 +508,5 @@ public class Mnemonics
this.applyMnemonicsToPrecedingLabels = apply; this.applyMnemonicsToPrecedingLabels = apply;
return this; return this;
} }
} }