RadioCircle

Beaucoup d'informations sont données pour le bouton PushZone qui ne sont pas toutes reprises ici. Une lecture de PushZone est une bonne idée.

RadioXXXX sont des classes de boutons radio comme on avait sur les vieux postes. Un bouton par gamme FM1, FM2, MW, SW, en appuyant sur un bouton, cela fait remonter les autres. Les commandes de volets roulants sont de ce type, ainsi que le choix d'un programme de lavage... Pour cette bibliothèque, lorsqu'on appuie dessus, le bouton s'active (ou reste actif), et un événement onSelect est généré. Lorsque l'on relâche l'appui, ou si l'appui sort de la zone d'action, il ne se passe rien. Si on appuie sur un bouton radio, cela va désactiver les autres boutons radio du même groupe.

On peut avoir plusieurs groupes indépendants. Avec cette bibliothèque, les limitations sont:
- le nombre maximum de boutons dans tous les groupes est le même et c'est une puissance de 2
- le nombre maximum de séries est une puissance de 2
- le produit des deux est 128
Par défaut, on peut avoir 4 groupes de 32 boutons. Ces nombres peuvent se changer au début du fichier PecheuxGraph_ILI9341_8bits.h . Dans les premières lignes on trouve:

#define RADIO_NB_BITS_GROUPE 2 // Nombre de bits pour la définition du groupe radio 0..6
                               // 0: 1 seul groupe de 128 boutons maxi
                               // 1: 2 groupes maxi de 64 boutons maxi chacun
                               // 2: 4 groupes maxi de 32 boutons maxi
                               // 3: 8 groupes maxi de 16 boutons maxi
                               // 4: 16 groupes maxi de 8 boutons maxi
                               // 5: 32 groupes maxi de 4 boutons maxi
                               // 6: 64 paires de boutons maxi
// 6: 64 paires de boutons maxi

Il suffit de changer le chiffre 2 en rouge pour ajuster les nombres à nos besoins.

On peut attribuer à chaque bouton une valeur comprise entre 0 inclus et le nombre maximum de boutons exclu (par défaut ente 0 et 31, tout excès sera tronqué). On n'est pas obligé, mais cela peut être pratique pour savoir quel bouton est sélectionné.

Un groupe est un ensemble de boutons se désactivant les uns les autres, mais ne touchant pas aux autres groupes. On peut attribuer à chaque groupe un nom GROUPE_0, GROUPE_1, GROUPE_2 ou GROUPE_3. Cela correspond aux nombres de 0 à 3, mais c'est plus lisible.

Trois fonctions vont permettre de gérer efficacement les boutons radio:
- unselectRadio() permet de désélectionner tous les boutons radios d'un groupe
- getRadioValeur() nous donne la valeur du contrôle actif du groupe
- getRadioPointeur() retourne l'adresse du contrôle actif, ce qui nous permet d'accéder à toutes ses données, par exemple sa position.

XXXXCircle sont des classes de boutons ronds qui changent de couleur quand ils sont actifs. Le disque visible mesure 11 pixels de diamètre, mais la zone sur laquelle on peut pointer est définie par les paramètres passés au constructeur. Elle peut être plus grande ou plus petite. Le disque se positionne au milieu, ce n'est qu'un dessin.

RadioCircle est donc une classe de boutons radio dessinés avec des cercles.

 

Exemples d'utilisation

RadioCircle bouton(0,0,LARGEUR,HAUTEUR); // Crée bouton sur toute la surface de l'écran
RadioCircle bouton(150,100,170,120); // Crée bouton au centre en mode PAYSAGE 320x240
RadioCircle bouton = new RadioCircle(100,100,120,120); // Crée une instance dynamique bouton
new RadioCircle(100,100,120,120); // Crée une instance dynamique bouton sans pointeur dessus

circle(bouton.demiX1+bouton.demiX2, bouton.demiY1+bouton.demiY2, 10); // Cercle centré sur le bouton

bouton.onSelectFunction = &action; // Appel la fonction void action(void) lors de l'appui
bouton.onUnselectFunction = &action; // Appel la fonction void action(void) lors du relâchement

if (bouton.isSelect())... // Si on est en train d'appuyer sur le bouton

groupe = getRadioValeur();//  groupe prend la valeur du bouton sélectionné du groupe GROUPE_0 
groupe = getRadioValeur(GROUPE_1); // groupe prend la valeur du bouton sélectionné du groupe GROUPE_1
unselectRadio(); // Désélectionne les boutons radio du groupe GROUPE_0 

 

Référence

class RadioCircle
 public:
  RadioCircle(int x1, int y1, int x2, int y2, char valeur = 0, char groupe = 0);
  byte demiX1, demiY1, demiX2, demiY2;
  word buttonColor;
  void (*onSelectFunction)(void);
  void (*onUnselectFunction)(void);
  RadioCircle *controleSuivant;
  void select(void);
  void unselect(void);
  boolean isSelected(void);
  virtual void onSelect(void);
  virtual void onUnselect(void)
  virtual void drawButton(void);

Attributs et méthodes

RadioCircle(): Constructeur, s'insère dans la liste des contrôles gérées. x1, y1, x2, y2: zone d'action

demiX1, demiY1, demiX2, demiY2: Occupation de l'espace dans l'écran, coordonnés absolues DIVISEES par 2

buttonColor: Couleur du fond des boutons de la classe

*onSelectFunction: : Pointeur sur la fonction à appeler lorsque le bouton est sélectionné

*onUnselectFunction: : Pointeur sur la fonction à appeler lorsque le bouton est désélectionné

