from javafx.scene.control import Button not working as expected

[vsquared]

Any idea why this syntax works for some things and not for others?

# Uses Imported mode for py5

from javafx.scene.control import Button

def setup():
    global root,btn
    
    size(300, 200, FX2D)
    window_title('JavaFX Button Demo')
    canvas = get_surface().get_native()
    root = canvas.getParent()
    btn = Button('Push Me')
    root.getChildren().add(btn)

Error message:

[hx2A]

How are you running this? What version of py5 are you using?

[vsquared]

Should be the latest version of py5; I used Thonny to update it.

[hx2A]

I just did some experimenting and I don't see why that doesn't work. Is there some extra initialization that must be done for this control to work? If so, I'll add it to the code.

[vsquared]

Is there some extra initialization that must be done for this control to work?
This is what I currently have to do to get it to work:

# Uses Imported mode for py5

# Need something up here to load javafx
import javafx.scene.Scene

def setup():
    global pane,btn
    
    size(300, 200, FX2D)
    window_title('JavaFX Button')
    canvas = get_surface().get_native()
    pane = canvas.getParent()
    btn = javafx.scene.control.Button('Push Me')
    pane.getChildren().add(btn)

[hx2A]

So import javafx.scene.Scene is necessary for that to work? What if you just did import javafx or import javafx.scene?

[vsquared]

What if you just did import javafx or import javafx.scene?
Both of those work too. I like 'import javafx' because it's simple and less complicated than trying to remember to add '.scene' or '.scene.Scene', but still have to use 'btn = javafx.scene.control.Button('Push Me')' instead of just 'btn = Button()'.

[GoToLoop]

Finally found a workaround to import problematic JavaFX classes:

import py5

# Class loader for problematic Java imports:
from java.lang import ClassLoader, String # type: ignore[reportMissingImports]
AppClassLoader = ClassLoader.getSystemClassLoader()

# Workaround for "from javafx.scene.control import Button":
ButtonConstructor = AppClassLoader.loadClass(
    "javafx.scene.control.Button").getConstructor(String)

def setup():
    py5.size(300, 200, py5.FX2D)
    py5.window_title('JavaFX Button')

    canvas = py5.get_surface().get_native()
    pane = canvas.getParent()
    pane_nodes = pane.getChildren()

    btn = ButtonConstructor.newInstance('Push Me')
    pane_nodes.add(btn)


py5.run_sketch()

I had to resort to reflection to get JavaFX Button's constructor, so it can be instantiated later.
But now, in order to instantiate it, we've gotta call method newInstance() though.

[vsquared]

@GoToLoop
Thank you for the workaround using AppClassLoader and ButtonConstructor. To me the bottleneck is in JPype for reasons I do not understand. I looked in jpype/imports.py and interestingly the following demo works. The Thonny editor will take 'import javafx.scene.control' without error but as soon as '.Button' is added it balks. Yet we got by just fine with 'from javafx.scene.web import WebView'. According to forms supported in jpype/imports.py 'from javafx.scene.control import Button' should work. Other than class Button and class WebView being in different jar files what's the difference? So far, it appears to be just a problem with Button. See Media Player thread; no problem there.

import javafx.scene.control as ctrls

def setup():
    global pane,btn
    
    size(300, 200, FX2D)
    window_title('JavaFX Button')
    canvas = get_surface().get_native()
    pane = canvas.getParent()
    print(ctrls.Button)
    btn = ctrls.Button('Push Me')
    pane.getChildren().add(btn)


"""
Taken from jpype/imports.py
Forms supported:
   - **import <java_pkg> [ as <name> ]**
   - **import <java_pkg>.<java_class> [ as <name> ]**
   - **from <java_pkg> import <java_class>[,<java_class>*]**
   - **from <java_pkg> import <java_class> [ as <name> ]**
   - **from <java_pkg>.<java_class> import <java_static> [ as <name> ]**
   - **from <java_pkg>.<java_class> import <java_inner> [ as <name> ]**

"""

Addendum:
Please look at the MediaPlayer demo in other thread for imports which work as expected:
#657

[hx2A]

Finally found a workaround to import problematic JavaFX classes

Nice, good job. I wonder why this is necessary. Does that Button class have multiple constructors? Is jpype somehow getting confused about which constructor should be used?

[GoToLoop]

Is jpype somehow getting confused about which constructor should be used?

It simply crashes if we do from javafx.scene.control import Button before size()!

Furthest we can reach is from javafx.scene import control.

Some JavaFX classes can't be imported using jpype before FX2D renderer is properly initialized.

My workaround uses Java's own ClassLoader.getSystemClassLoader().loadClass() in order to get a global class reference.

[vsquared]

@GoToLoop
It simply crashes if we do from javafx.scene.control import Button before size()!
This validates your findings:

def setup():
  size(400,200,FX2D)
  from javafx.scene.control import Button
  window_title('JavaFX Button in Default Window')
  canvas = get_surface().get_native()
  root = canvas.getParent()
  btn = Button('Push Me')
  root.getChildren().add(btn)

[vsquared]

Another observation: An exception only seems to be thrown with actual controls in javafx.scene.control. Consider the following code; anything which is an actual control fails while dialog, menu, event classes get by:

