Pourquoi est-il difficile de faire apparaître un programme Java "natif"?

La plupart des applications Java ne ressemblent pas aux applications C / C ++. Swing a peut-être été conçu exprès pour avoir un look distinctif, mais sur la base de ce que j'ai lu, SWT, par exemple, a essayé de «paraître natif» et n'a pas réussi.

Ma question est:

Pourquoi est-il difficile pour les développeurs du langage Java de concevoir un système d’interface graphique qui copie exactement l’aspect des interfaces graphiques natives? Qu'est-ce qui est différent dans les interfaces graphiques natives? N’est-ce pas seulement une question de concevoir des boutons qui ressemblent à des boutons «natifs»? Ou va-t-il plus profond que cela?

N’est-ce pas seulement une question de concevoir des boutons qui ressemblent à des boutons «natifs»?

En quelque sorte, pour les boutons. Mais cela pourrait être plus difficile que vous ne l'imaginez. De nos jours, les graphiques utilisés pour représenter les composants d'interface graphique ne sont pas aussi simples que des bitmaps aléatoires qui sont étirés (car ceux-ci ne s'adaptent pas du tout très bien). Ce sont souvent des graphiques vectoriels avec beaucoup de casse programmés ( ainsi, lorsque le bouton atteint le bord de l'écran, il peut sembler légèrement différent, par exemple.) Et bien sûr, vous aurez besoin de graphiques différents lorsque vous cliquez sur un bouton. Pour des raisons de droits d'auteur, les développeurs ne peuvent souvent pas simplement utiliser ces graphiques existants. Ils doivent donc être recréés. Bien qu'ils fassent du bon travail dans la plupart des cas, il y a inévitablement des choses qui manquent à cause du grand nombre de composants graphiques disponibles.

Je dis tout ce qui précède, basé sur Swing, qui est bien sûr une boîte à outils graphique non native et légère. Vous mentionnez spécifiquement que SWT ne semble pas natif, ce qui est un peu étrange, car SWT est natif. C'est une boîte à outils qui utilise JNI en dessous pour appeler des composants natifs - donc si quelque chose ne se présente pas comme il se doit, ce ne sera pas à cause de l'apparence.

Il existe littéralement une demi-douzaine de boîtes à outils pouvant être considérées comme «natives» sur un système donné. Certains d'entre eux ont des concepts ou des capacités plutôt uniques, et les répliquer dans une boîte à outils multiplateformes est fastidieux. Le look & feel d'une application n'est pas seulement déterminé par un "skin", mais aussi par la mise en page et son comportement. Quelques considérations:

• Dans une boîte de dialogue, de quel côté appartient le bouton «OK» - à gauche ou à droite? Très bien, construisons un dialogue séparé pour chaque système.
• Comment marquer le bouton par défaut sur un écran? Teinte de couleur, police en gras, agrandissement du bouton? Très bien, mettons cela dans une feuille de style.
• Sous Windows, le concept de «ruban» est plutôt natif. Comment cela serait-il traduit sur Mac, où le ruban n'est pas courant? Très bien, oublions la disposition au pixel près et fournissons une implémentation de barre d'outils différente pour chaque système.
• La barre de menus fait-elle partie de la fenêtre (Windows, éventuellement de KDE) ou se trouve-t-elle en haut de l'écran (Mac, Unity)? Très bien, écrivons une implémentation différente pour chaque système, car nous avons déjà jeté la disposition exacte au pixel près.
• Comment les polices sont-elles rendues? Aussi net que possible, ou lisse et anti-crénelé? Et quelle police faut-il utiliser? Notez que différentes polices ont des métriques différentes, de sorte qu'un même paragraphe rendu avec la même largeur peut avoir un nombre de lignes différent selon la police.
• L'arrière-plan d'une fenêtre est-il d'une seule couleur, d'une image ou d'un dégradé? Mettons simplement cela dans une feuille de style également.
• A quoi ressemblent les barres de défilement? Où sont les boutons - s'ils en ont? Quelle est leur largeur ou sont-ils seulement révélés lorsque le pointeur se déplace dans une région donnée?
• Comment incorporons-nous d'autres jeux de couleurs?
• Qu'est-ce qui devrait être déplaçable? Où sont les menus contextuels attendus?

Ces problèmes ne peuvent pas être résolus avec une simple feuille de style lorsqu'ils abordent le comportement ou la présentation générale de l'application. La seule solution réelle consiste à ré-écrire l'application pour chaque système (en ignorant ainsi les avantages multi-plateformes de Java). La seule solution réaliste consiste à oublier la disposition au pixel près et à écrire sur une interface commune qui résume des boîtes à outils spécifiques au système. La solution adoptée par Swing consiste à émuler divers systèmes qui échouent de manière spectaculaire.

