Eine Swing-Komponente – HexDumpView

 Java, Swing  Kommentare deaktiviert für Eine Swing-Komponente – HexDumpView
Sep 222018
 

Nach dem großen Erfolg der JVM-Memory-Indicator-Komponente und dem sensationellen Layout-Manager nun eine weitere unverzichtbare Komponente in jeder grafischen Oberfläche, die aus unverständlichen Gründen nicht schon standardmäßig in Swing ausgeliefert wird: die Anzeige eines klassischen Hexdumps. In der ebenso klassischen 8 + 16 + 16-Darstellung: 8-stellige Adresse, danach 16 Bytes in Hex-Darstellung, danach 16 ASCII-Zeichen als direkte Übersetzung der Bytes. Mit möglichst simpler API: hier ist das Byte-Array, mach’ mir die HexDump-View als Swing-Komponente dazu, die ich zur Nutzung nur noch in eine JScrollPane reinsetzen muss. Natürlich superschnell und superspeichersparend.

Testkandidat war eine 800KiB-Datei (ein adf-Floppyimage, aber das tut nichts zur Sache, hat aber mit dem Ursprung des Wunsches nach dieser Komponente zu tun – ich hoffe, da kann ich demnächst Vollzug melden, dann voraussichtlich nebenan im RISC OS-Blog), resultierend in einem rund 50000 (genau 51200) Zeilen umfassenden Hexdump.

Wie ist es implementiert? Da gab es natürlich eine Menge Varianten, die mir spontan in den Sinn kamen und die wie immer mit unterschiedlichen Kompromissen behaftet sind, die ich kurz anreißen will.

Variante 1: Erzeugen einer String-Repräsentation der Binärdaten und Nutzung einer “normalen” JTextArea oder JEditorPane. Geht schnell, ist unproblematisch in der Realisierung, alle typischen Dinge einer Textkomponente sind direkt verfügbar (auch wenn in diesem Falle das Copy&Paste vermutlich nicht ganz das ist, was der Anwender erwartet). Aber speicher- und laufzeittechnisch sicher suboptimal – die Konvertierung in eine lange Zeichenkette, obwohl man diese ja bei größeren Datensätzen niemals gleichzeitig auf dem Schirm sieht, ist doch verhältnismäßig teuer, und die Wahrscheinlichkeit, dass sowohl das Quell-Byte-Array als auch die Zeichenkette im Speicher verbleiben müssen, ist ja doch recht groß (vermutlich will der Verwender seine Quelldaten ja nicht wegwerfen, sondern noch weiter verarbeiten), und pro Byte kostet die String-Repräsentation ja zusätzlich etwa 14 Bytes (73 Zeichen pro 16 Bytes.

Variante 1a: Erzeugen einer String-Repräsentation der Binärdaten und wrappen in ein java.swing.text.Document als Unterfütterung einer JTextArea/JEditorPane. Spontan würde ich denken, dass so ein reines ReadOnly-Document etwas besser bei Speicher- und Laufzeitverhalten ist als ein Wald- und Wiesen-Document aus dem Swing-Bauchladen.

Variante 2: Erzeugen einer String-Repräsentation der Binärdaten und direkter Redraw in paintComponent. Habe ich getestet, für mäßig große Binärdaten funktioniert das erschreckenderweise recht gut (in meinem Falle waren das rund 50000 Zeilen des Hexdumps), was glaube ich eher zeigt, wie schnell die Maschinen heutzutage sind, und nicht, wie man ein solches Problem angehen sollte. Speichertechnisch ist das etwas günstiger als eine JTextArea oder JEditorPane weil man die ganze unnütze Funktionalität weglässt, aber das Hauptproblem der Erzeugung der großen Zeichenkette bleibt.

Variante 2a: wie 2, aber mit optimiertem Redraw (paintComponent) – nur die Zeilen zeichnen, die laut Clipping Rectangle tatsächlich gezeichnet werden. Das ist geschwindigkeitstechnisch schon erheblich besser als Variante 2, weil eben nur sagen wir 100 Zeilen gezeichnet werden statt 50000, und deshalb aus der vollständigen String-Repräsentation auch nur 100 Substring-Operationen anstatt 50000 durchgeführt werden müssen. Ich habe allerdings nicht analysiert, ob denn den Substring-Operationen im Vergleich zum dann weggeclippten drawString wirklich die teurere Operation ist – einigen wir uns auf “hilft beides nicht”.

Variante 3: kein Erzeugen der vollständigen String-Repräsentation, sondern Erzeugung der zu malenden Textzeile “on demand” aus den Quelldaten, dem Byte-Array. Dabei Inspektion des Clipping Rectangles, um nur die notwendigen Operationen durchzuführen.

Nachfolgend beispielhaft die Implementierungsvariante 3 (die anderen sind zu trivial :-)), als ganz nacktes Java – keine externen Abhängigkeiten, und vermutlich würde der Code so schon unter Java 1.1 mit Swing 1.1 funktionieren. Es gibt hier natürlich Lücken (es sind nur rund 200 Zeilen Code, für eine vollständige JComponent, inklusive JavaDoc!), die selbstverständlich nur als Aufforderung zur Übung an den Leser zu verstehen sind. Encoding-Unterstützung für den Textbereich, Implementierung eines Carets und einer Selektionsmöglichkeit, Unterstützung für nicht-Monospaced-Schriften, on-demand-loading der Binärdaten aus einer Datei größer als MaxHeap während der Benutzer scrollt, suchen nach Text und Bytes und Adressen, Darstellung in Byte- und Word-Form, hinzufügen der Zeilennummer…

Auch eine Variante 4 – ein Document das allein durch die Quelldaten unterfüttert ist und on-the-fly den Text für die JTextComponent generiert, wäre eine interessante Forschungsaufgabe.

/*
 * (c) hubersn Software
 * www.hubersn.com
 *
 * Use wherever you like, change whatever you want. It's free!
 */