from javafx.scene.control import Menu
from javafx.scene.control import Dialog
from javafx.scene.control import SortEvent
from javafx.scene.control import CheckMenuItem
from javafx.scene.control import CheckBoxTreeItem
# fails
# from javafx.scene.control import ProgressIndicator
# fails
# from javafx.scene.control import Label
# fails
# from javafx.scene.control import Cell
#fails
# from javafx.scene.control import Control
#fails
# from javafx.scene.control import ListView
# fails
# from javafx.scene.control import PasswordField
#fails
# from javafx.scene.control import MenuButton
#fails
# from javafx.scene.control import ScrollBar
#fails
# from javafx.scene.control import Slider
#fails
# from javafx.scene.control import Spinner
#fails
# from javafx.scene.control import ChoiceBox
#fails
# from javafx.scene.control import Button

[GoToLoop]

Another workaround: Implement a java_imports() which can be invoked after size():

#!/usr/bin/env python

import py5

def setup():
    py5.size(300, 200, py5.FX2D)
    py5.window_title('JavaFX Button')

    canvas = py5.get_surface().get_native()
    pane = canvas.getParent()
    pane_nodes = pane.getChildren()

    Button, = java_imports("javafx.scene.control", "Button")

    btn = Button('Push Me')
    pane_nodes.add(btn)


def java_imports(jfrom: str, *jimports: str):
    return tuple(py5.JClass(f"{jfrom}.{jclass}") for jclass in jimports)


py5.run_sketch()

[vsquared]

Creates a new syntax for calling javafx control imports; and succinct to boot. The comma after 'Button' is a little confusing and at first glance looks like a typo, but Thonny won't run the demo without it (not sure why it's required). The only downside I see is teaching a student how to do that tuple, but if it's boilerplate code all the user has to do is copy/paste. Alternatively the developer could make that function a part of the runtime so that all the programmer has to do is call it (preferably without the comma).

Addendum: Comma required for one-item tuple?

[GoToLoop]

Addendum: Comma required for one-item tuple?

The trailing comma is for unpacking the single JClass from the returning tuple.

Alternatively, we can explicitly get the index [0] from the tuple:

Button = late_java_imports("javafx.scene.control", "Button")[0]

The reason it returns a tuple is b/c we can pass multiple *jimports arguments to get them imported from the same package path (jfrom), like I did for the other example:

Label, Button, Slider, Spinner = java_imports("javafx.scene.control", "Label", "Button", "Slider", "Spinner")

The only downside I see is teaching a student how to do that tuple,

We can return a list if you'd prefer:

return [py5.JClass(f"{jfrom}.{jclass}") for jclass in jimports]

However, that won't change how we can unpack it. Lists and tuples are pretty much the same.

B/c the returning comprehension isn't supposed to be modified, I've picked a tuple over a list.

[vsquared]

Another workaround (until JPype can be fixed, assuming that is even possible) is to call the imports from a separate function after the renderer and window has been setup. Only downside that I see is that they all have to be 'global', otherwise it's no more code but does require a new app code structure.

def loadImports():
  global Button,Slider,Spinner,Label, VBox, Font, FontWeight
  
  from javafx.scene.control import Button, Label, Slider, Spinner
  from javafx.scene.text import Font, FontWeight
  from javafx.scene.layout import VBox
  
def setup():
  size(500,200,FX2D)
  window_title('JavaFX Controls in Default Window')
  canvas = get_surface().get_native()
  root = canvas.getParent()
  loadImports()
  btn = Button('Push Me')
  slider = Slider(0,100,25)
  label = Label("These controls all came from javafx.scene.control")
  font = Font.font("Menlo",  15)
  label.setFont(font)
  spinner = Spinner(0,100,25)
  spinner.setPrefSize(70, 25)
  vbox = VBox()
  vbox.setSpacing(30)
  vbox.getChildren().addAll(label,btn,slider,spinner)
  root.getChildren().add(vbox)

Output:

[GoToLoop]

Re-wrote it to use java_imports() in load_imports() to replace from...import...:

#!/usr/bin/env python

import py5

def java_imports(jfrom: str, *jimports: str):
    return tuple(py5.JClass(f"{jfrom}.{jclass}") for jclass in jimports)


def load_imports():
    global Label, Button, Slider, Spinner

    Label, Button, Slider, Spinner = java_imports("javafx.scene.control",
        "Label", "Button", "Slider", "Spinner")


VBox, = java_imports("javafx.scene.layout", "VBox")
Font, = java_imports("javafx.scene.text", "Font")

def setup():
    py5.size(500, 200, py5.FX2D)
    py5.window_title('JavaFX Button Controls in Default Window')

    load_imports()

    canvas = py5.get_surface().get_native()
    pane_root = canvas.getParent()
    pane_node_children = pane_root.getChildren()

    label = Label('These controls all came from javafx.scene.control')
    print(font := Font("DejaVu Sans Mono", 15))
    label.setFont(font)

    btn = Button('Push Me')
    slider = Slider(0, 100, 25)

    spinner = Spinner(0, 100, 25)
    spinner.setPrefSize(70, 25)

    vbox = VBox(30, label, btn, slider, spinner)
    pane_node_children.add(vbox)


py5.run_sketch()

So I don't need to add # type: ignore[reportMissingImports] for each Java import on VSCode.

EDIT: Moved up VBox & Font to invoke java_imports() globally, before size().

[vsquared]

So I don't need to add # type: ignore[reportMissingImports] for each Java import on VSCode.
Is that what you had to do for the demo I posted? Good to test in multiple editors. Runs ok in Thonny as does your revision.