To avoid the user having to toggle from title to in-program preview each time he moves to a new item in the list, it is necessary to keep the user's display preference.

If the preference is not available for the currently selected item, the title preview will be displayed by default.

it is necessary to implement a critical error manager (int 24h) to manage any disk access problems in the file open/selection/save view which displays a modal message box with the error description and the buttons with the actions that can be taken.

Define a standard color scheme for text-mode UI that identifies:

• standard state
• focused/current item state
• pressed/selected item state

Verify that the accelerator / highlighted text is highlighted relative to the rest of the text.

rloader is designed to be run from the directory it is in, otherwise ui.exe will not be found. To make it easier to use it should be allowed to run from any directory.

To do this, simply modify the main.asm launcher in one of the following ways:

• verify that argv[0] always contains the entire path to the executable, obtaining the path that contains the executable
• check that there is an environment variable RLOADER_PATH which will be set by the user with the path where rloader.exe is.

Set the current working directory to path.

Implement control class as base class for all TUI library controls.

It must include the implementation of:

• setting the unique identifier
• accelerator character setting
• setting of background and text colors
• flag that identifies if the control can receive focus
• methods for navigating the controls tree
• methods to add / remove child controls
• methods to manage the trigger of an accelerator
• methods for receiving messages from the TUI library
• calculation of the repaint rectangle in absolute coordinates, calculating it based on the position of the parent controls

When loading list files, lines starting with # and containing white-spaces are discarded, but not empty ones (zero length).

The latter must also be ignored.

Implement non-interactive (and non-focusable) label control in TUI library, with support for both text and 2-bits graphics mode.

To simplify the possible need to launch a list item several times to configure it, it would be optimal if the currently selected item is persistent between RLoader sessions.

Implement a dialog for opening / selecting and saving a file.

The window must contain the following controls:

• editbox for entering the file name or wildcard to filter the displayed files
• listbox to view files in the current folder
• listbox for viewing the drives and folders of the current folder
• open, save and cancel buttons

The difference in behavior between opening and saving consists in checking that the file exists when pressing the open / save button.

When moving in the file list or when changing directories the editbox must be synchronized accordingly, displaying the name of the selected file.

When in save mode, display a message box to confirm overwriting if the file already exists.

Implement a class uimsgbox derived from uiview to manage messageboxes.

Required features:

• customizable window title
• text message with word wrap
• be able to specify standard buttons and buttons with customized text
• automatic calculation of window size and position

Create a dialog box to allow the insertion or deletion of new items, or changing the properties of an existing item in a visual way.

Currently there is an event queue for each uiview, it is better to implement only one event queue and simplify the code.

If you hold key up or key down in text mode, the browsing is very fast.

In graphical mode it is slow because it tries to load thumbnail even you hold key down.

Two solutions:

1. load thumbnail only on key up event
2. implement background timer which will load the thumbnail with some delay (async)

A different color depth than expected can lead to a crash.

Add a check and display information about it to the user in case of incorrect format.

Create an abstract view class, to define a window or dialog box, which will receive events from the TUI library.

The view class will always contain an instance of the window control, and classes that inherit it will contain instances of the window's child controls.

It will define a pure virtual function defined like this:

virtual bool_t on_action(uiwindow *window, action_t *action) = 0;

to receive only the actions from the window or from the controls it contains.

And the following methods:

• open() to open the window, draw all the contained controls, and give focus to the first control that can receive it.
• close() to close the window, without deallocating resources, so that the values/states of the controls can be read or returned to the parent view.

Let's say you have your nice list of long folder names with DOS games in /home/user/DIST/GAMES

➭ ls -lah
total 0
drwxr-xr-x    6 user  staff   192B 31 oct 17:24 .
drwx------+ 177 user  staff   5,5K 31 oct 17:24 ..
drwxr-xr-x    2 user  staff    64B 31 oct 17:24 Commander Keen
drwxr-xr-x    2 user  staff    64B 31 oct 17:24 Destruction Derby
drwxr-xr-x    2 user  staff    64B 31 oct 17:24 Duke Nukem 3d
drwxr-xr-x    2 user  staff    64B 31 oct 17:24 Teenage Mutant Turtles 1

I created an automatic list generator using python
https://github.com/jsmolina/simple-menu-dos-launcher/blob/main/scripts/rloadergen.py

Example usage:
python3 rloadergen.py -i /home/user/DIST/GAMES -o /Users/jsmolina/OUT -d c:\menu

It scans the list of directories with long names, and copies such games to dos short names and generates the LIST.txt automatically. It will try to guess the executable, and ask you if it is ambiguous.
So it will generate in the directory /Users/jsmolina/OUT/GAMES something like this:

➭ ls -lah
total 0
drwxr-xr-x    6 jordism  staff   192B 31 oct 17:33 .
drwx------+ 177 user  staff   5,5K 31 oct 17:24 ..
drwxr-xr-x    2 user  staff    64B 31 oct 17:24 CKEEN
drwxr-xr-x    2 user  staff    64B 31 oct 17:24 DDERBY
drwxr-xr-x    2 user  staff    64B 31 oct 17:24 DUKE3D
drwxr-xr-x    2 user  staff    64B 31 oct 17:24 TMNT

And in /Users/jsmolina/OUT/LISTS/PCXT
LIST.TXT, ....