package com.hubersn.playground.swing;

import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.Rectangle;

import javax.swing.JComponent;

/**
 * Component showing a hexdump.
 */
public class HexDumpView extends JComponent {

  /** Number of characters in one line of a hexdump: 8 characters address, 16 2-character-bytes, 16 characters, spaces. */
  private static final int LINE_LENGTH = 8 + 1 + 3 * 16 + 16;

  private byte[] data;

  private int lineCount = -1;

  private FontMetrics fm = null;

  private int lineHeight = 0;

  private int lineAscent = 0;

  private int characterWidth;

  private int calculatedWidth;

  private int calculatedHeight;

  /**
   * Creates a hexdump view based on the given data with a monospaced 12pt font.
   *
   * @param data hexdump data.
   */
  public HexDumpView(final byte[] data) {
    setFont(new Font("Monospaced", Font.PLAIN, 12));
    setData(data);
  }

  /**
   * Sets the data to be visualized by this hexdump view.
   *
   * @param data hexdump data.
   */
  public void setData(final byte[] data) {
    this.data = data;
    refresh();
  }

  /**
   * Sets the font to be used for the hexdump - note that only a monospaced font will yield sensible results.
   */
  @Override
  public void setFont(final Font font) {
    super.setFont(font);
    this.fm = null;
    refresh();
  }

  private void refresh() {
    if (this.data == null) {
      return;
    }
    calculateSizes();
    revalidate();
  }

  private int calculateLineCount() {
    if (this.data == null) {
      return 0;
    }
    int lc = this.data.length / 16;
    if (this.data.length % 16 > 0) {
      lc++;
    }
    return lc;
  }

  private void calculateSizes() {
    if (this.fm == null) {
      this.fm = getFontMetrics(getFont());
      this.lineHeight = this.fm.getHeight();
      this.lineAscent = this.fm.getAscent();
      this.characterWidth = this.fm.stringWidth("M");
    }
    this.lineCount = calculateLineCount();
    this.calculatedWidth = getInsets().left + getInsets().right;
    this.calculatedWidth += LINE_LENGTH * this.characterWidth;
    this.calculatedHeight = getInsets().top + getInsets().bottom;
    this.calculatedHeight += this.lineCount * this.lineHeight + this.lineAscent;
  }

  @Override
  public Dimension getPreferredSize() {
    return new Dimension(this.calculatedWidth, this.calculatedHeight);
  }

  @Override
  protected void paintComponent(Graphics g) {
    super.paintComponent(g);
    if (this.data == null) {
      return;
    }
    Rectangle clipBounds = g.getClipBounds();
    Insets insets = getInsets();
    int y = insets.top + this.lineAscent;
    for (int i = 0; i < this.lineCount; i++) {
      // optimized redraw - check if clipping bounds contains line
      if (shouldDraw(clipBounds, y)) {
        String str = getHexDumpLine(this.data, 0, i * 16);
        g.drawString(str, insets.left, y);
      }
      y += this.lineHeight;
    }
  }

  private boolean shouldDraw(Rectangle r, int y) {
    return !(y + this.lineHeight < r.y || y - this.lineHeight > r.y + r.height);
  }

  //
  // -- utility methods for hex(dump) representation
  //

  /**
   * Converts a value between 0 and 15 into the corresponding hex character - throws an
   * IllegalArgumentException on illegal input values.
   *
   * @param value value to convert.
   * @param useUpperCase use upper case letters A-F?
   * @return hex character representing value.
   */
  private static char valueToHexChar(final long value) {
    if (value < 0 || value > 15) {
      throw new IllegalArgumentException("Value " + value + " out of range - must be 0-15");
    }
    if (value < 10) return (char) ('0' + value);

    return (char) ('A' + (value - 10));
  }

  /**
   * Converts the given value to a number of hex characters specified in nibble count value.
   *
   * @param value
   * @param nibbleCount amount of nibbles (characters) to return.
   * @param useUpperCase use upper case hex characters.
   * @return hex representation of value.
   */
  private static String valueToHexChars(final long value, final int nibbleCount) {
    char[] hexChars = new char[nibbleCount];
    for (int i = 0; i < nibbleCount; i++) {
      hexChars[i] = valueToHexChar(0b1111 & (value >> (4 * (nibbleCount - 1 - i))));
    }
    return new String(hexChars);
  }

  /**
   * Returns a line (not terminated) for a hexdump output - either 16 bytes starting from offset or less if data has less than 16 bytes available.
   *
   * @param data data for dump.
   * @param startAddress start address of data.
   * @param offset offset into data.
   * @return hexdump line.
   */
  private static String getHexDumpLine(final byte[] data, final long startAddress, final int offset) {
    StringBuilder sb = new StringBuilder(LINE_LENGTH);
    sb.append(valueToHexChars(startAddress + offset, 8));
    sb.append(' ');
    for (int lineOffset = 0; lineOffset < 16; lineOffset++) {
      if (offset + lineOffset < data.length) {
        sb.append(valueToHexChars(getUnsigned(data[offset + lineOffset]), 2));
        sb.append(' ');
      } else {
        sb.append("   ");
      }
    }
    for (int lineOffset = 0; lineOffset < 16; lineOffset++) {
      if (offset + lineOffset < data.length) {
        sb.append(getPrintableCharacter(getUnsigned(data[offset + lineOffset])));
      }
    }
    return sb.toString();
  }

  private static int getUnsigned(final byte b) {
    if (b < 0) {
      return ((int) b + 256);
    }
    return b;
  }

  private static char getPrintableCharacter(final int byteValue) {
    if (byteValue < 32 || byteValue > 255 || (byteValue > 128 && byteValue < 160)) {
      return '.';
    }
    return (char) byteValue;
  }

}

Bits frickeln mit Java

 Java, OS, Software  Kommentare deaktiviert für Bits frickeln mit Java
Aug 072018
 