*controleSuivant: Pointeur sur le contrôle suivant dans la liste des contrôles

select(): : Active ce bouton et désactive tous les boutons du groupe.

unselect(): : Désactive ce bouton. Si il était actif, plus aucun bouton de ce groupe ne l'est.

isSelected(): : Informe de l'état du bouton.

onSelect(): : Fonction appelée lors de la sélection. On peut surcharger cette fonction, par défaut elle est vide

onUnselect(): : Fonction appelée lors de la désélection. On peut surcharger cette fonction, par défaut elle est vide

drawButton(): : Fonction appelée lors de l'activation, la désactivation, à l'initialisation de la librairie ou sur appel de la fonction drawControles(). On peut surcharger cette fonction, par défaut elle est vide pour les boutons XXXXZone, et fait ce qu'il faut pour les autres. On peut surcharger cette méthode, mais si on veut garder le dessin par défaut, il faut appeler la méthode drawButton() de la classe mère.

 

Voir aussi

- unselectRadio() Désélectionne tous les boutons radios d'un groupe
- getRadioValeur() Donne la valeur du contrôle actif du groupe
- getRadioPointeur() retourne l'adresse du contrôle actif
- scanEvent(); Moteur de la gestion des événements
- PushCircle; Bouton poussoir rond
- CheckCircle; Bouton bistable (va vient) rond
- RadioZone; Bouton radio (un seul bouton actif parmi plusieurs) sans dessin
- RadioCoche; Bouton radio (un seul bouton actif parmi plusieurs) case à cocher
- RadioCircle; Bouton radio (un seul bouton actif parmi plusieurs) rond

 

Notes

Pour définir un bouton, il faut donner sa zone d'action. Pour des raisons de stockage mémoire et de précision, n'est enregistré que les nombres pairs des valeurs passées. Les nombres impairs sont arrondis au nombre pair inférieur. Ainsi la zone (100,100,201,201) est équivalente à (100,100,200,200).

Si on a plusieurs boutons dont les zones d'actions ont une partie commune, comme les boutons sont analysés dans l'ordre inverse de leur déclaration, la zone commune devient propriété du bouton défini en dernier. Cela évite les conflits. Cela permet aussi d'avoir un bouton dont la zone n'est pas rectangulaire, il peut manquer un coin.

 

Exemples

Exemple: 4 séries de 10 boutons RadioCircle

PecheuxGraph_ILI9341_8bits.zip\PecheuxGraph_ILI9341_8bits\examples\Documentation\Exemple-952-RadioCircle\Exemple-952-RadioCircle.ino (dans votre fichier téléchargé):

// Ceci montre un exemple d'utilisation de boutons radio
// - avec quatre séries
// - avec des boutons dynamiques trop de boutons pour écrire sans boucle!

#include <PecheuxGraph_ILI9341_8bits.h>

word valeur; // Ce qui est écrit avec les boutons
void onTimeAffiche(void) // Cette fonction met à jour l'affichage
{
  valeur = 0; // Lecture des boutons radio et calcul de la valeur à afficher
  for (byte chiffre = 0; chiffre < 4; chiffre++) // 4 chiffres à lire, on commence par les milliers
    valeur = (valeur * 10 + (getRadioValeur(chiffre))); // A chaque fois on décale d'un chiffre
  fillRect(0, 0, 83, 25, BLACK); // Efface ce qui est nécessaire
  setTextCursor(0, 0); // Écrire toujours au même endroit
  text(String(valeur)); // Écrit la valeur
}

void setup()
{
  RadioCircle *radio; // Pointeur sur un bouton, nécessaire pour présélectionner les zéros
  Clock *horloge = new Clock(1000); // Pour un rafraîchissement toutes les secondes
  horloge->onTimeFunction = &onTimeAffiche; // Pour appeler la fonction d'affichage toutes les secondes

  // Initialisations
  setGraphMode(PAYSAGE); // Initialisation générale de l'afficheur
  setTextCursor(0, 100);
  text("Cliquez\nsur\nles\nboutons"); // Dire un minimum ce qu'il faut faire

  // Création de boutons dynamiques, doit être fait ici après setGraphMode() car on utilise LARGEUR
  for (word colonne = 0; colonne < 150; colonne += 40) for (word ligne = 0; ligne < 200; ligne += 20) // Pour avoir une matrice de boutons
    { // Création d'un bouton
      // valeur sera 0, 1, 2, ... soit le dernier paramètre ligne/20
      radio = new RadioCircle(LARGEUR - 160 + colonne, ligne, LARGEUR - 140 + colonne, ligne + 20, /*parametres =*/ligne / 20, /*groupe =*/colonne / 40); // Zones de 20x20
      if (ligne == 0) radio->select(); // Présélection des 0
      // Nom du bouton
      setTextCursor(LARGEUR - 140 + colonne, ligne + 2);
      text(String(ligne / 20)); // Affichage des chiffres 0, 1, 2, 3, ...
    }

  // Pour avoir un bouton cyan/rouge, pour montrer comment on fait, pour la démo
  RadioCircle::buttonColor = CYAN; // Sera vrai pour tous les boutons radio, cela diminue le nombre de données


  drawControles(); // Il faut tout dessiner car les contrôles sont définis après setGraphMode()
  setTextSize(4); // Pour bien voir le résultat
}

void loop()
{
  scanEvent(); // Gestion des boutons et des horloges, le plus souvent seul dans le loop
}

Résultat:

 

RadioCoche   <<     >>   getRadioValeur