Step two, setting up the project.

• Launch NetBeans.
• Choose File, New Project.
• Choose Java with Ant, Java Class Library.
• Name the project - for example DemoSkin. If you want to name the project for your own skin instead, like MySkin, change all references in the following instructions and in the attached source files to match that name.
• In the Projects pane, right-click DemoSkin, and choose Properties.
• Under Sources, go to Source/Binary Format, and choose JDK 14. This will make it possible for users of older versions of jAlbum to use the skin.
• Under Libraries, go to Java Platform, and choose JDK 23.
• Under Libraries, Compile, click the plus sign next to Classpath, choose Add JAR/Folder, navigate to C:\Program Files\jAlbum\lib and choose jalbum-core.jar.
• Click the plus sign next to Classpath again, choose Add JAR/Folder, navigate to C:\Program Files\Java\javafx-sdk-23\lib and choose javafx.graphics.jar.
• Under Build, Packaging, check both Compress JAR File and Build JAR after Compiling.
• OK out of Properties.
• In the Projects pane, right-click Source Packages and choose New, Java Class.
• Create a new Java class named DemoSkin and click Finish. Repeat, and create one named SkinModel.
• If you're also going to create a custom UI panel, i.e., a panel for applying some settings to individual images or folders, which appears on the right side when you're in "edit" mode for an image or folder, create two more new Java classes, one named DemoSkinCustom and one named SlideModel. For a real-world example of a custom UI, see https://jefftucker.net/neptune/man/neptune_image-folder.html.
• Copy the contents of the attached source files to the appropriate source classes in NetBeans. You could, instead, exit NetBeans, then in Windows Explorer or Finder, replace the four files under NetBeansProjects\Sources\DemoSkin\src with the attached files.
• In each of the source files you have just created, hit ALT-SHIFT-F to clean up the formatting.

Step four, taking your existing skin's UI and converting it.

You'll need to stash your original onload.bsh somewhere so that you can copy things out of it.

If you try to copy your entire existing onload.bsh into NetBeans, you'll be chasing down problems forever, without being able to compile the UI until all the errors are fixed. I would suggest, instead, that you tackle one of your existing panels at a time. Define the variables in the SkinModel.java source file (type and default value), then edit YourSkin.java to define the UI fields, set up the StateMonitor()'s (if any), and lay out the panel.

My example uses anonymous inner classes, which I find much easier to maintain - it lets you move things from one panel to another without having to edit every reference to a variable that's on the panel. No more ui.varName or panelName.varName. If you use anonymous inner classes in onload.bsh, skin loading can be very slow, but in a compiled UI it's not an issue.

A lot of things are pretty much the same in a compiled UI as they are in an interpreted one, though Java is fussier about things like data typing than BeanShell is.

At any time, you can clean up your formatting by hitting ALT-SHIFT-F. You can automatically insert any missing imports with CTRL-SHIFT-I.

When you're ready to compile (don't even try it if there are any red error markers in NetBeans - it won't compile), click the hammer icon on the toolbar. When compilation is complete, copy NetBeansProjects\YourSkin\dist\YourSkin.jar to your skin's lib directory.

Do my examples show the only way to do things, or even the absolute best way? Not at all. They just show how I'm doing things in my skins, and these approaches work for me. Keeping things grouped the way they are (field definitions, monitors, layout, etc.) tends to keep me out of "improperly nested hell." And yes, you will find yourself there at some stage of the game. One thing to remember - when you enter an opening curly brace in NetBeans, it will automatically supply the closing one. But control panel definitions also require a closing semi-colon, which you have to enter manually. So before you even start populating a control panel with fields, close the sucker - that will cut down on the "endless red markers" phenomenon.

If you're wondering how to do some of the fancier things you might see in my skin's UI's, the source files are all bundled with the skins - burrow down into the skin directory to find the files.

One little time-saving tip: you can set up your NetBeans project so that it compiles the skin interface directly into the live version of the skin in jAlbum. See the attached screenshot. This eliminates the step of copying and pasting the .jar file. Just remember that there's no "undo" command, so keep a backup of your unmodified skin.

If you do this, you can, with jAlbum running, compile the skin, go to jAlbum, hit CTRL-R to reload the skin, and test the results.

But if you do this, you can't do the final clean and compile with jAlbum running, because the skin's lib directory is locked against deletion. Close jAlbum before doing this final compile.