Gerade bin ich dabei – zum besseren Kennenlernen von Filecore-basierten Dateisystemen (man muss den Feind kennen) – in Java ein kleines Tool zu entwickeln, das Disc-Images im Filecore-Format versteht und Dateien und Verzeichnisse daraus extrahieren kann. Nur lesend, um weitere Komplexitäten erst mal zu vermeiden.

Etwas Hintergrund: Filecore ist das native Dateisystem unter RISC OS. Oft wird es auch als “ADFS” bezeichnet, weil das “Advanced Disc Filing System” quasi die erste Implementierung von Filecore war (damals, Floppy-Zeit, zur Archimedes-Ära 800 KiB auf einer 3,5″-DD-Diskette), bevor es abstrahiert und generalisiert als Basis für Disketten- und Festplattenformate in RISC OS Einzug hielt. Es gab über die Jahre reichlich Varianten, um die diversen Einschränkungen und Limits in den besser nutzbaren Bereich zu schieben – das E-Format ist das Übliche für DD-Disketten (800 KiB) und man findet es heute in den Weiten des Internets als .adf-Disc-Images der klassischen Archimedes-Software. Später kam das F-Format für die HD-Floppies (1600 KiB). Schließlich wurde mit RISC OS 4 das E+/F+-Format eingeführt (“Big Map”), um die lächerlich niedrige Grenze solcher Dinge wie “maximale Anzahl von Einträgen in einem Verzeichnis” auf ein halbwegs erträgliches Niveau zu heben.

Wie auch immer – beim Hantieren mit Emulatoren und natürlich dem MIST(er) hat man häufig mit diesen .adf- (Floppy-Images) und .hdf- (Harddisc-Images) Dateien zu tun. Oftmals will man “nur kurz” einen Blick reinwerfen und dazu nicht gleich den Emulator hochfahren. Zumal die Emulatoren auch nicht alle so richtig nutzerfreundlich sind was das “Mounten” des Images angeht.

Also: ein Tool muss her. Systemunabhängig und natürlich mit anständigem UI. Also Java. Das Problem: Filecore wurde von echten Bitfuchsern entwickelt. Da wimmelt es nur so von Bitleisten, unsigned values mit allem zwischen 8 und 64 bit und sonstigem, was unter Java nicht so richtig “nativ” unterstützt wird. Übrigens gibt es Spezialisten, die es auch noch gut finden, dass Java keine “unsigned types” hat – für mich ist dieser Artikel ein Beispiel dafür, wie eine limitierte Erfahrung auf nur wenige Programmiersprachen den Blick aufs wesentliche vernebeln kann, denn die allermeisten der genannten Probleme sind nur inhärent im Java- und C-Typsystem, aber in vernünftigen Sprachen wie Ada elegant gelöst. Dumm, dass die Java-Erfinder vermutlich einen genauso eingeschränkten Blickwinkel hatten – C, C++, Smalltalk, Ende der Geschichte. Aber ich schweife ab.

Jedenfalls habe ich nach Bibliotheken gesucht, die unter Java die Bitfrickelei und unsigned types im Handling etwas angenehmer machen. Leider bin ich bis auf Lukas Eders jOOU-Bibliothek auf nix gescheites gestoßen. Klar, im Apache-Commons-Universum gibt es ein paar Dinge, in Guava ebenso, und sogar Oracle hat das Licht gesehen und ein paar nützliche Dinge in Java 8 nachgerüstet. Also: selbst ist der Mann. “Not invented here” ist schließlich eine der grundsätzlichen Triebfedern der IT.

Es sei denn, jemand hat einen Hinweis auf eine vernünftige, umfassende Bibliothek um meine Bedürfnisse zu erfüllen. Unter ebenso vernünftiger Open-Source-Lizenz natürlich. UAwg! Nebenbei: die eigentliche Implementierung ist nun nicht das große Problem, das Finden geeigneter Doku und fehlerarme Interpretation derselben nebst Erkennen gewünschter und unerwünschter Abweichungen davon in der Praxis hingegen schon. Hat man das Problem erst mal in einer Sprache geknackt, sollte eine Portierung in andere Sprachen kein großes Problem sein. Es wäre eine interessante Fallstudie, den Ada-Code neben dem Java-Code zu sehen.

Und falls jemand ein anständiges (nicht jedoch komplexes!) Dateisystem kennt mit einer simplen Implementierung in einer freien Lizenz – mail me. Filecore hat einen Nachfolger schon seit etwa 30 Jahren verdient.

Die zunehmende Entmündigung des Nutzers

 Rant  Kommentare deaktiviert für Die zunehmende Entmündigung des Nutzers
Apr 182018
 

Gerade hat sich mein Kindle eigenmächtig upgedated. Als ich ihn ein paar Minuten unbeaufsichtigt zwecks Lesepause, aber noch verbunden mit dem WLAN, liegen gelassen habe. Und es hat Minuten gedauert. Und er hat den alten Lesezustand leider vergessen. Ich hatte vor ein paar Tagen das Update noch explizit abgelehnt aufgrund von “never change a running system”.

Das ist eine zunehmende Unsitte von IT aller Art, gar nicht mehr auf die Zustimmung des Nutzers zu warten, ihn gar nicht mehr zu informieren was denn das Update so macht. Ihm die Entscheidung zu überlassen. Wäre auch nicht das erste Mal, dass Features von einer Version zur nächsten einfach Verschwinden. Zurück zu einer älteren Version kann man ja auch nur noch in den seltensten Fällen. Der Traum eines modularen Upgrademechanismuses, wo man “pick and mix” mit gewünschten und unerwünschten Updates machen kann, ist ja schon seit Jahrzehnten ausgeträumt. Langfristige Stabilität und Support etwas von gestern – Vorwärtsstrategie scheint das neue Zauberwort.

