Debughilfe

[White_Fox]

Guten Abend allerseits.

Ich beschäftige mich nach einer kleinen Pause mal wieder mit meinem jCLS-Projekt und hänge vor einem Problem, das ich partout nicht verstehe. Vielleicht kommt eine unverbrauchte Seele da eher drauf als ich...findet jemand das Problem?


Das Problem äußert sich folgendermaßen:
Ich habe einige Tutorials in mein Programm eingebaut, die den Benutzer durch das Programm führen und die Bedienung erklären.
Man öffne das Hilfe-Menü > Tutorium > Erste Schritte. Es öffnet sich ein neues Fenster mit etwas Text zum Lesen und drei Buttons: "Zurück", "Abbrechen", "Weiter". Man klicke ein paar Mal auf "Weiter". Ein paar Mal klicken, und der Weiterbutton ist ausgegraut - an dieser Stelle soll der Benutzer eine Aufgabe erledigen. Zwischendurch hat sich der linke Teil des Fensters farblich etwas geändert - dem Benutzer soll so klargemacht werden, worauf er seine Aufmerksamkeit richten soll.

Nun öffne man im eingefärbtem Bereich das Kontextmenü mit einem Rechtsklick. Der Menüeintrag, den der Benutzer nun anklicken soll, ist ebenfalls eingefärbt.

Soweit funktioniert alles so, wie es soll.

Nun erledigt der Benutzer die Aufgabe (erstellt eine neue Bibliothek), und kann wieder auf "Weiter" klicken und die nächste Aufgabe wartet. Jetzt soll der Benutzer wieder das Rechtsklickmenü an besagter Stelle öffnen und ein anderer Menüeintrag soll farblich abgehoben werden - und genau das passiert merkwürdigerweise nicht.



Im Programm funktioniert es so (oder soll so funktionieren):
Es gibt eine Klasse VcPlayerMaster. Diese Klasse klinkt sich in die View und den Controller ein und übernimmt in beiden Klassen verschiedene Steuerfunktionen. Den verschiedenen Viewelementen kann ein VcPlayerMaster-Objekt über ein Interface Befehle erteilen (Enum SlaveCommand), worauf hin diese z.B. diese Umfärbung vornehmen.
Außerdem klinkt sich das VcPlayerMasterobjekt in den Controller ein und prüft die Kommandos, die von der View hereinkommen. Soll der Benutzer eine Aufgabe erledigen und macht stattdessen irgendwelchen Blödsinn, werden die Kommandos einfach verworfen.

Das Kontextmenü, um das es hier geht, ist die Klasse LibrarybrowserConextmenu. Diese ist so ein eigenständiges Viewelement, das von einem VcPlayerMasterobjekt direkt befehligt werden kann. Das Umfärben selbst geschieht dadurch, daß einem MenuItem einfach eine neue StyleClass übergebügelt wird. Um das Umfärben rückgängig zu machen werden einfach alle MenuItems neu erstellt (es scheint da leider einen Bug mit der Clearmethode zu geben, und ich will nicht die vollständige Styleklasse von MenuItem mit der Vererbungshierarchie zusammenpuzzeln, das ist leider nicht gerade wenig).

Die Methode, die vom VcPlayerMasterobjekt aufgerufen wird ist die hier (Klasse LibrarybrowserContextmenu ab Zeile 224):

@Override
public void receiveCommand(SlaveCommand... sCommands) {
    for (SlaveCommand command : sCommands) {
        switch (command) {
            case CLEAR:
                rebuildMenu();    //Cause a bug in clearing style class, we renew simply all menu items.
                break;
            case MARK_NEW_LIBRARY_COMMAND:
                miNewLibrary.getStyleClass().add("distinct-menu-item");
                break;
            case MARK_NEW_LIBRARYPAGE_COMMAND:
                miNewLibrarypage.getStyleClass().add("distinct-menu-item");
                break;
            default:
        }
    }
}

Ich habe mal in alle drei Cases einen Breakpoint gesetzt, und alle Cases werden in der erwartete Reihenfolge angegangen. Es haut mir auf jeden Fall kein CLEAR ungewollt dazwischen oder so. Es ist einfach so, als ob der Ausdruck miNewLibrarypage.getStyleClass().add("distinct-menu-item"); schlicht nicht ausgefürt wird - angesprungen wird er jedenfalls.

