|
|
Java - "Mnemonic code" in una stringa
Data una stringa, ad esempio il testo di un menu grafico, il codice mnemonico e' quello che identifica una lettera di tale testo da usare come scorciatoia per attivare la funzionalita' del menu stesso. Ad esempio, spesso esiste il menu "File" con voce "Exit". In molti programmi una scorciatoia per attivare l'"Exit" e' l'utilizzo di ALT-x (si vede la "x" sottolineata nel menu).
Data una stringa, un modo per indicare nella stringa stessa il codice mnemonico, potrebbe essre l'anteporre al carattere scelto un altro carattere speciale che non verra' pero' visualizzato. Ad esempio, se scegliessimo come carattere "&", potremmo scrivere "E&xit" per indicare che il codice mnemonico di "Exit" e' "x". Sorge pero' il problema di inserire il carattere "&" all'interno del testo senza che venga considerato come codice mnemonico. Si puo' allora pensare di individuare "&" semplicemente raddoppiandolo. Ad esempio, "E&&xit" verrebbe visualizzato come "E&xit" ed "E&xit" come "Exit".
Le due routine che seguono, servono a eliminare i caratteri speciali restituendo una la stringa "pulita" e l'altra il codice mnemonico della stringa passata.
import java.util.StringTokenizer;
...
/**
* Un testo puo' contenere un codice mnemonico, cioe' la classica
* scorciatoia per un menu. Io ho deciso che per identificare un
* mnemonico, uso &<carattere>. Se voglio mettere l'"&" lo devo mettere con
* "&&". Questa funzione restituisce la lettera rappresentante il mnemonico
* @param text e' il testo da cui togliere il codice mnemonico
* @return il primo codice mnemonico estratto dal testo passato
*/
public static char parseMnemonic(String text)
{
char ris = ' ';
if (text!=null)
{
//Divido in token. I caratteri "&" generano ognuno
//un token formato solo da "&" in virtu' del parametro "true".
//Es. "E&xit&&Quit" diventa "E"+"&"+"xit"+"&"+"&"+"Quit"
StringTokenizer st = new StringTokenizer(text,"&",true);
String token = "";
//Serve ad allertarmi quando incontro un "&" che potrebbe identificare
//un codice mnemonico
boolean attenzione = false;
while (st.hasMoreTokens())
{
token = st.nextToken();
//In realta' si potrebbe anche non svuotare il token e modificare
//leggermente i controlli, ma a me piace cosi'.
if (token.equals("&")) token = "";
if (!token.equals("") && attenzione)
{
//Se avevo individuato in precedenza un carattere speciale
//e adesso mi ritrovo un token "normale" (non vuoto) allora sono
//in presenza di un codice mnemonico. Lo registro ed esco perche'
//ho deciso che solo il primo codice trovato e' valido.
//Ovviamente il carattere speciale individuato in precedenza
//non deve appartenere ad una coppia di caratteri speciali perche'
//altrimenti avrebbe un altro significato (ma a questo controllo
//ci pensano le condizioni che seguono).
ris = token.toCharArray()[0];
break;
}
else if (!token.equals(""))
{
//Se sono in presenza di un token normale vuol dire che
//ho comunque elaborato una eventuale precedente
//presenza di un carattere speciale e quindi devo resettare
//la situazione.
attenzione = false;
}
else if (token.equals("") && !attenzione)
{
//Il fatto di avere un token vuoto, mi indica la presenza di
//un carattere speciale. Invece, avere attenzione a false
//significa che questo e' il primo carattere speciale incontrato
//dopo un token normale. Quindi devo "allertare i sensi"...
attenzione = true;
}
else
{
//Il token e' nullo, cioe' sono in presenza di un carattere speciale.
//"attenzione" e' true, quindi e' il secondo carattere speciale di una
//coppia e quindi non identifica sicuramente un codice mnemonico.
//Ripristino la situazione iniziale.
attenzione = false;
}
}
}
return ris;
}
/**
* Un testo puo' contenere un codice mnemonico, cioe' la classica
* scorciatoia per un menu. Io ho deciso che per identificare un
* mnemonico, uso &<carattere>. Se voglio mettere l'"&" lo devo mettere con
* "&&". Ora, i menu Swing non accettano gli mnemonic scritti cosi' (tipici
* invece degli altri linguaggi ad oggetti). Devo quindi parsare e restituire
* una stringa epurata degli "&" inutili. Ogni carattere "&" singolo viene
* eliminato.
* @param text e' il testo da cui togliere il codice mnemonico
* @return il testo senza il codice mnemonico
*/
public static String deleteMnemonicFromText(String text)
{
String ris = "";
if (text!=null)
{
//L'agoritmo e' lo stesso della funzione precedente, quindi
//commentero' solamente i passaggi diversi.
//Uso uno StringBuffer per mantenere la ricustruzione
//parziale del testo.
StringBuffer sb = new StringBuffer();
StringTokenizer st = new StringTokenizer(text,"&",true);
//Conterra' gli eventuali caratteri "&" da stampare,
//ovvero, in presenza di una coppia di caratteri speciali
//conterra' un "&" da aggiungere allo StringBuffer.
String post_append = "";
String token = "";
boolean attenzione = false;
while (st.hasMoreTokens())
{
if (!post_append.equals("")) sb.append("&");
sb.append(token);
token = st.nextToken();
if (token.equals("&")) token = "";
if (!token.equals(""))
{
attenzione = false;
post_append = "";
}
else if (token.equals("") && !attenzione)
{
attenzione = true;
post_append = "";
}
else
{
attenzione = false;
post_append = "&";
}
}
//Non devo perdere l'ultimo token
if (!token.equals("")) sb.append(token);
//Non devo perdere l'eventuale ultimo carattere "&"
if (!post_append.equals("")) sb.append("&");
ris = sb.toString();
}
return ris;
}
(c) 1999-2006