Ignorer focusLost(), SWT.Verify ou d'autres écouteurs SWT dans le code Java

Question

En dehors de l'écouteur SWT réel, existe-t-il un moyen d'ignorer un écouteur via le code?

Par exemple, j'ai un programme java qui implémente SWT Text Widgets, et les widgets ont:

• auditeurs SWT.Verify pour filtrer l'entrée de texte non désiré.
• ModifyListeners attend le nombre correct de caractères d'entrée valides et définit automatiquement le focus (à l'aide de setFocus()) sur le champ valide suivant, en ignorant les autres widgets de texte dans l'ordre des onglets. Focus (FocusEvent) focusLost (FocusEvent) FocusListeners qui attendent la perte de focus du widget texte pour effectuer une vérification d'entrée supplémentaire et exécuter une requête SQL basée sur l'entrée de l'utilisateur.

Le problème que je rencontre est la suppression des widgets de texte. Un des widgets a le format "#### - ##" (Quatre Numbers, un trait d'union, puis deux nombres) et j'ai implémenté cet écouteur, qui est une version modifiée de SWT Snippet Snippet179. Le texte initial pour ce widget de texte est "-" pour fournir un retour visuel à l'utilisateur quant au format attendu. Seuls les nombres sont acceptés, et le programme saute automatiquement le trait d'union au point approprié.

 /* 
     * This listener was adapted from the "verify input in a template (YYYY/MM/DD)" SWT Code 
     * Snippet (also known as Snippet179), from the Snippets page of the SWT Project. 
     * SWT Code Snippets can be found at: 
     * http://www.eclipse.org/swt/snippets/ 
     */ 
    textBox.addListener(SWT.Verify, new Listener() 
    { 
    boolean ignore; 
    public void handleEvent(Event e) 
    { 
    if (ignore) return; 
    e.doit = false; 
    StringBuffer buffer = new StringBuffer(e.text); 
    char[] chars = new char[buffer.length()]; 
    buffer.getChars(0, chars.length, chars, 0); 
    if (e.character == '\b') 
    { 
    for (int i = e.start; i < e.end; i++) 
    { 
     switch (i) 
     { 
     case 0: /* [x]xxx-xx */ 
     case 1: /* x[x]xx-xx */ 
     case 2: /* xx[x]x-xx */ 
     case 3: /* xxx[x]-xx */ 
     case 5: /* xxxx-[x]x */ 
     case 6: /* xxxx-x[x] */ 
     { 
     buffer.append(' '); 
     break; 
     } 
     case 4: /* xxxx[-]xx */ 
     { 
     buffer.append('-'); 
     break; 
     } 
     default: 
     return; 
     } 
    } 
    textBox.setSelection(e.start, e.start + buffer.length()); 
    ignore = true; 
    textBox.insert(buffer.toString()); 
    ignore = false; 
    textBox.setSelection(e.start, e.start); 
    return; 
    } 

    int start = e.start; 
    if (start > 6) return; 
    int index = 0; 
    for (int i = 0; i < chars.length; i++) 
    { 
    if (start + index == 4) 
    { 
     if (chars[i] == '-') 
     { 
     index++; 
     continue; 
     } 
     buffer.insert(index++, '-'); 
    } 
    if (chars[i] < '0' || '9' < chars[i]) return; 
    index++; 
    } 
    String newText = buffer.toString(); 
    int length = newText.length(); 
    textBox.setSelection(e.start, e.start + length); 
    ignore = true; 
    textBox.insert(newText); 
    ignore = false; 

    /* 
    * After a valid key press, verifying if the input is completed 
    * and passing the cursor to the next text box. 
    */ 
    if (7 == textBox.getCaretPosition()) 
    { 
       /* 
       * Attempting to change the text after receiving a known valid input that has no results (0000-00). 
       */ 
       if ("0000-00".equals(textBox.getText())) 
       { 
        // "0000-00" is the special "Erase Me" code for these text boxes. 
        ignore = true; 
        textBox.setText(" - "); 
        ignore = false;  
       } 

    // Changing focus to a different textBox by using "setFocus()" method. 
    differentTextBox.setFocus(); 
    } 
    } 
    } 
); 

Comme vous pouvez le voir, la seule méthode que j'ai compris pour effacer ce widget texte à partir d'un point différent dans le code est en affectant « 0000-00 »

textBox.setText("000000") 

et la vérification des cette entrée dans l'auditeur. Lorsque cette entrée est reçue, l'auditeur change le texte en "-" (quatre espaces, un tiret, puis deux espaces).

Il existe également un écouteur focusLost qui analyse ce widget de texte pour les espaces, puis, pour éviter les requêtes SQL inutiles, efface/réinitialise tous les champs si l'entrée est invalide (i.e contient des espaces).

// Adding focus listener to textBox to wait for loss of focus to perform SQL statement. 
textBox.addFocusListener(new FocusAdapter() 
{ 
    @Override 
    public void focusLost(FocusEvent evt) 
    { 
    // Get the contents of otherTextBox and textBox. (otherTextBox must be <= textBox) 
    String boxFour = otherTextBox.getText(); 
    String boxFive = textBox.getText(); 

    // If either text box has spaces in it, don't perform the search. 
    if (boxFour.contains(" ") || boxFive.contains(" ")) 
    { 
     // Don't perform SQL statements. Debug statement. 
     System.out.println("Tray Position input contains spaces. Ignoring."); 

       //Make all previous results invisible, if any. 
       labels.setVisible(false); 
       differentTextBox.setText(""); 
       labelResults.setVisible(false); 
    } 
    else 
    { 
      //... Perform SQL statement ... 
      } 
    } 
} 
); 

OK. Souvent, j'utilise des widgets SWT MessageBox dans ce code pour communiquer avec l'utilisateur, ou je souhaite que les widgets de texte reviennent à un état vide après avoir vérifié l'entrée. Le problème est que les boîtes de message semblent créer un événement focusLost, et l'utilisation de la méthode .setText (string) est soumise aux écouteurs SWT.Verify présents sur le widget de texte.

Des suggestions pour ignorer sélectivement ces écouteurs dans le code, mais les garder présents pour toutes les autres entrées de l'utilisateur?

Merci d'avance pour votre aide.

Answer 1

Si vous nommez le programme d'écoute au lieu d'utiliser un programme anonyme, vous pouvez l'ajouter et le supprimer lorsque vous le souhaitez.

Exemple:

// Adding focus listener to textBox to wait for loss of focus to perform SQL statement. 
FocusAdapter focusTextBox = new FocusAdapter() 
{ 
    @Override 
    public void focusLost(FocusEvent evt) 
    { 
    // Get the contents of otherTextBox and textBox. (otherTextBox must be <= textBox) 
    String boxFour = otherTextBox.getText(); 
    String boxFive = textBox.getText(); 

    // If either text box has spaces in it, don't perform the search. 
    if (boxFour.contains(" ") || boxFive.contains(" ")) 
    { 
     // Don't perform SQL statements. Debug statement. 
     System.out.println("Tray Position input contains spaces. Ignoring."); 

       //Make all previous results invisible, if any. 
       labels.setVisible(false); 
       differentTextBox.setText(""); 
       labelResults.setVisible(false); 
    } 
    else 
    { 
      //... Perform SQL statement ... 
      } 
    } 
}; 

Vous pouvez ensuite ajouter l'auditeur en faisant ceci:

textBox.addFocusListener(focusTextBox); 

Le retrait est aussi facile que cela:

textBox.removeFocusListener(focusTextBox); 

Assurez-vous de re- Activez le programme d'écoute une fois que vous avez réalisé ce que vous avez voulu réaliser par programme, sinon votre code n'agira pas comme prévu.

Answer 2

Je n'ai pas testé votre code, mais essayez la méthode isFocusControl() dans l'écouteur pour voir si l'utilisateur entre le texte ou vous définissez le texte avec setText() lorsque le focus n'est pas dans textBox.