Irgendjemand wird jetzt sicher “Security” sagen. Ja, dann macht es doch einfach sicher. Ein stabiler Branch mit aktuellen Sicherheitspatches. Einen Development-Branch für die Mutigen. Das wäre das allermindeste, denn bei der üblichen Qualität heutiger Softwareentwicklung bedeutet ja jede Änderung ein neues Sicherheitsrisiko. Und bei einem komplett vernagelten System wie dem Kindle kann Security wohl kaum ein Argument sein, oder jemand hat wirklich Scheiße gebaut.

Ich hasse Intransparenz. Besonders, wenn es um meine eigenen Geräte geht. Macht im Web was ihr wollt. Aber nicht auf meinen Geräten.

Die zunehmende Nutzlosigkeit von Datenblättern

 Uncategorized  Kommentare deaktiviert für Die zunehmende Nutzlosigkeit von Datenblättern
Apr 082018
 

Wann immer ich ein Stück Technik kaufe, informiere ich mich vorher so gut es geht. Reviews bei Amazon, Testberichte, und natürlich die Hersteller-Website. Bei komplexeren Dingen hilft oft ein Blick ins Handbuch, das ja Gott sei Dank inzwischen fast immer zum Download verfügbar ist (und das auch sein muss, denn gedruckt beigelegt wird es heutzutage ja immer seltener – aber das ist eine andere Geschichte).

Seit Jahren beobachte ich dabei eine ständige Reduktion der Tiefe technischer Daten. Jahrelang habe ich z.B. bei DVD-Brennern den Strombedarf zu ermitteln versucht – meist stand nur “5V/12V” im “Datenblatt”. Sehr nützlich.

Ein besonders sparsames Beispiel ist mir gerade untergekommen: es geht um eine externe USB-Festplatte von Seagate. Was könnte es da an nützlichen Informationen geben, die man in ein Datenblatt schreiben könnte? 512 Bytes/Sektor vs. 4Kn? Strombedarf am USB, womöglich gar getrennt nach Anlaufstrom, Strombedarf im Betrieb und im Standby? rpm der verbauten Platte? Geräuschentwicklung? Ob es intern eine S-ATA-Platte ist und die USB-Schnittstelle mit SAT arbeitet? Format bei Auslieferung?

Man werfe einen Blick drauf und ergötze sich an zwei Druckseiten Nichtinformation.

Immerhin: wir wissen nun, dass in 320 bzw. 240 Hauptkartons pro Palette geliefert wird. Super!

Oracle und Java – hü, hott, oder was ganz anderes?

 Java  Kommentare deaktiviert für Oracle und Java – hü, hott, oder was ganz anderes?
Mrz 292018
 

Oracle hat die “Roadmap” für Java 11 verkündet (hier und hier). JavaFX fliegt aus Java SE raus. Das Java-Plugin und damit nicht nur das Applet, sondern auch Java Web Start (und damit ironischerweise das, was Oracle bei Abkündigung des Applets noch als Ersatzlösung propagiert hat, auch wenn jeder wusste, dass es nur eine Deployment-Lösung ist und keine Browserintegrationslösung), fliegen raus.

OK, kann man so machen. Es gibt sicher gute Gründe dafür (im Gegensatz zur Entscheidung “wir laden .properties-Dateien ab sofort immer UTF-8”, für die ich bis heute keine auch nur annähernd stichhaltige Begründung gefunden habe – auch warum JAXB nun plötzlich aus Java SE raus musste, man weiß es nicht). Aber es ist ein Rückwärtskompatibilitätsproblem. Und es ist Wasser auf die Mühlen der “Java auf dem Client ist tot”-Fraktion, obwohl es bis heute keine WORA-Alternative für grafische Oberflächen gibt. Und eine weitere Kehrtwende im scheinbar ewigen Auf und Ab, beginnend mit der Idee des AWT in Java 1.0.

Das hin- und her-Geeiere gab es ja auch schon beim Thema “Java-Datenbank” – irgendwann wurde recht überraschend die Apache Derby als “Java DB” ins JDK aufgenommen, dann hat man diese Version – mit Hinweis auf die angeblich gefährdete Rückwärtskompatibilität – nicht regelmäßig aktualisiert, um sie schließlich wieder komplett zu entfernen (Java 9).

Auch die JavaFX-Geschichte ist ja eher wechselvoll. Zuerst der Flash-/ActionScript-/Silverlight-/Flex-Konkurrent mit dieser merkwürdigen Skriptsprache, dann JavaFX 2 mit der (durchaus vernünftigen) Idee der Ablösetechnologie für Swing, ohne aber die Grundlagen einer modernen UI gleich mitzuliefern (Accessibility, Comboboxen…dafür waren Charts dabei…). Dann die Integration ins JRE und die Bestrebung, JavaFX auch auf Android und iOS zu bringen. Reichlich Manpower und – für Java-Verhältnisse – zügiges Bugfixing. Dann Abbau der Manpower, Absage an die Mobilstrategie, nun Rauswurf aus Java SE und Übergabe an (oder vielmehr Hoffnung auf Übernahme durch) die Community.

Nun ist es ja durchaus diskussionswürdig, was in den “Standardlieferumfang” gehören soll und was nicht. Und durch Project Jigsaw hatte man nun ja eigentlich die Möglichkeit, die “modular JRE” Wirklichkeit werden zu lassen. Warum also nicht einen “Kern” definieren und den bisherigen Lieferumfang “on demand” dazupacken? Man versteht es nicht.

Auch “Jakarta EE” als “community driven effort” und JavaEE-Weiterführung steht ja noch nicht wirklich in voller Blüte. Es könnte so enden wie bei Hudson und OpenOffice. Oder Glassfish. Und wie geht es eigentlich Netbeans und VisualVM?

