A New Milestone of MiniGUI: Version 5.0.0 Released!

The MiniGUI development team announces the availability of MiniGUI 5.0.0, which is the first official release of MiniGUI 5.0.x.

This version brings us some new and exciting features, and we did our best to ensure backward compatibility of the existed APIs so that the old applications can smoothly migrate to the new version. We recommend that you use this version and report any bugs and incompatibilities in

https://github.com/VincentWei/minigui

The team also announces that MiniGUI 4.0 was updated to version 4.0.7.

New Features of MiniGUI 5.0.0

In version 5.0.0, we introduced some new and exciting features, and refactored a lot basic modules of MiniGUI Core.

Compositing Schema

In this version, we enhanced the MiniGUI-Processes runtime mode to support the compositing schema. Under compositing schema, regardless a main window is created by the server (mginit) or a client, it renders the content in a separate rendering buffer, and the server composites the contents from all visible main windows to the ultimate scan-out frame buffer according to the z-order information.

On the contrary, the legacy schema of MiniGUI-Processes uses the same frame buffer for all processes (and all main windows) in the system. So the legacy schema is also called the shared frame buffer schema.

By enabling the compositing schema, MiniGUI now can provide a better implementation for multi-process environment:

Easy to implement advanced user interfaces with rounded corners, alpha blending, blurring, and so on.
Easy to implement animations for switching among main windows.
Better security. One client created by different user cannot read/write contents in/to another windows owned by other clients.

New Main Window Types

In this version, we also enhanced the window manager of MiniGUI Core to support some special main window types.

Before 5.0.0, you can create a topmost main window with the style WS_EX_TOPMOST in order to show the main window above all normal main windows, and if you use MiniGUI-Processes runtime mode, the server (mginit) will always create global main windows, which are shown on other main windows created by clients.

Since 5.0.0, we introduce a concept of z-order levels for main windows. There are eight levels in MiniGUI from top to bottom:

The tooltip level (WS_EX_WINTYPE_TOOLTIP).
The system/global level (WS_EX_WINTYPE_GLOBAL).
The screen lock level (WS_EX_WINTYPE_SCREENLOCK).
The docker level (WS_EX_WINTYPE_DOCKER).
The higher level (WS_EX_WINTYPE_HIGHER).
The normal level (WS_EX_WINTYPE_NORMAL).
The launcher level (WS_EX_WINTYPE_LAUNCHER).
The desktop or wallpaper.

This enhancement allows us to create a special app which acts as screen lock, docker, or launcher.

Virtual Window

You know that we can post or send a message to other windows which may run in another thread under MiniGUI-Threads. The MiniGUI messaging functions such as PostMessage(), SendMessage(), SendNotifyMessage(), and the window callback procedure provide a flexible, efficient, safe, and flexible data transfer and synchronization mechanism for your multithreaded applications.

For example, you can send or post a message to a window from a general purpose thread which may download a file from a remote server under MiniGUI-Threads.

But can we use the MiniGUI messaging mechanism under MiniGUI-Processes and MiniGUI-Standalone runtime modes for multithreading purpose? For example, we may download a file in a general thread and inform a window when the file is ready.

Furthermore, if we want to use the MiniGUI messaging mechanism in a general thread to handle messages from other threads, how to do this?

The virtual window provides a solution for the requirements above. A virtual window is a special window object which does not have a visible window area. But after you create a virtual window in a different thread, you can use the MiniGUI messaging mechanism to post or send messages between the current main window thread and the new thread.

This enhancement provides a very useful facility to you in order to develop a well-designed multithreaded application.

Other Enhancements

We also tune or enhance the following modules of MiniGUI Core:

Enhanced timer support. MiniGUI now manages the timers per message thread. Under MiniGUI-Threads runtime mode, you can set up 32 (64 on 64-bit architecture) timers for each GUI threads. If you enabled virtual window, you can also do this for each message thread.
Support for listening a file descriptor as long as the underlying system has the select() system call for all runtime modes. Now you can call RegisterListenFD() to register a file descriptor to be listened, and handle MSG_FDEVENT in your window callback procedure to read/write from/to the file descriptor. Before this version, this feature only available for MiniGUI-Processes runtime mode.
Support for local data of windows. You can now set or retrieve a local data which is bound with a string name for a window. This will give you an easy-to-use interface to manage various data of a window.
Support for hardware cursors under compositing schema. MiniGUI now can utilize the hardware cursors if your graphics device support it. You can also load a cursor from a PNG file.
Support for loading icon from a bitmap file. You can now load an icon from a bitmap file such as a PNG file.
Unified the message hook functions for all runtime modes. MiniGUI now provides the consistent message hook functions for all runtime modes.
Use the update regions for cumulative updating the screen. This will eliminate the flickers due to the frequently redrawing of controls.

Changes of MiniGUI Components and Tools

mGEff, mGUtils, mGPlus, and mGNCS
- Tune code for MiniGUI 5.0.0 or later.
- Cleanup code for bad symbols.
mGNCS4Touch
- Tune code to comply with MiniGUI 5.0.0 and mGEff 1.5.0.
- Tune the speed meter.
- Enhance ScrollViewPiece and HScrollViewPiece.
mg-tests:
- Add new test programs for MiniGUI 5.0.0 in 5.0/ directory.
- Add new test programs for compositing schema in compositor/ directory.
gvfb:
- Enhanced to use double buffering to support SyncUpdate method.
- Enhanced to simulate the hardware cursors.

This version brings the largest improvement since MiniGUI 3.0.0. We did our best to ensure backward compatibility of the existed APIs so that the old applications can smoothly migrate to the new version. However, there are still some slight changes you need to take care. For more information, please refer to release notes of MiniGUI Core and Components:

MiniGUI Core: https://github.com/VincentWei/minigui/blob/rel-5-0/RELEASE-NOTES.md
mGEff: https://github.com/VincentWei/mgeff/blob/rel-5-0/RELEASE-NOTES.md
mGNCS4Touch: https://github.com/VincentWei/mgncs4touch/blob/rel-5-0/RELEASE-NOTES.md

Building MiniGUI 5.0.x

If you are anxious to see the comprehensive demo of MiniGUI Core and MiniGUI components, please fetch one of the following repositories from GitHub and follow the instructions to build MiniGUI Core, MiniGUI components, the samples, and the demonstration programs:

https://github.com/VincentWei/build-minigui-5.0

https://gitlab.fmsoft.cn/VincentWei/build-minigui-5.0

Update of MiniGUI 4.0.7

What's new in MiniGUI 4.0.7

In this version, we mainly enhance DRM engine to support MiniGUI-Processes.

ENHANCEMENTS
- We tune the external driver interface of DRM engine and enhance DRM engine to support MiniGUI-Processes.
COMPATIBILITIES:
- Functions drmCreateDCFromName, drmCreateDCFromHandle, and drmCreateDCFromPrimeFd are extended to have the offset argument. Please use the version having Ex postfix.
- The interface of the external driver for DRM engine changed. The changes come from MiniGUI 5.0.0.
BUGFIXING
- Fix some bugs found when developing MiniGUI 5.0.0.

For more information about the external driver of DRM engine, please refer to the revised edition of the following document:

https://github.com/VincentWei/minigui-docs/blob/master/supplementary-docs/Writing-DRM-Engine-Driver-for-Your-GPU.md

Building MiniGUI 4.0.x

https://github.com/VincentWei/build-minigui-4.0

https://gitlab.fmsoft.cn/VincentWei/build-minigui-4-0