Warum ist es schwierig, ein Java-Programm "nativ" erscheinen zu lassen?

Die meisten Java-Anwendungen sehen anders aus als C / C ++ - Anwendungen. Swing wurde mit Absicht entwickelt, um ein unverwechselbares Erscheinungsbild zu erhalten, aber SWT hat zum Beispiel versucht, wie ich gelesen habe, "nativ" auszusehen, was jedoch nicht vollständig gelingt.

Meine Frage ist:

Warum fällt es den Entwicklern der Java-Sprache schwer, ein GUI-System zu entwerfen, das genau das Aussehen von nativen GUIs kopiert ? Was ist bei nativen GUIs anders? Geht es nicht nur darum, Schaltflächen zu entwerfen, die wie "native" Schaltflächen aussehen? Oder geht es tiefer als das?

Geht es nicht nur darum, Schaltflächen zu entwerfen, die wie "native" Schaltflächen aussehen?

Na ja, für Knöpfe. Aber das könnte schwieriger sein, als Sie sich vorstellen. Heutzutage sind die Grafiken, die zur Darstellung von GUI-Komponenten verwendet werden, nicht mehr so ​​einfach wie zufällige Bitmaps, die gestreckt werden (da diese überhaupt nicht gut skaliert werden). Wenn die Schaltfläche den Rand des Bildschirms erreicht, sieht sie beispielsweise möglicherweise etwas anders aus.) Wenn Sie auf eine Schaltfläche klicken, benötigen Sie natürlich andere Grafiken. Aus urheberrechtlichen Gründen können Entwickler diese vorhandenen Grafiken oft nicht direkt verwenden, sondern müssen neu erstellt werden - und obwohl sie zum größten Teil gute Arbeit leisten, werden aufgrund der Vielzahl grafischer Komponenten zwangsläufig einige Dinge übersehen.

Ich sage das alles basierend auf Swing, das natürlich ein leichtes, nicht-natives GUI-Toolkit ist. Sie erwähnen ausdrücklich, dass SWT nicht nativ aussieht, was etwas seltsam ist, da SWT nativ ist. Es handelt sich um ein Toolkit, das JNI verwendet, um native Komponenten aufzurufen. Wenn also etwas dort nicht richtig aussieht, liegt es nicht am Erscheinungsbild.

Es gibt buchstäblich ein halbes Dutzend Toolkits, die auf manchen Systemen als „nativ“ angesehen werden könnten. Einige von ihnen haben ziemlich einzigartige Konzepte oder Fähigkeiten, und ihre Replikation in einem plattformübergreifenden Toolkit ist mühsam. Das Look & Feel einer Anwendung wird nicht nur von einem „Skin“ bestimmt, sondern auch vom Layout und dessen Verhalten. Einige Überlegungen:

• Zu welcher Seite gehört in einem Dialog die Schaltfläche „OK“ - links oder rechts? Fair genug, lassen Sie uns für jedes System einen eigenen Dialog erstellen.
• Wie markieren wir die Standardschaltfläche auf einem Bildschirm? Farbtönung, fette Schrift, Vergrößerung der Schaltfläche? Fair genug, lassen Sie uns das in ein Stylesheet schreiben.
• Unter Windows ist das Konzept der Multifunktionsleiste eher nativ. Wie würde dies auf einen Mac übertragen, bei dem das Menüband nicht üblich ist? Vergessen wir das pixelgenaue Layout und stellen für jedes System eine andere Symbolleistenimplementierung bereit.
• Ist die Menüleiste Teil des Fensters (Windows, optional KDE) oder befindet sie sich oben auf dem Bildschirm (Mac, Unity)? Fairerweise, lassen Sie uns für jedes System eine andere Implementierung schreiben, da wir bereits pixelgenaues Layout weggeworfen haben
• Wie werden die Schriften gerendert? Möglichst knackig oder geschmeidig und antialias? Und welche Schriftart soll verwendet werden? Beachten Sie, dass unterschiedliche Schriftarten unterschiedliche Metriken haben, sodass der gleiche Absatz, der mit derselben Breite gerendert wird, je nach Schriftart eine unterschiedliche Anzahl von Zeilen aufweisen kann.
• Ist der Hintergrund eines Fensters eine einzelne Farbe, ein Bild oder ein Farbverlauf? Lassen Sie uns das auch in ein Stylesheet schreiben.
• Wie sehen Bildlaufleisten aus? Wo sind die Knöpfe - wenn sie welche haben? Wie breit sind sie oder werden sie nur angezeigt, wenn sich der Zeiger in einer bestimmten Region befindet?
• Wie integrieren wir andere Farbschemata?
• Was soll ziehbar sein? Wo werden Kontextmenüs erwartet?