Ist das jetzige Gewurschtel eine notwendige Konsequenz aus anderen Entscheidungen wie der erhöhten Release-Frequenz? Müsste man denn dann nicht logischerweise den Änderungsumfang eher kleiner halten – nur, weil man was entfernt, löst man doch kein Problem. Dafür schafft man massiv Unsicherheit bezüglich des Commitments von Oracle zur Langzeitstabilität der Java-Plattform. Und was spricht letztlich für Java wenn nicht das bisherige Kompatibilitätsversprechen? Versucht man, durch hektische Betriebsamkeit Dynamik vorzutäuschen?

Es bleibt spannend. Enttäuschend finde ich die an den Haaren herbeigezogenen Begründungen vor allem für das Ende von Java Web Start. Gerade Oracle müsste doch wissen, dass die IT aus mehr als “Apps aus dem App-Store” besteht, und dass die Voraussetzung “ich habe Java auf dem Client installiert” für typische Firmen-IT jetzt nicht gerade das große Hindernis ist – andere Software hat auch Abhängigkeiten, die separat installiert werden müssen (.NET anyone?). Oder will man demnächst die Oracle-Datenbank abkündigen, weil sie nicht auf Android läuft? Interessant auch die Aussage, dass alle Web Start-basierten Oracle-Produkte für immer auf Java 8 bleiben werden. Das klingt nach echtem Zukunftsplan.

Einzig positiv aus meiner Sicht: der Markt ist nun weit offen für eine andere, bessere Deployment-Art – Java Web Start hatte ja auch seine Macken. Vielleicht ist “Zero Install” vom alten RISC OS-Spezl Thomas Leonard (berühmt für den ROX-Filer und ROX Desktop) ja die Alternative, die sich durchsetzt.

Ein Swing-Layout-Manager – OneRowSameSizeLayoutManager

 Java, Swing  Kommentare deaktiviert für Ein Swing-Layout-Manager – OneRowSameSizeLayoutManager
Feb 262018
 

Jeder Java-Entwickler, der schon mal seriös mit Swing eine Oberfläche gebaut hat, hat schon einmal mit dem Layout-Manager seiner Wahl gekämpft. Die standardmäßig im JDK ausgelieferten Layout-Manager sind eher gewöhnungsbedürftig bis leistungsschwach, mindestens aber umständlich. GroupLayout für komplexe Dinge und BorderLayout für Basislayouts sind gerade noch so verwendbar. Beliebte 3rd-party-Layout-Manager sind sicherlich MigLayout (oder MiG Layout? Man kann sich nicht enscheiden…), FormLayout, TableLayout und DesignGridLayout (Jahre nach dem Ableben von java.net wohl nur noch über Maven Central beziehbar).

Für besondere Bedürfnisse ist es manchmal eine gute Idee, einen einfachen LayoutManager selbst zu bauen. Ich habe das mal beispielhaft getan für den Anwendungsfall “Layout einer typischen Reihe von Buttons unten in einem Dialog”. Im Gegensatz zum merkwürdigen Beispiel im Swing-Tutorial von Oracle namens “DiagonalLayout” hoffe ich jedenfalls, dass mein Beispiel etwas mehr Nützlichkeit ausstrahlt. Der Quellcode ist mehr auf Lesbarkeit und Nachvollziehbarkeit denn auf Eleganz getrimmt. An einem schmissigeren Namen arbeite ich noch…

Irgendwann werde ich noch mal den “Packer”, einen Layout-Manager von Tcl/Tk, für Swing nachbauen. M.E. war der “Packer” in seinem Verhalten und der Vorhersagbarkeit des programmierten Resultats absolut untadelig, etwas was ich von den meisten Swing-LayoutManagern nicht sagen kann. Aber vielleicht ist meine Erinnerung an den Packer auch rosarot verklärt – ist schon über zwei Jahrzehnte her seit meinem ersten und letzten Kontakt.

/*
 * (c) hubersn Software
 * www.hubersn.com
 */
package com.hubersn.playground.swing.layout;

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager;

import javax.swing.SwingConstants;

/**
 * A layout manager supporting a row of components kept at the same width and height with specifiable alignment and gap size between the
 * components. It has its own insets to avoid having to work with empty borders.
 */
public class OneRowSameSizeLayout implements LayoutManager {

  /** Constant for default left alignment (identical to SwingConstants.LEFT). */
  public static final int ALIGN_LEFT = SwingConstants.LEFT;
  /** Constant for default centre alignment (identical to SwingConstants.CENTER). */
  public static final int ALIGN_CENTER = SwingConstants.CENTER;
  /** Constant for default right alignment (identical to SwingConstants.RIGHT). */
  public static final int ALIGN_RIGHT = SwingConstants.RIGHT;

  // calculated overall minimum/preferred size
  private int minWidth = 0;
  private int minHeight = 0;
  private int preferredWidth = 0;
  private int preferredHeight = 0;
  // calculated maximum component preferred sizes
  private int maxPreferredWidth = 0;
  private int maxPreferredHeight = 0;

  private Insets insets;

  private int componentGap = 5;

  private int alignment;

  /**
   * Creates a new layout with right alignment, 4 pixels gap and 8 pixels insets all around.
   */
  public OneRowSameSizeLayout() {
    this(ALIGN_RIGHT, 4, new Insets(8, 8, 8, 8));
  }

  /**
   * Creates a new layout with given alignment, gap between components and insets.
   * 
   * @param alignment component alignment - ALIGN_LEFT, ALIGN_CENTER or ALIGN_RIGHT.
   * @param componentGap gap in pixels between components.
   * @param insets insets to use additional to possible container border - if null, all insets are 0.
   */
  public OneRowSameSizeLayout(final int alignment, final int componentGap, final Insets insets) {
    setAlignment(alignment);
    this.componentGap = componentGap;
    this.insets = insets;
    if (insets == null) {
      this.insets = new Insets(0, 0, 0, 0);
    }
  }

  /**
   * Sets the component alignment for this layout.
   * 
   * @param alignment component alignment - ALIGN_LEFT, ALIGN_CENTER or ALIGN_RIGHT.
   */
  public void setAlignment(final int alignment) {
    this.alignment = alignment;
  }