If you are interested, I could add in a Pull request or just take it directly to your repo and do any modification you might consider interesting (like allowing passing the LIST name on the commandline, or asking you about cycles).

it fastens a crazy lot the generation of lists.

NOTE: this implementation requires the management of the focus between the list frame and the info frame (if the info frame can scroll). Before starting development, it may be necessary to complete the TUI library to have consistent UI behavior.

Graphical user interface:

• move the screenshot display and the display of messages to the top right corner
• show the info in frame with scrolling to the bottom right corner.

Text-mode interface:

• replace the logo on the right with a full-height frame with scrolling containing info
• check where messages are currently displayed

To allow the management and maintenance of lists, the list and list_entry classes must implement serialization to save data in the list file.

When emulating an 80386, loading and displaying a thumbnail become really expensive due to re-coding during load in preparation of rendering to video memory.

This issue can be solved in two ways:

• caching the thumbnails at the cost of doubling the disk space
• displaying the thumbnail after a timeout.

Implement a listbox control to override game list management.

Provide the following features:

• scrolling of items by arrows, page up / down, home / end
• jump to a specific item by typing the first letters
• highlighting of occurrences in items of a specific string
• ability to hide items that do not match the string used for highlighting
• ability to view items on multiple columns (useful for rendering a list of files)

330 items, BMP folder is 24MB => it will crash. Is my LIST.TXT badly formatted or what is happening? I'm running inside DosBox just to test it now. Example list is working.

LIST.TXT

Implement button control in TUI library, with support for both text and 2-bits graphics mode.

Requested action handling:

• trigger button press on SPACE or ENTER key press/release
• trigger button press using ALT+accelerator character

To simplify the updating of the list files, it would be optimal if, upon returning to the program, the configured cycles are compared with those actually in use in DOSBox and updated accordingly if the user confirms.

Implement a window control with a text caption.

Actions required:

• methods for managing the focus of the contained controls
• method for returning the control that currently has focus
• method to return the control corresponding to the specified accelerator character, respecting the flag that identifies if a control can receive the focus

Make a sort of markdown pre-parser to automatically word-wrap the text and remove the limit of 38 characters per line on source .md files.

It appears that rloader.exe does not pass arguments to ui.exe correctly when LH is used. I.e.:

lh rloader.exe games ...

Implement a keyboard handler in order to have more precise control of the keys pressed, repeated, released and the currently pressed (SHIFT, CTRL, ALT) and locked shifts (CAPS LOCK, NUM LOCK, SCROLL LOCK, PAUSE. INSERT).

Define a data structure that contains:

• the ASCII code
• the scan code
• a virtual code (which normalizes the value of the key regardless of the pressed shifts or other modifiers)
• the pressed shifts
• the locked shifts

Describe the bug
I would expect that textmode works on CGA mode, but it shows garbled screen intead.

To Reproduce
Steps to reproduce the behavior:

1. Open any emulator (86box, pcem) or real PCXT.
2. execute rloader.
3. See error

Expected behavior
Garblet text is happening

Screenshots

Environment

• Running on: any PCXT
• OS: any msdos version

Additional context
Add any other context about the problem here.

Implement an editbox control in the TUI library that represents a single-line text entry field.

Required features:

• specify a maximum length of the text string to simplify memory allocation management
• manage the movement of the cursor with the arrow keys, home, end
• manage insert or overwrite modes
• manage the scrolling of the text inside the field by displaying overflow indicators on the right and left

Hi, thank you for a great launcher. In order to use it, there is one thing a bit problematic:

These games run without issues if I exit RLoader, but inside RLoader they fail to run and you are returned back to RLoader menu. Did you have a chance to try any of these? I have like 622kb of free conventional memory. I tried EMS/XMS as well. One game (Cannon Fodder) prints that there is not enough memory to run inside RLoader. But it will run without RLoader right after I exit RLoader.

I tried to run it several times and use Pause key to get print screen for you. It happens on native machine as well as in DosBox.

This quite famous DOS games won't run:

1. Lotus
2. Lost Vikings
3. Cannon Fodder
4. Alone In The Dark
5. Chaos Engine
6. Skyroads

Interesting is that Doom and Command & Conquer will run. The list is bigger, this is just what I remember now. It might be there is something residential that cause the issues or some vector has been modified and DOS4GW will have a problem (something that some file managers can cause - like Norton Commander).

I think the only solution for this would be to have some BAT file automatically run after you exit RLoader. When you choose game, RLoader would overwrite this BAT file to contain launch information for that game and then exit itself. This way it would work on principle of simple BAT file launching a game, nothing resident in memory. Because as you said, it takes only about 11kb of memory (if I remember correctly)...so the problem might be in Borland compiler itself and the way how it works with memory. There might be some magic compiler parameter or some smart workaround on a code level. But right now it will run only a few games.

Implement the main loop of sending and receiving messages with the following characteristics:

• send low-level messages to the controls
• receive from the controls the actions generated in response to low-level messages
• send the actions from the descendant controls of the window linked to the view to the uiview::on_action function.

For simplicity of implementation, given the needs of RLoader, all views will be modal.

One view can open another. At the close, an event will be sent to the view previously in focus, allowing to read the values/states exposed by public methods from the closed view.

For maximum compatibility with old real hardware or emulation of low end machine, make a text mode-based UI without display of thumbnails.

Since BIOS calls have been used, the required changes should be minimal.