Diese Probleme können nicht durch ein einfaches Stylesheet gelöst werden, wenn sie sich auf das Verhalten oder das allgemeine Layout der Anwendung auswirken. Die einzige echte Lösung besteht darin, die Anwendung für jedes System neu zu schreiben (wobei die plattformübergreifenden Vorteile von Java ignoriert werden). Die einzig realistische Lösung besteht darin, das pixelgenaue Layout zu vergessen und auf eine gemeinsame Oberfläche zu schreiben, die über systemspezifische Toolkits abstrahiert. Die Lösung von Swing besteht darin, verschiedene Systeme zu emulieren, was spektakulär ausfällt.

Und dann gibt es die plattformübergreifende Konsistenz, die Idee, dass Ihre App auf allen Systemen genau gleich aussehen kann (oft von Spielen gewählt, wo dies das Eintauchen erhöht). Bei Desktop-Anwendungen ist dies nur ärgerlich und verstößt gegen die Erwartungen der Benutzer.

Ja, es geht tiefer.

Das Erstellen einer Schaltfläche, die wie eine Windows- oder OS X-Schaltfläche aussieht, ist einfach, wenn Sie nur diese Schaltfläche erstellen. Die Schaltfläche muss sich jedoch wie die Originalschaltfläche "verhalten", was möglicherweise nicht einfach ist: Möglicherweise ist in der einen Version mehr Platz verfügbar, in der anderen nicht. Möglicherweise passt die Farbe besser zu Ihrem Design in der Windows-Version usw.

Dies ist besonders dann wichtig, wenn Sie eine vollständige Benutzeroberfläche haben: Ein OS X-Programm präsentiert seinen Inhalt anders als ein Windows-Programm. Dies ist nahezu unmöglich in einer GUI zu erfassen - Sie würden zwei GUIs benötigen, aber nicht viele Anwendungen machen so viel Aufhebens. Stattdessen zielen sie darauf ab, "auf den meisten Systemen in Ordnung zu sein" - dies sieht immer noch etwas fremd aus, ist aber brauchbar und viel einfacher zu entwickeln.

Es ist nicht schwer, eine Schaltfläche zu erstellen, die aussieht wie eine OSX-Schaltfläche, eine Windows-Schaltfläche oder die eines anderen Toolkits. Die Richtlinien für die Benutzeroberfläche in den meisten Umgebungen sind jedoch nicht so einfach wie die Grundlagen von "So sieht eine Schaltfläche aus". Es gibt viele subtilere Unterschiede, angefangen vom Abstand zwischen den Elementen der Benutzeroberfläche bis hin zur Reihenfolge, in der bestimmte bekannte Aktionen in einer Liste angezeigt werden sollen, bis hin zur genauen Position des Dialogfelds Einstellungen / Optionen im Menüsystem. Man kann die häufigsten Fälle für sehr einfache Benutzeroberflächen automatisieren, aber viele, wenn nicht die meisten UI-Aufgaben erfordern eine viel feinere Berührung.