  @Override
  public void addLayoutComponent(String name, Component comp) {
    // nothing to do - we are not interested in user-given layout constraints.
  }

  @Override
  public void removeLayoutComponent(Component comp) {
    // nothing to do.
  }

  private void calculateSizes(Container parent) {
    final int numberOfComponents = parent.getComponentCount();

    this.preferredWidth = this.insets.left + this.insets.right;
    this.preferredHeight = this.insets.top + this.insets.bottom;
    this.minWidth = 0;
    this.minHeight = 0;

    final int numberOfVisibleComponents = getNumberOfVisibleComponents(parent);
    for (int i = 0; i < numberOfComponents; i++) {
      final Component c = parent.getComponent(i);
      if (c.isVisible()) {
        final Dimension d = c.getPreferredSize();
        this.maxPreferredWidth = Math.max(this.maxPreferredWidth, d.width);
        this.maxPreferredHeight = Math.max(this.maxPreferredHeight, d.height);
        this.minWidth += c.getMinimumSize().width;
      }
    }

    this.preferredHeight += this.maxPreferredHeight;
    this.minHeight = this.maxPreferredHeight;

    if (numberOfVisibleComponents > 0) {
      this.preferredWidth += (this.maxPreferredWidth * numberOfVisibleComponents);
      this.preferredWidth += this.componentGap * (numberOfVisibleComponents - 1);
    }
  }

  @Override
  public Dimension preferredLayoutSize(Container parent) {
    final Dimension dim = new Dimension(0, 0);

    calculateSizes(parent);

    final Insets parentInsets = parent.getInsets();
    dim.width = this.preferredWidth + parentInsets.left + parentInsets.right;
    dim.height = this.preferredHeight + parentInsets.top + parentInsets.bottom;

    return dim;
  }

  @Override
  public Dimension minimumLayoutSize(Container parent) {
    final Dimension dim = new Dimension(0, 0);

    final Insets parentInsets = parent.getInsets();
    dim.width = this.minWidth + parentInsets.left + parentInsets.right;
    dim.height = this.minHeight + parentInsets.top + parentInsets.bottom;

    return dim;
  }

  @Override
  public void layoutContainer(Container parent) {
    final int numberOfVisibleComponents = getNumberOfVisibleComponents(parent);
    if (numberOfVisibleComponents == 0) {
      return;
    }

    calculateSizes(parent);

    final Insets parentInsets = parent.getInsets();

    // will all fit into parent? Which sizes to reduce?
    // width sizing strategy:
    // first, shrink gap and insets to 0
    // then, shrink button width and height
    // height sizing strategy:
    // shrink insets to 0
    final int parentWidth = parent.getWidth() - (parentInsets.left + parentInsets.right);
    final int parentHeight = parent.getHeight() - (parentInsets.top + parentInsets.bottom);
    final int heightToUse = Math.min(parentHeight, this.maxPreferredHeight);
    // width shrinking - toUse values are used for final layout bounds setting step
    int widthToUse = this.maxPreferredWidth;
    int buttonGapToUse = this.componentGap;
    int leftInsetToUse = this.insets.left;
    int rightInsetToUse = this.insets.right;

    int amountToReduceWidth = this.preferredWidth - parentWidth;
    if (amountToReduceWidth > 0) {
      // we need to save some pixels...
      // check for left/right insets
      if (leftInsetToUse + rightInsetToUse >= amountToReduceWidth) {
        int reduceInsetBy = amountToReduceWidth / 2;
        leftInsetToUse -= reduceInsetBy;
        amountToReduceWidth = 0;
      } else {
        leftInsetToUse = 0;
        amountToReduceWidth -= (this.insets.left + this.insets.right);
      }
      if (amountToReduceWidth > 0) {
        // check for button gaps
        if (numberOfVisibleComponents > 1 && (numberOfVisibleComponents - 1) * buttonGapToUse >= amountToReduceWidth) {
          buttonGapToUse -= amountToReduceWidth / (numberOfVisibleComponents - 1);
          amountToReduceWidth = 0;
        } else {
          buttonGapToUse = 0;
          amountToReduceWidth -= (numberOfVisibleComponents - 1) * this.componentGap;
        }
        // now shrink the button size itself as a last resort
        if (amountToReduceWidth > 0) {
          widthToUse = parentWidth / numberOfVisibleComponents;
        }
      }
    }

    // height shrinking - toUse values are used for final layout bounds setting step
    int topInsetToUse = this.insets.top;
    int amountToReduceHeight = this.preferredHeight - parentHeight;
    if (amountToReduceHeight > 0) {
      // we need to save some pixels...
      // check for top/bottom insets
      if (topInsetToUse + this.insets.bottom >= amountToReduceHeight) {
        int reduceInsetBy = amountToReduceHeight / 2;
        topInsetToUse -= reduceInsetBy;
      } else {
        topInsetToUse = 0;
      }
    }

    // finally size and place the components
    int x = parentInsets.left + leftInsetToUse;
    // alignment is only relevant if we have enough space
    if (parentWidth > this.preferredWidth) {
      if (this.alignment == ALIGN_CENTER) {
        x += (parentWidth - this.preferredWidth) / 2;
      } else if (this.alignment == ALIGN_RIGHT) {
        x += parentWidth - this.preferredWidth;
      }
    }

    final int y = parentInsets.top + topInsetToUse;

    final int numberOfComponents = parent.getComponentCount();
    for (int i = 0; i < numberOfComponents; i++) {
      Component c = parent.getComponent(i);
      if (c.isVisible()) {
        c.setBounds(x, y, widthToUse, heightToUse);
        x += widthToUse + buttonGapToUse;
      }
    }
  }

  private static int getNumberOfVisibleComponents(final Container parent) {
    final int numberOfComponents = parent.getComponentCount();
    int numberOfVisibleComponents = 0;

    for (int i = 0; i < numberOfComponents; i++) {
      Component c = parent.getComponent(i);
      if (c.isVisible()) {
        numberOfVisibleComponents++;
      }
    }

    return numberOfVisibleComponents;
  }
}

