Creating Your Own Modules¶

To create your own module, first create a class that extends tuiModule. Then, make sure to construct the module for any parameters needed.

There are many different methods you may override, each with their own respective functionality. The list with a quick description is as follows (but read through the full page if you ever feel confused)

Required(mostly)

display() // Returns a string of what to display

getValue() // Returns the selected value (can be any object)

Inputs:

onRight() // Returns Void, run whenever the right d-pad is clicked

onLeft() // Returns Void, run whenever the left d-pad is clicked

onDown() // Requires input release to be activated, returns void, run whenever the down d-pad is clicked

onUp() // Requires input release to be activated, returns void, run whenever the up d-pad is clicked

onClick() // Returns Void, run whenever the A button is pressed

Additional Usage:

inputReleased() // Returns a boolean on whether to allow up/down for menu.

mldisplay() // Returns a list of Strings. When not null, multi-line displaying is active.

isSkipping() // Returns a boolean on whether to skip the module when going through the lists.

Basic Usage¶

For the first part of this, we’ll create an Action (the simplest base module)

public Action extends tuiModule() {
    private final Runnable function;
    private final String displayName;

    public Action(String display, Runnable function) {
        this.function = function;
        this.displayName = display;
    }

}

All modules contain a constructor of inputs to determine how things are displayed. In the context of an Action this means taking in a runnable, and a string.

TuiLib works by always returning the display() method of each tuiModule inside of the buffer, creating what’s shown. It’s important to create a display() method that reflects how people should interact with it. In the case of actions, the display() method is as follows:

@Override
public String display() {
    return displayName
}

This works well, however, there is no way to run the function yet. In order to run it, you may override the onClick() method.

@Override
public void onClick() {
    function.run();
}

You most likely want more than just actions, so here’s the rest of the basic functions:

In order to return a usable value for your code, you can use the getValue() method, so long as it returns the object type of your returning value. Refer to the base modules page if you’re confused on what this means.

If you want to have different things activate when you click L/R, you may use the onLeft() or onRight() methods respectively.

If for some reason you’d like to skip the module when moving to it entirely (for example a custom display), you may return true with the isSkipping() method

Utilizing Up/Down Inputs¶

By default, the up and down buttons on the D-Pad move between different menu items. A lack of up / down keys however, can be limiting towards advanced usage. You may want to use these to increase / decrease a given value.

In order to use the onUp() or onDown() methods, you must override the inputReleased() class to return false , which now restricts the up / down keys, and means that the user cannot move between menu items. Be cautious of this!

As long as inputReleased() returns false you are free to use the dpad buttons to run different things.

Utilizing MultiLine display¶

By default, all modules utilize the display() method to return a string of what should be displayed. However, this on its own is limited for more advanced usage, such as displaying things over multiple lines.

In order to interface with the multi-line display you must override the mldisplay() class. By default, this class returns null, signifying to the displayManager that it should use the regular display() method. As long as mldisplay() is not null, it will use multi line displays.

To use multi line displays, simply return a list of Strings, where each item in the list is its own respective line.