SWT hat versucht, dies bis zu einem gewissen Grad zu automatisieren, und macht es wieder einmal richtig für einfache UI-Aufgaben. Es gibt jedoch keine einheitliche Lösung. Wenn die Benutzeroberflächen komplexer werden, fallen die grundlegenden Methoden auseinander. Es ist im Allgemeinen möglich, es mit der sorgfältigen manuellen Benutzeroberflächenarbeit in Einklang zu bringen, aber dies ist nicht etwas, was die meisten Programmierer für alle Plattformen können oder wollen.

Swings Ansatz bestand darin, native Toolkits zu vermeiden, wann immer dies möglich war. Es ist nicht einheimisch und versucht auch nicht zu sein: Stattdessen versucht es, etwas zu erstellen, das (fast) gleich aussieht, egal wo es ausgeführt wird. Anstatt (vergeblich) zu versuchen, alle zufrieden zu stellen, hat es versucht, sich selbst zufrieden zu stellen, und obwohl dies gelungen ist, kann man sich fragen, wie effektiv das Ergebnis für die breitere Benutzergemeinschaft ist.

Es gibt einen Kompromiss zwischen der Erwartung, dass Ihre Anwendung auf jedem System so natürlich wie möglich aussieht, und der Erwartung, dass Ihre Anwendung auf jedem System auf die gleiche Weise funktioniert. Es gibt keine "richtige" Wahl.

Selbst wenn Sie sich für die "natürlich aussehende" Seite entscheiden, möchten Sie die Benutzer Ihres Grafik-Toolkits möglicherweise vor "Verbesserungen" der zugrunde liegenden nativen Komponenten und API schützen, die ihre Anwendung möglicherweise unerwartet beschädigen.

Aus diesem Grund bevorzugen es einige Entwickler von GUI-Toolkits, ihre eigenen Komponenten bereitzustellen, die native Komponenten imitieren, aber ihre eigene Implementierung bereitstellen. Auf der anderen Seite ist die Entwicklung eines funktional vollständigen GUI-Toolkits ein erheblicher Aufwand, und wirtschaftliche Überlegungen können dazu führen, dass sich nur wenige Vorteile ergeben.

Beachten Sie, dass dieses Problem nicht Java-spezifisch ist, sondern von jedem Unternehmen verursacht wird, das plattformunabhängige Toolkits herstellt.

Das liegt alles an der Geschichte.

Sun wünschte sich, dass alle Java-Programme auf allen Computern gleich funktionieren.

Damit Software "nativ" erscheint, muss sie auf dem jeweiligen Betriebssystem genauso funktionieren wie andere Software.

Sun tat alles, um das Schreiben von Java-Software, die in ein Betriebssystem integriert ist, zu erschweren. Bei jeder Integration in ein Betriebssystem würde die Software auf jedem Betriebssystem anders funktionieren.

Heutzutage kümmern sich nur noch wenige Java-Programmierer um etwas anderes als um Webserver-basierte Software.

Sun hat Java auf dem Desktop getötet, indem alle Programmierer, die Microsoft Java-basierte Systeme verwendeten, geschockt wurden, sodass jeder Programmierer, der sich in den frühen Tagen für Java entschied, schlecht aussah.

Jeder, der Desktop-Software schreibt, die darauf bedacht ist, „nativ zu sein“, hat vor langer Zeit gelernt, Java nicht zu verwenden, und seine Ansichten werden jedes Mal verstärkt, wenn er Oracle-Software verwendet.

Daher ist es heutzutage nicht mehr erforderlich, dass Desktop-Software von Java-Programmierern „nativ angezeigt“ wird.

Was Sie denken, ist, nativedass native Apps ihr eigenes Ding machen, während Toolkits wie SWT den veröffentlichten Standards für die Benutzeroberfläche dieses Betriebssystems folgen. Das Problem ist, dass niemand Apps nach diesen Standards erstellt, wenn Sie eine Java-App starten. Es scheint nicht heimisch zu sein. Beispielsweise können fast alle Microsoft-Projekte (Office, Outlook usw.) mit Windows-Standardsteuerelementen nicht visuell reproduziert werden.