Eine Swing-Komponente – JVM-Memory-Indicator

 Java, Swing  Kommentare deaktiviert für Eine Swing-Komponente – JVM-Memory-Indicator
Feb 242018
 

Ich entwickle grafische Oberflächen in Java Swing seit der Zeit, als man Swing noch separat herunterladen musste und es noch im Package com.sun.java.swing wohnte. JDK 1.1. In JDK 1.0.2 hat man sich kurz AWT angeschaut, gelacht und es zu den Akten gelegt. Swing hingegen war ein seriöser Versuch eines leistungsfähigen und trotzdem plattformübergreifenden UI-Toolkits.

Drei Dinge jenseits von Java SE braucht der Swing-Entwickler bis heute: Komponenten, Layout-Manager und ggf. ein Application Framework. Neulich war ich auf der Suche nach einer kleinen schmalen Komponente für eins meiner zahlreichen Swing-basierten Inhouse-Tools, um den Zustand der JVM-Speicherverwaltung zu signalisieren, ähnlich wie Eclipse es standardmäßig anbietet wenn man es aktiviert unter “Window -> Preferences -> Global -> Show heap status”.

Als erfahrener Googler hätte ich erwartet, eher ein Problem mit zuviel als zuwenig Auswahl zu haben. Aber Pustekuchen: letztlich fand ich nur eine Frage auf StackOverflow (witzigerweise wenige Stunden nach meiner Antwort als off-topic geschlossen – und das bei einer Frage von 2009!) nach einer solchen Komponente, die lediglich zwei komplett falsche Antworten der Kategorie “Thema verfehlt” nach sich zog. Also habe ich mir mal eine Stunde Zeit genommen, um mit minimalem Aufwand eine solche Komponente zu bauen. Als Basis habe ich JProgressBar verwendet. Das Ergebnis ist natürlich weit weg von der wünschenswerten Flexibilität einer solchen Komponente, wenn sie in unterschiedlichen Kontexten wiederverwendbar sein soll, aber als ein schönes einfaches Beispiel taugt es dennoch. Die Komponente ist lizenztechnisch frei verwendbar allüberall. Eigene Anpassungen ausdrücklich erwünscht. i18n-Unterstützung, MiB vs. MB, Text und Tooltip über extern vorgebbare Texte mit Platzhaltern realisieren, ein “Trash”-Icon zum Auslösen des GC anstatt der nichtoffensichtlichen Doppelclick-Variante, eine “Mark”-Funktionalität ähnlich Eclipse – die Erweiterungsideen sind beinahe endlos.

/*
 * (c) hubersn Software
 * www.hubersn.com
 * 
 * Use wherever you like, change whatever you want. It's free!
 */
package com.hubersn.playground.swing;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.JProgressBar;
import javax.swing.Timer;

/**
 * JVM Memory Indicator based on JProgressBar.
 */
public class ProgressBarBasedJVMMemoryIndicator extends JProgressBar {

  private static final long serialVersionUID = 1L;

  private static final int TIMER_INTERVAL_IN_MS = 1000;

  /**
   * Creates a new instance of ProgressBarBasedJVMMemoryIndicator.
   */
  public ProgressBarBasedJVMMemoryIndicator() {
    super(0, 100);
    setStringPainted(true);
    setString("");
    addMouseListener(new MouseAdapter() {
      @Override
      public void mouseClicked(final MouseEvent mev) {
        if (mev.getClickCount() == 2) {
          System.gc();
          update();
        }
      }
    });
    final Timer t = new Timer(TIMER_INTERVAL_IN_MS, new ActionListener() {
      @Override
      public void actionPerformed(final ActionEvent aev) {
        update();
      }
    });
    t.start();
    update();
  }

  private void update() {
    final Runtime jvmRuntime = Runtime.getRuntime();
    final long totalMemory = jvmRuntime.totalMemory();
    final long maxMemory = jvmRuntime.maxMemory();
    final long usedMemory = totalMemory - jvmRuntime.freeMemory();

    final long MEBIBYTE_FACTOR = 1024 * 1024;
    final long totalMemoryInMebibytes = totalMemory / MEBIBYTE_FACTOR;
    final long maxMemoryInMebibytes = maxMemory / MEBIBYTE_FACTOR;
    final long usedMemoryInMebibytes = usedMemory / MEBIBYTE_FACTOR;
    final int usedPercentage = (int) ((100 * usedMemory) / totalMemory);
    final String textToShow = usedMemoryInMebibytes + "MiB of " + totalMemoryInMebibytes + "MiB";
    final String toolTipToShow = "Heap size: " + usedMemoryInMebibytes + "MiB of total: " + totalMemoryInMebibytes + "MiB max: "
        + maxMemoryInMebibytes + "MiB - double-click to run Garbage Collector";

    setValue(usedPercentage);
    setString(textToShow);
    setToolTipText(toolTipToShow);
  }
}

Aus mir unerfindlichen Gründen habe ich danach angefangen, eine superflexible, i18n-fähige, effiziente, JComponent-basierte Variante davon zu bauen. Hat auch nicht viel länger gedauert. Soll “demnächst” im Rahmen meiner ultimativen Swing-Bibliothek das Licht der Welt erblicken – das soll diese Bibliothek aber schon seit ungefähr 2001…

Beknackte Oberflächen – heute: Toshiba 32XV733G

 UI  Kommentare deaktiviert für Beknackte Oberflächen – heute: Toshiba 32XV733G
Jan 282018
 

Wer es nicht gleich an der Typenbezeichnung erkannt hat: es soll heute um ein kleines Detail der Benutzungsoberfläche eines Fernsehers gehen. Ein Fernseher nach altem Schrot und Korn, kein “Smart TV” oder sowas. 32″-LCD Standardtechnologie ohne Schnick und Schnack.