Was mir jedoch aufgefallen ist (und was ich mir genauso wenig erklären kann): Erledigt man die erste Aufgabe und klickt auf "Zurück", ist die Einfärbung wieder raus (so soll es auch sein). Klickt man jedoch wieder auf "Vorwärts", so müßte die erste MenuItemmarkierung (die ja im normalen Durchlauf funktioniert), auch wieder da sein - sie bleibt aber weg.
Es ist so, als ob ich nur ein einziges Mal ein MenuItem umfärben könnte. Wenn man das Tutorial abbricht und neu startet, wird auch das erste (zunächst funktionierende) MenuItem nicht mehr eingefärbt. Ich habe keine Ahnung, warum.

Aber: das folgende funktionionert auch:

case MARK_NEW_LIBRARY_COMMAND:
    miNewLibrary.getStyleClass().add("distinct-menu-item");
    rebuildMenu();
    miNewLibrary.getStyleClass().add("distinct-menu-item");
    break;

Soll heißen: Elemente mehrmals umfärben ist eigentlich kein Problem.

Danke schonmal für die Kenntnisnahme bis hierher. Hat irgendjemand eine Idee, was das Problem sein könnte? Ich habe absolut keine Idee mehr.

Der aktuelle Quellcode ist hier: https://sourceforge.net/projects/jcls/files/jCLS debug discussion.zip/download

 

[White_Fox]

Schade...weiß keiner Rat?

Ich habe, um mal die Komplexität etwas herauszunehemen, das Problem mal in einem eigenen kleinen Projekt isoliert, das macht es deutlich übersichtlicher. Das Problem besteht jedenfalls nicht in meinem Programm an sich - das funktioniert anscheinend genauso, wie ich es will.
Aber wahrscheinlich hab ich da irgendeine Wissenslücke über JavaFX und wende da etwas falsch an.

Die folgenden Klassen bilden ein kleines Fenster mit einem Button und einem Kontextmenü. Wenn der Button angeklickt wird, soll das jeweils andere Item umgefärbt werden. Aber: wie auch in meinem Programm funktioniert das genau einmal (und zwar auch nur beim Initialisieren am Anfang), danach nicht mehr.

Da sind die Klassen:

public class JavaFXCSSTest extends Application {
    SomeContextMenu contextMenu;
    
    @Override
    public void start(Stage primaryStage) {
        String css;
        
        contextMenu = new SomeContextMenu();
        
        Button btn = new Button();
        btn.setText("Item umschalten");
        btn.setOnAction(new EventHandler<ActionEvent>() {
            
            @Override
            public void handle(ActionEvent event) {
                contextMenu.changeColorState();
            }
        });
        
        StackPane root = new StackPane();
        root.getChildren().add(btn);
        root.setOnContextMenuRequested(new EventHandler<ContextMenuEvent>(){
            @Override
            public void handle(ContextMenuEvent event) {
                contextMenu.show(root, event.getScreenX(), event.getScreenY());
            }
        });
        
        Scene scene = new Scene(root, 300, 250);
        scene.getStylesheets().clear();
        css = "Modenastyle.css";
        scene.getStylesheets().add(css);
        
        primaryStage.setTitle("Kontextmenü CSS Test");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        launch(args);
    }   
}


public class SomeContextMenu extends ContextMenu {
    private enum State{
        STATE1,
        STATE2
    }
    
    private MenuItem item1;
    private MenuItem item2;
    private State state;

    public SomeContextMenu() {
        state = State.STATE1;
        rebuildMenu();
        changeColorState();
    }
    
    private void rebuildMenu(){
        item1 = new MenuItem("Item 1");
        item1.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                event.consume();
            }
        });
        item2 = new MenuItem("Item 2");
        item2.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                event.consume();
            }
        });
        
        getItems().clear();
        getItems().addAll(item1, item2);
    }
    
    public void changeColorState(){
        rebuildMenu();
        switch(state){
            case STATE1:
                item1.getStyleClass().add("distinct-menu-item");
                break;
            case STATE2:
                item2.getStyleClass().add("distinct-menu-item");
                break;
        }
    }
}

Ach ja, und die zugehörige CSS-Datei. Sie enthält eigentilch nur die Farbdefinition des originalen JavaFX-CSS plus zwei oder drei weiterer Farben und die Styleklasse für Menuitems.

/*/////////////////////////////////////////////////////////////////////////////
//                        A light weight light theme,                        //
//         inspired by the JavaFX Modena style, but much more easier.        //
//               Includes some special formats for excanchges.               //
/////////////////////////////////////////////////////////////////////////////*/