Es wird noch schlimmer, wenn Microsoft und Apple ihren Betriebssystemplattformen dynamische UI-Funktionen hinzufügen. Entwickler können ihre Apps auf die gleiche Weise gestalten, wie Webdesigns Stile für Websites erstellen.

Java auf der Android-Plattform folgt diesem Pfad. Erstellen der in XML definierten Benutzeroberflächenelemente für Android mit Skins.

Java war noch nie als Desktop-Plattform sehr beliebt. Infolgedessen werden diese Änderungen in der Branche nicht auf die Desktop-Laufzeiten übertragen. Es gibt nicht genug Entwickler, die bereit sind, Zeit für die Behebung des Problems aufzuwenden.

Welches Betriebssystem möchten Sie auch "native" aussehen?

Man kann einfach nicht zu 100% für alle einheimisch sein.

SWT usw. sind der beste Ansatz, um für alle so natürlich zu wirken, wie es nur geht, wenn Sie einen Kompromiss eingehen müssen .

Tatsächlich wird dieser Kompromiss immer schwieriger zu erreichen. nicht so sehr aufgrund von Betriebssystemen, sondern aufgrund von Eingabegeräten. Für Touchscreens, müssen Sie tatsächlich entwerfen anders, weil es keine rechte Maustaste. Aus diesem Grund müssen Sie ansonsten dieselbe Funktionalität bereitstellen.

Es wird niemals eine magische Taste geben, die die Funktionalität "intuitiv" von der rechten Maustaste auf die Gastsysteme überträgt, ohne dass Sie jeden einzelnen Aspekt für jedes einzelne Eingabegerät spezifizieren (zu diesem Zeitpunkt sind Sie für jede von Ihnen in Betracht gezogene Plattform beheimatet, aber dennoch nicht -Native für alle, die Sie nicht berücksichtigt haben).

Wirklich gute Frage. Ich habe mich in den letzten Jahren immer selbst darüber gewundert, ich dachte, es steckt ein legitimer Grund dahinter, aber das gibt es wirklich nicht.

Ich denke, die Antwort ist ziemlich einfach, und viele Antworten befassen sich nicht wirklich mit dem Thema.

Wenn Ihre Sprache das Zeichnen von Kreisen auf dem Bildschirm zulässt, ist es zu 100% möglich, ein darauf basierendes GUI-Framework zu erstellen, das das Erscheinungsbild und Verhalten von Windows-Formularsteuerelementen genau nachahmt.

Da Java plattformübergreifend ist, ist es durchaus möglich, sicherzustellen, dass die Benutzeroberfläche basierend auf dem aktuell ausgeführten Systemtyp (Mac / Windows) auf beiden Plattformen unterschiedlich aussieht und dem Laufzeitplattformstil entspricht.

Wie Sie beispielsweise in XAML sehen können, kann die Benutzeroberfläche leicht in sehr strukturierter Form und Sprache dargestellt werden. Die Auswahl des "nativen" Verhaltens ist auch möglich, wenn dafür Zeit benötigt wird.

So wäre es möglich, ein GUI-Framework zu erstellen, mit dem Java-Entwickler Anwendungen erhalten, die auf Mac und Windows nativ aussehen.

Wir kommen also zu Swing, das ist nur ein GUI-Framework aus der potenziellen Unendlichkeit von GUI-Frameworks, die für Java erstellt werden könnten. Es verhält sich wie es programmiert wurde, was nicht dem obigen Prozess folgt und Sie erhalten auf beiden Systemen seltsam aussehende Apps. Das ist die Entscheidung, die die Swing-Entwickler getroffen haben. Niemand hat sie gezwungen, dies zu tun und sich so zu verhalten.