Et puis, il y a la cohérence entre les plates-formes, l'idée que votre application peut être exactement la même sur tous les systèmes (souvent choisis par les jeux, ce qui augmente l'immersion). Sur les applications de bureau, cela est simplement ennuyeux et répond aux attentes des utilisateurs.

Oui, ça va plus loin.

Il est facile de créer un bouton ressemblant à un bouton Windows ou OS X lorsque vous ne créez que ce bouton. Mais le bouton doit "se comporter" comme les boutons originaux, ce qui pourrait ne pas être simple: peut-être qu'il y a plus d'espace disponible dans une version, mais pas dans l'autre, peut-être que la couleur est plus adaptée à votre conception dans la version Windows, etc.

Ceci est plus important lorsque vous avez une interface graphique complète: un programme OS X présente son contenu différemment d’un programme Windows. Cela est presque impossible à capturer dans une interface graphique - vous auriez besoin de deux interfaces graphiques, mais peu d'applications font autant d'histoires. Au lieu de cela, ils cherchent à obtenir un "look ok sur la plupart des systèmes" - cela a toujours l’air quelque peu étrange, mais est utilisable et beaucoup plus facile à développer.

Il n’est pas difficile de créer un bouton qui ressemble à un bouton OSX, à un bouton Windows ou à un autre toolkit. Toutefois, les consignes d'utilisation de l'interface utilisateur pour la plupart des environnements ne sont pas aussi simples que les principes de base "voici à quoi ressemble un bouton". Il existe de nombreuses différences plus subtiles, allant de l'espacement entre les éléments de l'interface utilisateur à l'ordre dans lequel certaines actions bien connues doivent apparaître dans une liste jusqu'à la position exacte de la boîte de dialogue Préférences / Options dans le système de menus. On peut automatiser les cas les plus courants pour des interfaces utilisateur très simples, mais la plupart des tâches d'interface utilisateur, sinon la plupart, nécessitent une intervention beaucoup plus fine.

SWT a essayé d'automatiser cela dans une certaine mesure et, encore une fois, il convient parfaitement aux tâches simples de l'interface utilisateur. Mais il n'y a pas de solution unique, et donc, lorsque les interfaces utilisateur deviennent plus complexes, les méthodes de base qu'elle utilise commencent à s'effriter. Il est généralement possible de le ramener au travail manuel fastidieux de l'interface utilisateur, mais ce n'est pas quelque chose que la plupart des programmeurs sont capables ou disposés à faire pour toutes les plateformes.

La démarche de Swing visait simplement à éviter les boîtes à outils natives chaque fois que cela était possible. Ce n'est pas natif, et il n'essaye pas de l'être: il essaie plutôt de créer quelque chose qui aura l'air (presque) le même, peu importe où il est exécuté. Plutôt que d'essayer (en vain) de plaire à tout le monde, il a essayé de se faire plaisir et, même s'il a réussi dans la mesure du possible, on peut s'interroger sur l'efficacité du résultat pour la communauté d'utilisateurs dans son ensemble.

Vous devez vous attendre à ce que votre application soit aussi naturelle que possible sur chaque système et à ce que votre application fonctionne de la même manière sur chaque système. Il n'y a pas de "bon" choix.

De plus, même si vous choisissez le côté "naturel", vous voudrez peut-être protéger les utilisateurs de votre boîte à outils graphiques contre les "améliorations" des composants natifs et de l'API sous-jacents qui pourraient endommager inopinément leur application.

C'est pourquoi certains développeurs de kits d'outils graphiques préfèrent fournir leurs propres composants qui imitent ceux d'origine, mais fournissent leur propre implémentation. D'autre part, développer une boîte à outils d'interface graphique entièrement fonctionnelle représente un effort important, et des considérations économiques peuvent conduire à couper quelques bords.

Notez que ce problème n'est pas spécifique à Java, mais que chaque entreprise produisant des kits d'outils indépendants de la plate-forme est confrontée.

Tout est dû à l'histoire.

Sun a souhaité que tous les logiciels Java fonctionnent de la même manière sur toutes les machines.

Pour qu'un logiciel apparaisse comme natif, il doit fonctionner de la même manière que les autres logiciels du système d'exploitation donné.

