Cloud with rain
.:G
G:.
0 and 1 serie, black on white
pulled card
myjsp.feelinglinux.com
ver. 1.1.9-4
Hallo, welcome to my world.
Here you can find some stuff about computer science.
<<< Enjoy your visit! >>>
0 and 1 serie, white on black

Java - "Mnemonic code" in una stringa

        Scritto: Giansante Gabriele, 14/12/2002     

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 alert = 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("") && alert)
       {
         //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.
         alert = false;
       }
       else if (token.equals("") && !alert) 
       {
         //Il fatto di avere un token vuoto, mi indica la presenza di 
         //un carattere speciale. Invece, avere alert a false 
         //significa che questo e' il primo carattere speciale incontrato 
         //dopo un token normale. Quindi devo "allertare i sensi"...
         alert = true; 
       }
       else 
       {
         //Il token e' nullo, cioe' sono in presenza di un carattere speciale.
         //"alert" e' true, quindi e' il secondo carattere speciale di una 
         //coppia e quindi non identifica sicuramente un codice mnemonico.
         //Ripristino la situazione iniziale. 
         alert = 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 alert = false;
     while (st.hasMoreTokens())
     {
       if (!post_append.equals("")) sb.append("&");
       sb.append(token);
       token = st.nextToken();
       if (token.equals("&")) token = "";
       if (!token.equals("")) 
       {
         alert = false; 
         post_append = "";
       }
       else if (token.equals("") && !alert) 
       {
          alert = true; 
          post_append = "";
       }
       else 
       {
         alert = 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;
 }


Hai trovato utile questo articolo?
Aiutami a condividerlo o metti un "mi piace".
Grazie mille!


Gli strumenti di condivisione (Google+, Facebook) sono visibili in alto a destra solo dopo aver accettato la policy di utilizzo dei cookie per questo sito.
FAQ - Come faccio a cambiare la mia scelta?

 

Strumenti (myjsp.feelinglinux.com)
Gioco: allenamento con la tastiera Strumenti di codifica/decodifica URI (%-encoding) e Base64 Strumenti di calcolo online per IP e Reti
QUIZ GAME
Quiz game

Cerca @myjsp.feelinglinux.com

Pubblicita'