.root{
    /*//////////////////////////////////
    //                                //
    //    Standard colors for elements  //
    //                                //
    //////////////////////////////////*/
    
    /* A light grey that is the base color for objects.  Instead of using
     * -fx-base directly, the sections in this file will typically use -fx-color.
     */
    -fx-base: #ececec;

    /* A very light grey used for the background of windows.  See also
     * -fx-text-background-color, which should be used as the -fx-text-fill
     * value for text painted on top of backgrounds colored with -fx-background.
     */
    -fx-background: derive(-fx-base,26.4%);

    /* Used for the inside of text boxes, password boxes, lists, trees, and
     * tables.  See also -fx-text-inner-color, which should be used as the
     * -fx-text-fill value for text painted on top of backgrounds colored
     * with -fx-control-inner-background.
     */
    -fx-control-inner-background: derive(-fx-base,80%);
    /* Version of -fx-control-inner-background for alternative rows */
    -fx-control-inner-background-alt: derive(-fx-control-inner-background,-2%);

    /* One of these colors will be chosen based upon a ladder calculation
     * that uses the brightness of a background color.  Instead of using these
     * colors directly as -fx-text-fill values, the sections in this file should
     * use a derived color to match the background in use.  See also:
     *
     * -fx-text-base-color for text on top of -fx-base, -fx-color, and -fx-body-color
     * -fx-text-background-color for text on top of -fx-background
     * -fx-text-inner-color for text on top of -fx-control-inner-color
     * -fx-selection-bar-text for text on top of -fx-selection-bar
     */
    -fx-dark-text-color: black;
    -fx-mid-text-color: #333;
    -fx-light-text-color: white;

    /* A bright blue for highlighting/accenting objects.  For example: selected
     * text; selected items in menus, lists, trees, and tables; progress bars */
    -fx-accent: #0096C9;

    /* Default buttons color, this is similar to accent but more subtle */
    -fx-default-button: #ABD8ED;

    /* A bright blue for the focus indicator of objects. Typically used as the
     * first color in -fx-background-color for the "focused" pseudo-class. Also
     * typically used with insets of -1.4 to provide a glowing effect.
     */
    -fx-focus-color: #039ED3;
    -fx-faint-focus-color: #039ED322;

    /* The color that is used in styling controls. The default value is based
     * on -fx-base, but is changed by pseudoclasses to change the base color.
     * For example, the "hover" pseudoclass will typically set -fx-color to
     * -fx-hover-base (see below) and the "armed" pseudoclass will typically
     * set -fx-color to -fx-pressed-base.
     */
    -fx-color: -fx-base;

    /* Chart Color Palette */
    CHART_COLOR_1: #f3622d;
    CHART_COLOR_2: #fba71b;
    CHART_COLOR_3: #57b757;
    CHART_COLOR_4: #41a9c9;
    CHART_COLOR_5: #4258c9;
    CHART_COLOR_6: #9a42c8;
    CHART_COLOR_7: #c84164;
    CHART_COLOR_8: #888888;
    /* Chart Color Palette Semi-Transparent
     * These are used by charts that need semi transparent versions of the above colors, such as BubbleChart. They
     * are exactly the same colors as above just with alpha
     *
     * 20% opacity
     */
    CHART_COLOR_1_TRANS_20: #f3622d33;
    CHART_COLOR_2_TRANS_20: #fba71b33;
    CHART_COLOR_3_TRANS_20: #57b75733;
    CHART_COLOR_4_TRANS_20: #41a9c933;
    CHART_COLOR_5_TRANS_20: #4258c933;
    CHART_COLOR_6_TRANS_20: #9a42c833;
    CHART_COLOR_7_TRANS_20: #c8416433;
    CHART_COLOR_8_TRANS_20: #88888833;
    /* 70% opacity */
    CHART_COLOR_1_TRANS_70: #f3622db3;
    CHART_COLOR_2_TRANS_70: #fba71bb3;
    CHART_COLOR_3_TRANS_70: #57b757b3;
    CHART_COLOR_4_TRANS_70: #41a9c9b3;
    CHART_COLOR_5_TRANS_70: #4258c9b3;
    CHART_COLOR_6_TRANS_70: #9a42c8b3;
    CHART_COLOR_7_TRANS_70: #c84164b3;
    CHART_COLOR_8_TRANS_70: #888888b3;

    /***************************************************************************
     *                                                                         *
     * Colors that are derived from the main color palette.                    *
     *                                                                         *
     **************************************************************************/

    /* A little lighter than -fx-base and used as the -fx-color for the
     * "hovered" pseudoclass state.
     */
    -fx-hover-base: ladder(
        -fx-base,
        derive(-fx-base,20%) 20%,
        derive(-fx-base,30%) 35%,
        derive(-fx-base,40%) 50%
     );

    /* A little darker than -fx-base and used as the -fx-color for the
     * "armed" pseudoclass state.
     *
     * TODO: should this be renamed to -fx-armed-base?
     */
    -fx-pressed-base: derive(-fx-base,-6%);

    /* The color to use for -fx-text-fill when text is to be painted on top of
     * a background filled with the -fx-background color.
     */
    -fx-text-background-color: ladder(
        -fx-background,
        -fx-light-text-color 45%,
        -fx-dark-text-color  46%,
        -fx-dark-text-color  59%,
        -fx-mid-text-color   60%
    );

    /* A little darker than -fx-color and used to draw boxes around objects such
     * as progress bars, scroll bars, scroll panes, trees, tables, and lists.
     */
    -fx-box-border: ladder(
        -fx-color,
        black 20%,
        derive(-fx-color,-15%) 30%
    );

    /* Darker than -fx-background and used to draw boxes around text boxes and
     * password boxes.
     */
    -fx-text-box-border: ladder(
        -fx-background,
        black 10%,
        derive(-fx-background, -15%) 30%
    );

    /* Lighter than -fx-background and used to provide a small highlight when
     * needed on top of -fx-background. This is never a shadow in Modena but
     * keep -fx-shadow-highlight-color name to be compatible with Caspian.
     */
    -fx-shadow-highlight-color: ladder(
        -fx-background,
        rgba(255,255,255,0.07) 0%,
        rgba(255,255,255,0.07) 20%,
        rgba(255,255,255,0.07) 70%,
        rgba(255,255,255,0.7) 90%,
        rgba(255,255,255,0.75) 100%
      );

    /* A gradient that goes from a little darker than -fx-color on the top to
     * even more darker than -fx-color on the bottom.  Typically is the second
     * color in the -fx-background-color list as the small thin border around
     * a control. It is typically the same size as the control (i.e., insets
     * are 0).
     */
    -fx-outer-border: derive(-fx-color,-23%);

    /* A gradient that goes from a bit lighter than -fx-color on the top to
     * a little darker at the bottom.  Typically is the third color in the
     * -fx-background-color list as a thin highlight inside the outer border.
     * Insets are typically 1.
     */
    -fx-inner-border: linear-gradient(to bottom,
                ladder(
                    -fx-color,
                    derive(-fx-color,30%) 0%,
                    derive(-fx-color,20%) 40%,
                    derive(-fx-color,25%) 60%,
                    derive(-fx-color,55%) 80%,
                    derive(-fx-color,55%) 90%,
                    derive(-fx-color,75%) 100%
                ),
                ladder(
                    -fx-color,
                    derive(-fx-color,20%) 0%,
                    derive(-fx-color,10%) 20%,
                    derive(-fx-color,5%) 40%,
                    derive(-fx-color,-2%) 60%,
                    derive(-fx-color,-5%) 100%
                ));
    -fx-inner-border-horizontal: linear-gradient(to right, derive(-fx-color,55%), derive(-fx-color,-5%));
    -fx-inner-border-bottomup: linear-gradient(to top, derive(-fx-color,55%), derive(-fx-color,-5%));

    /* A gradient that goes from a little lighter than -fx-color at the top to
     * a little darker than -fx-color at the bottom and is used to fill the
     * body of many controls such as buttons.
     */
    -fx-body-color: linear-gradient(to bottom,
            ladder(
                -fx-color,
                derive(-fx-color,8%) 75%,
                derive(-fx-color,10%) 80%
            ),
            derive(-fx-color,-8%));
    -fx-body-color-bottomup: linear-gradient(to top, derive(-fx-color,10%) ,derive(-fx-color,-6%));
    -fx-body-color-to-right: linear-gradient(to right, derive(-fx-color,10%) ,derive(-fx-color,-6%));

    /* The color to use as -fx-text-fill when painting text on top of
     * backgrounds filled with -fx-base, -fx-color, and -fx-body-color.
     */
    -fx-text-base-color: ladder(
        -fx-color,
        -fx-light-text-color 45%,
        -fx-dark-text-color  46%,
        -fx-dark-text-color  59%,
        -fx-mid-text-color   60%
    );

    /* The color to use as -fx-text-fill when painting text on top of
     * backgrounds filled with -fx-control-inner-background.
     */
    -fx-text-inner-color: ladder(
        -fx-control-inner-background,
        -fx-light-text-color 45%,
        -fx-dark-text-color  46%,
        -fx-dark-text-color  59%,
        -fx-mid-text-color   60%
    );

    /* The color to use for small mark-like objects such as checks on check
     * boxes, filled in circles in radio buttons, arrows on scroll bars, etc.
     */
    -fx-mark-color: ladder(
        -fx-color,
        white 30%,
        derive(-fx-color,-63%) 31%
    );

    /* The small thin light "shadow" for mark-like objects. Typically used in
     * conjunction with -fx-mark-color with an insets of 1 0 -1 0. */
    -fx-mark-highlight-color: ladder(
        -fx-color,
        derive(-fx-color,80%) 60%,
        white 70%
    );

    /* Background for items in list like things such as menus, lists, trees,
     * and tables. */
    -fx-selection-bar: -fx-accent;

    /* Background color to use for selection of list cells etc. This is when
     * the control doesn't have focus or the row of a previously selected item. */
    -fx-selection-bar-non-focused: lightgrey;

    /* The color to use as -fx-text-fill when painting text on top of
     * backgrounds filled with -fx-selection-bar.
     *
     * TODO: this can be removed
     */
    -fx-selection-bar-text: -fx-text-background-color;

    /* These are needed for Popup */
    -fx-background-color: inherit;
    -fx-background-radius: inherit;
    -fx-background-insets: inherit;
    -fx-padding: inherit;

    /* The color to use in ListView/TreeView/TableView to indicate hover. */
    -fx-cell-hover-color: #cce3f4;

    /** Focus line for keyboard focus traversal on cell based controls */
    -fx-cell-focus-inner-border: derive(-fx-selection-bar,30%);

    /* The colors to use in Pagination */
    -fx-page-bullet-border: #acacac;
    -fx-page-indicator-hover-border: #accee5;

    -fx-focused-text-base-color : ladder(
        -fx-selection-bar,
        -fx-light-text-color 45%,
        -fx-dark-text-color 46%,
        -fx-dark-text-color 59%,
        -fx-mid-text-color 60%
    );
    -fx-focused-mark-color : -fx-focused-text-base-color ;

    /***************************************************************************
     *                                                                         *
     * Set the default background color for the scene                          *
     *                                                                         *
     **************************************************************************/

    -fx-background-color: -fx-background;
    
    
    /*/////////////////////////////////////
    //                                   //
    //    Colors for highlighted elements  //
    //                                   //
    /////////////////////////////////////*/

    -distinct-accent: #dbb229;

    /* *** Colors without modena pendant *** */
    
    -distinct-go-accent: #51db29;
    -distinct-border-color: #db5929;
}