In einem heroischen Versuch, die Bedienung für das elterliche Gerät etwas einfacher zu gestalten, habe ich die Eingänge “beschriftet”, also mit einer sprechenderen Bezeichnung als “Input 1″ oder HDMI 3” versehen.

Texteingabe mit einer Standard-Fernsehfernbedienung ist natürlich immer mühsam, egal wie man das technisch löst (Grundig hatte bei einem S-VHS-Topmodell mal eine komplette Tastatur auf der Rückseite der Fernbedienung untergebracht – das war eine seriöse Lösung!). Texteingabe ohne volle Tastatur ist immer eine Kompromisslösung. Der ist diesmal gar nicht so schlecht gelungen, man kann “umschalten” zwischen Groß- und Kleinbuchstaben sowie Ziffern und Sonderzeichen. Amüsanterweise kann man dann über eine andere Farbtaste noch Sonder-Sonderzeichen wie Umlaute einblenden. “Häh”, denkt sich da der gemeine Benutzer – aber egal. Wer schon mal bei einem Yamaha-Receiver die Eingänge mit Text versehen wollte, wird die Toshiba-Lösung für das Allerbeste halten.

Jedenfalls wollte ich einen Eingang mit dem Text “Blu-Ray-Recorder” versehen (lobenswertes Detail am Rande: es gibt die Möglichkeit, vorgefertigte Texte zu verwenden wie “Receiver” oder “DVD” – sehr gut mitgedacht, Toshiba!). Mühsam eingetippt. Bestätigt mit der blauen Farbtaste (warum? In anderen Teilen des Menüs sind es andere Tasten). Das Gerät erfreut mich mit der Meldung, dass nur maximal 10 Zeichen Text erlaubt sind.

Tja…das Gerät ist von 2010, da war so fortschrittliche UI-Technologie wie ein längenbeschränktes Eingabefeld natürlich noch unbekannt.

Nun gut, in der Welt der Fernsehbedienung sicher nicht das allergrößte Problem der Benutzungsoberflächen. Wer mal ein paar Stunden damit verbracht hat, Sender nach einem Sendersuchlauf in eine sinnvolle Reihenfolge zu bringen wird wissen, dass es noch viel größere Ergonomiekatastrophen gibt – ich hätte schon lange einen Artikel darüber verfasst, aber das Thema macht mich depressiv. Nicht mal ein positiver Artikel zur Sendersortierung beim Macrosystem Enterprise wollte meiner Feder entspringen. Vielleicht irgendwann…

Oracle und VisualVM

 Java  Kommentare deaktiviert für Oracle und VisualVM
Dez 302017
 

Eines meiner Lieblings-Java-Tools ist die VisualVM – vor wenigen Tagen wurde Version 1.4 released, mit offiziellem Java 9-Support. Die Vorgänger-Version 1.3.9 funktionierte schon leidlich mit Java 9, aber “offiziell” ist bekanntlich immer besser.

Und das führt uns zum traurigen Teil der Geschichte, nämlich Oracle’s Entscheidung, JDK 9 ohne die VisualVM auszuliefern (neben der grandiosen Idee, die bisher per Definition in ISO-8859-1 vorliegenden .properties-Dateien einfach mal in UTF-8 zu lesen, sicher die schlechteste). Und das ohne vernünftigen Ersatz – Java Mission Control hat bekanntlich eine üble Lizenzeinschränkung bezüglich kommerziellem Einsatz, und die gute alte JConsole ist eben genau das – alt. Mit VisualVM war es schön einfach, selbst unbedarfte User “mal schnell” einen Heapdump oder Threaddump ziehen zu lassen. Vorbei.

Immerhin ist die Version 1.4 ein Lebenszeichen, ich hatte schon Schlimmeres befürchtet. Der Hinweis, dass 1.4 nun auf der NetBeans-Plattform Version 9 basiert (wenn auch einer Entwicklungsversion), ist gleichzeitig auch ein Lebenszeichen von NetBeans, das bekanntlich vor einiger Zeit von Oracle zu Apache gewechselt ist – seither hoffen alle, dass das besser läuft als bei OpenOffice. NetBeans 8.2 war ja von Oktober 2016, seither waren die News eher sparsam. Ich bin zar nie mit NetBeans warm geworden, aber etwas Konkurrenz tut sowohl Eclipse als auch IntelliJ immer gut.

Amüsantes Detail aus den Release Notes von VisualVM 1.4: Windows 10 ist offenbar keine unterstützte Plattform…

Frohes Fest, guten Rutsch

 Uncategorized  Kommentare deaktiviert für Frohes Fest, guten Rutsch
Dez 252017
 

2017 war ein eher sparsames Blog-Jahr in meiner IT-Abteilung. Gewisse Dinge in der IT frustrieren mich zunehmend. Sei es die beinahe grenzenlose Naivität gewisser Teile der agilen Bewegung, die Entscheidung von eBay einen unglaublich schlechten automatischen Übersetzungsmechanismus für Angebote aus dem Ausland einzusetzen (natürlich nicht abschaltbar), die unentwegte Ankündigung des autonomen Fahrens ohne auch nur die grundlegenden Probleme KI-technisch im Griff zu haben, das ständige Erfinden neuer Programmiersprachen mit denselben alten Schwächen ohne aus der Historie zu lernen, die Unfähigkeit von Windows einfach nur eine Menge Dateien unfallfrei zu kopieren (unbedingt lesen: der Fehler 0x80070057)…aber man kann doch nicht jede Woche einen Abkotzartikel schreiben. Das macht doch schlechte Stimmung.

Vielleicht bin ich im neuen Jahr ja erfolgreicher beim Aufstöbern von positiven Entwicklungen im IT-Bereich. Die Hoffnung stirbt zuletzt (aber sie stirbt…) – immerhin hat die IT noch nicht den Frustfaktor der Politik erreicht.