Une alternative pratique au modèle Signals + Slots pour la programmation GUI?

La majorité des boîtes à outils GUI utilisent de nos jours le modèle Signals + Slots. Ce sont Qt et GTK +, si je ne me trompe pas, qui ont été les pionniers.

Vous savez, les widgets ou objets graphiques (parfois même ceux qui ne sont pas affichés) envoient des signaux au gestionnaire de boucle principale. Le gestionnaire de boucle principale appelle ensuite les événements , rappels ou emplacements attribués pour ce widget / objet graphique. Il existe généralement des gestionnaires d' virtualévénements par défaut (et dans la plupart des cas ) déjà fournis par la boîte à outils pour gérer tous les signaux prédéfinis, par conséquent, contrairement aux conceptions précédentes où le développeur devait écrire l'intégralité de la boucle principale et du gestionnaire pour chaque message lui-même (pensez à WINAPI), le développeur n'a qu'à se soucier des signaux dont il a besoin pour implémenter de nouvelles fonctionnalités.

Maintenant que je sache, cette conception est utilisée dans la plupart des boîtes à outils modernes. Il y a Qt, GTK +, FLTK etc. Il y a Java Swing. C # a même une fonction de langue pour cela (événements et délégués), et Windows Forms a été développé sur cette conception. En fait, au cours de la dernière décennie, cette conception pour la programmation GUI est devenue une sorte de norme non écrite. Puisqu'il augmente la productivité et fournit une plus grande abstraction.

Cependant, ma question est:

Existe-t-il une conception alternative, parallèle ou pratique pour la programmation graphique moderne?

c'est-à-dire que la conception Signals + Slots est la seule pratique en ville? Est-il possible de faire de la programmation GUI avec une autre conception? Existe-t-il des boîtes à outils graphiques modernes (de préférence réussies et populaires) construites sur une conception alternative?

Bien que je n'appellerais pas cela si populaire, il existe toujours une programmation réactive pour les interfaces graphiques, en particulier la programmation réactive fonctionnelle , telle que mise en œuvre, par exemple, par le .NET Rx Framework , ainsi que par plusieurs boîtes à outils dans des langages / plates-formes un peu plus ésotériques , comme reactive-banana ou FrTime , pour Haskell et Racket respectivement.

C'est un de mes sujets favoris, et pendant environ une décennie (des années 70 à 86), j'ai pensé qu'avoir une interface graphique composée d'objets qui répondent aux événements était juste la bonne façon de le faire.

Ensuite, je suis tombé sur une autre façon de le faire décrite ici et avec un projet sourceforge ici .

En un mot, le problème avec les objets est qu'ils persistent, et si vous écrivez du code pour les créer, vous devez également écrire du code pour les modifier de manière incrémentielle si des changements sont nécessaires, et en quelque sorte obtenir des messages vers et depuis eux. Ce ne serait pas bien si vous pouviez simplement peindre ce que vous vouliez, puis le repeindre si vous voulez quelque chose de différent, sans avoir à vous soucier de la persistance des objets antérieurs? Ne serait-ce pas aussi bien si vous n'aviez jamais à écrire de code pour la gestion des messages, car tout se fait sous le capot?

C'est ce que fait ce paquet. Pour les dialogues simples, il enregistre un ordre de grandeur dans le code. Pour les dialogues complexes à changement dynamique, cela les rend possibles.

PS Je n'ai fait cela que pour les interfaces utilisateur de bureau et les interfaces de terminal distant, pas pour les interfaces utilisateur de navigateur Web. Je suis sûr que c'est possible, mais je n'ai pas eu l'occasion de l'essayer.

Eh bien, il y a deux façons distinctes de procéder:

1. Demandez à chaque widget d'exposer un mécanisme d'abonnement granulaire (signal / slot, observateur / observable, événement / délégué) et demandez au code client de s'abonner et d'agir en conséquence.
2. Construit un widget contre une abstraction des données qu'il présente et demande au code client de mettre en œuvre cette abstraction.

Voici un exemple pour la deuxième approche:

interface Action {
     void execute();
     Bool isEnabled();
     Null<String> description();//used for tooltip
}
interface LabledAction extends Action {
     String getName();
}

Et maintenant, vous pouvez créer un LabelButtoncontre un LabledActionet le code client peut simplement l'implémenter ou utiliser une implémentation générique par défaut, si elle est disponible et appropriée.

D'une certaine manière, la deuxième approche est moins flexible, mais plus rigide. Vous ne vous contentez pas de relier la vue au modèle d'une manière relativement atomique. Vous concevez une interface graphique appropriée en fonction de vos besoins, puis vous implémentez les adaptateurs entre cette interface graphique et votre logique de domaine / application.

Quelques systèmes de type contrôle utilisent une approche de base de données - chaque contrôle gui est lié à un fichier dans la base de données afin que le Gui reflète toujours l'état de la base de données. Les hooks DB sont utilisés pour déclencher des fonctions lorsqu'une valeur change.