/*////////////////////////////
//                          //
//    Context Menu Items    //
//                          //
////////////////////////////*/

.distinct-menu-item {
    -fx-background-color: -distinct-accent;
    -fx-border-color: -distinct-border-color;
}

.distinct-menu-item:hover{
    -fx-background-color: -distinct-go-accent;
}

Gibt es sowas wie eine repaint()-Methode, die ich vergessen habe aufzurufen? Nicht daß ich sowas nicht schon gesucht hätte...

 

[Thallius]

Du setzt state ja auch nie state auf einen anderen Wert als STATE1. Wie soll da sich was ändern?

 

[White_Fox]

Ah ja...das ist natürlich richtig, ich habs mal eben korrigiert. Danke.

Aber das ist nicht das eigentliche Problem.
Wenn es sonst funktionieren würde, würde das Item ja wieder eingefärbt werden, für den Benutzer würde sich genau gar nichts tun und das eine Item seine Styleklasse behalten.

Es ist aber so, daß die Items nicht mehr an die Styleklasse angepasst werden. Während am Anfang ein Element ocker/grün erscheint, erscheinen beide Elemente nach einem rebuild() und .getStyleClass.add() im ganz normalen Modenastil. Eigentlich sollte aber das andere Item ocker/grün werden.

Die geänderte Methode:

public void changeColorState(){
        rebuildMenu();
        switch(state){
            case STATE1:
                item1.getStyleClass().add("distinct-menu-item");
                state = State.STATE2;
                break;
            case STATE2:
                item2.getStyleClass().add("distinct-menu-item");
                state = State.STATE1;
                break;
        }
    }

 

[Thallius]

Also ich habe von Java fix keine Ahnung aber es würde mich wundern wenn da irgendwelche Farben bei einem Click geändert werden. Du machst ja gar nichts in den Even Händlern außer event.consume() aufzurufen.

 

[White_Fox]

Die Farbe soll auch im Event vom Button geändert werden. Dort wird die Methode zum ändern der Farben vom Contextmenu aufgerufen (das ist die, wo ich gerade den von dir bemerkten Fehler korrigiert habe). Dort sollen die Items erst neu erstellt und dann über eines eine neue Styleklasse drübergezogen werden.

Edit:
So isoliert betrachtet sieht die Struktur natürlich fragwürdig aus. Allerdings soll das Kommando zum Ändern der Styleklasse schon von einer externen Stelle kommen, und ich wollte das Beispiel kurz halten.

 

[Thallius]

Ok also nehmen wir mal an dein ChangeColorState wird durch einen Button Event aufgerufen (ich hoffe das hast du überprüft?) dann wird aber immer nur entweder item1 oder item2 die Klasse —distinC5-menu-item hinzugefügt. Das führt aber nur dazu, dass du nach 10 Klicks auf den Button 10x die gleiche klasse hinzugefügt hast. Wie denkst du soll sich denn dadurch irgendwas ändern?

 

