Mon p'tit coin du web

Méthodes d'entrée sous Qt

Nicolas — 2009-01-04T14:38:20Z

Pour permettre de saisir du japonais [1] sous un dialogue Qt [2], j'ai trouvé une solution à base de QInputContextFactory, classe donnant accès aux méthodes d'entrée [3] disponibles.

Et tant qu'à faire j'ai mis un menu contextuel dans la zone de saisie pour changer de méthode de saisie.

Conventions :
widget est la zone de saisie sur laquelle on veut permettre la saisie en japonais
MyDialog est la classe de dialogue qui contient widget

Le dialogue doit avoir les slots suivants :

class MyDialog : public QDialog
 {
 ...
 
 protected slots:
 void onWidgetContextMenu(const QPoint& pos);
 void onInputContextChange(QAction* action);
 }

Quand on construit le dialogue et ses zones de saisie, il faut rajouter les lignes suivantes (dans une fonction de MyDialog :

widget->setContextMenuPolicy(Qt::CustomContextMenu);
 connect(widget, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(onWidgetContextMenu(const QPoint&)));

L'implémentation du menu contextuel, affichant la liste des méthodes d'entrée, est assez simple :

void MyDialog::onWidgetContextMenu(const QPoint& pos)
 {
 QWidget* edit = getMyCurrentWidget(); /** à nous de savoir quelle zone est concernée */
 
 QMenu popup(tr("Propriétés"));
 QMenu* context = popup.addMenu(tr("Méthode d'entrée"));
 
 QAction* def = context->addAction(tr("(défaut: %1)").arg(QInputContextFactory::displayName(qApp->inputContext()->identifierName())));
 def->setCheckable(true);
 if (edit->inputContext()->identifierName() == qApp->inputContext()->identifierName())
 {
 def->setChecked(true);
 }
 
 foreach(QString key, QInputContextFactory::keys())
 {
 if (key == qApp->inputContext()->identifierName())
 continue;
 
 QAction* action = context->addAction(QInputContextFactory::displayName(key));
 action->setCheckable(true);
 action->setData(key);
 if (edit->inputContext()->identifierName() == key)
 {
 action->setChecked(true);
 }
 }
 
 connect(&popup, SIGNAL(triggered(QAction*)), this, SLOT(onInputContextChange(QAction*)));
 popup.exec(edit->mapToGlobal(pos));
 }

Et enfin la gestion du changement de méthode d'entrée n'a plus grand-chose à faire :

void MyDialog::onInputContextChange(QAction* action)
 {
 QString input = action->data().toString();
 QWidget* edit = getMyCurrentWidget();
 if (edit->inputContext()->identifierName() == input || (input.isEmpty() && edit->inputContext()->identifierName() == qApp->inputContext()->identifierName()))
 // pas la peine de changer pour rien
 return;
 
 if (input.isEmpty())
 {
 edit->setInputContext(QInputContextFactory::create(qApp->inputContext()->identifierName(), edit));
 }
 else
 {
 QInputContext* context = QInputContextFactory::create(input, edit);
 if (context)
 edit->setInputContext(context);
 }
 // pour une raison inconnue, il y a des problèmes de saisie, en solution de contournement on joue avec le focus
 edit->nextInFocusChain()->setFocus();
 edit->setFocus();
 }

Et voici le résultat :

[1] En pratique, cette solution permettra de saisir n'importe quelle langue pourvu que le support soit disponible sur le système.

[2] J'utilise la version 4.4.2 sous Linux, mais j'imagine que ce n'est pas trop différent pour les autres versions.

[3] Sous Linux, une « méthode d'entrée » est une façon d'entrer du texte. Pour de l'alphabet romain, il n'y a rien de spécial à faire, mais pour entrer des kanjis, il faut pouvoir par exemple entrer la phonétique et choisir les caractères voulus.

Les surprises du Javascript

Nicolas — 2007-03-04T19:54:51Z

Pour répondre aux besoins d'un client, j'ai dernièrement été amené à m'intéresser de près au Javascript, et je dois dire que j'ai été agréablement surpris.

Qu'est-ce que c'est que Javascript ?

C'est un langage de programmation, principalement utilisé dans les pages Web. Dès que vous voyez un calendrier qui s'ouvre quand on clique dessus, une liste qui propose des noms selon votre saisie, des menus se déroulant quand la souris passe dessus, etc., c'est quasiment toujours du Javascript.

Il est au cœur du « Web 2.0 », pour faire simple une association entre collaboration entre utilisateurs et sites très dynamiques.

Revers de la médaille, il est aussi utilisé pour ouvrir des fenêtres popup intempestives, ou autres choses peu agréables.

Des exemples de sites utilisant Javascript incluent La RATP (pour le choix des stations), Gmail (pour l'édition des messages, le retour à la boîte de réception, ...), Google Maps et de nombreux autres sites.

Particularités du langage

J'avais quelques notions de Javascript de base (petits effets comme afficher / cacher des éléments en réponse à des clics de souris sur des boutons, ce genre de chose), mais j'ai eu l'occasion de me plonger plus en détail, et là suite de bonnes surprises.

C'est un langage de script orienté objet, avec ce qu'il faut de polymorphisme, héritage, encapsulation.

Il n'a pas de typage fort, c'est-à-dire qu'il est par exemple possible d'« additionner » un nombre et un caractère, le script faisant en sorte de se débrouiller pour convertir tout seul.

Il comporte de nombreuses fonctions de base, pour lire du XML, effectuer des requêtes au serveur en arrière-plan, effectuer des évènements après un certain délai, ...

Bref

À mon sens Javascript est un très bon langage, qui souffre de quelques faiblesses :
pas de compilateur, ce qui permettrait de voir rapidement les erreurs comme variables non déclarées, mauvais appels de fonctions, etc. Il existe cependant de bon déboggeurs, à travers Firefox ou Internet Explorer.
il existe des différences notables entre l'implémentation des différents navigateurs. Des champs n'ont pas le même nom (innerText versus text), les objets n'ont pas tout à fait les mêmes méthodes, la gestion de la souris est très différente, etc. Cependant il existe plusieurs libraries d'abstraction, et ce n'est pas trop difficile à faire si besoin, il y a beaucoup d'exemples sur Internet.

Interpréteur Python dans du code C, avec variables séparées

Nicolas — 2006-03-26T11:02:52Z

Crossfire comporte un plugin permettant d'exécuter des scripts Python. Un des problèmes posés était que les variables Python persistaient entre les exécutions de scripts. Après un passage sur #python, la solution suivante est apparue.

 dict = PyDict_New();
 PyDict_SetItemString(dict, "__builtins__", PyEval_GetBuiltins());
 ret = PyRun_File(scriptfile, scriptname, Py_file_input, dict, dict);
 if (PyErr_Occurred()) {
 PyErr_Print();
 }
 Py_XDECREF(ret);
 Py_DECREF(dict);

En l'occurrence l'utilisation de la fonction PyEval_GetBuiltins.

Cela fonctionne, peut-être qu'il reste des références pas libérées, difficile à dire...

De plus la fonction n'est pas documentée, donc changera peut-être sur une prochaine version de Python.