Sun a tout mis en œuvre pour rendre difficile l’écriture de logiciels Java intégrés à un système d’exploitation, car toute intégration avec un système d’exploitation rendrait le logiciel différent sur chaque système d’exploitation.

De nos jours, très peu de programmeurs Java s'intéressent à autre chose qu'aux logiciels basés sur un serveur Web.

Sun a tué Java sur le bureau en utilisant tous les programmeurs utilisant les systèmes Microsoft Java, ce qui rendrait tout programmeur qui choisissait Java jadis de mal paraître.

Toute personne qui écrit un logiciel de bureau soucieux d’être «apparemment native» a appris il ya longtemps à ne pas utiliser Java et voit sa vision renforcée chaque fois qu’elle utilise un logiciel Oracle.

Par conséquent, de nos jours, les programmeurs Java n’exigent aucune «apparence native» pour les logiciels de bureau.

Ce que vous pensez, en nativeréalité, est que les applications natives agissent de leur côté alors que des kits tels que SWT respectent les normes publiées pour l'interface utilisateur de ce système d'exploitation. Le problème est que personne ne crée d'applications qui respectent ces normes, donc lorsque vous lancez une application Java. Il semble ne pas être natif. Par exemple, presque tous les projets de Microsoft (Office, Outlook, etc.) ne peuvent pas être reproduits visuellement à l'aide des contrôles standard Windows.

La situation ne fera qu'empirer, car Microsoft et Apple ajouteront des fonctionnalités d'interface utilisateur dynamiques à leurs plates-formes de système d'exploitation. Permettre aux développeurs de personnaliser / habiller leurs applications de la même manière que les conceptions Web créent des styles pour les sites Web.

Java sur la plate-forme Android suit ce chemin. Définition des éléments d'interface utilisateur pour Android en XML avec des styles personnalisables.

Java n'a jamais été très populaire en tant que plate-forme de bureau. En conséquence, ces changements dans l'industrie ne se propagent pas jusqu'aux exécutions de postes de travail. Il n’ya tout simplement pas assez de développeurs prêts à consacrer du temps à résoudre le problème.

Quel système d'exploitation voulez-vous aussi avoir l'air "natif"?

Vous ne pouvez tout simplement pas être natif de tous à 100% du temps.

Les SWT, etc. constituent la meilleure approche possible pour donner l’impression d’être native pour chacun d’entre eux lorsque vous avez besoin de parvenir à un compromis .

Et en fait, ce compromis commence à devenir de plus en plus difficile à atteindre; pas tellement à cause des systèmes d'exploitation, mais à cause des périphériques d'entrée. Pour les écrans tactiles, vous devez réellement concevoir différemment, car il n’ya pas de bouton droit de la souris. Par conséquent, vous devez sinon utiliser la même fonctionnalité.

Il n’existera jamais de bouton magique permettant de déplacer "intuitivement" les fonctionnalités du bouton droit de la souris aux invités, sans que vous spécifiiez chaque aspect détaillé pour chaque périphérique d’entrée (à quel point vous êtes natif de chaque -natif à tout ce que vous n'avez pas considéré).

Très bonne question. Je me suis toujours posé des questions moi-même au cours des années suivantes, je pensais qu'il y avait une raison légitime à cela, mais ce n'est pas le cas.

Je pense que la réponse est assez simple, et beaucoup de réponses ne creusent pas vraiment la question.

Si votre langue permet de dessiner piexel à l'écran, il est alors 100% possible de créer un framework d'interface graphique basé sur celui-ci, qui imitera précisément les contrôles de formulaire Windows.

Étant donné que Java est une plate-forme croisée, il est également tout à fait possible de s’assurer que, en fonction du type de système en cours d’exécution (Mac / Windows), l’UI choisira d’avoir une apparence différente sur les deux plates-formes, correspondant au style de plate-forme d’exécution.

Comme vous pouvez le voir dans XAML par exemple, l'interface utilisateur peut être facilement présentée sous une forme et un langage très structurés. Le choix des comportements "natifs" est également possible si on prend le temps de le faire.

Il serait donc possible de créer une infrastructure graphique permettant aux développeurs Java d’obtenir des applications ayant un aspect natif sur Mac et Windows.

Nous arrivons donc à Swing, qui n’est qu’un framework GUI sur une infinité potentielle de frameworks GUI pouvant être créés pour Java. Il se comporte comme il a été programmé, ce qui ne suit pas le processus ci-dessus et vous obtenez des applications étranges à la recherche sur les deux systèmes. C’est le choix des développeurs Swing, personne ne les a forcés à le faire et à se comporter de la sorte.