[White_Fox]

Nun, in der Klasse SomeContextMenu gibt es für jedes MenuItem eine Instanzvariable, item1 und item2.

Bei Aufruf der rebuildMenu()-Methode werden beide MenuItemobjekte neu erstellt, anschließend werden alle bisherigen MenuItems, die das SomeContextMenuobjekt bereits hat, entfernt (getItems().clear();). Alle Items in dieser Liste sind damit GC-Futter (oder sollten es wenigstens sein).
Anschließend werden die neuen MenuItemobjekte item1 und item2 dem SomeContextMenuobjekt hinzugefügt (getItems().addAll(item1, item2);).

Ab hier sollte das Kontextmenü ganz normal aussehen, ohne speziell eingefärbte Einträge.

Danach wird - je nach Inhalt von state - item1 oder item2 eine neue Styleklasse mit anderen Farben hinzugefügt (Switchanweisung in der Methode changeColorState()). Jetzt müßte einer von beiden Menüeinträgen ocker/grün sein - aber das ist nicht der Fall. Ich habe es gerade nochmal getestet - die Methoden werden schon so angesprochen wie ich es erwarte. Nur das Ergebnis stimmt halt trotzdem nicht.

 

[Thallius]

Das ist auch keine gängige Vorgehensweise. Normalerweise sollten die Elemente nur einmal erstellt werden und dann änderst du halt den Zustand. Du kannst ja auch Klassen wieder rausnehmen und nicht Nur hinzufügen. Die Elemente bei jedem Button Klick neu zu erstellen ist jedenfalls komplett überflüssig

 

[White_Fox]

Ich wünschte es wäre so. Allerdings funktioniert das Ändern der Styleklasse für MenuItems in JavaFX nicht besonders gut, irgendwo gibt es da einen Bug. Der empfohlene Workaround wäre, für unterschiedliche Darstellungen unterschiedliche Styleklassen zu verwenden.

Das Problem dabei ist, das die Standardstyleklasse von MenuItem nicht so ohne Weiteres zu überschreiben ist bzw. das sonst sehr schnell ausufert.

Daher das Neuerstellen der Objekte...aber wenn es eine bessere Lösung gibt - immer her damit.

 

[Thallius]

Also meinem Verständnis nach müßtest du doch einfach eine css Klasse erstellen die nichts anderes macht als deine Farbe ändern. Diese fügst du dann mit getStyleClass().add() hinzu und nimmst sie entsprechend wieder mit getStyleClass().remove() wieder raus.

 

[White_Fox]

Ja...so sollte es sein. Und das funktioniert auch nicht...hab ich auch ausprobiert.

 

[White_Fox]

Ok...ich denke, ich hab das Problem, es scheint mit der (ich glaube mittlerweile doch sehr alten) JavaFX-Version zusammenzuhängen.

Jedenfalls habe ich es mal mit einer neueren JavaFX-Version (und einer neuen Version von Netbeans und überhaupt einer neuen Javaversion...) probiert und nun funktioniert es. Es sieht zwar noch etwas käsig aus, aber das hat wohl er was mit der schmalen CSS-Konfiguration zu tun.