Merge branch 'rel-5-0'

README.md

@@ -72,7 +72,7 @@ It greatly reduces the size and resource consumption of the entire solution, imp
 [HybridOS] is another large open source project initiated by FMSoft.
 It is an open source operating system designed for embedded/AIoT devices and cloud computing environment.
 
-HybridOS provides the complete software stack and the app framework based on HVML for embedded systems.
+HybridOS provides the complete software stack and the app framework based on [HVML] for embedded systems.
 You can easily develop your products which has rich functions and excellent expressiveness by using HybridOS.
 
 In practice, MiniGUI and the software which are used to integrated with GPU constitute the graphics stack of HybridOS.
@@ -85,13 +85,13 @@ The following chart shows the graphics stack of HybridOS:
   -----------------------------------------------
  |               MiniGUI/HVML Apps               |
  |-----------------------------------------------|
- |           |         (Graphics Stack)          |
- |           |              ---------------------|
- |           |              | hiMesa             |
- |           | hiCairo      |  ------------------|
- |           | MiniGUI      |  | EGL for MiniGUI |
- | C++ libs  | hiDRMDrivers |  | GL, GLES, VG    |
- | C libs    | libDRM       |  | GPU drivers     |
+ |          |         (Graphics Stack)           |
+ |          |                --------------------|
+ |          |               |    Mesa-HBD        |
+ |          | Cairo-HBD     |  ------------------|
+ |          | MiniGUI       |  | EGL for MiniGUI |
+ | C++ libs | HBDDRMDrivers |  | GL, GLES, VG    |
+ | C libs   | libDRM        |  | GPU drivers     |
  |-----------------------------------------------|
  |  Linux Kernel                                 |
  |            -----------------------------------|
@@ -102,10 +102,10 @@ The following chart shows the graphics stack of HybridOS:
 As shown in the chart above, the HybridOS graphics stack consists of the following software:
 
 - `libDRM` provides some user land APIs for Linux Direct Rendering Infrastructure.
-- `hiDRMDrivers` contains the drivers (user land drivers, not kernel drivers) for
+- `HBDDRMDrivers` contains the drivers (user land drivers, not kernel drivers) for
    MiniGUI DRM engine. The drivers implement the basic hardware accelerated
    2D graphics operations of various GPUs for MiniGUI.
-- `hiMesa` is the Mesa derivative for HybridOS, while Mesa is the open source
+- `Mesa-HBD` is the Mesa derivative for HybridOS, while Mesa is the open source
   implementation of OpenGL and other graphics APIs, including OpenGL ES
   (versions 1, 2, 3), OpenCL, OpenMAX, and Vulkan. It contains the following
   components:
@@ -113,13 +113,17 @@ As shown in the chart above, the HybridOS graphics stack consists of the followi
      graphics APIs.
    + The EGL implementation for MiniGUI platform.
    + The graphics drivers for various GPUs and a software driver called `swrast`.
-- `hiCairo` is the Cairo derivative for HybridOS. Cairo is a 2D vector graphics
+- `Cairo-HBD` is the Cairo derivative for HybridOS. Cairo is a 2D vector graphics
   library for Gtk. We provide support for MiniGUI backend in `hiCairo`.
 
 For more information about HybridOS, please refer to:
 
 <https://hybridos.fmsoft.cn/>
 
+For more information about HVML, please refer to:
+
+<https://hvml.fmsoft.cn/> or <https://www.hvml.org>
+
 ### Source Code Repositories
 
 FMSoft had created the public repositories for MiniGUI Core, MiniGUI
@@ -456,7 +460,7 @@ for examples:
 
 ## HISTORY
 
-21 years have pasted since MiniGUI was initially created at
+27 years have pasted since MiniGUI was initially created at
 the end of 1998, and now it becomes much reliable and stable.
 During the past years, many remarkable changes have taken place in
 the MiniGUI project.
@@ -561,13 +565,15 @@ A brief history description of the development progress is listed as follow:
 1. May., 2021:     FMSoft released MiniGUI version 5.0.6.
 1. Jan., 2022:     FMSoft released MiniGUI version 5.0.9.
 1. Sep., 2022:     FMSoft released MiniGUI version 5.0.10.
+1. Aug., 2023:     FMSoft released MiniGUI version 5.0.13.
+1. May., 2025:     FMSoft released MiniGUI version 5.0.15.
 
 ## AUTHORS AND COPYING
 
 The original author of MiniGUI is Vincent Wei, and now MiniGUI is maintained by FMSoft.
 For more information, please refer to <http://www.fmsoft.cn>.
 
-Copyright (C) 2002 ~ 2022, Beijing FMSoft Technologies Co., Ltd.  
+Copyright (C) 2002 ~ 2025, Beijing FMSoft Technologies Co., Ltd.  
 Copyright (C) 1998 ~ 2002, Vincent Wei
 
 This program is free software: you can redistribute it and/or modify
@@ -645,13 +651,12 @@ A: Yes, FMSoft can provide you with guaranteed commercial technical
 [FMSoft Technologies]: https://www.fmsoft.cn
 [FMSoft]: https://www.fmsoft.cn
 [HybridOS Official Site]: https://hybridos.fmsoft.cn
-[MiniGUI Official Site]: https://hvml.fmsoft.cn
+[MiniGUI Official Site]: https://minigui.fmsoft.cn
 [HVML Official Site]: https://hvml.fmsoft.cn
 [Vincent Wei]: https://github.com/VincentWei
 
-[MiniGUI]: https://github.com/VincentWei/MiniGUI
-[HybridOS]: https://github.com/FMSoftCN/HybridOS
-
+[MiniGUI]: https://github.com/VincentWei
+[HybridOS]: https://github.com/HybridOS2
 [HVML]: https://github.com/HVML
 [PurC]: https://github.com/HVML/PurC
 [xGUI Pro]: https://github.com/HVML/xGUI-Pro

RELEASE-NOTES.md

@@ -1,5 +1,11 @@
 # Release Notes
 
+- [Version 5.0.15](#version-5015)
+   + [What's new in version 5.0.15](#whats-new-in-version-5015)
+- [Version 5.0.13](#version-5013)
+   + [What's new in version 5.0.13](#whats-new-in-version-5013)
+- [Version 5.0.12](#version-5012)
+   + [What's new in version 5.0.12](#whats-new-in-version-5012)
 - [Version 5.0.11](#version-5011)
    + [What's new in version 5.0.11](#whats-new-in-version-5011)
 - [Version 5.0.10](#version-5010)
@@ -28,6 +34,56 @@
    + [Changes leading to incompatibility](#changes-leading-to-incompatibility)
    + [Deprecated APIs](#deprecated-apis)
 
+## Version 5.0.15
+
+On May 09, 2025, FMSoft announces the availability of MiniGUI 5.0.15,
+which is an enhancement release with some minor enhancements
+of MiniGUI 5.0.x.
+
+* ENHANCEMENTS:
+   - Optimize NEWGAL engines: `shadow`, `drm`, and `fbcon` for large resolution.
+   - New APIs: `GetWindowSharedSurfaceFD()` and `CreateMemDCFromSharedSurfaceFD()` for compositing schema.
+* CHANGES:
+   - The operations for DRM userland driver changed.
+
+## Version 5.0.13
+
+On Aug. 31, 2023, FMSoft announces the availability of MiniGUI 5.0.13,
+which is an enhancement release with some minor enhancements
+of MiniGUI 5.0.x.
+
+### What's new in version 5.0.13
+
+In this version, we made some enhancements:
+
+* ENHANCEMENTS:
+   - Disable BIDI for text in UTF-8 charset by default.
+* CHANGES:
+   - Add `BIDI_FLAG_NONE` and `BIDI_FLAG_LEGACY`.
+* BUGFIXING:
+   - Ignore C0CTRL characters when renerding text.
+   - Support for vowels.
+
+## Version 5.0.12
+
+On May 10, 2023, FMSoft announces the availability of MiniGUI 5.0.12,
+which is an enhancement release with some minor enhancements
+of MiniGUI 5.0.x.
+
+### What's new in version 5.0.12
+
+In this version, we made some enhancements:
+
+* ENHANCEMENTS:
+  - Add new API `GetACharsExtentPointEx()`.
+  - Add new APIs `GetTabbedACharsExtent()`, `GetTabbedACharsExtentPoint()`,
+    and `GetTabbedACharsExtentPointEx()`.
+  - Enhance two APIs `GetTextExtentPoint()` and `GetTabbedTextExtentPoint()`
+    to support BIDI charsets.
+  - Tune management of tick count.
+* BUGFIXING:
+   - Fix a typo: `Achar2UChar()` to `AChar2UChar()`.
+
 ## Version 5.0.11
 
 On Dec. 31, 2022, FMSoft announces the availability of MiniGUI 5.0.11,

Version.md

@@ -1,4 +1,4 @@
-Version 5.0.11 (2022/12/31)
+Version 5.0.15 (2025/05/09)
 
 This is a minor enhancement and bugfix release of MiniGUI 5.0.x, the stable version.
 

configure.ac

@@ -1,6 +1,6 @@
 dnl Process this file with autoconf to produce a configure script.
 AC_PREREQ(2.60)
-AC_INIT(libminigui, 5.0.11)
+AC_INIT(libminigui, 5.0.15)
 AC_CONFIG_SRCDIR(src/main/main.c)
 
 dnl Set various version strings - taken gratefully from the SDL sources
@@ -16,9 +16,9 @@ dnl Set various version strings - taken gratefully from the SDL sources
 #
 MINIGUI_MAJOR_VERSION=5
 MINIGUI_MINOR_VERSION=0
-MINIGUI_MICRO_VERSION=11
-MINIGUI_INTERFACE_AGE=1
-MINIGUI_BINARY_AGE=1
+MINIGUI_MICRO_VERSION=15
+MINIGUI_INTERFACE_AGE=0
+MINIGUI_BINARY_AGE=0
 MINIGUI_VERSION=$MINIGUI_MAJOR_VERSION.$MINIGUI_MINOR_VERSION.$MINIGUI_MICRO_VERSION
 
 AC_SUBST(MINIGUI_MAJOR_VERSION)
@@ -62,7 +62,7 @@ dnl ========================================================================
 dnl Checks for header files.
 AC_HEADER_STDC
 AC_HEADER_DIRENT
-AC_CHECK_HEADERS(limits.h math.h locale.h unistd.h termio.h sys/types.h sys/time.h sys/select.h sys/memfd.h)
+AC_CHECK_HEADERS(limits.h math.h stdatomic.h locale.h unistd.h termio.h sys/types.h sys/time.h sys/select.h sys/memfd.h)
 
 dnl Checks for typedefs, structures, and compiler characteristics.
 AC_C_CONST
@@ -95,7 +95,7 @@ message_string="no"
 osname="unspecified"
 runtime_mode="procs"
 compositing_schema="yes"
-virtual_window="no"
+virtual_window="yes"
 use_shmopen="no"
 mgslice_use_fallback="no"
 
@@ -1704,12 +1704,12 @@ fi
 
 CPPFLAGS="$CPPFLAGS -D__MINIGUI_LIB__"
 
-surface_schema="shared frame buffer"
+surface_schema="shared"
 case "$runtime_mode" in
     sa)
         AC_DEFINE(_MGRM_STANDALONE, 1,
             [Define if build MiniGUI-Standalone])
-        MINIGUI_RUNMODE="sa"
+        MINIGUI_RUNMODE="standalone"
         RUNMODE_LADD="standalone/libstandalone.la"
         RUNMODE_SUBDIRS="standalone"
     ;;
@@ -1717,13 +1717,13 @@ case "$runtime_mode" in
         AC_DEFINE(_MGRM_THREADS, 1,
             [Define if build MiniGUI-Threads])
         CPPFLAGS="$CPPFLAGS -D_REENTRANT"
-        MINIGUI_RUNMODE="ths"
+        MINIGUI_RUNMODE="threads"
         virtual_window="yes"
     ;;
     *)
         AC_DEFINE(_MGRM_PROCESSES, 1,
             [Define if build MiniGUI-Processes])
-        MINIGUI_RUNMODE="procs"
+        MINIGUI_RUNMODE="processes"
         RUNMODE_LADD="server/libserver.la client/libclient.la"
         RUNMODE_SUBDIRS="server client"
         if test "x$compositing_schema" = "xyes"; then
@@ -2664,6 +2664,7 @@ if test "x$no_math" = "xno"; then
 fi
 
 DEP_LIBS="$DEP_LIBS -lpthread"
+MINIGUI_RUNMODE="$MINIGUI_RUNMODE-${surface_schema}"
 
 AC_SUBST(VIDEO_SUBDIRS)
 AC_SUBST(VIDEO_DRIVERS)

etc/MiniGUI.cfg

@@ -55,6 +55,36 @@ wallpaper_pattern_size=full
 # def_compositor_so=
 #}}
 
+#{{ifdef _MGGAL_SHADOW
+[shadow]
+real_engine=pc_xvfb
+defaultmode=800x600-16bpp
+
+# `cw`: rotating screen clock-wise.
+# `ccw`: rotating screen counter clock-wise.
+# `hflip`: flipping screen horizontally.
+# `vflip`: flipping screen vertically.
+rotate_screen=ccw
+
+# Whether the async. update is enabled.
+# Use `true` or `yes` for enabled, anything else for disabled.
+# Since 5.0.13.
+async_update=yes
+
+# The synchronization interval for the asyn. updater (milli-seconds).
+# This setting is only valid when `async_update` is enabled and
+# the real engine does not provide WaitWBlank method.
+# Since 5.0.13.
+update_interval=15
+
+# The minimal pixels to use the hardware accelerator.
+# If the number of pixels to copy is less than this value,
+# MiniGUI will use the software copy routine to update the real screen,
+# even if the real device provides a hardware accelerator.
+# Since 5.0.13.
+min_pixels_using_hwaccl=4096
+#}}
+
 #{{ifdef _MGGAL_DRM
 [drm]
 defaultmode=1024x768-32bpp
@@ -78,9 +108,21 @@ dpi=96
 # Since 5.0.0.
 double_buffering=true
 
+# The update interval for the asyn. updater (milli-seconds).
+# This setting is only valid when drmWaitVBlank doesn't work correctly.
+# Since 5.0.13.
+update_interval=15
+
+# The minimal pixels to use the hardware accelerator.
+# If the number of pixels to copy is less than this value,
+# MiniGUI will use the software copy routine to update the real screen,
+# even if the device provides a hardware accelerator.
+# Since 5.0.13.
+min_pixels_using_hwaccl=4096
+
 # The filename of the shared library for the external driver.
 # The equivalent environment variable: MG_GAL_DRM_DRIVER
-exdriver=libhidrmdrivers-0.2.so.0
+exdriver=libdrmdrivers.so
 #}}
 
 #{{ifdef _MGIAL_SINGLETOUCHKEY
@@ -111,6 +153,16 @@ dpi=96
 # Note that under compositing schema, double buffering is always enabled.
 # Since 5.0.10.
 double_buffering=true
+
+# Whether the async. update is enabled.
+# Use `true` or `yes` for enabled, anything else for disabled.
+# Since 5.0.13.
+async_update=yes
+
+# The update interval for the asyn. updater (milli-seconds).
+# This setting is only valid when drmWaitVBlank doesn't work correctly.
+# Since 5.0.13.
+update_interval=15
 #}}
 
 #{{ifdef _MGGAL_PCXVFB
@@ -123,13 +175,6 @@ exec_file=/usr/local/bin/gvfb
 [rtos_xvfb]
 defaultmode=800x600-16bpp
 
-#{{ifdef _MGGAL_SHADOW
-[shadow]
-real_engine=pc_xvfb
-defaultmode=800x600-16bpp
-rotate_screen=ccw
-#}}
-
 #{{ifdef _MGGAL_MLSHADOW
 [mlshadow]
 real_engine=qvfb

include/common.h

@@ -268,6 +268,8 @@ MGUI_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8);
 #define MG_UNLIKELY(expr) (expr)
 #endif
 
+#define HAVE(FEATURE) (defined HAVE_##FEATURE && HAVE_##FEATURE)
+
     /**
      * \defgroup endian_info Endianness information
      * @{
@@ -2347,6 +2349,7 @@ int init_minigui_printf (int (*output_char) (int ch),
 #define _ERR_PRINTF(fmt, ...)                   \
     do {                                        \
         TCS_RED (stderr);                       \
+        fprintf (stderr, "%s: ", __FUNCTION__); \
         fprintf (stderr, fmt, ##__VA_ARGS__);   \
         TCS_NONE (stderr);                      \
     } while (0)

include/exstubs.h

@@ -84,6 +84,14 @@ extern "C" {
      * @{
      */
 
+/** The current version of DRM driver. */
+#define DRM_DRIVER_VERSION  2
+
+#define DRM_SURBUF_TYPE_OFFSCREEN       0x0000
+#define DRM_SURBUF_TYPE_SHADOW          0x0001
+#define DRM_SURBUF_TYPE_SCANOUT         0x0002
+#define DRM_SURBUF_TYPE_MASK            0x000F
+
 /**
  * The struct type represents the DRI sub driver.
  * The concrete struct should be defined by the driver.
@@ -129,6 +137,8 @@ typedef struct _DrmSurfaceBuffer {
     uint32_t dumb:1;
     /** Is it a scanout buffer. Since 5.0.0. */
     uint32_t scanout:1;
+    /** The buffer is also a dma-buf. Since 5.0.13. */
+    uint32_t dma_buf:1;
 
     /** The width of the buffer. */
     uint32_t width;
@@ -154,11 +164,23 @@ typedef struct _DrmSurfaceBuffer {
       * The address of the pixel data:
       *     uint8_t* pixels = this->buff + this->offset;
       */
-    uint8_t* buff;
+    uint8_t* vaddr;
 } DrmSurfaceBuffer;
 
+typedef struct _DrmBlitOperations {
+    BlitCopyOperation   cpy;
+    BlitKeyOperation    key;
+    BlitAlphaOperation  alf;
+    ColorBlendMethod    bld;
+    ColorLogicalOp      rop;
+    ScalingFilter       scl;
+
+    uint32_t            key_min, key_max;
+    uint8_t             alpha;
+} DrmBlitOperations;
+
 /**
- * The structure type defines the operations for a DRM driver.
+ * The structure type defines the operations for a userland DRM driver.
  */
 typedef struct _DrmDriverOps {
     /**
@@ -176,12 +198,13 @@ typedef struct _DrmDriverOps {
     void (*destroy_driver) (DrmDriver *driver);
 
     /**
-     * This operation flushes the batch buffer of the driver or
-     * the hardware cache.
+     * This operation flushes the batch buffer of the driver and/or
+     * the specified buffer.
      *
      * \note This operation can be NULL.
      */
-    void (* flush_driver) (DrmDriver *driver);
+    void (* flush) (DrmDriver *driver, DrmSurfaceBuffer* buff,
+            const GAL_Rect *dirty_rect);
 
     /**
      * This operation creates a surface buffer with the specified pixel format,
@@ -194,7 +217,7 @@ typedef struct _DrmDriverOps {
      */
     DrmSurfaceBuffer* (* create_buffer) (DrmDriver *driver,
             uint32_t drm_format, uint32_t hdr_size,
-            uint32_t width, uint32_t height);
+            uint32_t width, uint32_t height, unsigned flags);
 
     /**
      * This operation creates a buffer from a given and possibly foreign handle
@@ -207,7 +230,9 @@ typedef struct _DrmDriverOps {
      *  DrmSurfaceBuffer object.
      */
     DrmSurfaceBuffer* (* create_buffer_from_handle) (DrmDriver *driver,
-            uint32_t handle, size_t size);
+            uint32_t handle, size_t size,
+            uint32_t drm_format, uint32_t hdr_size,
+            uint32_t width, uint32_t height, uint32_t pitch);
 
     /**
      * This operation creates a buffer for the given system global name
@@ -219,7 +244,9 @@ typedef struct _DrmDriverOps {
      *  DrmSurfaceBuffer object.
      */
     DrmSurfaceBuffer* (* create_buffer_from_name) (DrmDriver *driver,
-            uint32_t name);
+            uint32_t name,
+            uint32_t drm_format, uint32_t hdr_size,
+            uint32_t width, uint32_t height, uint32_t pitch);
 
     /**
      * This operation creates a buffer for the given PRIME file descriptor
@@ -231,21 +258,19 @@ typedef struct _DrmDriverOps {
      *  DrmSurfaceBuffer object.
      */
     DrmSurfaceBuffer* (* create_buffer_from_prime_fd) (DrmDriver *driver,
-            int prime_fd, size_t size);
+            int prime_fd, size_t size,
+            uint32_t drm_format, uint32_t hdr_size,
+            uint32_t width, uint32_t height, uint32_t pitch);
 
     /**
      * This operation maps the buffer into the current process's virtual memory
      * space, and returns the virtual address. If failed, it returns NULL.
      *
-     * When \a for_scanout is not zero, the buffer will be used for scan out
-     * frame buffer.
-     *
      * \note The driver must implement this operation. The driver must
      *  set a valid value for buff field of the DrmSurfaceBuffer object
      *  on success.
      */
-    uint8_t* (* map_buffer) (DrmDriver *driver, DrmSurfaceBuffer* buffer,
-            int for_scanout);
+    uint8_t* (* map_buffer) (DrmDriver *driver, DrmSurfaceBuffer* buffer);
 
     /**
      * This operation un-maps a buffer.
@@ -264,96 +289,51 @@ typedef struct _DrmDriverOps {
     void (* destroy_buffer) (DrmDriver *driver, DrmSurfaceBuffer* buffer);
 
     /**
-     * This operation clears the specific rectangle area of a buffer
+     * This operation fills the specific rectangle area of a buffer
      * with the specific pixel value. If succeed, it returns 0.
      *
      * \note If this operation is set as NULL, the driver does not support
-     * hardware accelerated clear operation.
+     * hardware accelerated filling operation.
      */
-    int (* clear_buffer) (DrmDriver *driver,
+    int (* fill_rect) (DrmDriver *driver,
             DrmSurfaceBuffer* dst_buf, const GAL_Rect* rc, uint32_t pixel_value);
 
     /**
-     * This operation checks whether a hardware accelerated blit
+     * This operation checks whether a specified hardware accelerated blit
      * can be done between the source buffer and the destination buffer.
-     * If succeed, it returns 0.
+     * If succeed, it returns zero, otherwise for failure.
+     * If succeed, it is safe to call do_blit operation.
      *
      * \note If this operation is set as NULL, it will be supposed that
      * the driver does not support any hardware accelerated blitting operation.
      */
     int (* check_blit) (DrmDriver *driver,
-            DrmSurfaceBuffer* src_buf, DrmSurfaceBuffer* dst_buf);
-
-    /**
-     * This operation copies bits from a source buffer to a destination buffer.
-     *
-     * \note If this operation is set as NULL, the driver does not support
-     * hardware accelerated copy blitting.
-     *
-     * \note Currently, the logical operation is ignored.
-     */
-    int (* copy_blit) (DrmDriver *driver,
             DrmSurfaceBuffer* src_buf, const GAL_Rect* src_rc,
             DrmSurfaceBuffer* dst_buf, const GAL_Rect* dst_rc,
-            ColorLogicalOp logic_op);
+            const DrmBlitOperations *ops);
 
     /**
-     * This operation blits pixels from a source buffer with the source alpha
-     * value specified to a destination buffer.
-     *
-     * \note If this operation is set as NULL, the driver does not support
-     * hardware accelerated blitting with alpha.
+     * This operation does the real blit. It should not be NULL if check_blit
+     * is not NULL.
      */
-    int (* alpha_blit) (DrmDriver *driver,
-            DrmSurfaceBuffer* src_buf, const GAL_Rect* src_rc,
-            DrmSurfaceBuffer* dst_buf, const GAL_Rect* dst_rc,
-            uint8_t alpha);
+    int (* do_blit) (DrmDriver *driver,
+            DrmSurfaceBuffer *src_buf, const GAL_Rect *src_rc,
+            DrmSurfaceBuffer *dst_buf, const GAL_Rect *dst_rc,
+            const DrmBlitOperations *blit_ops);
 
     /**
-     * This operation blits pixels from a source buffer to a destination buffer,
-     * but skipping the pixel value specified by \a color_key.
+     * This operation copies the pixels from the source buffer to
+     * the destination buffer, with or without scaling, rotation, and flip.
      *
      * \note If this operation is set as NULL, the driver does not support
-     * hardware accelerated blitting with color key.
+     * hardware accelerated copy operation between buffers.
      */
-    int (* key_blit) (DrmDriver *driver,
+    int (* copy_buff) (DrmDriver *driver,
             DrmSurfaceBuffer* src_buf, const GAL_Rect* src_rc,
             DrmSurfaceBuffer* dst_buf, const GAL_Rect* dst_rc,
-            uint32_t color_key);
-
-    /**
-     * This operation blits pixels from a source buffer with the source alpha
-     * value specified to a destination buffer, but skipping the pixel value
-     * specified.
-     *
-     * \note If this operation is set as NULL, the driver does not support
-     * hardware accelerated blitting with alpha and color key.
-     */
-    int (* alpha_key_blit) (DrmDriver *driver,
-            DrmSurfaceBuffer* src_buf, const GAL_Rect* src_rc,
-            DrmSurfaceBuffer* dst_buf, const GAL_Rect* dst_rc,
-            uint8_t alpha, uint32_t color_key);
-
-    /**
-     * This operation blits pixels from a source buffer with the source alpha
-     * value of pixels to the destination buffer, and with the specified color
-     * compositing/blending method (\a ColorBlendMethod).
-     *
-     * \note If this operation is set as NULL, the driver does not support
-     * hardware accelerated blitting with alpha on basis per pixel.
-     *
-     * \note Currently, the color compositing/blending method is ignored.
-     */
-    int (* alpha_pixel_blit) (DrmDriver *driver,
-            DrmSurfaceBuffer* src_buf, const GAL_Rect* src_rc,
-            DrmSurfaceBuffer* dst_buf, const GAL_Rect* dst_rc,
-            ColorBlendMethod blend_method);
-
+            BlitCopyOperation op);
 } DrmDriverOps;
 
-/** The current version of DRM driver. */
-#define DRM_DRIVER_VERSION  1
-
 /**
  * Implement this stub to return the DRI driver operations
  *

include/gdi.h

@@ -1704,6 +1704,304 @@ MG_EXPORT BOOL GUIAPI IsScreenDC (HDC hdc);
  */
 MG_EXPORT BOOL GUIAPI IsWindowDC (HDC hdc);
 
+struct GAL_Surface;
+typedef struct GAL_Surface *HSURF;
+
+#ifdef _MGSCHEMA_COMPOSITING
+/**
+ * \fn HSURF GUIAPI CreateSharedSurface (GHANDLE video,
+ *      const char *name, DWORD flags,
+ *      int width, int height, int depth,
+ *      Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
+ * \brief Creates a shared surface for specified size and pixel format.
+ *
+ * This function creates a shared surface on the current video device with
+ * the specified size and pixel format. This function also registers
+ * the shared surface by using the specified name \a name to the server
+ * if \a name is not NULL. Another client can use the name to get
+ * the shared surface by calling \a GetSharedSurfaceFDByName().
+
+ * \param video The handle to the video; NULL for the current default video.
+ * \param name The gobal unique name for the shared surface.
+ * \param flags The flags, can be one of the following values:
+ *   - MEMDC_FLAG_SWSURFACE\n
+ *     Creates the surface in the system memory.
+ *   - MEMDC_FLAG_HWSURFACE\n
+ *     Creates the surface in the video memory.
+ * \param width The expected width of the result surface.
+ * \param height The expected height of the result surface.
+ * \param depth The expected color depth of the surface.
+ * \param Rmask The bit-masks of the red components in a pixel value.
+ * \param Gmask The bit-masks of the green components in a pixel value.
+ * \param Bmask The bit-masks of the blue components in a pixel value.
+ * \param Amask The bit-masks of the alpha components in a pixel value.
+ *
+ * \return The file descriptor which represents the new shared surface buffer;
+ *      a value less than 0 indicates an error.
+ *
+ * \note This function only available when _MGSCHEMA_COMPOSITING is defined.
+ *
+ * \sa DestroySharedSurface, GetSharedSurfaceFDByName
+ *
+ * Since 5.2.0
+ */
+MG_EXPORT HSURF GUIAPI CreateSharedSurface (GHANDLE video,
+        const char *name, DWORD flags,
+        int width, int height, int depth,
+        Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
+
+/**
+ * \fn BOOL GUIAPI GUIAPI DestroySharedSurface (HSURF surf, const char *name)
+ * \brief Destroies a shared surface.
+ *
+ * This function destroies the specified shared surface \a surf,
+ * and/or revoke the global unique name \a name from the server if \a name
+ * is not NULL.
+ * \param surf The handle to the shared surface.
+ * \param name The gobal unique name for the shared surface.
+ *
+ * \return TRUE on success, otherwise failure.
+ *
+ * \note This function only available when _MGSCHEMA_COMPOSITING is defined.
+ *
+ * \sa CreateSharedSurface
+ *
+ * Since 5.2.0
+ */
+MG_EXPORT BOOL GUIAPI DestroySharedSurface (HSURF surf);
+
+/**
+ * \fn int GUIAPI GetSharedSurfaceFDByClientWindow (int client,
+ *      HWND hwnd, size_t *map_size, DWORD *flags)
+ * \brief Gets the file descriptor of the shared surface of a window created
+ * by another client.
+ *
+ * This function gets the file descriptor of the shared surface of the window
+ * \a hwnd, which is created by another client. If there is one such window
+ * in the system, the server will return a file descriptor which represents
+ * the shared surface of the window to the caller.
+ *
+ * \param client The client identifier.
+ * \param hwnd The handle to the window created by the client.
+ * \param map_size The pointer to a buffer of size_t to receive the whole size
+ *      of the shared surface in bytes; nullable.
+ * \param flags The pointer to a buffer of DWORD to receive the flags of
+ *      the shared surface; nullable.
+ *
+ * \return The file descriptor which represents the shared surface on success;
+ *      a value less than 0 for failure.
+ *
+ * \note This function only available when _MGSCHEMA_COMPOSITING is defined.
+ *
+ * \sa AttachToSharedSurface, GetWindowSharedSurfaceFD
+ *
+ * Since 5.2.0
+ */
+MG_EXPORT int GUIAPI GetSharedSurfaceFDByClientWindow (int client,
+        HWND hwnd, size_t *map_size, DWORD *flags);
+
+/**
+ * \fn int GUIAPI GetSharedSurfaceFDByName (const char *name,
+ *      size_t *map_size, DWORD *flags)
+ * \brief Gets the file descriptor of a shared surface by name.
+ *
+ * This function gets the file descriptor of the shared surface created
+ * by \a CreateSharedSurface by another client. If there is one such window
+ * in the system, the server will return a file descriptor which represents
+ * the shared surface.
+ *
+ * \param name The gobal unique name for the shared surface.
+ * \param map_size The pointer to a buffer of size_t to receive the whole size
+ *      of the shared surface in bytes; nullable.
+ * \param flags The pointer to a buffer of DWORD to receive the flags of
+ *      the shared surface; nullable.
+ *
+ * \return The file descriptor which represents the shared surface on success;
+ *      a value less than 0 for failure.
+ *
+ * \note This function only available when _MGSCHEMA_COMPOSITING is defined.
+ *
+ * \sa CreateSharedSurface, AttachToSharedSurface
+ *
+ * Since 5.2.0
+ */
+MG_EXPORT int GUIAPI GetSharedSurfaceFDByName (const char *name,
+        size_t *map_size, DWORD *flags);
+
+/**
+ * \fn HSURF GUIAPI AttachToSharedSurface (GHANDLE video, int fd,
+ *      size_t map_size, DWORD flags)
+ * \brief Attaches to a shared surface.
+ *
+ * This function attaches to the shared surface which is represents by
+ * the given file descriptor \a fd.
+ *
+ * \param video The handle to the video; NULL for the current default video.
+ * \param fd The file descriptor of the shared surface.
+ *
+ * \return The handle to the shared surface on success; NULL for failure.
+ *
+ * \note This function only available when _MGSCHEMA_COMPOSITING is defined.
+ *
+ * \sa GetSharedSurfaceFDByName, DetachFromSharedSurface
+ *
+ * Since 5.2.0
+ */
+MG_EXPORT HSURF GUIAPI AttachToSharedSurface (GHANDLE video, int fd,
+        size_t map_size, DWORD flags);
+
+/**
+ * \fn const char *GUIAPI GetSharedSurfaceInfo (HSURF surf, int *fd,
+ *          SIZE *size, int *pitch, size_t *map_size, off_t *pixels_off)
+ * \brief Gets the basic information of a shared surface.
+ *
+ * This function gets the name and other information of
+ * the given shared surface \a surf. It also returns the file descriptor,
+ * the size, or the pitch of the surface if \a fd, \a size or \a pitch
+ * is not NULL.
+ *
+ * \param surf The handle to the shared surface.
+ * \param fd The pointer to a buffer of int to return the file descriptor of
+ *      the shared surface; nullable.
+ * \param size The pointer to a buffer of SIZE to return the size of
+ *      the shared surface; nullable.
+ * \param pitch The pointer to a buffer of int for value of pitch; nullable.
+ * \param file_size The pointer to a buffer of size_t for the whole file size;
+ *      nullable.
+ * \param pixel_off The pointer to a buffer of size_t for the offset of
+ *      pixel data; nullable.
+ *
+ * \return The name of the shared surface on success; NULL for failure.
+ *      Note that if the name is an empty string, it is an anonymous surface.
+ *
+ * \note This function only available when _MGSCHEMA_COMPOSITING is defined.
+ *
+ * \sa GetSharedSurfaceFDByName, DetachFromSharedSurface
+ *
+ * Since 5.2.0
+ */
+MG_EXPORT const char *GUIAPI GetSharedSurfaceInfo (HSURF surf, int *fd,
+        SIZE *size, int *pitch, size_t *map_size, off_t *pixels_off);
+
+/**
+ * \fn BOOL GUIAPI TestIfSharedSurfaceChanged (HSURF surf,
+ *      unsigned dirty_age)
+ * \brief Tests if a shared surface changed.
+ *
+ * This function tests if the given shared surface \a surf had changed, i.e.,
+ * it has a different dirty age value against the specified value \a dirty_age.
+ *
+ * \param surf The handle to the shared surface.
+ * \param dirty_age The dirty age to compare.
+ *
+ * \return TRUE for changed; FALSE for no change or failure.
+ *
+ * \note This function only available when _MGSCHEMA_COMPOSITING is defined.
+ *
+ * \sa LockSharedSurface
+ *
+ * Since 5.2.0
+ */
+MG_EXPORT BOOL GUIAPI TestIfSharedSurfaceChanged (HSURF surf,
+        unsigned dirty_age);
+
+/**
+ * \fn BOOL GUIAPI LockSharedSurface (HSURF surf,
+ *      unsigned *dirty_age, int *nr_dirty_rects, const RECT **dirty_rects)
+ * \brief Locks the shared surface for read.
+ *
+ * This function locks the given shared surface \a surf and returns
+ * the dirty information.
+ *
+ * \param surf The handle to the shared surface.
+ * \param dirty_age The pointer to a buffer of unsigned integer to
+ *      return the latest dirty age of the shared surface; nullable.
+ * \param nr_dirty_rects The pointer to a buffer of integer to return the valid
+ *      dirty rectangles; nullable.
+ * \param dirty_rects The pointer to a buffer of (const RECT *) for the array
+ *      of dirty rectangles; nullable.
+ *
+ * \return TRUE for locked; FALSE for failure.
+ *
+ * \note This function only available when _MGSCHEMA_COMPOSITING is defined.
+ *
+ * \sa UnlockSharedSurface
+ *
+ * Since 5.2.0
+ */
+MG_EXPORT BOOL GUIAPI LockSharedSurface (HSURF surf,
+        unsigned *dirty_age, int *nr_dirty_rects, const RECT **dirty_rects);
+
+/**
+ * \fn BOOL GUIAPI UnlockSharedSurface (HSURF surf)
+ * \brief Unlocks the shared surface.
+ *
+ * This function unlocks the given shared surface \a surf.
+ *
+ * \param surf The handle to the shared surface.
+ *
+ * \return TRUE on success; otherwise failure.
+ *
+ * \note This function only available when _MGSCHEMA_COMPOSITING is defined.
+ *
+ * \sa LockSharedSurface
+ *
+ * Since 5.2.0
+ */
+MG_EXPORT BOOL GUIAPI UnlockSharedSurface (HSURF surf);
+
+/**
+ * \fn BOOL GUIAPI DetachFromSharedSurface (HSURF surf)
+ * \brief Detaches from a shared surface.
+ *
+ * This function detaches from the shared surface \a surf and delete the memory
+ * used by the surface.
+ *
+ * \param surf The handle to the shared surface.
+ *
+ * \return TRUE on success; otherwise failure.
+ *
+ * \note This function only available when _MGSCHEMA_COMPOSITING is defined.
+ *
+ * \sa AttachToSharedSurface
+ *
+ * Since 5.2.0
+ */
+MG_EXPORT BOOL GUIAPI DetachFromSharedSurface (HSURF surf);
+#endif /* _MGSCHEMA_COMPOSITING */
+
+/**
+ * \fn HDC GUIAPI CreateMemDCFromSurface (HSURF surf);
+ * \brief Creates a memory DC from a surface.
+ *
+ * This function creates a memory DC on the specified surface \a surf.
+ *
+ * \param surf The handle to the shared surface.
+ *
+ * \return The handle to a new memory DC, HDC_INVALID indicates an error.
+ *
+ * \sa DeleteMemDC
+ *
+ * Since 5.2.0
+ */
+MG_EXPORT HDC GUIAPI CreateMemDCFromSurface(HSURF surf);
+
+/**
+ * \fn HSURF GUIAPI GetSurfaceFromDC(HDC hdc);
+ * \brief Gets surface handle from a DC.
+ *
+ * This function returns the handle to the surface of the given DC \a hdc.
+ *
+ * \param hdc The handle to the DC.
+ *
+ * \return The handle to the surface, NULL for failure.
+ *
+ * \sa CreateMemDCFromSurface
+ *
+ * Since 5.2.0
+ */
+MG_EXPORT HSURF GUIAPI GetSurfaceFromDC(HDC hdc);
+
 /**
  * \fn HDC GUIAPI CreateMemDCEx (int width, int height, int depth, DWORD flags, \
  Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask,
@@ -5162,6 +5460,27 @@ MG_EXPORT BOOL GUIAPI FillBitmapPartInBox (HDC hdc, int box_x, int box_y,
                 int box_w, int box_h, const BITMAP* pbmp, int bmp_x, int bmp_y,
                 int bmp_w, int bmp_h);
 
+typedef enum {
+   BLIT_COPY_TRANSLATE = 0,
+   BLIT_COPY_ROT_90,
+   BLIT_COPY_ROT_180,
+   BLIT_COPY_ROT_270,
+   BLIT_COPY_FLIP_H,
+   BLIT_COPY_FLIP_V,
+   BLIT_COPY_FLIP_H_V
+} BlitCopyOperation;
+
+typedef enum {
+   BLIT_COLORKEY_NONE = 0,
+   BLIT_COLORKEY_NORMAL,
+   BLIT_COLORKEY_INVERTED,
+} BlitKeyOperation;
+
+typedef enum {
+   BLIT_ALPHA_NONE = 0,
+   BLIT_ALPHA_SET,
+} BlitAlphaOperation;
+
 /**
  * The color blend mothed.
  *
@@ -5170,7 +5489,8 @@ MG_EXPORT BOOL GUIAPI FillBitmapPartInBox (HDC hdc, int box_x, int box_y,
  */
 typedef enum {
     COLOR_BLEND_LEGACY      = 0,
-    COLOR_BLEND_FLAGS_MASK  = 0x00FF,
+    COLOR_BLEND_MASK        = 0xFFFF,
+    COLOR_BLEND_PIXMAN_MASK = 0x00FF,
 
     /** Porter Duff rule: clear */
     COLOR_BLEND_PD_CLEAR    = 0x0100,   // PIXMAN_OP_CLEAR          = 0x00
@@ -5308,22 +5628,25 @@ typedef enum {
  * The color logical operations.
  */
 typedef enum {
-   COLOR_LOGICOP_CLEAR = 0,
-   COLOR_LOGICOP_NOR,
-   COLOR_LOGICOP_AND_INVERTED,
-   COLOR_LOGICOP_COPY_INVERTED,
-   COLOR_LOGICOP_AND_REVERSE,
-   COLOR_LOGICOP_INVERT,
-   COLOR_LOGICOP_XOR,
-   COLOR_LOGICOP_NAND,
-   COLOR_LOGICOP_AND,
-   COLOR_LOGICOP_EQUIV,
-   COLOR_LOGICOP_NOOP0,
-   COLOR_LOGICOP_OR_INVERTED1,
-   COLOR_LOGICOP_COPY,
-   COLOR_LOGICOP_OR_REVERSE,
-   COLOR_LOGICOP_OR,
-   COLOR_LOGICOP_SET,
+    COLOR_LOGICOP_CLEAR             = 0,
+    COLOR_LOGICOP_NOR               = 0x01 << 24,
+    COLOR_LOGICOP_AND_INVERTED      = 0x02 << 24,
+    COLOR_LOGICOP_COPY_INVERTED     = 0x03 << 24,
+    COLOR_LOGICOP_AND_REVERSE       = 0x04 << 24,
+    COLOR_LOGICOP_INVERT            = 0x05 << 24,
+    COLOR_LOGICOP_XOR               = 0x06 << 24,
+    COLOR_LOGICOP_NAND              = 0x07 << 24,
+    COLOR_LOGICOP_AND               = 0x08 << 24,
+    COLOR_LOGICOP_EQUIV             = 0x09 << 24,
+    COLOR_LOGICOP_NOOP0             = 0x0A << 24,
+    COLOR_LOGICOP_OR_INVERTED1      = 0x0B << 24,
+    COLOR_LOGICOP_COPY              = 0x0C << 24,
+    COLOR_LOGICOP_OR_REVERSE        = 0x0D << 24,
+    COLOR_LOGICOP_OR                = 0x0E << 24,
+    COLOR_LOGICOP_SET               = 0x0F << 24,
+
+    COLOR_LOGICOP_MASK              = 0x0F << 24,
+    COLOR_LOGICOP_SHIFT             = 24,
 } ColorLogicalOp;
 
 /**
@@ -5353,15 +5676,18 @@ typedef enum {
  *        in the destination DC.
  * \param dy The y coordinate of the upper-left corner of the rectangle
  *        in the destination DC.
- * \param dwRop The color blending method, see \a ColorBlendMethod.
- *        This argument is only valid when Pixman is used.
+ * \param dwRop The color blending method, see \a ColorBlendMethod, OR'd
+ *        with a color logical operation, see \a ColorLogicalOp.
+ *        This argument is only valid when Pixman is used, or the hardware
+ *        provides a proper accelerator.
  *
  * \note When the source color key is specified for the blitting operation,
  *      or the formats of the device contexts are not supported by Pixman,
  *      this function will use the legacy implementation. In this situation,
  *      the color blending method will be ignored.
  *
- * \sa StretchBlt, SetMemDCAlpha, SetMemDCColorKey, ColorBlendMethod
+ * \sa StretchBlt, SetMemDCAlpha, SetMemDCColorKey, ColorBlendMethod,
+ *      ColorLogicalOp
  */
 MG_EXPORT void GUIAPI BitBlt (HDC hsdc, int sx, int sy, int sw, int sh,
                 HDC hddc, int dx, int dy, DWORD dwRop);
@@ -5371,18 +5697,20 @@ MG_EXPORT void GUIAPI BitBlt (HDC hsdc, int sx, int sy, int sw, int sh,
  */
 typedef enum {
     /** The fast filter (DDA scaler) */
-    SCALING_FILTER_FAST     = 0x00000000,
+    SCALING_FILTER_FAST         = 0x0000 << 16,
     /** The good filter */
-    SCALING_FILTER_GOOD     = 0x00010000,
+    SCALING_FILTER_GOOD         = 0x0001 << 16,
     /** The best filter */
-    SCALING_FILTER_BEST     = 0x00020000,
+    SCALING_FILTER_BEST         = 0x0002 << 16,
     /** The filter using nearest algorithm */
-    SCALING_FILTER_NEAREST  = 0x00020000,
+    SCALING_FILTER_NEAREST      = 0x0003 << 16,
     /** The filter using bi-linear algorithm */
-    SCALING_FILTER_BILINEAR = 0x00040000,
+    SCALING_FILTER_BILINEAR     = 0x0004 << 16,
     /** The filter using convolution algorithm */
-    SCALING_FILTER_CONVOLUTION = 0x00050000,
-    SCALING_FILTER_SHIFT    = 16,
+    SCALING_FILTER_CONVOLUTION  = 0x0005 << 16,
+
+    SCALING_FILTER_MASK         = (0x0F << 16),
+    SCALING_FILTER_SHIFT        = 16,
 } ScalingFilter;
 
 /**
@@ -5435,8 +5763,10 @@ typedef struct _STRETCH_EXTRA_INFO {
  * \param sei The pointer to a stretch extra information strucure;
  *        can be NULL. Note this only works when Pixman is used.
  * \param dwRop The color blending method, see \a ColorBlendMethod, OR'd
- *        with a fiter of the scaling, see \a ScalingFilter.
- *        This argument only works when Pixman is used.
+ *        with a fiter of the scaling, see \a ScalingFilter, and OR'd
+ *        with a color logical operation, see \a ColorLogicalOp.
+ *        This argument only works when Pixman is used or the hardware
+ *        provides a proper accelerator.
  *
  * \return TRUE for success, FALSE for bad arguments and there is no any
  *      drawing occurred.
@@ -5448,7 +5778,7 @@ typedef struct _STRETCH_EXTRA_INFO {
  *      will be ignored.
  *
  * \sa BitBlt, SetMemDCAlpha, SetMemDCColorKey, STRETCH_EXTRA_INFO,
- *     ColorBlendMethod, ScalingFilter
+ *     ColorBlendMethod, ScalingFilter, ColorLogicalOp
  */
 MG_EXPORT BOOL GUIAPI StretchBltEx (HDC hsdc, int sx, int sy, int sw, int sh,
         HDC hddc, int dx, int dy, int dw, int dh,
@@ -10713,7 +11043,10 @@ MG_EXPORT int GUIAPI GetTabbedTextExtent (HDC hdc,
             SetDCAttr (hdc, DC_ATTR_TEXT_ALIGN, (DWORD)ta_flags)
 
 #define BIDI_FLAG_LTR       0x00
-#define BIDI_FLAG_RTL       0x10
+#define BIDI_FLAG_RTL       0x01
+
+#define BIDI_FLAG_NONE      BIDI_FLAG_LTR
+#define BIDI_FLAG_LEGACY    0x10
 
 #define GetBIDIFlags(hdc)                   \
             GetDCAttr (hdc, DC_ATTR_BIDI_FLAGS)
@@ -12632,7 +12965,7 @@ MG_EXPORT int GUIAPI BIDIGetTextVisualAChars (LOGFONT* log_font,
  *      Achar32* achars, int nr_achars, int pel,
  *      void* extra, CB_REVERSE_ARRAY cb_reverse_extra)
  * \brief Reorder the specified logical glyph string in visual order and
- * reorder an extra array to reflect the visule order of the achars.
+ * reorder an extra array to reflect the visual order of the achars.
  *
  * This function reorders the logical glyph string in place to visual order.
  * If \a extra and \a cb_reverse_extra are both not NULL, it also reorders
@@ -12837,6 +13170,105 @@ MG_EXPORT int GUIAPI GetACharsExtent (HDC hdc, Achar32* achars, int nr_achars,
 MG_EXPORT int GUIAPI GetACharsExtentPoint (HDC hdc, Achar32* achars,
         int nr_achars, int max_extent, SIZE* size);
 
+/**
+ * \fn int GUIAPI GetACharsExtentPointEx (HDC hdc, Achar32* achars, \
+ *         int nr_achars, int max_extent, int* dx_chars, SIZE* size)
+ * \brief Get the visual extent value of an achar string.
+ *
+ * This function gets the visual extent value of a glpyh string.
+ * Note that this function ignore all breaks in the achar string.
+ *
+ * \param hdc The device context.
+ * \param achars The pointer to the achar string.
+ * \param nr_achars The length of the achar string len.
+ * \param max_extent The maximal output extent value.
+ * \param dx_achars The output positions of each character in the text will be
+ *        returned through this pointer. It can be NULL.
+ * \param size The real extent of all visual achars in the achar string.
+ *
+ * \return The index of the last achar which can be fit to the extent.
+ *
+ * \sa GetACharsExtentPoint
+ *
+ * Since 5.0.12
+ */
+MG_EXPORT int GUIAPI GetACharsExtentPointEx (HDC hdc, Achar32* achars,
+        int nr_achars, int max_extent, int* dx_achars, SIZE* size);
+
+/**
+ * \fn int GUIAPI GetTabbedACharsExtent (HDC hdc, Achar32* achars,
+ *          int nr_achars, SIZE* size)
+ * \brief Get visual extent value of an achar string.
+ *
+ * This function gets the extent value of an achar string on a DC. Note that
+ * this function will ignore all breaks in the achar string.
+ *
+ * \param hdc The device context.
+ * \param achars The pointer to the achar string.
+ * \param nr_achars The length of the achar string.
+ * \param size The buffer restoring the extents of the achar strings.
+ *
+ * \return The extent of the achar string.
+ *
+ * \sa GetTabbedACharsExtentPoint
+ *
+ * Since 5.0.12
+ */
+MG_EXPORT int GUIAPI GetTabbedACharsExtent (HDC hdc, Achar32* achars,
+        int nr_achars, SIZE* size);
+
+/**
+ * \fn int GUIAPI GetTabbedACharsExtentPoint (HDC hdc, Achar32* achars,
+ *         int nr_achars, int max_extent, SIZE* size)
+ * \brief Get the visual extent value of an achar string.
+ *
+ * This function gets the visual extent value of a glpyh string.
+ * Note that this function ignore all breaks in the achar string.
+ *
+ * \param hdc The device context.
+ * \param achars The pointer to the achar string.
+ * \param nr_achars The length of the achar string len.
+ * \param max_extent The maximal output extent value.
+ * \param size The real extent of all visual achars in the achar string.
+ *
+ * \return The the index of the last achar which can be fit to the extent.
+ *
+ * \sa GetTabbedACharsExtentPointEx
+ *
+ * Since 5.0.12
+ */
+MG_EXPORT int GUIAPI GetTabbedACharsExtentPoint (HDC hdc, Achar32* achars,
+        int nr_achars, int max_extent, SIZE* size);
+
+/**
+ * \fn int GUIAPI GetTabbedACharsExtentPointEx (HDC hdc,
+ *          Achar32* achars, int nr_achars, int max_extent,
+ *          int* dx_chars, int* dy_chars, SIZE* size)
+ * \brief Get the visual extent value of an achar string.
+ *
+ * This function gets the visual extent value of a glpyh string.
+ * Note that this function ignore all breaks in the achar string.
+ *
+ * \param hdc The device context.
+ * \param achars The pointer to the achar string.
+ * \param nr_achars The length of the achar string len.
+ * \param max_extent The maximal output extent value.
+ * \param dx_achars The output x-positions of each character in the text
+ *      will be returned through this pointer. It can be NULL.
+ * \param dy_achars The output y-positions of each character in the text
+ *      will be returned through this pointer. It can be NULL.
+ * \param size The real extent of all visual achars in the achar string.
+ *
+ * \return The index of the last achar which can be fit to the extent.
+ *
+ * \sa GetTabbedACharsExtentPoint
+ *
+ * Since 5.0.12
+ */
+MG_EXPORT int GUIAPI GetTabbedACharsExtentPointEx (HDC hdc,
+        Achar32* achars, int nr_achars, int max_extent,
+        int* dx_achars, int* dy_achars, SIZE* size);
+
 /**
  * \fn Glyph32 GUIAPI GetGlyphValue (LOGFONT* logfont, const char* mchar, \
  *         int mchar_len, const char* pre_mchar, int pre_len)
@@ -12870,7 +13302,7 @@ MG_EXPORT Glyph32 GUIAPI GetGlyphValueAlt(LOGFONT* logfont, Achar32 chv);
  *         int* adv_x, int* adv_y)
  * \brief Draw a glyph.
  *
- * This function draws a glyph to the specific postion of a DC.
+ * This function draws a glyph to the specific position of a DC.
  *
  * \param hdc The device context.
  * \param x The output start x position.
@@ -12886,6 +13318,27 @@ MG_EXPORT Glyph32 GUIAPI GetGlyphValueAlt(LOGFONT* logfont, Achar32 chv);
 MG_EXPORT int GUIAPI DrawGlyph (HDC hdc, int x, int y, Glyph32 glyph_value,
         int* adv_x, int* adv_y);
 
+/**
+ * \fn int GUIAPI DrawVowel (HDC hdc, int x, int y, Glyph32 glyph_value, \
+ *         int last_adv)
+ * \brief Draw a glyph as vowel.
+ *
+ * This function draws a glyph as a vowel of the last glyph to
+ * the specific position of a DC.
+ *
+ * \param hdc The device context.
+ * \param x The output start x position.
+ * \param y The output start y position.
+ * \param glyph_value The glyph value.
+ * \param last_adv The advance on the baseline of the last glyph.
+ *
+ * \return The advance on baseline of the vowel.
+ *
+ * Since 5.0.13
+ */
+MG_EXPORT int GUIAPI DrawVowel (HDC hdc, int x, int y, Glyph32 glyph_value,
+        int last_adv);
+
 /*
  * \fn int GUIAPI DrawGlyphString (HDC hdc, Glyph32* glyphs, int nr_glyphs,
  *      const POINT* pts);

include/minigui.h

@@ -456,6 +456,45 @@ MG_EXPORT void GUIAPI MiniGUIPanic (int exitcode);
      * @{
      */
 
+/**
+ * \fn GHANDLE GUIAPI JoinLayerEx (const char* layer_name,
+                const char* client_name,
+                int max_nr_highers, int max_nr_normals, int *cli_id)
+ * \brief Joins to a layer and returns the client identifier if success.
+ *
+ * This function should be called by clients before calling any other MiniGUI
+ * functions. You can call \a GetLayerInfo to get the layer information.
+ * If the layer to be joined does not exist, the server, i.e. \a mginit, will
+ * try to create a new one. If you passed a NULL pointer or a null string for
+ * \a layer_name, the client will join to the default layer.
+ *
+ * If the client want to create a new layer, you should specify the maximal
+ * number of z-nodes in the higher level (max_nr_highers) and the maximal
+ * number of z-nodes in the normal level (max_nr_normals) of the new layer.
+ * Passing zero to \a max_nr_highers and max_nr_normals will use the default
+ * values, and the default values are specified by ServerStartup.
+ *
+ * Note that the server will create a default layer named "mginit".
+ *
+ * \param layer_name The name of the layer. You can use NAME_TOPMOST_LAYER to
+ *        specify the current topmost layer.
+ * \param client_name The name of the client.
+ * \param max_nr_highers The maximal number of z-nodes in the higher level of
+ *        the new layer.
+ * \param max_nr_normals The maximal number of z-nodes in the normal level of
+ *        the new layer.
+ * \param cli_id The pointer to a buffer of int to return the client identifier.
+ *
+ * \return The handle to the layer on success, INV_LAYER_HANDLE on error.
+ *
+ * \note Only call this function in clients of MiniGUI-Processes.
+ *
+ * \sa GetLayerInfo, ServerStartup, ServerCreateLayer
+ */
+MG_EXPORT GHANDLE GUIAPI JoinLayerEx (const char* layer_name,
+                const char* client_name,
+                int max_nr_highers, int max_nr_normals, int *cli_id);
+
 /**
  * \fn GHANDLE GUIAPI JoinLayer (const char* layer_name,
                 const char* client_name,
@@ -490,9 +529,30 @@ MG_EXPORT void GUIAPI MiniGUIPanic (int exitcode);
  *
  * \sa GetLayerInfo, ServerStartup, ServerCreateLayer
  */
-MG_EXPORT GHANDLE GUIAPI JoinLayer (const char* layer_name,
+static inline GHANDLE GUIAPI JoinLayer (const char* layer_name,
                 const char* client_name,
-                int max_nr_highers, int max_nr_normals);
+                int max_nr_highers, int max_nr_normals)
+{
+    return JoinLayerEx (layer_name, client_name,
+                max_nr_highers, max_nr_normals, NULL);
+}
+
+/**
+ * \fn int GUIAPI GetClientId (void)
+ * \brief Gets the client identifier.
+ *
+ * You can get the information of a layer through this function.
+ * The information will be returned through the pointer arguments
+ * if the specific pointer is not NULL.
+ *
+ * \return Returns the client identifier of the current process.
+ *      Note that the server always returns 0.
+ *
+ * \sa JoinLayerEx
+ *
+ * Since 5.2.0
+ */
+MG_EXPORT int GUIAPI GetClientId (void);
 
 /**
  * \fn GHANDLE GUIAPI GetLayerInfo (const char* layer_name,
@@ -2125,7 +2185,7 @@ MG_EXPORT int GUIAPI ServerSendReplyEx (int clifd,
  * \fn int GUIAPI ServerSendReply (int clifd, const void* reply, int len)
  * \brief Sends the reply to the client.
  *
- * This function sends a replay pointed to by \a reply which is
+ * This function sends a reply pointed to by \a reply which is
  * \a len bytes long to the client.
  *
  * \note Only used by the server to send the reply to the client.
@@ -2673,6 +2733,26 @@ MG_EXPORT void GUIAPI DesktopUpdateAllWindow (void);
 
 #define DUMMY_LAYER_HANDLE  (GHANDLE)(-1)
 
+/**
+ * \fn GHANDLE GUIAPI JoinLayerEx (const char* layer_name,
+                const char* client_name,
+                int max_nr_highers, int max_nr_normals, int *cli_fd)
+ * \brief The dummy replacement of the same function for MiniGUI-Processes.
+ *
+ * This function is a replacment of the same function for MiniGUI-Processes
+ * runtime mode. We provide this function for MiniGUI-Threads and
+ * MiniGUI-Standalone runtime modes, in order to avoid using the
+ * conditional compilation instructions in your source code.
+ *
+ * \return Always returns DUMMY_LAYER_HANDLE to indicate success.
+ */
+static inline GHANDLE GUIAPI JoinLayerEx (const char* layer_name,
+        const char* client_name,
+        int max_nr_highers, int max_nr_normals, int *cli_fd)
+{
+    return DUMMY_LAYER_HANDLE;
+}
+
 /**
  * \fn GHANDLE GUIAPI JoinLayer (const char* layer_name,
                 const char* client_name,
@@ -2687,7 +2767,8 @@ MG_EXPORT void GUIAPI DesktopUpdateAllWindow (void);
  * \return Always returns DUMMY_LAYER_HANDLE to indicate success.
  */
 static inline GHANDLE GUIAPI JoinLayer (const char* layer_name,
-        const char* client_name, int max_nr_highers, int max_nr_normals)
+        const char* client_name,
+        int max_nr_highers, int max_nr_normals)
 {
     return DUMMY_LAYER_HANDLE;
 }

include/window.h

@@ -2990,18 +2990,22 @@ typedef struct _WINMASKINFO {
    if the client moved to a new layer */
 #define MSG_LAYERCHANGED    0x0149
 
+/* Since 5.2.0; the server send this message to the client
+   if a window has been composited to the screen.  */
+#define MSG_WINCOMPOSITED   0x014A
+
 #endif /* defined _MGRM_PROCESSES */
 
 /* Since 5.0.0: for managing message thread */
-#define MSG_MANAGE_MSGTHREAD    0x014A
+#define MSG_MANAGE_MSGTHREAD    0x014B
     #define MSGTHREAD_SIGNIN        0x00
     #define MSGTHREAD_SIGNOUT       0x01
 
 /* Since 5.0.0: for calculating the default position */
-#define MSG_CALC_POSITION       0x014B
+#define MSG_CALC_POSITION       0x014C
 
 /* Since 5.0.6: for waking up the client */
-#define MSG_WAKEUP_CLIENT       0x014C
+#define MSG_WAKEUP_CLIENT       0x014D
 
 /**
  * \def MSG_DOESNEEDIME
@@ -7237,6 +7241,31 @@ MG_EXPORT BOOL GUIAPI SetMainWindowGestureFlags (HWND hWnd, DWORD dwFlags);
 
 #ifdef _MGSCHEMA_COMPOSITING
 
+/**
+ * \fn int GUIAPI GetWindowSharedSurfaceFD (HWND hwnd, size_t *map_size,
+ *      DWORD *flags)
+ * \brief Gets the file descriptor of the surface buffer for a window or
+ * the main window it locates.
+ *
+ * This function gets the file descriptor of the surface buffer for
+ * the specified window if it is a main window or the main window it locates.
+ * Note that if the window is a control that has the style `WS_EX_CTRLASMAINWIN`,
+ * the window will have a separate surface buffer.
+ *
+ * \param hwnd The handle to the window.
+ *
+ * \return An integer larger than or equal to 0 for a valid file descriptor,
+ *      otherwise a negative value.
+ *
+ * \note This function only available when _MGSCHEMA_COMPOSITING is defined.
+ *
+ * \sa CreateMemDCFromSharedSurfaceFD
+ *
+ * Since 5.0.13
+ */
+MG_EXPORT int GUIAPI GetWindowSharedSurfaceFD (HWND hWnd, size_t *map_size,
+        DWORD *flags);
+
 /**
  * \fn BOOL GUIAPI SetMainWindowCompositing (HWND hWnd,
         int type, DWORD arg)

minigui.pc.in

@@ -2,11 +2,12 @@ prefix=@prefix@
 exec_prefix=@exec_prefix@
 libdir=@libdir@
 includedir=@includedir@
+runmode=@MINIGUI_RUNMODE@
+libsuffix=@MGLIB_SUFFIX@
 
 Name: MiniGUI
 Description: A mature cross-platform windowing and GUI system for embedded systems and IoT smart devices.
 Version: @MINIGUI_VERSION@
-Runmode: @MINIGUI_RUNMODE@
 Requires:
 Libs: -L${libdir} -lminigui_@MGLIB_SUFFIX@ @DEP_LIBS@
 Libs.private:

src/client/client.c

@@ -184,6 +184,23 @@ static void process_socket_message (MSG *msg)
                 LOSWORD(msg->wParam), HISWORD(msg->wParam),
                 LOSWORD(msg->lParam), HISWORD(msg->lParam));
     }
+#ifdef _MGSCHEMA_COMPOSITING
+    else if (msg->message == MSG_WINCOMPOSITED) {
+        /* Since 5.2.0 */
+        int slot = (int)msg->wParam;
+        HWND hwnd = (HWND)msg->lParam;
+        unsigned dirty_age = (unsigned)msg->time;
+        if (__mg_client_check_znode_hwnd(slot, hwnd, __mg_client_id)) {
+            GAL_Surface *ssurf = ((PMAINWIN)hwnd)->surf;
+            assert(ssurf->shared_header);
+            __mg_lock_file_for_write(ssurf->fd);
+            if (ssurf->dirty_info->dirty_age == dirty_age) {
+                ssurf->dirty_info->nr_dirty_rcs = 0;
+            }
+            __mg_unlock_file_for_write(ssurf->fd);
+        }
+    }
+#endif
     else {
         if (msg->hwnd == HWND_NULL) {
             msg->hwnd = HWND_DESKTOP;
@@ -518,8 +535,8 @@ BOOL client_IdleHandler4Client (PMSGQUEUE msg_queue, BOOL wait)
     return (n > 0);
 }
 
-GHANDLE GUIAPI JoinLayer (const char* layer_name, const char* client_name,
-               int max_nr_topmosts, int max_nr_normals)
+GHANDLE GUIAPI JoinLayerEx (const char* layer_name, const char* client_name,
+               int max_nr_topmosts, int max_nr_normals, int *cli_id)
 {
     GHANDLE layer_handle = INV_LAYER_HANDLE;
     REQUEST req;
@@ -529,8 +546,12 @@ GHANDLE GUIAPI JoinLayer (const char* layer_name, const char* client_name,
     if (mgIsServer)
         return layer_handle;
 
-    if (__mg_client_id != 0) /* Already joined, return the handle */
+    if (__mg_client_id != 0) {
+        /* Already joined, return the handle */
+        if (cli_id)
+            *cli_id = __mg_client_id;
         return GetLayerInfo (NAME_SELF_LAYER, NULL, NULL, NULL);
+    }
 
     if (layer_name) {
         strncpy (info.layer_name, layer_name, LEN_LAYER_NAME);
@@ -593,10 +614,18 @@ GHANDLE GUIAPI JoinLayer (const char* layer_name, const char* client_name,
 
     __mg_start_client_desktop ();
 
+    if (cli_id)
+        *cli_id = __mg_client_id;
+
 ret:
     return layer_handle;
 }
 
+int GUIAPI GetClientId (void)
+{
+    return __mg_client_id;
+}
+
 GHANDLE GUIAPI GetLayerInfo (const char* layer_name,
                 int* nr_clients, BOOL* is_topmost, int* cli_active)
 {

src/control/listmodel.c

@@ -404,7 +404,7 @@ void mglist_set_itemops (MgList *mglst, PMGITEMOPS iop)
     mglst->iop = *iop;
 }
 
-int DefaultItemViewProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam,
+LRESULT DefaultItemViewProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam,
                          PSCRDATA pscrdata, MgList *mglst)
 {
     switch (message) {

src/control/listmodel.h

@@ -140,7 +140,7 @@ struct _MgList
 
 /* ------------------------- external api -------------------------- */
 
-MG_EXPORT int DefaultItemViewProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam,
+MG_EXPORT LRESULT DefaultItemViewProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam,
                          PSCRDATA pscrdata, MgList *mglst);
 
 MG_EXPORT SVITEM_DRAWFUNC mglist_set_itemdraw (MgList *mglst, SVITEM_DRAWFUNC draw_func);

src/control/scrolled.c

@@ -589,7 +589,7 @@ int scrolled_init (HWND hWnd, PSCRDATA pscrdata, int w, int h)
     return 0;
 }
 
-int DefaultScrolledProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
+LRESULT DefaultScrolledProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
 {
     PSCRDATA pscrdata = NULL;
 

src/control/scrolled.h

@@ -96,7 +96,7 @@ typedef struct _scrdata
 typedef SCRDATA *PSCRDATA;
 
 
-MG_EXPORT int     DefaultScrolledProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam);
+MG_EXPORT LRESULT DefaultScrolledProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam);
 MG_EXPORT int     scrolled_init (HWND hWnd, PSCRDATA pscrdata, int w, int h);
 MG_EXPORT void    scrolled_destroy (PSCRDATA pscrdata);
 MG_EXPORT void    scrolled_hscroll (HWND hWnd, PSCRDATA pscrdata, WPARAM wParam, LPARAM lParam);

src/font/bitmapfont.c

@@ -202,6 +202,17 @@ static void destroy (GLYPHTREENODE *root)
 
 /*** device font ops ***/
 
+static DWORD get_feature (LOGFONT* logfont, DEVFONT* devfont,
+        enum devfont_feature feature)
+{
+    switch (feature) {
+    case DEVFONT_FEATURE_MARK_BBOX:
+        return 0;
+    }
+
+    return 0;
+}
+
 static DWORD get_glyph_bmptype (LOGFONT* logfont, DEVFONT* devfont)
 {
     return DEVFONTGLYPHTYPE_PRERDRBMP;
@@ -380,6 +391,7 @@ static int get_glyph_bbox (LOGFONT* logfont, DEVFONT* devfont,
 
 /**************************** Global data ************************************/
 FONTOPS __mg_bitmap_font_ops = {
+    get_feature,
     get_glyph_bmptype,
     get_ave_width,
     get_max_width,

src/font/charset-arabic.c

@@ -15,7 +15,7 @@
  *   and Graphics User Interface (GUI) support system for embedded systems
  *   and smart IoT devices.
  *
- *   Copyright (C) 2002~2018, Beijing FMSoft Technologies Co., Ltd.
+ *   Copyright (C) 2002~2023, Beijing FMSoft Technologies Co., Ltd.
  *   Copyright (C) 1998~2002, WEI Yongming
  *
  *   This program is free software: you can redistribute it and/or modify
@@ -226,7 +226,7 @@ static int iso8859_6_conv_from_uc32 (Uchar32 wc, unsigned char* mchar)
 }
 #endif
 
-/* must attetion the para s is arabic chv value.*/
+#if 0
 static int is_arabic_char_vowel(Uint8 c)
 {
 
@@ -240,6 +240,7 @@ static int is_arabic_char_vowel(Uint8 c)
     */
     return 0;
 }
+#endif
 
 /* ISO8859-6 charset vowel relative define and judge */
 #define ISARABIC_VOWEL(s) ((s >= FATHATAN) && (s <= SUKUN))
@@ -469,9 +470,12 @@ static int iso8859_6_len_first_char (const unsigned char* mstr, int len)
 
 static unsigned int iso8859_6_char_type (Achar32 chv)
 {
+    chv = REAL_ACHAR(chv);
+#if 1
+    return sb_char_type(chv);
+#else
     unsigned int ch_type = ACHAR_BASIC_UNKNOWN;
 
-    chv = REAL_ACHAR(chv);
     if (is_arabic_char_vowel (chv)) {  /* is vowel */
         ch_type = ACHAR_BASIC_VOWEL;
     }
@@ -480,6 +484,7 @@ static unsigned int iso8859_6_char_type (Achar32 chv)
     }
 
     return ch_type;
+#endif
 }
 
 static BidiType __mg_iso8859_6_bidi_char_type_map[] = {
@@ -868,6 +873,7 @@ static CHARSETOPS CharsetOps_iso8859_6 = {
     3,
     FONT_CHARSET_ISO8859_6,
     0,
+    1,
     iso8859_6_len_first_char,
     iso8859_6_get_char_value,
     iso8859_6_get_shaped_char_value,

src/font/charset-unicode.c

@@ -15,7 +15,7 @@
  *   and Graphics User Interface (GUI) support system for embedded systems
  *   and smart IoT devices.
  *
- *   Copyright (C) 2002~2018, Beijing FMSoft Technologies Co., Ltd.
+ *   Copyright (C) 2002~2023, Beijing FMSoft Technologies Co., Ltd.
  *   Copyright (C) 1998~2002, WEI Yongming
  *
  *   This program is free software: you can redistribute it and/or modify
@@ -210,6 +210,8 @@ static unsigned int unicode_char_type (Achar32 chv)
         mchar_type = ACHAR_BASIC_LF;
     else if (break_type == UCHAR_BREAK_SPACE)
         mchar_type = ACHAR_BASIC_SPACE;
+    else if (basic_type == UCHAR_CATEGORY_NON_SPACING_MARK)
+        mchar_type = ACHAR_BASIC_VOWEL;
     else if (chv != 0x00AD && ISZEROWIDTHTYPE (basic_type))
         mchar_type = ACHAR_BASIC_ZEROWIDTH;
     else if ((chv >= 0x1160 && chv < 0x1200)
@@ -239,10 +241,36 @@ static const BidiType linear_enum_to_bidi_type[] = {
 #undef _UNIBIDI_ADD_TYPE
 };
 
+/* Since 5.0.13: this function only returns BidiType which
+   is recognizable by the legacy BIDI algorithm. */
 static BidiType unicode_bidi_char_type(Achar32 ch)
 {
     ch = REAL_ACHAR(ch);
-    return linear_enum_to_bidi_type[UNIBIDI_GET_BIDI_TYPE(ch)];
+    BidiType bt = linear_enum_to_bidi_type[UNIBIDI_GET_BIDI_TYPE(ch)];
+
+    switch (bt) {
+        case BIDI_TYPE_LTR:
+        case BIDI_TYPE_RTL:
+        case BIDI_TYPE_AL:
+        case BIDI_TYPE_EN:
+        case BIDI_TYPE_AN:
+        case BIDI_TYPE_ET:
+        case BIDI_TYPE_CS:
+        case BIDI_TYPE_NSM:
+        case BIDI_TYPE_BN:
+        case BIDI_TYPE_BS:
+        case BIDI_TYPE_SS:
+        case BIDI_TYPE_WS:
+        case BIDI_TYPE_ON:
+        case BIDI_TYPE_SOT:
+        case BIDI_TYPE_EOT:
+            return bt;
+        default:
+            _DBG_PRINTF("Not recognizable for char (0x%04x): %u\n", ch, bt);
+            break;
+    }
+
+    return BIDI_TYPE_WS;
 }
 
 BidiType GUIAPI UCharGetBidiType(Uchar32 uc)
@@ -628,6 +656,7 @@ CHARSETOPS __mg_CharsetOps_utf8 = {
     6,
     FONT_CHARSET_UTF8,
     0,
+    0,
     utf8_len_first_char,
     utf8_get_char_value,
     NULL,
@@ -854,6 +883,7 @@ CHARSETOPS __mg_CharsetOps_utf16le = {
     4,
     FONT_CHARSET_UTF16LE,
     0,
+    0,
     utf16le_len_first_char,
     utf16le_get_char_value,
     NULL,
@@ -1080,6 +1110,7 @@ CHARSETOPS __mg_CharsetOps_utf16be = {
     4,
     FONT_CHARSET_UTF16BE,
     0,
+    0,
     utf16be_len_first_char,
     utf16be_get_char_value,
     NULL,

src/font/charset.c

@@ -15,7 +15,7 @@
  *   and Graphics User Interface (GUI) support system for embedded systems
  *   and smart IoT devices.
  *
- *   Copyright (C) 2002~2018, Beijing FMSoft Technologies Co., Ltd.
+ *   Copyright (C) 2002~2023, Beijing FMSoft Technologies Co., Ltd.
  *   Copyright (C) 1998~2002, WEI Yongming
  *
  *   This program is free software: you can redistribute it and/or modify
@@ -235,6 +235,7 @@ static CHARSETOPS CharsetOps_ascii = {
     1,
     FONT_CHARSET_US_ASCII,
     0,
+    0,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -298,6 +299,7 @@ static CHARSETOPS CharsetOps_iso8859_1 = {
     1,
     FONT_CHARSET_ISO8859_1,
     0,
+    0,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -409,6 +411,7 @@ static CHARSETOPS CharsetOps_iso8859_2 = {
     1,
     FONT_CHARSET_ISO8859_2,
     0,
+    0,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -521,6 +524,7 @@ static CHARSETOPS CharsetOps_iso8859_3 = {
     1,
     FONT_CHARSET_ISO8859_3,
     0,
+    0,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -634,6 +638,7 @@ static CHARSETOPS CharsetOps_iso8859_4 = {
     1,
     FONT_CHARSET_ISO8859_4,
     0,
+    0,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -728,6 +733,7 @@ static CHARSETOPS CharsetOps_iso8859_5 = {
     1,
     FONT_CHARSET_ISO8859_5,
     0,
+    0,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -886,6 +892,7 @@ static CHARSETOPS CharsetOps_iso8859_7 = {
     1,
     FONT_CHARSET_ISO8859_7,
     0,
+    0,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -1159,6 +1166,7 @@ static CHARSETOPS CharsetOps_iso8859_8 = {
     2, // This is a trick for bidi reorder only implemented for MBC.
     FONT_CHARSET_ISO8859_8,
     0,
+    1,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -1260,6 +1268,7 @@ static CHARSETOPS CharsetOps_iso8859_9 = {
     1,
     FONT_CHARSET_ISO8859_9,
     0,
+    0,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -1373,6 +1382,7 @@ static CHARSETOPS CharsetOps_iso8859_10 = {
     1,
     FONT_CHARSET_ISO8859_10,
     0,
+    0,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -1485,6 +1495,7 @@ static CHARSETOPS CharsetOps_iso8859_11 = {
     1,
     FONT_CHARSET_ISO8859_11,
     0,
+    0,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -1597,6 +1608,7 @@ static CHARSETOPS CharsetOps_iso8859_13 = {
     1,
     FONT_CHARSET_ISO8859_13,
     0,
+    0,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -1709,6 +1721,7 @@ static CHARSETOPS CharsetOps_iso8859_14 = {
     1,
     FONT_CHARSET_ISO8859_14,
     0,
+    0,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -1820,6 +1833,7 @@ static CHARSETOPS CharsetOps_iso8859_15 = {
     1,
     FONT_CHARSET_ISO8859_15,
     0,
+    0,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -1970,6 +1984,7 @@ static CHARSETOPS CharsetOps_iso8859_16 = {
     1,
     FONT_CHARSET_ISO8859_16,
     0,
+    0,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -2167,6 +2182,7 @@ static CHARSETOPS CharsetOps_gb2312_0 = {
     2,
     FONT_CHARSET_GB2312_0,
     0,
+    0,
     gb2312_0_len_first_char,
     gb2312_0_get_char_value,
     NULL,
@@ -2324,6 +2340,7 @@ static CHARSETOPS CharsetOps_gbk = {
     2,
     FONT_CHARSET_GBK,
     0,
+    0,
     gbk_len_first_char,
     gbk_get_char_value,
     NULL,
@@ -2592,6 +2609,7 @@ static CHARSETOPS CharsetOps_gb18030_0 = {
     4,
     FONT_CHARSET_GB18030_0,
     0,
+    0,
     gb18030_0_len_first_char,
     gb18030_0_get_char_value,
     NULL,
@@ -2749,6 +2767,7 @@ static CHARSETOPS CharsetOps_big5 = {
     2,
     FONT_CHARSET_BIG5,
     0,
+    0,
     big5_len_first_char,
     big5_get_char_value,
     NULL,
@@ -2895,6 +2914,7 @@ static CHARSETOPS CharsetOps_ksc5601_0 = {
     2,
     FONT_CHARSET_EUCKR,
     0,
+    0,
     ksc5601_0_len_first_char,
     ksc5601_0_get_char_value,
     NULL,
@@ -3019,6 +3039,7 @@ static CHARSETOPS CharsetOps_jisx0201_0 = {
     1,
     FONT_CHARSET_JISX0201_0,
     0,
+    0,
     jisx0201_0_len_first_char,
     jisx0201_0_get_char_value,
     NULL,
@@ -3162,6 +3183,7 @@ static CHARSETOPS CharsetOps_jisx0208_0 = {
     2,
     FONT_CHARSET_JISX0208_0,
     0,
+    0,
     jisx0208_0_len_first_char,
     jisx0208_0_get_char_value,
     NULL,
@@ -3247,6 +3269,7 @@ static CHARSETOPS CharsetOps_jisx0201_1 = {
     1,
     FONT_CHARSET_JISX0201_1,
     0,
+    0,
     sb_len_first_char,
     sb_get_char_value,
     NULL,
@@ -3418,6 +3441,7 @@ static CHARSETOPS CharsetOps_jisx0208_1 = {
     2,
     FONT_CHARSET_JISX0208_1,
     0,
+    0,
     jisx0208_1_len_first_char,
     jisx0208_1_get_char_value,
     NULL,

src/font/freetype1.c

@@ -255,6 +255,17 @@ compute_kernval (TTFINSTANCEINFO* ttf_inst_info)
     return kernval;
 }
 
+static DWORD get_feature (LOGFONT* logfont, DEVFONT* devfont,
+        enum devfont_feature feature)
+{
+    switch (feature) {
+    case DEVFONT_FEATURE_MARK_BBOX:
+        return 0;
+    }
+
+    return 0;
+}
+
 static DWORD get_glyph_bmptype (LOGFONT* logfont, DEVFONT* devfont)
 {
     if (logfont->style & FS_WEIGHT_BOOK)
@@ -792,6 +803,7 @@ static int is_rotatable (LOGFONT* logfont, DEVFONT* devfont, int rot_desired)
 }
 /**************************** Global data ************************************/
 FONTOPS __mg_ttf_ops = {
+    get_feature,
     get_glyph_bmptype,
     get_ave_width,
     get_max_width,

src/font/freetype2.c

@@ -197,6 +197,17 @@ print_bitmap_grey (const BYTE* buffer, int width, int rows, int pitch)
     printf("*******************************************\n");
 }
 
+static DWORD get_feature (LOGFONT* logfont, DEVFONT* devfont,
+        enum devfont_feature feature)
+{
+    switch (feature) {
+    case DEVFONT_FEATURE_MARK_BBOX:
+        return 1;
+    }
+
+    return 0;
+}
+
 static DWORD get_glyph_bmptype (LOGFONT* logfont, DEVFONT* devfont)
 {
     switch (logfont->style & FS_RENDER_MASK) {
@@ -1265,6 +1276,7 @@ void font_TermFreetypeLibrary (void)
 
 /**************************** Global data ************************************/
 FONTOPS __mg_ttf_ops = {
+    get_feature,
     get_glyph_bmptype,
     get_ave_width,
     get_max_width,

src/font/legacy-bidi.c

@@ -735,8 +735,7 @@ Achar32* __mg_legacy_bidi_map_reorder (const CHARSETOPS* charset_ops,
         run_pos = node_p->pos;
         run_len = node_p->len;
 
-        for (i=0; i<run_len; i++)
-        {
+        for (i=0; i<run_len; i++) {
             (map+run_pos+i)->is_rtol = (node_p)->level & 1;
         }
     }

src/font/nullfont.c

@@ -66,6 +66,17 @@
 #define NUF_WIDTH   8
 #define NUF_HEIGHT  1
 
+static DWORD get_feature (LOGFONT* logfont, DEVFONT* devfont,
+        enum devfont_feature feature)
+{
+    switch (feature) {
+    case DEVFONT_FEATURE_MARK_BBOX:
+        return 0;
+    }
+
+    return 0;
+}
+
 static DWORD get_glyph_bmptype (LOGFONT* logfont, DEVFONT* devfont)
 {
     return DEVFONTGLYPHTYPE_MONOBMP;
@@ -171,6 +182,7 @@ static void unload_font_data (DEVFONT* devfont, void* data)
 }
 
 FONTOPS __mg_null_font_ops = {
+    get_feature,
     get_glyph_bmptype,
     get_ave_width,
     get_max_width,

src/font/qpf.c

@@ -287,6 +287,17 @@ static unsigned char def_smooth_bitmap [] =
 static QPF_GLYPH def_glyph = {&def_metrics, def_bitmap};
 static QPF_GLYPH def_smooth_glyph = {&def_smooth_metrics, def_smooth_bitmap};
 
+static DWORD get_feature (LOGFONT* logfont, DEVFONT* devfont,
+        enum devfont_feature feature)
+{
+    switch (feature) {
+    case DEVFONT_FEATURE_MARK_BBOX:
+        return 0;
+    }
+
+    return 0;
+}
+
 static DWORD get_glyph_bmptype (LOGFONT* logfont, DEVFONT* devfont)
 {
     if (QPFONT_INFO_P (devfont)->fm->flags & FLAG_MODE_SMOOTH)
@@ -541,6 +552,7 @@ static int is_rotatable (LOGFONT* logfont, DEVFONT* devfont, int rot_desired)
 
 /**************************** Global data ************************************/
 FONTOPS __mg_qpf_ops = {
+    get_feature,
     get_glyph_bmptype,
     get_ave_width,
     get_max_width,

src/font/rawbitmap.c

@@ -151,6 +151,17 @@ static void unload_font_data (DEVFONT* devfont, void* data)
 
 /*************** Raw bitmap font operations *********************************/
 
+static DWORD get_feature (LOGFONT* logfont, DEVFONT* devfont,
+        enum devfont_feature feature)
+{
+    switch (feature) {
+    case DEVFONT_FEATURE_MARK_BBOX:
+        return 0;
+    }
+
+    return 0;
+}
+
 static DWORD get_glyph_bmptype (LOGFONT* logfont, DEVFONT* devfont)
 {
     return DEVFONTGLYPHTYPE_MONOBMP;
@@ -280,6 +291,7 @@ static int is_rotatable (LOGFONT* logfont, DEVFONT* devfont, int rot_desired)
 
 /**************************** Global data ************************************/
 FONTOPS __mg_rbf_ops = {
+    get_feature,
     get_glyph_bmptype,
     get_ave_width,
     get_ave_width,  // max_width same as ave_width

src/font/scripteasy.c

@@ -377,6 +377,17 @@ static int get_max_width (LOGFONT* logfont, DEVFONT* devfont)
     return logfont->size;
 }
 
+static DWORD get_feature (LOGFONT* logfont, DEVFONT* devfont,
+        enum devfont_feature feature)
+{
+    switch (feature) {
+    case DEVFONT_FEATURE_MARK_BBOX:
+        return 0;
+    }
+
+    return 0;
+}
+
 static DWORD get_glyph_bmptype (LOGFONT* logfont, DEVFONT* devfont)
 {
     if (logfont->style & FS_WEIGHT_BOOK)
@@ -598,6 +609,7 @@ static int is_rotatable (LOGFONT* logfont, DEVFONT* devfont, int rot_desired)
 
 /**************************** Global data ************************************/
 static FONTOPS scripteasy_font_ops = {
+    get_feature,
     get_glyph_bmptype,
     get_ave_width,
     get_max_width,

src/font/upf.c

@@ -148,6 +148,17 @@ static void unload_font_data (DEVFONT* devfont, void* data)
     free (((UPFINFO*) data));
 }
 
+static DWORD get_feature (LOGFONT* logfont, DEVFONT* devfont,
+        enum devfont_feature feature)
+{
+    switch (feature) {
+    case DEVFONT_FEATURE_MARK_BBOX:
+        return 0;
+    }
+
+    return 0;
+}
+
 static DWORD get_glyph_bmptype (LOGFONT* logfont, DEVFONT* devfont)
 {
     Uint8* p_upf = (Uint8 *)UPFONT_INFO_P (devfont)->root_dir;
@@ -525,6 +536,7 @@ static int is_rotatable (LOGFONT* logfont, DEVFONT* devfont, int rot_desired)
 }
 
 FONTOPS __mg_upf_ops = {
+    get_feature,
     get_glyph_bmptype,
     get_ave_width,
     get_max_width,

src/font/varbitmap.c

@@ -109,6 +109,17 @@ typedef struct _FONT_PROPT {
     int def_glyph;
 } FONT_PROPT;
 
+static DWORD get_feature (LOGFONT* logfont, DEVFONT* devfont,
+        enum devfont_feature feature)
+{
+    switch (feature) {
+    case DEVFONT_FEATURE_MARK_BBOX:
+        return 0;
+    }
+
+    return 0;
+}
+
 static DWORD get_glyph_bmptype (LOGFONT* logfont, DEVFONT* devfont)
 {
     return DEVFONTGLYPHTYPE_MONOBMP;
@@ -477,6 +488,7 @@ static void unload_font_data (DEVFONT* devfont, void* data)
 }
 
 FONTOPS __mg_vbf_ops = {
+    get_feature,
     get_glyph_bmptype,
     get_ave_width,
     get_max_width,

src/gui/menu.c

@@ -2185,7 +2185,7 @@ static int create_memdc_for_menu (TRACKMENUINFO* ptmi)
         return -1;
     }
 
-    ptmi->dc = CreateMemDCFromSurface (surf);
+    ptmi->dc = __mg_create_memdc_for_surface (surf);
     if (ptmi->dc == HDC_INVALID) {
         GAL_FreeSurface (surf);
         return -1;

src/gui/window.c

@@ -4476,10 +4476,10 @@ HWND GUIAPI CreateMainWindowEx2 (PMAINWINCREATE pCreateInfo, LINT id,
 #endif
 
 #ifdef _MGSCHEMA_COMPOSITING
-    // Close file descriptor to free kernel memory?
-    if (pWin->surf->shared_header) {
-        close (pWin->surf->shared_header->fd);
-        pWin->surf->shared_header->fd = -1;
+    /* Since 5.2.0: keep fd available. */
+    if (0 && pWin->surf->shared_header) {
+        close (pWin->surf->fd);
+        pWin->surf->fd = -1;
     }
 #endif
 
@@ -5585,11 +5585,13 @@ BOOL GUIAPI ValidateRegion (HWND hWnd, const CLIPRGN* pRgn)
 BOOL GUIAPI GetUpdateRect (HWND hWnd, RECT* update_rect)
 {
     PMAINWIN pWin;
+    RECT rcClient;
 
     MG_CHECK_RET (MG_IS_NORMAL_WINDOW(hWnd), FALSE);
     pWin = MG_GET_WINDOW_PTR (hWnd);
 
-    *update_rect = pWin->InvRgn.rgn.rcBound;
+    GetClientRect(hWnd, &rcClient);
+    IntersectRect(update_rect, &pWin->InvRgn.rgn.rcBound, &rcClient);
     return TRUE;
 }
 
@@ -6036,10 +6038,10 @@ HWND GUIAPI CreateWindowEx2 (const char* spClassName,
     }
 
 #ifdef _MGSCHEMA_COMPOSITING
-    // Close file descriptor to free kernel memory?
-    if (dwExStyle & WS_EX_CTRLASMAINWIN && pNewCtrl->surf->shared_header) {
-        close (pNewCtrl->surf->shared_header->fd);
-        pNewCtrl->surf->shared_header->fd = -1;
+    /* Since 5.2.0: keep fd available. */
+    if (0 && dwExStyle & WS_EX_CTRLASMAINWIN && pNewCtrl->surf->shared_header) {
+        close (pNewCtrl->surf->fd);
+        pNewCtrl->surf->fd = -1;
     }
 #endif
 
@@ -6066,6 +6068,28 @@ error:
     return HWND_INVALID;
 }
 
+#ifdef _MGSCHEMA_COMPOSITING
+int GUIAPI GetWindowSharedSurfaceFD (HWND hWnd, size_t *map_size, DWORD *flags)
+{
+    MG_CHECK_RET (MG_IS_NORMAL_WINDOW (hWnd), -1);
+
+    PMAINWIN pWin = (PMAINWIN)hWnd;
+    if (pWin->surf->shared_header) {
+        if (map_size)
+            *map_size = pWin->surf->shared_header->map_size;
+        if (flags) {
+            *flags = MEMDC_FLAG_SWSURFACE;
+            if (pWin->surf->shared_header->byhw)
+                *flags |= MEMDC_FLAG_HWSURFACE;
+        }
+
+        return pWin->surf->fd;
+    }
+
+    return -1;
+}
+#endif /* _MGSCHEMA_COMPOSITING */
+
 BOOL GUIAPI DestroyWindow (HWND hWnd)
 {
     PCONTROL pCtrl;

src/include/client.h

@@ -105,6 +105,10 @@
 #define REQID_GETSHAREDSURFACE      0x001C
     // for compositing schema
     #define SYSSF_WALLPAPER_PATTER      "syssf-wallpaper-pattern"
+    #define APPSF_NAME_PREFIX           "appsf-name-"
+    #define APPSF_NAME_PATTER           "appsf-name-%s"
+    #define APPSF_HWND_PREFIX           "appsf-hwnd-"
+    #define APPSF_HWND_PATTER           "appsf-hwnd-%d-%p"
     // for sharedfb schema
     #define SYSSF_REAL_SCREEN           "syssf-real-screen"
     #define SYSSF_SHADOW_SCREEN         "syssf-shadow-screen"
@@ -113,10 +117,22 @@
 #define REQID_LOADCURSOR_PNG        0x001D
 // Load cursor from in-memory PNG
 #define REQID_LOADCURSOR_PNG_MEM    0x001E
+
+#if 0 // Deprecated since 5.2.0
 // allocate semaphore for shared surface
 #define REQID_ALLOC_SURF_SEM        0x001F
 // free semaphore of shared surface
 #define REQID_FREE_SURF_SEM         0x0020
+#endif
+
+/* Since 5.2.0 */
+// Operate a shared surface to register/revoke the name and set the fd
+#define REQID_OPERATENAMEDSSURF     0x001F
+    #define ID_NAMEDSSURFOP_REGISTER    1
+    #define ID_NAMEDSSURFOP_SET         2
+    #define ID_NAMEDSSURFOP_REVOKE      3
+
+#define REQID_RESERVED              0x0020
 
 // Move the current client to another layer
 #define REQID_MOVETOLAYER           0x0021
@@ -142,15 +158,23 @@ MGUI_COMPILE_TIME_ASSERT(sys_request_id, MAX_SYS_REQID >= REQID_SYS_LAST);
 
 #undef MGUI_COMPILE_TIME_ASSERT
 
+/* Since 5.2.0 */
+typedef struct OperateNSSurfInfo
+{
+    int     id_op;
+    char    name[NAME_MAX + 1];
+    size_t  map_size;
+} OPERATENSSURFINFO;
+
 /* Since 5.0.0 */
 typedef struct _SharedSurfInfo {
+    size_t      size;       // whole size of the surface
+    off_t       offset;     // offset of pixel data
     uint32_t    flags;      // the flags of the surface
     uint32_t    width, height;
     uint32_t    pitch;
     uint32_t    name;       // when use flink name
     uint32_t    drm_format; // DRM pixel format
-    size_t      size;       // whole size of the surface
-    off_t       offset;     // offset of pixel data
 } SHAREDSURFINFO;
 
 typedef struct JoinLayerInfo {
@@ -359,6 +383,7 @@ void __mg_start_client_desktop (void);
 
 void __mg_update_window (HWND hwnd, int left, int top, int right, int bottom);
 
+BOOL __mg_client_check_znode_hwnd (int slot, HWND hwnd, int cli);
 BOOL __mg_client_check_hwnd (HWND hwnd, int cli);
 BOOL __mg_client_on_layer_changed (GHANDLE layer_handle, int zi_shmid);
 

src/include/dc.h

@@ -521,14 +521,16 @@ static inline void _dc_step_y (PDC pdc, int step)
 
 #       define BLOCK_DRAW_SEM(pdc)                                  \
 do {                                                                \
-    if (pdc->surface->shared_header)                                \
-        LOCK_SURFACE_SEM (pdc->surface->shared_header->sem_num);    \
+    if (pdc->surface->shared_header) {                              \
+        __mg_lock_file_for_write(pdc->surface->fd);                 \
+    }                                                               \
 } while (0)
 
 #       define UNBLOCK_DRAW_SEM(pdc)                                \
 do {                                                                \
-    if (pdc->surface->shared_header)                                \
-        UNLOCK_SURFACE_SEM (pdc->surface->shared_header->sem_num);  \
+    if (pdc->surface->shared_header) {                              \
+        __mg_unlock_file_for_write(pdc->surface->fd);               \
+    }                                                               \
 } while (0)
 
 #       define IS_SCREEN_SURFACE(pdc)                       \

src/include/devfont.h

@@ -15,7 +15,7 @@
  *   and Graphics User Interface (GUI) support system for embedded systems
  *   and smart IoT devices.
  *
- *   Copyright (C) 2002~2018, Beijing FMSoft Technologies Co., Ltd.
+ *   Copyright (C) 2002~2023, Beijing FMSoft Technologies Co., Ltd.
  *   Copyright (C) 1998~2002, WEI Yongming
  *
  *   This program is free software: you can redistribute it and/or modify
@@ -209,6 +209,9 @@ struct _CHARSETOPS
     /** Default character. */
     Achar32 def_char_value;
 
+    /** Whether using legacy BIDI algorithm (Since 5.0.13). */
+    unsigned legacy_bidi:1;
+
     /** The method to get the length of the first character. */
     int (*len_first_char) (const unsigned char* mstr, int mstrlen);
 
@@ -263,9 +266,17 @@ struct _CHARSETOPS
 
 #define DEVFONTGLYPHTYPE_MASK_BMPTYPE   0x0F
 
+enum devfont_feature {
+    DEVFONT_FEATURE_MARK_BBOX = 0,
+};
+
 /** The font operation structure. */
 struct _FONTOPS
 {
+    /** The method to get the feature value of the font (Since 5.0.13). */
+    DWORD (*get_feature) (LOGFONT* logfont, DEVFONT* devfont,
+            enum devfont_feature feature);
+
     /** The method to get the glyph bitmap type . */
     DWORD (*get_glyph_bmptype) (LOGFONT* logfont, DEVFONT* devfont);
 

src/include/drawsemop.h

@@ -51,12 +51,10 @@
 #ifndef GUI_DRAWSEMOP_H
     #define GUI_DRAWSEMOP_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif  /* __cplusplus */
-
 #include <errno.h>
 
+#include "misc.h"
+
 static inline void my_sem_op (int semid, int num, int op)
 {
     struct sembuf sb;
@@ -70,6 +68,9 @@ again:
         if (errno == EINTR) {
             goto again;
         }
+        else {
+            _ERR_PRINTF("Failed semop: %m\n");
+        }
     }
 }
 
@@ -79,10 +80,7 @@ again:
 #define LOCK_SCREEN_SEM()   my_sem_op(SHAREDRES_SEMID, _IDX_SEM_SCR, -1)
 #define UNLOCK_SCREEN_SEM() my_sem_op(SHAREDRES_SEMID, _IDX_SEM_SCR, 1)
 
-#ifdef _MGSCHEMA_COMPOSITING
-#   define LOCK_SURFACE_SEM(num)    my_sem_op(SHAREDRES_SEMID_SHARED_SURF, num, -1)
-#   define UNLOCK_SURFACE_SEM(num)  my_sem_op(SHAREDRES_SEMID_SHARED_SURF, num, 1)
-#endif
+extern int __mg_client_id;
 
 #ifdef _MGHAVE_CURSOR
 
@@ -157,6 +155,10 @@ again:
 #   define UNLOCK_MOUSEMOVE_SEM()   my_sem_op(SHAREDRES_SEMID, _IDX_SEM_MOUSEMOVE, 1)
 #endif /* _MGRM_PROCESSES */
 
+#ifdef __cplusplus
+extern "C" {
+#endif  /* __cplusplus */
+
 #ifdef __cplusplus
 }
 #endif  /* __cplusplus */

src/include/internals.h

@@ -258,7 +258,7 @@ struct _MSGQUEUE
     int loop_depth;             // message loop depth, for dialog boxes
 
     int idle_counter;           // the idle connter for MSG_IDLE
-    DWORD last_ticks_desktop;   // the last tick count for desktop timer
+    DWORD last_ticks;           // the last tick count saved; since 5.0.14
 
     /* Since 5.0.0, MiniGUI provides support for timers per message thread */
     int nr_timers;              // the number of active timers
@@ -911,40 +911,9 @@ static inline MSGQUEUE* getMsgQueueIfMainWindowInThisThread (PMAINWIN pMainWin)
 
 #endif  /* defined _MGHAVE_VIRTUAL_WINDOW */
 
-#if 0   /* deprecated code */
-/* since 5.0.0, we always use QS_DESKTIMER for desktop timer */
-/* since 5.0.0, we no longer use the timer thread */
-static inline void AlertDesktopTimerEvent (void)
-{
-    if (__mg_dsk_msg_queue) {
-        __mg_dsk_msg_queue->expired_timer_mask = 1;
-        POST_MSGQ (__mg_dsk_msg_queue);
-    }
-}
-
-static inline void AlertDesktopTimerEvent (void)
-{
-    __mg_dsk_msg_queue->dwState |= QS_DESKTIMER;
-#ifdef _MGHAVE_VIRTUAL_WINDOW
-    if (getMsgQueueForThisThread() != __mg_dsk_msg_queue)
-        POST_MSGQ (__mg_dsk_msg_queue);
-#endif  /* defined _MGHAVE_VIRTUAL_WINDOW */
-}
-
-static inline void setMsgQueueTimerFlag (PMSGQUEUE pMsgQueue, int slot)
-{
-    pMsgQueue->expired_timer_mask |= (0x01UL << slot);
-    POST_MSGQ (pMsgQueue);
-}
-
-static inline void removeMsgQueueTimerFlag (PMSGQUEUE pMsgQueue, int slot)
-{
-    pMsgQueue->expired_timer_mask &= ~(0x01UL << slot);
-}
-#endif /* deprecated code */
-
-BOOL mg_InitTimer (BOOL use_sys_timer);
-void mg_TerminateTimer (BOOL use_sys_timer);
+/* Since 5.0.14, remove arg use_sys_timer */
+BOOL mg_InitTimer (void);
+void mg_TerminateTimer (void);
 
 /*window element renderer manager interface*/
 extern WINDOW_ELEMENT_RENDERER * __mg_def_renderer;
@@ -958,9 +927,7 @@ BOOL gui_LoadIconRes(HDC hdc, const char* rdr_name, char* file);
 void gui_WndRect(HWND hWnd, PRECT prc);
 void gui_WndClientRect(HWND hWnd, PRECT prc);
 
-/* Undisclosed APIs */
-HDC CreateMemDCFromSurface (struct GAL_Surface* surface);
-struct GAL_Surface* GetSurfaceFromDC (HDC hdc);
+HDC __mg_create_memdc_for_surface (struct GAL_Surface* surface);
 
 /* Since 5.0.0 */
 #ifdef _MGRM_PROCESSES

src/include/map.h

@@ -83,6 +83,11 @@ static inline int comp_key_string (const void *key1, const void *key2)
     return strcmp (key1, key2);
 }
 
+static inline void free_val_alloc (void *val)
+{
+    free (val);
+}
+
 typedef struct _map_t map_t;
 typedef struct _map_entry_t {
     struct rb_node  node;
@@ -100,8 +105,15 @@ int __mg_map_get_size (map_t* map);
 
 map_entry_t* __mg_map_find (map_t* map, const void* key);
 
-int __mg_map_insert_ex (map_t* map, const void* key,
+map_entry_t* __mg_map_insert_ex2 (map_t* map, const void* key,
         const void* val, free_val_fn free_val_alt);
+
+static int __mg_map_insert_ex (map_t* map, const void* key,
+        const void* val, free_val_fn free_val_alt)
+{
+    return __mg_map_insert_ex2(map, key, val, NULL) ? 0 : -1;
+}
+
 static inline int  __mg_map_insert (map_t* map, const void* key,
         const void* val)
 {
@@ -114,7 +126,7 @@ int __mg_map_find_replace_or_insert (map_t* map, const void* key,
 int __mg_map_replace (map_t* map, const void* key,
         const void* val, free_val_fn free_val_alt);
 
-int __mg_map_erase (map_t* map, void* key);
+int __mg_map_erase (map_t* map, const void* key);
 int __mg_map_get_size (map_t* map);
 
 #if 0   /* deprecated code */

src/include/misc.h

@@ -79,6 +79,11 @@ struct timezone {
 extern "C" {
 #endif  /* __cplusplus */
 
+void __mg_lock_file_for_read(int fd);
+void __mg_unlock_file_for_read(int fd);
+void __mg_lock_file_for_write(int fd);
+void __mg_unlock_file_for_write(int fd);
+
 unsigned int __mg_os_get_random_seed (void);
 void __mg_os_time_delay (int ms);
 void __mg_os_start_time (void);
@@ -115,10 +120,11 @@ void mg_TerminateMisc (void);
 BOOL mg_InitSystemRes (void);
 void mg_TerminateSystemRes (void);
 
+/* Deprecated since 5.2.0
 #ifdef _MGSCHEMA_COMPOSITING
 int __mg_alloc_sem_for_shared_surf (void);
 int __mg_free_sem_for_shared_surf (int sem_num);
-#endif /* _MGSCHEMA_COMPOSITING */
+#endif _MGSCHEMA_COMPOSITING */
 
 size_t __mg_lookfor_unused_slot (unsigned char* bitmap, size_t len_bmp, int set);
 

src/include/msgstr.h

@@ -396,10 +396,10 @@ char * __mg_msgstr3 [] =
     "MSG_SRVNOTIFY",          // 0x0147
     "MSG_UPDATECLIWIN",       // 0x0148
     "MSG_LAYERCHANGED",       // 0x0149
-    "MSG_MANAGE_MSGTHREAD",   // 0x014A
-    "MSG_CALC_POSITION",      // 0x014B
-    "",                       // 0x014C
-    "",                       // 0x014D
+    "MSG_WINCOMPOSITED",      // 0x014A
+    "MSG_MANAGE_MSGTHREAD",   // 0x014B
+    "MSG_CALC_POSITION",      // 0x014C
+    "MSG_WAKEUP_CLIENT",      // 0x014D
     "",                       // 0x014E
     "",                       // 0x014F
 

src/include/newgal.h

@@ -117,8 +117,10 @@ void GAL_FreeFormat(GAL_PixelFormat *format);
 
 /* typedef for private surface blitting functions */
 struct GAL_Surface;
-typedef int (*GAL_blit)(struct GAL_Surface *src, GAL_Rect *srcrect,
-                        struct GAL_Surface *dst, GAL_Rect *dstrect);
+
+typedef int (*GAL_blit)(GAL_VideoDevice *video,
+        struct GAL_Surface *src, GAL_Rect *srcrect,
+        struct GAL_Surface *dst, GAL_Rect *dstrect);
 
 #if IS_COMPOSITING_SCHEMA
 typedef struct _DirtyInfo {
@@ -137,20 +139,25 @@ typedef struct _DirtyInfo {
  * than the creator.
  */
 typedef struct _SharedSurfaceHeader {
-    /* The number of semphore for this surface.
-       The SysV semaphore set id for synchronizing this shared surface:
-       SHAREDRES_SEMID_SHARED_SURF. */
-    int             sem_num;
+    /* the name of the shared surface; since 5.2.0. */
+    char            name[NAME_MAX + 1];
 
-    /* The pid of the creator */
-    pid_t           creator;
+    /* The client identifier of the creator. */
+    int             create_cli;
 
-    /* The file descriptor in context of the creator. */
-    int             fd;
     /* Not zero for hardware surface. */
     int             byhw;
-    /* The dirty information */
-    GAL_DirtyInfo   dirty_info;
+
+    /* Deprecated since 5.2.0.
+       The number of semphore for this surface.
+       The SysV semaphore set id for synchronizing this shared surface:
+       SHAREDRES_SEMID_SHARED_SURF.
+    int             sem_num; */
+
+    /* Deprecated since 5.2.0.
+       The file descriptor in context of the creator.
+    int             fd; */
+
     /* the size of the surface */
     int             width, height;
     /* the pitch of the surface */
@@ -164,6 +171,9 @@ typedef struct _SharedSurfaceHeader {
     size_t          map_size;
     /* the offset of pixels data */
     off_t           pixels_off;
+
+    /* The dirty information */
+    GAL_DirtyInfo   dirty_info;
 } GAL_SharedSurfaceHeader;
 #endif /* IS_COMPOSITING_SCHEMA */
 
@@ -228,6 +238,8 @@ typedef struct GAL_Surface {
     GAL_SharedSurfaceHeader *shared_header;     /* Private */
     /* The dirty info for non-shared surface. */
     GAL_DirtyInfo *dirty_info;                  /* Private */
+    /* The file descriptor if the surface is a shared surface. */
+    int  fd;                                    /* Private; since 5.2.0. */
 #endif
 } GAL_Surface;
 
@@ -250,6 +262,8 @@ typedef struct GAL_Surface {
 
 #define GAL_PREALLOC         0x01000000    /* Surface uses preallocated memory */
 #define GAL_FORMAT_CHECKED   0x02000000    /* Pixman format checked */
+#define GAL_SSURF_ATTACHED   0x04000000    /* The shared surface is attached to. */
+#define GAL_SSURF_LOCKED     0x08000000    /* The shared surface is locked. */
 
 /* Available for GAL_SetVideoMode() */
 #define GAL_ANYFORMAT        0x10000000     /* Allow any video depth/pixel-format */
@@ -569,6 +583,11 @@ GAL_Surface *GAL_CreateRGBSurface
 GAL_Surface *GAL_CreateRGBSurfaceFrom (void *pixels,
                         int width, int height, int depth, int pitch,
                         Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
+/* Since 5.2.0 */
+static GAL_Surface *GAL_RefSurface (GAL_Surface *surface) {
+    surface->refcount++;
+    return surface;
+}
 void GAL_FreeSurface (GAL_Surface *surface);
 
 typedef struct REQ_HWSURFACE {
@@ -649,11 +668,11 @@ GAL_Surface *GAL_CreateSurfaceForZNodeAs (const GAL_Surface* ref_surf,
 void GAL_FreeSharedSurfaceData (GAL_Surface *surface);
 
 /* Attach to a shared RGB surface. */
-GAL_Surface *GAL_AttachSharedRGBSurface (int fd, size_t map_size,
-            Uint32 flags, BOOL with_wr);
+GAL_Surface *GAL_AttachSharedRGBSurface (GAL_VideoDevice* video,
+        int fd, size_t map_size, Uint32 flags, BOOL with_wr);
 
-/* Dettach from a shared RGB surface from the specific video device. */
-void GAL_DettachSharedSurfaceData (GAL_Surface *surface);
+/* Detach from a shared RGB surface from the specific video device. */
+void GAL_DetachSharedSurfaceData (GAL_Surface *surface);
 
 /* Create a cursor surface from the specific video device. */
 GAL_Surface* GAL_CreateCursorSurface (GAL_VideoDevice* video,
@@ -670,7 +689,6 @@ void GAL_MoveCursor (GAL_Surface* surface, int x, int y);
 
 #endif /* defined _MGSCHEMA_COMPOSITING */
 
-#if 0
 /*
  * GAL_LockSurface() sets up a surface for directly accessing the pixels.
  * Between calls to GAL_LockSurface()/GAL_UnlockSurface(), you can write
@@ -680,9 +698,7 @@ void GAL_MoveCursor (GAL_Surface* surface, int x, int y);
  *
  * Not all surfaces require locking.  If GAL_MUSTLOCK(surface) evaluates
  * to 0, then you can read and write to the surface at any time, and the
- * pixel format of the surface will not change.  In particular, if the
- * GAL_HWSURFACE flag is not given when calling GAL_SetVideoMode(), you
- * will not need to lock the display surface before accessing it.
+ * pixel format of the surface will not change.
  *
  * No operating system or library calls should be made between lock/unlock
  * pairs, as critical system locks may be held during this time.
@@ -691,7 +707,6 @@ void GAL_MoveCursor (GAL_Surface* surface, int x, int y);
  */
 int GAL_LockSurface (GAL_Surface *surface);
 void GAL_UnlockSurface (GAL_Surface *surface);
-#endif
 
 /*
  * Set the color key (transparent pixel) in a blittable surface.

src/include/ourhdr.h

@@ -73,6 +73,8 @@
 
 #if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
 /* union semun is defined by including <sys/sem.h> */
+#elif defined(__DARWIN__)
+/* union semun is defined by including <sys/sem.h> */
 #else
 /* according to X/OPEN we have to define it ourselves */
 union semun {

src/include/server.h

@@ -132,6 +132,13 @@ void __mg_client_del (int cli);
 
 void __mg_release_global_res (int cli);
 
+/* Since 5.2.0 */
+int __mg_nssurf_map_new(void);
+void __mg_nssurf_map_delete(void);
+int __mg_nssurf_map_operate_srv(const OPERATENSSURFINFO* req_info,
+        int cli, int fd);
+int __mg_get_shared_surface_srv(const char *itn_name, SHAREDSURFINFO *info);
+
 void __mg_remove_client (int cli, int clifd);
 
 int __mg_handle_request (int clifd, int req_id, int cli);
@@ -150,6 +157,7 @@ int __mg_remove_all_znodes_of_client (int cli);
 
 int __mg_handle_normal_mouse_move (const ZORDERINFO* zi, int x, int y);
 int __mg_get_znode_at_point (const ZORDERINFO* zi, int x, int y, HWND* hwnd);
+ZORDERNODE *__mg_find_znode_by_client_hwnd (int cli, HWND hwnd);
 
 int __mg_do_reghook_operation (int cli, const REGHOOKINFO* info);
 int __mg_handle_mouse_hook (int message, WPARAM wParam, LPARAM lParam);

src/include/sharedres.h

@@ -112,7 +112,7 @@ typedef struct tagG_RES {
 
     int nr_layers;
     int semid_layer;
-#ifdef _MGSCHEMA_COMPOSITING
+#if 0 && defined(_MGSCHEMA_COMPOSITING) // deprecated since 5.2.0
     int semid_shared_surf;  /* the id of semaphore set for shared surfaces */
 #endif
 
@@ -208,7 +208,7 @@ typedef G_RES* PG_RES;
 #define SHAREDRES_NR_LAYSERS    (((PG_RES)mgSharedRes)->nr_layers)
 #define SHAREDRES_SEMID_LAYER   (((PG_RES)mgSharedRes)->semid_layer)
 
-#ifdef _MGSCHEMA_COMPOSITING
+#if 0 && defined(_MGSCHEMA_COMPOSITING) // Deprecated since 5.2.0
 # define SHAREDRES_SEMID_SHARED_SURF (((PG_RES)mgSharedRes)->semid_shared_surf)
 #endif
 

src/include/timer.h

@@ -74,7 +74,7 @@ typedef struct _MSGQUEUE MSGQUEUE;
 extern "C" {
 #endif  /* __cplusplus */
 
-void __mg_update_tick_count (void* data);
+DWORD __mg_update_tick_count (MSGQUEUE* msg_queue);
 int  __mg_check_expired_timers (MSGQUEUE* msg_queue, DWORD inter);
 void __mg_remove_timers_by_msg_queue (MSGQUEUE* msg_queue);
 void __mg_remove_timer (MSGQUEUE* msg_queue, int slot);

src/kernel/compsor-fallback.c

@@ -228,6 +228,7 @@ static void composite_wallpaper_rect (CompositorCtxt* ctxt,
         }
     }
     else {
+        SelectClipRect (HDC_SCREEN_SYS, dirty_rc);
         SetBrushColor (HDC_SCREEN_SYS,
             GetWindowElementPixelEx (HWND_DESKTOP, HDC_SCREEN_SYS,
                 WE_BGC_DESKTOP));
@@ -678,6 +679,19 @@ static BOOL merge_dirty_ppp (CompositorCtxt* ctxt, MG_Layer* layer, int zidx)
     return rc;
 }
 
+#if 0
+static void dump_dirty_region(CompositorCtxt* ctxt, const char *prefix, int zidx)
+{
+    CLIPRGN* rgn = &ctxt->dirty_rgn;
+    _WRN_PRINTF("%s (%d): dirty region on screen: (%d, %d) %d x %d; "
+            "highest dirty win: %d; lowest dirty win: %d\n",
+            prefix, zidx,
+            rgn->rcBound.left, rgn->rcBound.top,
+            RECTW (rgn->rcBound), RECTH (rgn->rcBound),
+            ctxt->highest_dirty_win, ctxt->lowest_dirty_win);
+}
+#endif
+
 static BOOL merge_dirty_win (CompositorCtxt* ctxt, MG_Layer* layer, int zidx)
 {
     BOOL rc = FALSE;
@@ -721,9 +735,13 @@ static BOOL merge_dirty_wpp (CompositorCtxt* ctxt, MG_Layer* layer)
 static BOOL refresh_dirty_region (CompositorCtxt* ctxt, MG_Layer* layer)
 {
     /* the fallback compositor only manages znodes on the topmost layer. */
-    if (layer != mgTopmostLayer || IsEmptyClipRgn (&ctxt->dirty_rgn))
+    if (layer != mgTopmostLayer)
         return FALSE;
 
+    if (IsEmptyClipRgn (&ctxt->dirty_rgn)) {
+        return FALSE;
+    }
+
     if (ctxt->highest_dirty_ppp >= 0) {
         composite_ppp_znodes (ctxt);
     }

src/kernel/compsor-manager.c

@@ -56,7 +56,6 @@
 #include <string.h>
 #include <errno.h>
 
-#define _DEBUG
 #include "common.h"
 
 #if defined(_MGRM_PROCESSES) && defined(_MGSCHEMA_COMPOSITING)
@@ -69,6 +68,7 @@
 #include "constants.h"
 #include "zorder.h"
 #include "dc.h"
+#include "server.h"
 
 #define MAX_NR_COMPOSITORS      8
 #define LEN_COMPOSITOR_NAME     15
@@ -133,31 +133,51 @@ static void lock_znode_surface (PDC pdc, ZORDERNODE* node)
 {
     if (node->lock_count == 0) {
         if (pdc->surface->shared_header) {
-            LOCK_SURFACE_SEM (pdc->surface->shared_header->sem_num);
+            __mg_lock_file_for_read(pdc->surface->fd);
         }
 
         node->dirty_age = pdc->surface->dirty_info->dirty_age;
         node->nr_dirty_rcs = pdc->surface->dirty_info->nr_dirty_rcs;
         node->dirty_rcs = pdc->surface->dirty_info->dirty_rcs;
-
     }
 
     node->lock_count++;
 }
 
-static void unlock_znode_surface (PDC pdc, ZORDERNODE* node)
+static BOOL unlock_znode_surface (PDC pdc, ZORDERNODE* node)
 {
+    BOOL need_reset = FALSE;
     if (node->lock_count > 0) {
         node->lock_count--;
         if (node->lock_count == 0) {
-            if (pdc->surface->shared_header)
-                UNLOCK_SURFACE_SEM (pdc->surface->shared_header->sem_num);
+            if (node->changes != pdc->surface->dirty_info->dirty_age) {
+                node->changes = pdc->surface->dirty_info->dirty_age;
+                need_reset = TRUE;
+            }
+
+            if (pdc->surface->shared_header) {
+                __mg_unlock_file_for_read(pdc->surface->fd);
+            }
 
             node->dirty_age = 0;
             node->nr_dirty_rcs = 0;
             node->dirty_rcs = NULL;
         }
     }
+
+    return need_reset;
+}
+
+static void reset_znode_surface_dirty (PDC pdc, ZORDERNODE* node, int slot)
+{
+    if (node->cli == 0 || slot == 0) {
+        pdc->surface->dirty_info->nr_dirty_rcs = 0;
+    }
+    else if (node->hwnd) {
+        MSG msg = { HWND_NULL, MSG_WINCOMPOSITED,
+            slot, (LPARAM)node->hwnd, (DWORD)node->changes };
+        __mg_send2client(&msg, mgClients + node->cli);
+    }
 }
 
 #if 0   /* not optimized */
@@ -322,10 +342,8 @@ static void composite_layer (MG_Layer* layer, CompositorCtxt* ctxt,
         nodes = GET_MENUNODE(zi);
         for (i = 0; i < zi->nr_popupmenus; i++) {
             pdc = dc_HDC2PDC (nodes[i].mem_dc);
-
-            nodes[i].changes = pdc->surface->dirty_info->dirty_age;
-            pdc->surface->dirty_info->nr_dirty_rcs = 0;
-            unlock_znode_surface (pdc, nodes + i);
+            if (unlock_znode_surface (pdc, nodes + i))
+                reset_znode_surface_dirty (pdc, nodes + i, i);
         }
     }
 
@@ -335,9 +353,8 @@ static void composite_layer (MG_Layer* layer, CompositorCtxt* ctxt,
     while ((next = __kernel_get_next_znode (zi, next)) > 0) {
         if (nodes [next].flags & ZOF_VISIBLE) {
             pdc = dc_HDC2PDC (nodes[next].mem_dc);
-            nodes[next].changes = pdc->surface->dirty_info->dirty_age;
-            pdc->surface->dirty_info->nr_dirty_rcs = 0;
-            unlock_znode_surface (pdc, nodes + next);
+            if (unlock_znode_surface (pdc, nodes + next))
+                reset_znode_surface_dirty (pdc, nodes + next, next);
         }
     }
 
@@ -346,9 +363,8 @@ static void composite_layer (MG_Layer* layer, CompositorCtxt* ctxt,
     if (layer == mgTopmostLayer) {
         pdc = dc_HDC2PDC (HDC_SCREEN);
         if (pdc->surface->w > 0 && pdc->surface->h > 0) {
-            nodes[0].changes = pdc->surface->dirty_info->dirty_age;
-            pdc->surface->dirty_info->nr_dirty_rcs = 0;
-            unlock_znode_surface (pdc, nodes);
+            if (unlock_znode_surface (pdc, nodes))
+                reset_znode_surface_dirty (pdc, nodes, 0);
         }
     }
 }

src/kernel/cursor-procs.c

@@ -1081,6 +1081,12 @@ void kernel_ShowCursorForGDI (BOOL fShow, void* pdc)
     const RECT* prc;
 
     prc = &cur_pdc->rc_output;
+
+    /* Since 5.0.13 */
+    if (!fShow) {
+        GAL_LockSurface(cur_pdc->surface);
+    }
+
     if (cur_pdc->surface != __gal_screen) {
         if (fShow) {
             GAL_UpdateRect (cur_pdc->surface,
@@ -1090,7 +1096,7 @@ void kernel_ShowCursorForGDI (BOOL fShow, void* pdc)
     }
     else {
         if (!mgIsServer && (SHAREDRES_TOPMOST_LAYER != __mg_layer)) {
-            return;
+            goto done;
         }
 
         if (!fShow) {
@@ -1109,6 +1115,12 @@ void kernel_ShowCursorForGDI (BOOL fShow, void* pdc)
             UNLOCK_CURSOR_SEM ();
         }
     }
+
+done:
+    /* Since 5.0.13 */
+    if (fShow) {
+        GAL_UnlockSurface(cur_pdc->surface);
+    }
 }
 
 #else   /* defined _MGSCHEMA_SHAREDFB */
@@ -1124,6 +1136,12 @@ void kernel_ShowCursorForGDI (BOOL fShow, void* pdc)
     }
 
     prc = &cur_pdc->rc_output;
+
+    /* Since 5.0.13 */
+    if (!fShow) {
+        GAL_LockSurface(cur_pdc->surface);
+    }
+
     if (cur_pdc->surface == __gal_screen) {
         // Under compositing schema, we never call SyncUpdate in
         // kernel_ShowCursorForGDI for __gal_screen.
@@ -1150,6 +1168,11 @@ void kernel_ShowCursorForGDI (BOOL fShow, void* pdc)
         // For surface other than screen, we call SyncUpdate.
         GAL_SyncUpdate (cur_pdc->surface);
     }
+
+    /* Since 5.0.13 */
+    if (fShow) {
+        GAL_UnlockSurface(cur_pdc->surface);
+    }
 }
 
 #endif  /* not defined _MGSCHEMA_SHAREDFB */
@@ -1228,26 +1251,25 @@ void kernel_ShowCursorForGDI (BOOL fShow, void* pdc)
     PDC cur_pdc = (PDC)pdc;
     const RECT* prc = NULL;
 
-    prc = &cur_pdc->rc_output;
-
-    /* houhh20080827, if --disable-cursor, mginit can not update auto(qvfb). */
-#if 0
-    if (cur_pdc->surface == __gal_screen
-            && mgIsServer && (SHAREDRES_TOPMOST_LAYER != __mg_layer))
-        return;
-
-    if (fShow)
-        GAL_UpdateRect (cur_pdc->surface,
-                        prc->left, prc->top, RECTWP(prc), RECTHP(prc));
-#else
     if (!mgIsServer && (SHAREDRES_TOPMOST_LAYER != __mg_layer)) {
         return;
     }
 
+    prc = &cur_pdc->rc_output;
+
+    /* Since 5.0.13 */
+    if (!fShow) {
+        GAL_LockSurface(cur_pdc->surface);
+    }
+
     if (fShow)
         GAL_UpdateRect (cur_pdc->surface,
                 prc->left, prc->top, RECTWP(prc), RECTHP(prc));
-#endif
+
+    /* Since 5.0.13 */
+    if (fShow) {
+        GAL_UnlockSurface(cur_pdc->surface);
+    }
 }
 
 #endif /* _MGHAVE_CURSOR */

src/kernel/cursor-sa.c

@@ -448,6 +448,11 @@ void kernel_ShowCursorForGDI (BOOL fShow, void* pdc)
 
     prc = &cur_pdc->rc_output;
 
+    /* Since 5.0.13 */
+    if (!fShow) {
+        GAL_LockSurface(cur_pdc->surface);
+    }
+
     if (cur_pdc->surface != __gal_screen) {
         if (fShow) {
             GAL_UpdateRect (cur_pdc->surface,
@@ -472,7 +477,7 @@ void kernel_ShowCursorForGDI (BOOL fShow, void* pdc)
                                 prc->left, prc->top, RECTWP(prc), RECTHP(prc));
                 //GAL_SyncUpdate (cur_pdc->surface);
             }
-            return;
+            goto done;
         }
 
         if (fShow && nShowCount >= 0 && pCurCsr) {
@@ -488,6 +493,12 @@ void kernel_ShowCursorForGDI (BOOL fShow, void* pdc)
             //GAL_SyncUpdate (cur_pdc->surface);
         }
     }
+
+done:
+    /* Since 5.0.13 */
+    if (fShow) {
+        GAL_UnlockSurface(cur_pdc->surface);
+    }
 }
 
 int GUIAPI ShowCursor (BOOL fShow)
@@ -516,9 +527,16 @@ void kernel_ShowCursorForGDI(BOOL fShow, void* pdc)
 
     prc = &cur_pdc->rc_output;
 
-    if (fShow)
+    /* Since 5.0.13 */
+    if (!fShow) {
+        GAL_LockSurface(cur_pdc->surface);
+    }
+    else {
         GAL_UpdateRect (cur_pdc->surface,
                         prc->left, prc->top, RECTWP(prc), RECTHP(prc));
+        /* Since 5.0.13 */
+        GAL_UnlockSurface(cur_pdc->surface);
+    }
 }
 
 #endif /* _MGHAVE_CURSOR */

src/kernel/cursor.c

@@ -472,11 +472,15 @@ void kernel_ShowCursorForGDI (BOOL fShow, void *pdc)
 
     prc = &cur_pdc->rc_output;
 
+    /* Since 5.0.13 */
+    if (!fShow) {
+        GAL_LockSurface(cur_pdc->surface);
+    }
+
     if (cur_pdc->surface != __gal_screen) {
         if (fShow) {
-            GAL_UpdateRect (cur_pdc->surface,
+            GAL_UpdateRect(cur_pdc->surface,
                             prc->left, prc->top, RECTWP(prc), RECTHP(prc));
-            // GAL_SyncUpdate (cur_pdc->surface);
         }
     }
     else {
@@ -500,7 +504,7 @@ void kernel_ShowCursorForGDI (BOOL fShow, void *pdc)
                 pthread_mutex_unlock(&__mg_mouselock);
                 // GAL_SyncUpdate (cur_pdc->surface);
             }
-            return;
+            goto done;
         }
 
         if (fShow && nShowCount >= 0 && pCurCsr) {
@@ -518,6 +522,12 @@ void kernel_ShowCursorForGDI (BOOL fShow, void *pdc)
             // GAL_SyncUpdate (cur_pdc->surface);
         }
     }
+
+done:
+    /* Since 5.0.13 */
+    if (fShow) {
+        GAL_UnlockSurface(cur_pdc->surface);
+    }
 }
 
 int GUIAPI ShowCursor(BOOL fShow)
@@ -558,9 +568,17 @@ void kernel_ShowCursorForGDI (BOOL fShow, void* pdc)
 
     prc = &cur_pdc->rc_output;
 
-    if (fShow)
+    /* Since 5.0.13 */
+    if (!fShow) {
+        GAL_LockSurface(cur_pdc->surface);
+    }
+    else {
         GAL_UpdateRect (cur_pdc->surface,
                         prc->left, prc->top, RECTWP(prc), RECTHP(prc));
+
+        /* Since 5.0.13 */
+        GAL_UnlockSurface(cur_pdc->surface);
+    }
 }
 
 #endif /* _MGHAVE_CURSOR */

src/kernel/desktop-procs.c

@@ -55,6 +55,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
+#include <assert.h>
 
 #include "common.h"
 
@@ -364,7 +365,7 @@ static intptr_t cliAllocZOrderNode (PMAINWIN pWin, const COMPOSITINGINFO* ct_inf
     }
 
     if (ClientRequestEx2 (&req, caption, strlen(caption) + 1,
-            pWin->surf->shared_header->fd,
+            pWin->surf->fd,
             &ret, sizeof (intptr_t), NULL) < 0)
         return -1;
 #else   /* ndef _MGSCHEMA_COMPOSITING */
@@ -523,7 +524,7 @@ static intptr_t cliStartTrackPopupMenu (PTRACKMENUINFO ptmi)
 
         info.surf_flags = surf->flags;
         info.surf_size = surf->shared_header->map_size;
-        if (ClientRequestEx2 (&req, NULL, 0, surf->shared_header->fd,
+        if (ClientRequestEx2 (&req, NULL, 0, surf->fd,
                 &ret, sizeof (intptr_t), NULL) < 0)
             return -1;
     }
@@ -836,8 +837,10 @@ static int srvAllocZOrderNode (int cli, HWND hwnd, HWND main_win,
         surf->refcount++;
     }
     else if (fd >= 0) {
-        surf = GAL_AttachSharedRGBSurface (fd, surf_size, surf_flags, TRUE);
-        close (fd);
+        surf = GAL_AttachSharedRGBSurface (NULL, fd,
+                surf_size, surf_flags, TRUE);
+        /* Since 5.2.0: keep fd available.
+        close (fd); */
     }
     else {
         _ERR_PRINTF("KERNEL: not server but fd for shared surface is invalid\n");
@@ -845,7 +848,7 @@ static int srvAllocZOrderNode (int cli, HWND hwnd, HWND main_win,
     }
 
     if (surf) {
-        memdc = CreateMemDCFromSurface (surf);
+        memdc = __mg_create_memdc_for_surface (surf);
         if (memdc == HDC_INVALID) {
             if (cli > 0) {
                 GAL_FreeSurface (surf);
@@ -993,12 +996,14 @@ static int srvMoveWindow (int cli, int idx_znode, const RECT* rcWin,
             surf->refcount++;
         }
         else {
-            surf = GAL_AttachSharedRGBSurface (fd, surf_size, surf_flags, TRUE);
-            close (fd);
+            surf = GAL_AttachSharedRGBSurface (NULL, fd,
+                    surf_size, surf_flags, TRUE);
+            /* Since 5.2.0: keep fd available.
+            close (fd); */
         }
 
         if (surf) {
-            memdc = CreateMemDCFromSurface (surf);
+            memdc = __mg_create_memdc_for_surface (surf);
             if (memdc == HDC_INVALID) {
                 if (cli > 0) {
                     GAL_FreeSurface (surf);
@@ -1013,7 +1018,6 @@ static int srvMoveWindow (int cli, int idx_znode, const RECT* rcWin,
             return -1;
         }
     }
-
 #endif /* def _MGSCHEMA_COMPOSITING */
 
     ret = dskMoveWindow (cli, idx_znode, memdc, rcWin);
@@ -1520,6 +1524,33 @@ static BOOL _cb_update_rc_nocli (void* context,
 }
 #endif /* not defined _MGSCHEMA_COMPOSITING */
 
+/* Since 5.2.0 */
+ZORDERNODE *__mg_find_znode_by_client_hwnd (int cli, HWND hwnd)
+{
+    ZORDERINFO* zi = get_zorder_info(cli);
+    ZORDERNODE* nodes;
+
+    if (zi == NULL)
+        return NULL;
+
+    int level, slot = -1;
+    nodes = GET_ZORDERNODE(zi);
+    for (level = 0; level < NR_ZORDER_LEVELS; level++) {
+        slot = zi->first_in_levels[level];
+        for (; slot > 0; slot = nodes[slot].next) {
+            if (nodes[slot].cli == cli && nodes[slot].hwnd == hwnd) {
+                goto found;
+            }
+        }
+    }
+
+    return NULL;
+
+found:
+    assert(slot >= 0);
+    return nodes + slot;
+}
+
 int __mg_remove_all_znodes_of_client (int cli)
 {
     BOOL has_special = FALSE;
@@ -2180,7 +2211,7 @@ static int resize_window_surface (PMAINWIN pWin, const RECT* prcResult)
 
         pWin->surf = new_surf;
         if (pWin->surf->shared_header)
-            return pWin->surf->shared_header->fd;
+            return pWin->surf->fd;
         else
             return 0;
     }
@@ -2225,9 +2256,10 @@ static int dskMoveGlobalControl (PMAINWIN pCtrl, RECT* prcExpect)
     }
 
 #ifdef _MGSCHEMA_COMPOSITING
-    if (pCtrl->surf->shared_header && pCtrl->surf->shared_header->fd >= 0) {
-        close (pCtrl->surf->shared_header->fd);
-        pCtrl->surf->shared_header->fd = -1;
+    /* Since 5.2.0: keep fd available. */
+    if (0 && pCtrl->surf->shared_header && pCtrl->surf->fd >= 0) {
+        close (pCtrl->surf->fd);
+        pCtrl->surf->fd = -1;
     }
 #endif
 
@@ -2256,9 +2288,10 @@ static int dskMoveMainWindow (PMAINWIN pWin, RECT* prcExpect)
         __mg_update_dc_on_surface_changed ((HWND)pWin, pWin->surf);
     }
 
-    if (pWin->surf->shared_header && pWin->surf->shared_header->fd >= 0) {
-        close (pWin->surf->shared_header->fd);
-        pWin->surf->shared_header->fd = -1;
+    /* Since 5.2.0: keep fd available. */
+    if (0 && pWin->surf->shared_header && pWin->surf->fd >= 0) {
+        close (pWin->surf->fd);
+        pWin->surf->fd = -1;
     }
 #endif
 
@@ -2874,6 +2907,21 @@ int __mg_handle_mouse_hook (int message, WPARAM wParam, LPARAM lParam)
 }
 #endif  /* deprecated code */
 
+/* used by client to check the validation of a hwnd in the given znode slot. */
+BOOL __mg_client_check_znode_hwnd (int slot, HWND hwnd, int cli)
+{
+    BOOL ret = FALSE;
+    ZORDERINFO* zi = __mg_zorder_info;
+    ZORDERNODE* nodes;
+
+    nodes = GET_ZORDERNODE(zi);
+    lock_zi_for_read (zi);
+    if (nodes[slot].hwnd == hwnd && nodes[slot].cli == cli)
+        ret = TRUE;
+    unlock_zi_for_read (zi);
+    return ret;
+}
+
 /* used by client to check the validation of a hwnd */
 BOOL __mg_client_check_hwnd (HWND hwnd, int cli)
 {

src/kernel/desktop-ths.c

@@ -141,6 +141,14 @@ BOOL mg_InitDesktop (void)
 
 #include "debug.h"
 
+static IDLEHANDLER std_idle_handler;
+
+static BOOL idle_handler_for_desktop_thread (MSGQUEUE *msg_queue, BOOL wait)
+{
+    __mg_update_tick_count (msg_queue);
+    return std_idle_handler (msg_queue, wait);
+}
+
 void* __kernel_desktop_main (void* data)
 {
     MSG Msg;
@@ -152,8 +160,10 @@ void* __kernel_desktop_main (void* data)
         return NULL;
     }
 
-    /* for threads mode, the idle handler for desktop thread is NULL */
-    __mg_dsk_msg_queue->OnIdle = NULL;
+    /* For bug reported in Issue #116, under threads mode, the idle handler
+       for the desktop thread should call __mg_update_tick_count () */
+    std_idle_handler = __mg_dsk_msg_queue->OnIdle;
+    __mg_dsk_msg_queue->OnIdle = idle_handler_for_desktop_thread;
 
     /* init desktop window */
     init_desktop_win ();

src/kernel/desktop.c

@@ -1603,8 +1603,10 @@ static int srvStartTrackPopupMenu (int cli, const RECT* rc, HWND ptmi,
             surf->refcount++;
         }
         else if (fd >= 0) {
-            surf = GAL_AttachSharedRGBSurface (fd, surf_size, surf_flags, TRUE);
-            close (fd);
+            surf = GAL_AttachSharedRGBSurface (NULL, fd,
+                    surf_size, surf_flags, TRUE);
+            /* Since 5.2.0: keep fd available.
+            close (fd); */
         }
         else {
             _WRN_PRINTF("not server but fd for shared surface is invalid\n");
@@ -1612,7 +1614,7 @@ static int srvStartTrackPopupMenu (int cli, const RECT* rc, HWND ptmi,
         }
 
         if (surf) {
-            memdc = CreateMemDCFromSurface (surf);
+            memdc = __mg_create_memdc_for_surface (surf);
             if (memdc == HDC_INVALID) {
                 GAL_FreeSurface (surf);
                 _WRN_PRINTF("failed to create memory dc for znode\n");
@@ -1646,11 +1648,14 @@ static int srvStartTrackPopupMenu (int cli, const RECT* rc, HWND ptmi,
     menu_nodes [zi->nr_popupmenus].flags = ZOF_TYPE_POPUPMENU;
     menu_nodes [zi->nr_popupmenus].rc = *rc;
     menu_nodes [zi->nr_popupmenus].hwnd = ptmi;
+    menu_nodes [zi->nr_popupmenus].cli = 0;
 #ifdef _MGSCHEMA_COMPOSITING
     menu_nodes [zi->nr_popupmenus].changes = 0;
     menu_nodes [zi->nr_popupmenus].ct = CT_OPAQUE;
     menu_nodes [zi->nr_popupmenus].ct_arg = 0;
     menu_nodes [zi->nr_popupmenus].mem_dc = memdc;
+    menu_nodes [zi->nr_popupmenus].dirty_age = 0;
+    menu_nodes [zi->nr_popupmenus].nr_dirty_rcs = 0;
     menu_nodes [zi->nr_popupmenus].dirty_rcs = NULL;
 #endif
     menu_nodes [zi->nr_popupmenus].priv_data = NULL;
@@ -2356,6 +2361,8 @@ static int AllocZOrderNodeEx (ZORDERINFO* zi, int cli, HWND hwnd, HWND main_win,
     nodes [free_slot].ct = validate_compositing_type (flags, ct);
     nodes [free_slot].ct_arg = ct_arg;
     nodes [free_slot].mem_dc = mem_dc;
+    nodes [free_slot].dirty_age = 0;
+    nodes [free_slot].nr_dirty_rcs = 0;
     nodes [free_slot].dirty_rcs = NULL;
 #else
     nodes [free_slot].age = 1;

src/kernel/init.c

@@ -391,14 +391,6 @@ static BOOL InstallSEGVHandler (void)
 #include <locale.h>
 #endif
 
-static IDLEHANDLER std_idle_handler;
-
-static BOOL idle_handler_for_main_thread (MSGQUEUE *msg_queue, BOOL wait)
-{
-    __mg_update_tick_count (NULL);
-    return std_idle_handler (msg_queue, wait);
-}
-
 int GUIAPI InitGUI (int args, const char *agr[])
 {
     char engine [LEN_ENGINE_NAME + 1];
@@ -583,14 +575,9 @@ int GUIAPI InitGUI (int args, const char *agr[])
         goto failure;
     }
 
-    /* for threads mode, the idle handler for the main threads should
-       call __mg_update_tick_count () */
-    std_idle_handler = msg_queue->OnIdle;
-    msg_queue->OnIdle = idle_handler_for_main_thread;
-
     /* init timer for tick counter */
     step++;
-    if (!mg_InitTimer (FALSE)) {
+    if (!mg_InitTimer()) {
         _ERR_PRINTF ("KERNEL>InitGUI: failed to start time counter\n");
         goto failure;
     }
@@ -615,7 +602,7 @@ failure1:
 
 void GUIAPI TerminateGUI (int not_used)
 {
-    mg_TerminateTimer (FALSE);
+    mg_TerminateTimer ();
 
     mg_FreeMsgQueueForThisThread (TRUE);
 

src/kernel/message.c

@@ -955,6 +955,12 @@ checkagain:
 
         goto checkagain;
     }
+    else {
+        /* no message, wait again. */
+        if (pMsgQueue->OnIdle && !pMsgQueue->OnIdle (pMsgQueue, FALSE)) {
+            handle_idle_message (pMsgQueue);
+        }
+    }
 #else   /* defined _MGHAVE_VIRTUAL_WINDOW */
     /* no message, idle */
     if (bWait) {
@@ -964,6 +970,11 @@ checkagain:
         }
         goto checkagain;
     }
+    else {
+        if (!pMsgQueue->OnIdle (pMsgQueue, FALE)) {
+            handle_idle_message (pMsgQueue);
+        }
+    }
 #endif  /* not defined _MGHAVE_VIRTUAL_WINDOW */
 
     /* no message */

src/kernel/timer.c

@@ -44,7 +44,7 @@
  *   <http://www.minigui.com/blog/minigui-licensing-policy/>.
  */
 /*
-** timer.c: The Timer module for MiniGUI-Threads.
+** timer.c: The Timer module for MiniGUI.
 **
 ** Current maintainer: Wei Yongming.
 **
@@ -79,82 +79,45 @@
 
 DWORD __mg_tick_counter = 0;
 
-/* update timer count for desktop thread */
-void __mg_update_tick_count (void *data)
+/* update timer count for message and desktop thread */
+DWORD __mg_update_tick_count (MSGQUEUE* msg_queue)
 {
+    DWORD ticks;
+
 #if defined(_MGRM_PROCESSES)
     if (mgIsServer) {
-        __mg_tick_counter = __mg_os_get_time_ticks ();
-        SHAREDRES_TIMER_COUNTER = __mg_tick_counter;
+        ticks = __mg_os_get_time_ticks ();
+        SHAREDRES_TIMER_COUNTER = ticks;
     }
     else {
-        __mg_tick_counter = SHAREDRES_TIMER_COUNTER;
+        ticks = SHAREDRES_TIMER_COUNTER;
     }
 #else   /* defined _MGRM_PROCESSES */
-    __mg_tick_counter = __mg_os_get_time_ticks ();
+    ticks = __mg_os_get_time_ticks ();
 #endif  /* not defined _MGRM_PROCESSES */
 
-    /* Since 5.0.0, the desktop only handles caret blinking in MSG_TIMEOUT
-       message, and the interval for the timer of desktop changes to 0.05s. */
-    if (__mg_tick_counter >
-            __mg_dsk_msg_queue->last_ticks_desktop + DESKTOP_TIMER_INERTVAL) {
-        __mg_dsk_msg_queue->dwState |= QS_DESKTIMER;
+    if (msg_queue && ticks != msg_queue->last_ticks) {
+        /* Since 5.0.0, the desktop only handles caret blinking in MSG_TIMEOUT
+           message, and the interval for the timer of desktop changes to 0.05s.
+         */
+        if (msg_queue == __mg_dsk_msg_queue) {
+            if (ticks > __mg_dsk_msg_queue->last_ticks +
+                    DESKTOP_TIMER_INERTVAL) {
+                __mg_dsk_msg_queue->dwState |= QS_DESKTIMER;
 #ifdef _MGRM_THREADS    /* only wake up desktop for threads mode */
-        POST_MSGQ (__mg_dsk_msg_queue);
+                POST_MSGQ (__mg_dsk_msg_queue);
 #endif
-        __mg_dsk_msg_queue->last_ticks_desktop = __mg_tick_counter;
+            }
+        }
+
+        msg_queue->last_ticks = ticks;
     }
 
-#if 0  /* deprecated code */
+    __mg_tick_counter = ticks;
+    return ticks;
+}
+
 #if defined(_MGRM_PROCESSES)
-    if (mgIsServer) {
-        DWORD elapsed_ticks;
-
-        /* Since 5.0.0, we use elapsed time in ms to count the ticks */
-        elapsed_ticks = __mg_os_get_elapsed_ms ();
-        elapsed_ticks = (elapsed_ticks + 5) / 10;
-
-        __mg_tick_counter += elapsed_ticks;
-        SHAREDRES_TIMER_COUNTER = __mg_tick_counter;
-    }
-    else {
-        __mg_tick_counter = SHAREDRES_TIMER_COUNTER;
-    }
-#else   /* defined _MGRM_PROCESSES */
-    DWORD elapsed_ticks;
-
-    /* Since 5.0.0, we use elapsed time in ms to count the ticks */
-    elapsed_ticks = __mg_os_get_elapsed_ms ();
-    elapsed_ticks = (elapsed_ticks + 5) / 10;
-    __mg_tick_counter += elapsed_ticks;
-#endif  /* not defined _MGRM_PROCESSES */
-
-    /* Since 5.0.0, the desktop only handles caret blinking in MSG_TIMEOUT
-       message, and the interval for the timer of desktop changes to 0.05s. */
-    if (__mg_tick_counter >
-            __mg_dsk_msg_queue->last_ticks_desktop + DESKTOP_TIMER_INERTVAL) {
-        __mg_dsk_msg_queue->dwState |= QS_DESKTIMER;
-#ifdef _MGRM_THREADS    /* only wake up desktop for threads mode */
-        POST_MSGQ (__mg_dsk_msg_queue);
-#endif
-        __mg_dsk_msg_queue->last_ticks_desktop = __mg_tick_counter;
-    }
-#endif  /* deprecated code */
-}
-
-#ifdef __NOUNIX__
-
-static BOOL install_system_timer (void)
-{
-    return TRUE;
-}
-
-static BOOL unintall_system_timer (void)
-{
-    return TRUE;
-}
-
-#else   /* defined __NOUNIX__ */
 
 #include <signal.h>
 #include <unistd.h>
@@ -163,6 +126,12 @@ static BOOL unintall_system_timer (void)
 static struct sigaction old_alarm_handler;
 static struct itimerval old_timer;
 
+static void timer_handler(int sig)
+{
+    (void)sig;
+    __mg_update_tick_count(NULL);
+}
+
 static BOOL install_system_timer (void)
 {
     struct itimerval timerv;
@@ -171,20 +140,12 @@ static BOOL install_system_timer (void)
     sigaction (SIGALRM, NULL, &old_alarm_handler);
 
     siga = old_alarm_handler;
-    siga.sa_handler = (void(*)(int))__mg_update_tick_count;
-#ifndef _MGRM_STANDALONE
+    siga.sa_handler = timer_handler;
     siga.sa_flags = 0;
-#else
-    siga.sa_flags = SA_RESTART;
-#endif
     sigaction (SIGALRM, &siga, NULL);
 
     timerv.it_interval.tv_sec = 0;
-#if defined(__uClinux__) && defined(_MGRM_STANDALONE)
-    timerv.it_interval.tv_usec = 100000;        /* 100 ms */
-#else
     timerv.it_interval.tv_usec = 10000;         /* 10 ms */
-#endif
     timerv.it_value = timerv.it_interval;
 
     if (setitimer (ITIMER_REAL, &timerv, &old_timer) == -1) {
@@ -209,26 +170,30 @@ static BOOL unintall_system_timer (void)
 
     return TRUE;
 }
+#endif /* defined(_MGRM_PROCESSES) */
 
-#endif /* not defined __NOUNIX__ */
-
-BOOL mg_InitTimer (BOOL use_sys_timer)
+BOOL mg_InitTimer ()
 {
     __mg_tick_counter = 0;
 
     __mg_os_start_time();
 
-    if (use_sys_timer) {
+#if defined(_MGRM_PROCESSES)
+    if (mgIsServer) {
         install_system_timer ();
     }
+#endif
 
     return TRUE;
 }
 
-void mg_TerminateTimer (BOOL use_sys_timer)
+void mg_TerminateTimer (void)
 {
-    if (use_sys_timer)
+#if defined(_MGRM_PROCESSES)
+    if (mgIsServer) {
         unintall_system_timer ();
+    }
+#endif
 }
 
 /************************* Functions run in message thread *******************/
@@ -247,34 +212,19 @@ int __mg_check_expired_timers (MSGQUEUE* msg_queue, DWORD inter)
         int i;
         TIMER** timer_slots = msg_queue->timer_slots;
 
+        __mg_update_tick_count (msg_queue);
+
         for (i = 0; i < DEF_NR_TIMERS; i++) {
             if (timer_slots[i]) {
-                if (__mg_tick_counter >= timer_slots[i]->ticks_expected) {
+                if (msg_queue->last_ticks >= timer_slots[i]->ticks_expected) {
                     /* setting timer flag is simple, we do not need to lock
                        msgq, or else we may encounter dead lock here */
                     msg_queue->expired_timer_mask |= (0x01UL << i);
                     POST_MSGQ (msg_queue);
-
                     timer_slots[i]->ticks_expected += timer_slots[i]->interv;
-                    timer_slots[i]->ticks_fired = __mg_tick_counter;
+                    timer_slots[i]->ticks_fired = msg_queue->last_ticks;
                     nr++;
                 }
-#if 0   /* deprecated code */
-                timer_slots[i]->count += inter;
-                if (timer_slots[i]->count >= timer_slots[i]->interv) {
-#ifdef _MGRM_PROCESSES
-                    timer_slots[i]->ticks_current = SHAREDRES_TIMER_COUNTER;
-#else
-                    timer_slots[i]->ticks_current = __mg_tick_counter;
-#endif
-                    /* setting timer flag is simple, we do not need to lock msgq,
-                       or else we may encounter dead lock here */
-                    msg_queue->expired_timer_mask |= (0x01UL << i);
-                    POST_MSGQ (msg_queue);
-                    timer_slots[i]->count -= timer_slots[i]->interv;
-                    nr++;
-                }
-#endif /* deprecated code */
             }
         }
     }
@@ -291,7 +241,7 @@ BOOL GUIAPI SetTimerEx (HWND hWnd, LINT id, DWORD interv,
     int i;
     int slot = -1;
     TIMER** timer_slots;
-    PMSGQUEUE pMsgQueue;
+    PMSGQUEUE msg_queue;
 
     if (id == 0) {
         _WRN_PRINTF ("bad identifier (%ld).\n", id);
@@ -302,12 +252,14 @@ BOOL GUIAPI SetTimerEx (HWND hWnd, LINT id, DWORD interv,
         interv = 1;
     }
 
-    timer_slots = getTimerSlotsForThisThread (&pMsgQueue);
+    timer_slots = getTimerSlotsForThisThread (&msg_queue);
     if (MG_UNLIKELY (timer_slots == NULL)) {
         _WRN_PRINTF ("called for non message thread\n");
         goto badret;
     }
 
+    __mg_update_tick_count (msg_queue);
+
     /* Since 5.0.0: only check hWnd if timer_proc is NULL */
     if (MG_UNLIKELY (timer_proc == NULL &&
                 !getMainWinIfWindowInThisThread (hWnd))) {
@@ -326,7 +278,7 @@ BOOL GUIAPI SetTimerEx (HWND hWnd, LINT id, DWORD interv,
             /* Since 5.0.0: we reset timer parameters for duplicated call of
                this function */
             timer_slots[i]->interv = interv;
-            timer_slots[i]->ticks_expected = __mg_tick_counter + interv;
+            timer_slots[i]->ticks_expected = msg_queue->last_ticks + interv;
             timer_slots[i]->ticks_fired = 0;
             timer_slots[i]->proc = timer_proc;
             return TRUE;
@@ -343,14 +295,14 @@ BOOL GUIAPI SetTimerEx (HWND hWnd, LINT id, DWORD interv,
     timer_slots[slot]->hWnd = hWnd;
     timer_slots[slot]->id = id;
     timer_slots[slot]->interv = interv;
-    timer_slots[slot]->ticks_expected = __mg_tick_counter + interv;
+    timer_slots[slot]->ticks_expected = msg_queue->last_ticks + interv;
     timer_slots[slot]->ticks_fired = 0;
     timer_slots[slot]->proc = timer_proc;
 
     _DBG_PRINTF ("ticks_expected (%d): %lu, tick_counter: %lu\n",
-            slot, timer_slots[slot]->ticks_expected, __mg_tick_counter);
+            slot, timer_slots[slot]->ticks_expected, msg_queue->last_ticks);
 
-    pMsgQueue->nr_timers++;
+    msg_queue->nr_timers++;
 
     return TRUE;
 
@@ -358,24 +310,6 @@ badret:
     return FALSE;
 }
 
-#if 0   /* deprected code */
-#ifdef _MGRM_PROCESSES
-static void reset_select_timeout (TIMER** timer_slots)
-{
-    int i;
-
-    unsigned int interv = 0;
-    for (i = 0; i < DEF_NR_TIMERS; i++) {
-        if (timer_slots[i]) {
-            if (interv == 0 || timer_slots[i]->interv < interv)
-                interv = timer_slots[i]->interv;
-        }
-    }
-    __mg_set_select_timeout (USEC_10MS * interv);
-}
-#endif
-#endif  /* deprecated code */
-
 void __mg_remove_timer (MSGQUEUE* msg_queue, int slot)
 {
     TIMER** timer_slots;
@@ -415,7 +349,12 @@ int GUIAPI KillTimer (HWND hWnd, LINT id)
     int i;
     int killed = 0;
     MSGQUEUE* msg_queue;
-   
+
+#ifndef _MGRM_THREADS
+    /* Force to update tick count */
+    GetTickCount();
+#endif
+
     msg_queue = getMsgQueueForThisThread ();
     if (msg_queue) {
 
@@ -447,7 +386,12 @@ BOOL GUIAPI ResetTimerEx (HWND hWnd, LINT id, DWORD interv,
 {
     int i;
     MSGQUEUE* msg_queue;
-   
+
+#ifndef _MGRM_THREADS
+    /* Force to update tick count */
+    GetTickCount();
+#endif
+
     if (id == 0)
         return FALSE;
 
@@ -455,13 +399,14 @@ BOOL GUIAPI ResetTimerEx (HWND hWnd, LINT id, DWORD interv,
     if (MG_LIKELY (msg_queue)) {
         TIMER** timer_slots = msg_queue->timer_slots;
 
+        __mg_update_tick_count (msg_queue);
         for (i = 0; i < DEF_NR_TIMERS; i++) {
             if (timer_slots[i] &&
                     timer_slots[i]->hWnd == hWnd && timer_slots[i]->id == id) {
                 /* Should clear old timer flags */
                 msg_queue->expired_timer_mask &= ~(0x01UL << i);
                 timer_slots[i]->interv = interv;
-                timer_slots[i]->ticks_expected = __mg_tick_counter + interv;
+                timer_slots[i]->ticks_expected = msg_queue->last_ticks + interv;
                 timer_slots[i]->ticks_fired = 0;
                 if (timer_proc != (TIMERPROC)INV_PTR)
                     timer_slots[i]->proc = timer_proc;
@@ -482,6 +427,11 @@ BOOL GUIAPI IsTimerInstalled (HWND hWnd, LINT id)
     int i;
     TIMER** timer_slots;
 
+#ifndef _MGRM_THREADS
+    /* Force to update tick count */
+    GetTickCount();
+#endif
+
     if (id == 0)
         return FALSE;
 
@@ -507,6 +457,11 @@ BOOL GUIAPI HaveFreeTimer (void)
     int i;
     TIMER** timer_slots;
 
+#ifndef _MGRM_THREADS
+    /* Force to update tick count */
+    GetTickCount();
+#endif
+
     timer_slots = getTimerSlotsForThisThread (NULL);
     if (timer_slots) {
         for (i = 0; i < DEF_NR_TIMERS; i++) {
@@ -523,187 +478,6 @@ BOOL GUIAPI HaveFreeTimer (void)
 
 DWORD GUIAPI GetTickCount (void)
 {
-#if defined(_MGRM_PROCESSES)
-    if (mgIsServer) {
-        __mg_tick_counter = __mg_os_get_time_ticks ();
-        SHAREDRES_TIMER_COUNTER = __mg_tick_counter;
-    }
-    else {
-        __mg_tick_counter = SHAREDRES_TIMER_COUNTER;
-    }
-#else   /* defined _MGRM_PROCESSES */
-    __mg_tick_counter = __mg_os_get_time_ticks ();
-#endif  /* not defined _MGRM_PROCESSES */
-
-    return __mg_tick_counter;
+    return __mg_update_tick_count(getMsgQueueForThisThread ());
 }
 
-#if 0   /* deprecated code */
-
-/* Since 5.0.0, we no longer use the timer thread for MiniGUI-Threads runmode */
-   in message queue */
-
-/* timer entry for thread version */
-#ifdef _MGRM_THREADS
-
-#ifdef __AOS__
-
-#include "os_api.h"
-
-static OS_TIMER_ID __mg_os_timer = 0;
-
-#else /* __AOS__ */
-static void* TimerEntry (void* data)
-{
-    sem_post ((sem_t*)data);
-
-    while (__mg_quiting_stage > _MG_QUITING_STAGE_TIMER) {
-        __mg_os_time_delay (10);
-        __mg_update_tick_count (NULL);
-    }
-
-    /* printf("quit from TimerEntry()\n"); */
-    return NULL;
-}
-#endif /* !__AOS__ */
-
-int __mg_timer_init (void)
-{
-    if (!mg_InitTimer ()) {
-        fprintf (stderr, "KERNEL>timer: Init Timer failure.\n");
-        return -1;
-    }
-
-#ifdef __AOS__
-    __mg_os_timer = tp_os_timer_create ("mgtimer", __mg_update_tick_count,
-                                         NULL, AOS_TIMER_TICKT,
-                                         OS_AUTO_ACTIVATE | OS_AUTO_LOAD);
-#else /* __AOS__ */
-    {
-        sem_t wait;
-        sem_init (&wait, 0, 0);
-        pthread_create (&__mg_timer, NULL, TimerEntry, &wait);
-        sem_wait (&wait);
-        sem_destroy (&wait);
-    }
-#endif /* !__AOS__ */
-
-    return 0;
-}
-
-void mg_TerminateTimer (void)
-{
-#ifdef __AOS__
-    tp_os_timer_delete (__mg_os_timer);
-#endif
-
-#ifdef __WINBOND_SWLINUX__
-    pthread_detach (__mg_timer); /* XXX: Can we pthread_join()? */
-#else
-    pthread_join (__mg_timer, NULL);
-#endif /* __WINBOND_SWLINUX__ */
-
-#ifdef _MGHAVE_VIRTUAL_WINDOW
-    pthread_mutex_destroy (&timerLock);
-#endif
-
-#if 0   /* deprecated code */
-    /* Since 5.0.0, we allocate timer slots per thread, and manage the time slots
-       in message queue */
-    for (i = 0; i < DEF_NR_TIMERS; i++) {
-        if (timerstr[i] != NULL)
-            free ( timerstr[i] );
-        timerstr[i] = NULL;
-    }
-
-#ifdef _MGHAVE_VIRTUAL_WINDOW
-    pthread_mutex_destroy (&timerLock);
-#endif
-#endif  /* deprecated code */
-}
-
-#else /* defined _MGRM_THREADS */
-#endif /* defined _MGRM_THREADS */
-
-/* Since 5.0.0, we use timer slots per thread, and manage the time slots
-   in message queue */
-static TIMER *timerstr[DEF_NR_TIMERS];
-
-#ifdef _MGHAVE_VIRTUAL_WINDOW
-/* lock for protecting timerstr */
-static pthread_mutex_t timerLock;
-#define TIMER_LOCK()   pthread_mutex_lock(&timerLock)
-#define TIMER_UNLOCK() pthread_mutex_unlock(&timerLock)
-#else
-#define TIMER_LOCK()
-#define TIMER_UNLOCK()
-#endif
-
-int __mg_get_timer_slot (HWND hWnd, int id)
-{
-    int i;
-    int slot = -1;
-
-    TIMER_LOCK ();
-    for (i = 0; i < DEF_NR_TIMERS; i++) {
-        if (timerstr[i] != NULL) {
-            if (timerstr[i]->hWnd == hWnd && timerstr[i]->id == id) {
-                slot = i;
-                break;
-            }
-        }
-    }
-
-    TIMER_UNLOCK ();
-    return slot;
-}
-
-void __mg_move_timer_last (TIMER* timer, int slot)
-{
-    if (slot < 0 || slot >= DEF_NR_TIMERS)
-        return;
-
-    TIMER_LOCK ();
-
-    if (timer && timer->msg_queue) {
-        /* The following code is already called in message.c...
-         * timer->ticks_current = 0;
-         * timer->msg_queue->expired_timer_mask &= ~(0x01UL << slot);
-         */
-
-        if (slot != (DEF_NR_TIMERS - 1)) {
-            TIMER* t;
-
-            if (timer->msg_queue->expired_timer_mask & (0x01UL << (DEF_NR_TIMERS -1))) {
-                timer->msg_queue->expired_timer_mask |= (0x01UL << slot);
-                timer->msg_queue->expired_timer_mask &= ~(0x01UL << (DEF_NR_TIMERS -1));
-            }
-
-            t = timerstr [DEF_NR_TIMERS - 1];
-            timerstr [DEF_NR_TIMERS - 1] = timerstr [slot];
-            timerstr [slot] = t;
-        }
-    }
-
-    TIMER_UNLOCK ();
-    return;
-}
-
-TIMER* __mg_get_timer (int slot)
-{
-    TIMER** timer_slots;
-
-    if (slot < 0 || slot >= DEF_NR_TIMERS)
-        return NULL;
-
-    timer_slots = getTimerSlotsForThisThread (NULL);
-    if (timer_slots) {
-        return timer_slots[slot];
-    }
-
-    _WRN_PRINTF ("called for non message thread\n");
-    return NULL;
-}
-
-#endif  /* deprecated code */
-

src/misc/Makefile.am

@@ -7,7 +7,7 @@ EXTRA_DIST= misc.c systext.c rwops.c endianrw.c nposix.c clipboard.c \
 
 libmisc_la_SOURCES = misc.c systext.c rwops.c endianrw.c nposix.c clipboard.c \
                 math.c about.c license.c anon_file.c rbtree.c map.c \
-                error.c sockio.c
+                error.c sockio.c lock_file.c
 
 SRC_FILES = $(libmisc_la_SOURCES)
 LIB_NAME=libmisc

src/misc/about.c

@@ -114,7 +114,7 @@ static LRESULT AboutWinProc (HWND hWnd, UINT message,
         DrawText (hdc,
                 "MiniGUI -- a mature cross-platform windowing system "
                 "and GUI support system for embedded or IoT devices.\n\n"
-                "Copyright (C) 2002 ~ 2020 FMSoft Co., Ltd.",
+                "Copyright (C) 2002 ~ 2023 FMSoft Co., Ltd.",
                 -1, &rcClient, DT_WORDBREAK | DT_CENTER);
 
         EndPaint (hWnd, hdc);

src/misc/lock_file.c

@@ -0,0 +1,112 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+//                          IMPORTANT NOTICE
+//
+// The following open source license statement does not apply to any
+// entity in the Exception List published by FMSoft.
+//
+// For more information, please visit:
+//
+// https://www.fmsoft.cn/exception-list
+//
+//////////////////////////////////////////////////////////////////////////////
+/*
+ *   This file is part of MiniGUI, a mature cross-platform windowing
+ *   and Graphics User Interface (GUI) support system for embedded systems
+ *   and smart IoT devices.
+ *
+ *   Copyright (C) 2023, Beijing FMSoft Technologies Co., Ltd.
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ *   Or,
+ *
+ *   As this program is a library, any link to this program must follow
+ *   GNU General Public License version 3 (GPLv3). If you cannot accept
+ *   GPLv3, you need to be licensed from FMSoft.
+ *
+ *   If you have got a commercial license of this program, please use it
+ *   under the terms and conditions of the commercial license.
+ *
+ *   For more information about the commercial license, please refer to
+ *   <http://www.minigui.com/blog/minigui-licensing-policy/>.
+ */
+/*
+** lock_file.c: This file include functions for locking/unlocking a file.
+**
+** Create date: 2023/09/10
+**
+** Current maintainer: Wei Yongming.
+*/
+
+#include "common.h"
+
+#ifndef __NOUNIX__
+
+#include "misc.h"
+
+#include <unistd.h>
+#include <sys/file.h>
+#include <fcntl.h>
+#include <errno.h>
+
+void __mg_lock_file_for_read(int fd)
+{
+    struct flock lock;
+
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0;
+    lock.l_len = 0;
+
+    while (fcntl(fd, F_SETLKW, &lock) == -1 && errno == EINTR);
+}
+
+void __mg_unlock_file_for_read(int fd)
+{
+    struct flock lock;
+
+    lock.l_type = F_UNLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0;
+    lock.l_len = 0;
+
+    fcntl(fd, F_SETLK, &lock);
+}
+
+void __mg_lock_file_for_write(int fd)
+{
+    struct flock lock;
+
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0;
+    lock.l_len = 0;
+
+    while (fcntl(fd, F_SETLKW, &lock) == -1 && errno == EINTR);
+}
+
+void __mg_unlock_file_for_write(int fd)
+{
+    struct flock lock;
+
+    lock.l_type = F_UNLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0;
+    lock.l_len = 0;
+
+    fcntl(fd, F_SETLK, &lock);
+}
+
+#endif /* __NOUNIX__ */

src/misc/map.c

@@ -243,7 +243,7 @@ map_entry_t* __mg_map_find (map_t* map, const void* key)
     return entry;
 }
 
-int __mg_map_erase (map_t* map, void* key)
+int __mg_map_erase (map_t* map, const void* key)
 {
     int retval = -1;
     map_entry_t* entry = NULL;
@@ -299,7 +299,7 @@ ret:
     return retval;
 }
 
-int __mg_map_insert_ex (map_t* map, const void* key,
+map_entry_t*  __mg_map_insert_ex2 (map_t* map, const void* key,
         const void* val, free_val_fn free_val_alt)
 {
     map_entry_t **pentry;
@@ -307,7 +307,7 @@ int __mg_map_insert_ex (map_t* map, const void* key,
     map_entry_t *parent;
 
     if (map == NULL)
-        return -1;
+        return NULL;
 
     WRLOCK_MAP (map);
 
@@ -317,7 +317,7 @@ int __mg_map_insert_ex (map_t* map, const void* key,
 
     while (*pentry) {
         int ret;
-       
+
         if (map->comp_key)
             ret = map->comp_key (key, (*pentry)->key);
         else
@@ -354,7 +354,7 @@ int __mg_map_insert_ex (map_t* map, const void* key,
     }
 
     UNLOCK_MAP (map);
-    return 0;
+    return entry;
 }
 
 int __mg_map_find_replace_or_insert (map_t* map, const void* key,

src/mybmp/mybmp.c

@@ -96,8 +96,12 @@ static BITMAP_TYPE_INFO bitmap_types [MAX_BITMAP_TYPES] =
    { "jpeg", __mg_init_jpg, __mg_load_jpg, __mg_cleanup_jpg, __mg_save_jpg, __mg_check_jpg },
 #endif
 #ifdef _MGIMAGE_PNG
+#if _MGLIBPNG_VER == 16
+   { "png", __mg_init_png, __mg_load_png, __mg_cleanup_png, __mg_save_png, __mg_check_png },
+#else
    { "png", __mg_init_png, __mg_load_png, __mg_cleanup_png, NULL, __mg_check_png },
 #endif
+#endif
 #ifdef _MGIMAGE_WEBP
    { "webp", __mg_init_webp, __mg_load_webp, __mg_cleanup_webp, NULL, __mg_check_webp },
 #endif

src/mybmp/png16.c

@@ -381,6 +381,287 @@ BOOL __mg_check_png (MG_RWops* fp)
     return png_check_sig (sig, 8);
 }
 
+static void png_error_callback (png_structp png, png_const_charp error_msg)
+{
+    int *error = png_get_error_ptr (png);
+
+    *error = ERR_BMP_CANT_SAVE;
+
+#ifdef PNG_SETJMP_SUPPORTED
+    longjmp (png_jmpbuf (png), 1);
+#endif
+}
+
+static void png_warning_callback (png_structp png, png_const_charp error_msg)
+{
+}
+
+static void png_output_flush_fn (png_structp png_ptr)
+{
+}
+
+static void my_write_data_fn (png_structp png_ptr, png_bytep data,
+                png_size_t length)
+{
+    png_size_t check;
+    png_voidp io_ptr = png_get_io_ptr(png_ptr);
+
+    if (MGUI_RWwrite((MG_RWops*)io_ptr, data, 1, length) !=
+            (size_t) length) {
+        png_error(png_ptr, "Write Error");
+    }
+}
+
+typedef BYTE* (*MYBITMAP_get_pixel_row)(unsigned int cinfo,
+        MYBITMAP* mybmp,RGB* pal);
+
+static BYTE* MYBITMAP_get_pixel_row_pal16(unsigned int next_scanline,
+                       MYBITMAP* mybmp, RGB* pal)
+{
+    RGB rgb0, rgb1;
+
+    BYTE *bits = mybmp->bits + next_scanline * mybmp->pitch;
+    int nr_data = mybmp->w * 4;
+    BYTE *data = (BYTE *)malloc(nr_data);
+    uint8_t alpha = 0xFF;
+
+    for (int i = 0, j = 0, end_i = (mybmp->w + 1) >> 1; i < end_i; ++i) {
+
+        rgb0 = pal[ (bits[ i ] & 0XF0) >> 4 ];
+        rgb1 = pal[  bits[ i ] & 0X0F ];
+
+        data[ j ++ ] = rgb0.r;
+        data[ j ++ ] = rgb0.g;
+        data[ j ++ ] = rgb0.b;
+        data[ j ++ ] = alpha;
+
+        data[ j ++ ] = rgb1.r;
+        data[ j ++ ] = rgb1.g;
+        data[ j ++ ] = rgb1.b;
+        data[ j ++ ] = alpha;
+    }
+
+    return data;
+}
+
+static BYTE* MYBITMAP_get_pixel_row_pal256(unsigned int next_scanline,
+                       MYBITMAP* mybmp, RGB* pal)
+{
+    RGB rgb;
+    BYTE *bits = mybmp->bits + next_scanline * mybmp->pitch;
+
+    int nr_data = mybmp->w * 4;
+    BYTE *data = (BYTE *)malloc(nr_data);
+    uint8_t alpha = 0xFF;
+
+    for (int i = 0, j = 0; i < mybmp->w; i++, j += 4) {
+        rgb = pal [bits[i] ];
+
+        data[0] = rgb.r;
+        data[1] = rgb.g;
+        data[2] = rgb.b;
+        data[3] = alpha;
+    }
+
+    return data;
+}
+
+#define RGB_FROM_RGB565(pixel, r, g, b)                         \
+{                                                               \
+    r = (((pixel&0xF800)>>11)<<3);                              \
+    g = (((pixel&0x07E0)>>5)<<2);                               \
+    b = ((pixel&0x001F)<<3);                                    \
+}
+
+static BYTE* MYBITMAP_get_pixel_row_RGB565(unsigned int next_scanline,
+                       MYBITMAP* mybmp, RGB* pal)
+{
+    Uint16* bits = (Uint16*)(mybmp->bits + next_scanline * mybmp->pitch);
+
+    int nr_data = mybmp->w * 4;
+    BYTE* data = (BYTE *)malloc(nr_data);
+    uint8_t alpha = 0xFF;
+    for (int i = 0, j = 0; i < nr_data; i += 4, j++) {
+        uint8_t *b = data + i;
+        Uint16 *pixel = bits + j;
+        RGB_FROM_RGB565(pixel[j], b[0], b[1], b[2])
+        b[3] = alpha;
+    }
+
+    return data;
+}
+
+static BYTE* MYBITMAP_get_pixel_row_RGB(unsigned int next_scanline,
+                       MYBITMAP* mybmp, RGB* pal)
+{
+    BYTE *bits = mybmp->bits + next_scanline * mybmp->pitch;
+
+    int nr_data = mybmp->w * 4;
+    BYTE *data = (BYTE *)malloc(nr_data);
+    uint8_t alpha = 0xFF;
+
+    for (int i = 0, j = 0; i < nr_data; i += 4, j += 3) {
+        uint8_t *b = data + i;
+        BYTE *pixel = bits + j;
+        b[0] = pixel[2];
+        b[1] = pixel[1];
+        b[2] = pixel[0];
+        b[3] = alpha;
+    }
+
+    return data;
+}
+
+static BYTE* MYBITMAP_get_pixel_row_BGR(unsigned int next_scanline,
+                       MYBITMAP* mybmp, RGB* pal)
+{
+    BYTE *bits = mybmp->bits + next_scanline * mybmp->pitch;
+
+    int nr_data = mybmp->w * 4;
+    BYTE *data = (BYTE *)malloc(nr_data);
+    uint8_t alpha = 0xFF;
+
+    for (int i = 0, j = 0; i < nr_data; i += 4, j += 3) {
+        uint8_t *b = data + i;
+        BYTE *pixel = bits + j;
+        b[0] = pixel[0];
+        b[1] = pixel[1];
+        b[2] = pixel[2];
+        b[3] = alpha;
+    }
+
+    return data;
+}
+
+static BYTE* MYBITMAP_get_pixel_row_RGBA(unsigned int next_scanline,
+                       MYBITMAP* mybmp, RGB* pal)
+{
+    BYTE *bits = mybmp->bits + next_scanline * mybmp->pitch;
+
+    int nr_data = mybmp->w * 4;
+    BYTE *data = (BYTE *)malloc(nr_data);
+
+    for (int i = 0; i < nr_data; i += 4) {
+        uint8_t *b = data + i;
+        BYTE *pixel = bits + i;
+
+        uint8_t alpha = pixel[3];
+        if (alpha == 0) {
+            b[0] = b[1] = b[2] = b[3] = 0;
+        } else {
+            b[0] = (pixel[2] * 255 + alpha / 2) / alpha; /* red */
+            b[1] = (pixel[1] * 255 + alpha / 2) / alpha; /* green */
+            b[2] = (pixel[0] * 255 + alpha / 2) / alpha; /* blue */
+            b[3] = alpha;
+        }
+    }
+
+    return data;
+}
+
+int __mg_save_png (MG_RWops* fp, MYBITMAP* bmp, RGB* pal)
+{
+    png_struct *png;
+    png_info *info;
+    png_byte **volatile rows = NULL;
+    MYBITMAP_get_pixel_row get_row;
+    png_color_16 white;
+    int png_color_type;
+    int retcode = ERR_BMP_CANT_SAVE;
+    int bpc;
+    int bmp_type;
+
+    rows = calloc(bmp->h, sizeof(png_byte*));
+    if (rows == NULL) {
+        retcode = ERR_BMP_CANT_SAVE;
+        goto failed;
+    }
+
+    png = png_create_write_struct (PNG_LIBPNG_VER_STRING, &retcode,
+            png_error_callback, png_warning_callback);
+    if (png == NULL) {
+        retcode = ERR_BMP_MEM;
+        goto failed_clear_rows;
+    }
+
+    info = png_create_info_struct (png);
+    if (info == NULL) {
+        retcode = ERR_BMP_MEM;
+        goto failed_clear_struct;
+    }
+
+#ifdef PNG_SETJMP_SUPPORTED
+    if (setjmp (png_jmpbuf (png))) {
+        goto failed_clear_struct;
+    }
+#endif
+
+    png_set_write_fn (png, fp, my_write_data_fn, png_output_flush_fn);
+
+    bmp_type = bmp->flags & MYBMP_TYPE_MASK;
+
+    switch(bmp->depth) {
+    case 4:
+        get_row = MYBITMAP_get_pixel_row_pal16;
+        break;
+    case 8:
+        get_row = MYBITMAP_get_pixel_row_pal256;
+        break;
+    case 16:
+        get_row = MYBITMAP_get_pixel_row_RGB565;
+        break;
+    case 24:
+        if(MYBMP_TYPE_RGB == bmp_type)
+            get_row = MYBITMAP_get_pixel_row_RGB;
+        else
+            get_row = MYBITMAP_get_pixel_row_BGR;
+        break;
+    case 32:
+        get_row = MYBITMAP_get_pixel_row_RGBA;
+        break;
+    default:
+        _ERR_PRINTF("MYBMP>PNG: invalid MYBITMAP.depth = %d\n", bmp->depth);
+        goto failed_clear_struct;
+    }
+
+    for (int i = 0; i < bmp->h; i++) {
+        rows[i] = get_row(i, bmp, pal);
+    }
+    bpc = 8;
+    png_color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+
+    png_set_IHDR (png, info,
+            bmp->w,
+            bmp->h, bpc,
+            png_color_type,
+            PNG_INTERLACE_NONE,
+            PNG_COMPRESSION_TYPE_DEFAULT,
+            PNG_FILTER_TYPE_DEFAULT);
+
+    white.gray = (1 << bpc) - 1;
+    white.red = white.blue = white.green = white.gray;
+    png_set_bKGD (png, info, &white);
+
+    png_write_info (png, info);
+
+    png_write_image (png, rows);
+    png_write_end (png, info);
+
+    retcode = ERR_BMP_OK;
+
+failed_clear_struct:
+    png_destroy_write_struct (&png, &info);
+failed_clear_rows:
+    for (int i = 0; i < bmp->h; i++) {
+        if (rows[i]) {
+            free(rows[i]);
+        }
+    }
+    free (rows);
+failed:
+    return retcode;
+}
+
 #endif /* _MGLIBPNG_VER == 16 */
 #endif /* _MGIMAGE_PNG */
 

src/newgal/RLEaccel.c

@@ -462,99 +462,100 @@ static void RLEClipBlit(int w, Uint8 *srcbuf, GAL_Surface *dst,
 
 }
 
-
 /* blit a colorkeyed RLE surface */
-int GAL_RLEBlit(GAL_Surface *src, GAL_Rect *srcrect,
+int GAL_RLEBlit(GAL_VideoDevice *video, GAL_Surface *src, GAL_Rect *srcrect,
                 GAL_Surface *dst, GAL_Rect *dstrect)
 {
-        Uint8 *dstbuf;
-        Uint8 *srcbuf;
-        int x, y;
-        int w = src->w;
-        unsigned alpha;
+    (void)video;
 
-        /* Set up the source and destination pointers */
-        x = dstrect->x;
-        y = dstrect->y;
-        dstbuf = (Uint8 *)dst->pixels
-                 + y * dst->pitch + x * src->format->BytesPerPixel;
-        srcbuf = (Uint8 *)src->map->sw_data->aux_data;
+    Uint8 *dstbuf;
+    Uint8 *srcbuf;
+    int x, y;
+    int w = src->w;
+    unsigned alpha;
 
-        {
-            /* skip lines at the top if neccessary */
-            int vskip = srcrect->y;
-            int ofs = 0;
-            if(vskip) {
+    /* Set up the source and destination pointers */
+    x = dstrect->x;
+    y = dstrect->y;
+    dstbuf = (Uint8 *)dst->pixels
+             + y * dst->pitch + x * src->format->BytesPerPixel;
+    srcbuf = (Uint8 *)src->map->sw_data->aux_data;
+
+    {
+        /* skip lines at the top if neccessary */
+        int vskip = srcrect->y;
+        int ofs = 0;
+        if(vskip) {
 
 #define RLESKIP(bpp, Type)                        \
-                for(;;) {                        \
-                    int run;                        \
-                    ofs += *(Type *)srcbuf;        \
-                    run = ((Type *)srcbuf)[1];        \
-                    srcbuf += sizeof(Type) * 2;        \
-                    if(run) {                        \
-                        srcbuf += run * bpp;        \
-                        ofs += run;                \
-                    } else if(!ofs)                \
-                        goto done;                \
-                    if(ofs == w) {                \
-                        ofs = 0;                \
-                        if(!--vskip)                \
-                            break;                \
-                    }                                \
-                }
+            for(;;) {                        \
+                int run;                        \
+                ofs += *(Type *)srcbuf;        \
+                run = ((Type *)srcbuf)[1];        \
+                srcbuf += sizeof(Type) * 2;        \
+                if(run) {                        \
+                    srcbuf += run * bpp;        \
+                    ofs += run;                \
+                } else if(!ofs)                \
+                    goto done;                \
+                if(ofs == w) {                \
+                    ofs = 0;                \
+                    if(!--vskip)                \
+                        break;                \
+                }                                \
+            }
 
-                switch(src->format->BytesPerPixel) {
-                case 1: RLESKIP(1, Uint8); break;
-                case 2: RLESKIP(2, Uint8); break;
-                case 3: RLESKIP(3, Uint8); break;
-                case 4: RLESKIP(4, Uint16); break;
-                }
+            switch(src->format->BytesPerPixel) {
+            case 1: RLESKIP(1, Uint8); break;
+            case 2: RLESKIP(2, Uint8); break;
+            case 3: RLESKIP(3, Uint8); break;
+            case 4: RLESKIP(4, Uint16); break;
+            }
 
 #undef RLESKIP
 
-            }
         }
+    }
 
-        alpha = (src->flags & GAL_SRCALPHA) == GAL_SRCALPHA
-                ? src->format->alpha : 255;
-        /* if left or right edge clipping needed, call clip blit */
-        if ( srcrect->x || srcrect->w != src->w ) {
-            RLEClipBlit(w, srcbuf, dst, dstbuf, srcrect, alpha);
-        } else {
-            GAL_PixelFormat *fmt = src->format;
+    alpha = (src->flags & GAL_SRCALPHA) == GAL_SRCALPHA
+            ? src->format->alpha : 255;
+    /* if left or right edge clipping needed, call clip blit */
+    if ( srcrect->x || srcrect->w != src->w ) {
+        RLEClipBlit(w, srcbuf, dst, dstbuf, srcrect, alpha);
+    } else {
+        GAL_PixelFormat *fmt = src->format;
 
 #define RLEBLIT(bpp, Type, do_blit)                                              \
-            do {                                                              \
-                int linecount = srcrect->h;                                      \
-                int ofs = 0;                                                      \
-                for(;;) {                                                      \
-                    unsigned run;                                              \
-                    ofs += *(Type *)srcbuf;                                      \
-                    run = ((Type *)srcbuf)[1];                                      \
-                    srcbuf += 2 * sizeof(Type);                                      \
-                    if(run) {                                                      \
-                        do_blit(dstbuf + ofs * bpp, srcbuf, run, bpp, alpha); \
-                        srcbuf += run * bpp;                                      \
-                        ofs += run;                                              \
-                    } else if(!ofs)                                              \
-                        break;                                                      \
-                    if(ofs == w) {                                              \
-                        ofs = 0;                                              \
-                        dstbuf += dst->pitch;                                      \
-                        if(!--linecount)                                      \
-                            break;                                              \
-                    }                                                              \
+        do {                                                              \
+            int linecount = srcrect->h;                                      \
+            int ofs = 0;                                                      \
+            for(;;) {                                                      \
+                unsigned run;                                              \
+                ofs += *(Type *)srcbuf;                                      \
+                run = ((Type *)srcbuf)[1];                                      \
+                srcbuf += 2 * sizeof(Type);                                      \
+                if(run) {                                                      \
+                    do_blit(dstbuf + ofs * bpp, srcbuf, run, bpp, alpha); \
+                    srcbuf += run * bpp;                                      \
+                    ofs += run;                                              \
+                } else if(!ofs)                                              \
+                    break;                                                      \
+                if(ofs == w) {                                              \
+                    ofs = 0;                                              \
+                    dstbuf += dst->pitch;                                      \
+                    if(!--linecount)                                      \
+                        break;                                              \
                 }                                                              \
-            } while(0)
+            }                                                              \
+        } while(0)
 
-            CHOOSE_BLIT(RLEBLIT, alpha, fmt);
+        CHOOSE_BLIT(RLEBLIT, alpha, fmt);
 
 #undef RLEBLIT
-        }
+    }
 
 done:
-        return(0);
+    return(0);
 }
 
 #undef OPAQUE_BLIT
@@ -720,9 +721,12 @@ static void RLEAlphaClipBlit(int w, Uint8 *srcbuf, GAL_Surface *dst,
 }
 
 /* blit a pixel-alpha RLE surface */
-int GAL_RLEAlphaBlit(GAL_Surface *src, GAL_Rect *srcrect,
-                     GAL_Surface *dst, GAL_Rect *dstrect)
+int GAL_RLEAlphaBlit(GAL_VideoDevice *video,
+        GAL_Surface *src, GAL_Rect *srcrect,
+        GAL_Surface *dst, GAL_Rect *dstrect)
 {
+    (void)video;
+
     int x, y;
     int w = src->w;
     Uint8 *srcbuf, *dstbuf;
@@ -1502,7 +1506,7 @@ void GAL_UnRLESurface(GAL_Surface *surface, int recode)
                 full.h = surface->h;
                 alpha_flag = surface->flags & GAL_SRCALPHA;
                 surface->flags &= ~GAL_SRCALPHA; /* opaque blit */
-                GAL_RLEBlit(surface, &full, surface, &full);
+                GAL_RLEBlit(NULL, surface, &full, surface, &full);
                 surface->flags |= alpha_flag;
             } else
                 UnRLEAlpha(surface);

src/newgal/RLEaccel_c.h

@@ -47,9 +47,11 @@
 /* Useful functions and variables from RLEaccel.c */
 
 extern int GAL_RLESurface(GAL_Surface *surface);
-extern int GAL_RLEBlit(GAL_Surface *src, GAL_Rect *srcrect,
-                       GAL_Surface *dst, GAL_Rect *dstrect);
-extern int GAL_RLEAlphaBlit(GAL_Surface *src, GAL_Rect *srcrect,
-                GAL_Surface *dst, GAL_Rect *dstrect);
+extern int GAL_RLEBlit(GAL_VideoDevice *video,
+        GAL_Surface *src, GAL_Rect *srcrect,
+        GAL_Surface *dst, GAL_Rect *dstrect);
+extern int GAL_RLEAlphaBlit(GAL_VideoDevice *video,
+        GAL_Surface *src, GAL_Rect *srcrect,
+        GAL_Surface *dst, GAL_Rect *dstrect);
 extern void GAL_UnRLESurface(GAL_Surface *surface, int recode);
 

src/newgal/bf533/bf533video.c

@@ -157,8 +157,6 @@ static GAL_VideoDevice *BF533_CreateDevice(int devindex)
     device->AllocHWSurface = BF533_AllocHWSurface;
     device->CheckHWBlit = NULL;
     device->FillHWRect = NULL;
-    device->SetHWColorKey = NULL;
-    device->SetHWAlpha = NULL;
     device->FreeHWSurface = BF533_FreeHWSurface;
     device->UpdateRects = BF533_UpdateRects;
 

src/newgal/blit.c

@@ -57,9 +57,12 @@
 #include "memops.h"
 
 /* The general purpose software blit routine */
-static int GAL_SoftBlit(GAL_Surface *src, GAL_Rect *srcrect,
-            GAL_Surface *dst, GAL_Rect *dstrect)
+static int GAL_SoftBlit(GAL_VideoDevice *video,
+        GAL_Surface *src, GAL_Rect *srcrect,
+        GAL_Surface *dst, GAL_Rect *dstrect)
 {
+    (void)video;
+
     int okay;
 
     /* Everything is okay at the beginning...  */
@@ -166,12 +169,14 @@ static void GAL_BlitCopyOverlap(GAL_BlitInfo *info)
 #ifdef _MGUSE_PIXMAN
 #include <pixman.h>
 
-static int GAL_PixmanBlit (struct GAL_Surface *src, GAL_Rect *srcrect,
+static int GAL_PixmanBlit(GAL_VideoDevice *video,
+        struct GAL_Surface *src, GAL_Rect *srcrect,
         struct GAL_Surface *dst, GAL_Rect *dstrect);
 #endif
 
 /* Figure out which of many blit routines to set up on a surface */
-int GAL_CalculateBlit(GAL_Surface *surface)
+int GAL_CalculateBlit(GAL_Surface *surface, const GAL_Rect *srcrc,
+        const GAL_Rect *dstrc, DWORD op)
 {
     int blit_index;
     GAL_VideoDevice *src_video, *dst_video, *cur_video = NULL;
@@ -242,7 +247,8 @@ int GAL_CalculateBlit(GAL_Surface *surface)
         if (hw_blit_ok && cur_video) {
             GAL_VideoDevice *video = cur_video;
             GAL_VideoDevice *this  = cur_video;
-            video->CheckHWBlit (this, surface, surface->map->dst);
+            video->CheckHWBlit (this, surface, srcrc,
+                    surface->map->dst, dstrc, op);
         }
     }
 
@@ -343,7 +349,7 @@ int GAL_SetupBlitting (GAL_Surface *src, GAL_Surface *dst, DWORD ops)
         else
             src->msk_img = NULL;
 
-        ops &= COLOR_BLEND_FLAGS_MASK;
+        ops &= COLOR_BLEND_PIXMAN_MASK;
         if (ops == COLOR_BLEND_LEGACY) {
             if ((src->flags & GAL_SRCPIXELALPHA) && src->format->Amask && src != dst) {
                 src->pix_op = PIXMAN_OP_OVER;
@@ -381,9 +387,12 @@ int GAL_CleanupBlitting (GAL_Surface *src, GAL_Surface *dst)
     return 0;
 }
 
-static int GAL_PixmanBlit (struct GAL_Surface *src, GAL_Rect *srcrect,
+static int GAL_PixmanBlit (GAL_VideoDevice *video,
+        struct GAL_Surface *src, GAL_Rect *srcrect,
         struct GAL_Surface *dst, GAL_Rect *dstrect)
 {
+    (void)video;
+
     pixman_image_t *src_img = src->pix_img, *dst_img = dst->pix_img;
     pixman_image_t *msk_img;
     pixman_op_t op;

src/newgal/blit.h

@@ -80,7 +80,11 @@ typedef struct GAL_BlitMap {
     Uint8 *table;
     GAL_blit hw_blit;
     GAL_blit sw_blit;
+    GAL_VideoDevice *video;
+
+    /* data for hardware blittor */
     struct private_hwaccel *hw_data;
+    /* data for software blittor */
     struct private_swaccel *sw_data;
 
     int identity;
@@ -94,7 +98,8 @@ typedef struct GAL_BlitMap {
 #include "blit_A.h"
 
 /* Functions found in GAL_blit.c */
-extern int GAL_CalculateBlit(GAL_Surface *surface);
+extern int GAL_CalculateBlit(GAL_Surface *surface, const GAL_Rect *srcrc,
+        const GAL_Rect *dstrc, DWORD op);
 
 /* Functions found in GAL_blit_{0,1,N,A}.c */
 extern GAL_loblit GAL_CalculateBlit0(GAL_Surface *surface, int complex);

src/newgal/commlcd/commlcd.c

@@ -236,8 +236,6 @@ static GAL_VideoDevice *COMMLCD_CreateDevice (int devindex)
     device->FreeHWSurface = COMMLCD_FreeHWSurface;
     device->CheckHWBlit = NULL;
     device->FillHWRect = NULL;
-    device->SetHWColorKey = NULL;
-    device->SetHWAlpha = NULL;
     device->UpdateRects = NULL;
     device->SyncUpdate = NULL;
 

src/newgal/dfb/dfbvideo.c

@@ -107,7 +107,7 @@ static int DFB_AllocHWSurface (_THIS, GAL_Surface *surface);
 static void DFB_FreeHWSurface (_THIS, GAL_Surface *surface);
 static int DFB_HWAccelBlit (GAL_Surface *src, GAL_Rect *srcrect, GAL_Surface *dst, GAL_Rect *dstrect);
 static int DFB_CheckHWBlit (_THIS, GAL_Surface * src, GAL_Surface * dst);
-static int DFB_FillHWRect (_THIS, GAL_Surface *dst, GAL_Rect *rect, Uint32 color);
+static int DFB_FillHWRect (_THIS, GAL_Surface *dst, const GAL_Rect *rect, Uint32 color);
 
 /* common dfb function address */
 GAL_FunctionTable mgGALFuncTable = {
@@ -173,8 +173,6 @@ static GAL_VideoDevice *DFB_CreateDevice (int devindex)
         device->AllocHWSurface = DFB_AllocHWSurface;
         device->CheckHWBlit = DFB_CheckHWBlit;
         device->FillHWRect = DFB_FillHWRect;
-        device->SetHWColorKey = NULL;
-        device->SetHWAlpha = NULL;
         device->FreeHWSurface = DFB_FreeHWSurface;
         device->free = DFB_DeleteDevice;
 
@@ -518,7 +516,8 @@ static void DFB_RequestHWSurface (_THIS, const REQ_HWSURFACE* request, REP_HWSUR
     }
 }
 
-static int DFB_FillHWRect (_THIS, GAL_Surface *dst, GAL_Rect *rect, Uint32 color)
+static int
+DFB_FillHWRect (_THIS, GAL_Surface *dst, const GAL_Rect *rect, Uint32 color)
 {
     if ((dst->hwdata == NULL && dst != GAL_VideoSurface)) {
         fprintf(stderr, "NEWGAL>DFB: src_hwdata or dst_hwdata NULL\n");

src/newgal/dfb/dfbvideo.h

@@ -111,7 +111,7 @@ typedef struct _GAL_FunctionTable {
     int (*AllocHWSurface)(_THIS, GAL_Surface *surface);
     int (*CheckHWBlit)(_THIS, GAL_Surface *src, GAL_Surface *dst);
     int (*HWAccelBlit)(GAL_Surface *src, GAL_Rect *srcrect, GAL_Surface *dst, GAL_Rect *dstrect);
-    int (*FillHWRect)(_THIS, GAL_Surface *dst, GAL_Rect *rect, Uint32 color);
+    int (*FillHWRect)(_THIS, GAL_Surface *dst, const GAL_Rect *rect, Uint32 color);
     int (*SetHWColorKey)(_THIS, GAL_Surface *surface, Uint32 key);
     int (*SetHWAlpha)(_THIS, GAL_Surface *surface, Uint8 value);
     void (*FreeHWSurface)(_THIS, GAL_Surface *surface);

src/newgal/drm/drmvideo.h

@@ -53,10 +53,12 @@
 #ifndef _MGSCHEMA_COMPOSITING
 #include <fcntl.h>           /* For O_* constants */
 #include <sys/stat.h>        /* For mode constants */
+#endif
+
+#include <pthread.h>
 #include <semaphore.h>
 
-#define SEM_UPDATE_LOCK     "mginit-drm-update"
-#endif
+#define SEM_UPDATE_LOCK     "minigui-drm-update"
 
 /* Hidden "this" pointer for the video functions */
 #define _THIS   GAL_VideoDevice *this
@@ -85,9 +87,10 @@ typedef struct GAL_PrivateVideoData {
 
     /* the global names of real screen and shadow screen */
     uint32_t        real_name, shadow_name;
-    sem_t *update_lock;
 #endif  /* not defined _MGSCHEMA_COMPOSITING */
 
+    sem_t *update_lock;
+
 #if !IS_SHAREDFB_SCHEMA_PROCS
     RECT dirty_rc;
 #endif
@@ -100,8 +103,11 @@ typedef struct GAL_PrivateVideoData {
     uint32_t        cap_cursor_width;
     uint32_t        cap_cursor_height;
     uint32_t        cap_dumb:1;
+    uint32_t        cap_vblank_high_crtc:1;
     uint32_t        dbl_buff:1;
+    uint32_t        dirty_fb_ok:1;
     uint32_t        scanout_buff_id;
+    int             crtc_idx;
 
     void*           exdrv_handle;
     DrmDriverOps*   driver_ops;
@@ -113,10 +119,20 @@ typedef struct GAL_PrivateVideoData {
     DrmModeInfo*    saved_info;
     drmModeCrtc*    saved_crtc;
 
-#if 0   /* deprecated code */
-    uint32_t        console_buff_id;
-    uint8_t*        scanout_fb;
-#endif  /* deprecated code */
+    int             min_pixels_using_hwaccl;
+
+    /* async updater */
+    int             updater_ready;
+    int             update_interval;
+    RECT            update_rect;
+    pthread_t       update_thd;
+    sem_t           sync_sem;
+
+#ifdef _DEBUG
+    struct timespec ts_start;
+    unsigned        frames;
+#endif
+
 } DrmVideoData;
 
 #endif /* _NEWGAL_DRIVIDEO_H */

src/newgal/drm/linux-dma-buf.h

@@ -0,0 +1,41 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/*
+ * Framework for buffer objects that can be shared across devices/subsystems.
+ *
+ * Copyright(C) 2015 Intel Ltd
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _DMA_BUF_UAPI_H_
+#define _DMA_BUF_UAPI_H_
+
+#include <linux/types.h>
+
+/* begin/end dma-buf functions used for userspace mmap. */
+struct dma_buf_sync {
+	__u64 flags;
+};
+
+#define DMA_BUF_SYNC_READ      (1 << 0)
+#define DMA_BUF_SYNC_WRITE     (2 << 0)
+#define DMA_BUF_SYNC_RW        (DMA_BUF_SYNC_READ | DMA_BUF_SYNC_WRITE)
+#define DMA_BUF_SYNC_START     (0 << 2)
+#define DMA_BUF_SYNC_END       (1 << 2)
+#define DMA_BUF_SYNC_VALID_FLAGS_MASK \
+	(DMA_BUF_SYNC_RW | DMA_BUF_SYNC_END)
+
+#define DMA_BUF_BASE		'b'
+#define DMA_BUF_IOCTL_SYNC	_IOW(DMA_BUF_BASE, 0, struct dma_buf_sync)
+
+#endif

src/newgal/dummy/nullvideo.c

@@ -139,8 +139,6 @@ static GAL_VideoDevice *DUMMY_CreateDevice(int devindex)
     device->AllocHWSurface = DUMMY_AllocHWSurface;
     device->CheckHWBlit = NULL;
     device->FillHWRect = NULL;
-    device->SetHWColorKey = NULL;
-    device->SetHWAlpha = NULL;
     device->FreeHWSurface = DUMMY_FreeHWSurface;
 
     device->free = DUMMY_DeleteDevice;

src/newgal/em85xxosd/em85xxosd.c

@@ -183,8 +183,6 @@ static GAL_VideoDevice *EM85XXOSD_CreateDevice(int devindex)
     device->AllocHWSurface = EM85XXOSD_AllocHWSurface;
     device->CheckHWBlit = NULL;
     device->FillHWRect = NULL;
-    device->SetHWColorKey = NULL;
-    device->SetHWAlpha = NULL;
     device->FreeHWSurface = EM85XXOSD_FreeHWSurface;
     device->UpdateRects = EM85XXOSD_UpdateRects;
 

src/newgal/em85xxyuv/em85xxyuv.c

@@ -454,8 +454,6 @@ static GAL_VideoDevice *EM85XXYUV_CreateDevice(int devindex)
     device->AllocHWSurface = EM85XXYUV_AllocHWSurface;
     device->CheckHWBlit = NULL;
     device->FillHWRect = NULL;
-    device->SetHWColorKey = NULL;
-    device->SetHWAlpha = NULL;
     device->FreeHWSurface = EM85XXYUV_FreeHWSurface;
     device->UpdateRects = EM85XXYUV_UpdateRects;
 

src/newgal/em86gfx/em86gfx.c

@@ -69,7 +69,7 @@ static int GFX_VideoInit(_THIS, GAL_PixelFormat * vformat);
 static GAL_Rect ** GFX_ListModes(_THIS, GAL_PixelFormat * format, Uint32 flags);
 static GAL_Surface * GFX_SetVideoMode(_THIS, GAL_Surface * current, int width, int height, int bpp, Uint32 flags);
 static void GFX_VideoQuit(_THIS);
-static int GFX_FillHWRect(_THIS, GAL_Surface * dst, GAL_Rect * rect, Uint32 color);
+static int GFX_FillHWRect(_THIS, GAL_Surface *dst, const GAL_Rect *rect, Uint32 color);
 static int GFX_AllocHWSurface(_THIS, GAL_Surface * surface);
 static void GFX_FreeHWSurface(_THIS, GAL_Surface * surface);
 static int GFX_HWAccelBlit(GAL_Surface * src, GAL_Rect * srcrect, GAL_Surface * dst, GAL_Rect * dstrect);
@@ -112,8 +112,6 @@ static GAL_VideoDevice * GFX_CreateDevice(int devindex)
     this->AllocHWSurface = GFX_AllocHWSurface;
     this->CheckHWBlit = GFX_CheckHWBlit;
     this->FillHWRect = GFX_FillHWRect;
-    this->SetHWColorKey = NULL;
-    this->SetHWAlpha = NULL;
     this->UpdateRects = NULL;
     this->FreeHWSurface = GFX_FreeHWSurface;
 
@@ -298,7 +296,8 @@ static void GFX_VideoQuit (_THIS)
     return;
 }
 
-static int GFX_FillHWRect(_THIS, GAL_Surface * surface, GAL_Rect * rect, Uint32 color)
+static int
+GFX_FillHWRect(_THIS, GAL_Surface *surface, const GAL_Rect *rect, Uint32 color)
 {
     struct GFXEngine_FillRectangle_type fill_param;
     struct GFXEngine_Surface_type surface_param;

src/newgal/fbcon/fb3dfx.c

@@ -68,13 +68,7 @@ static void WaitIdle(_THIS)
     tdfx_waitidle();
 }
 
-/* Set video mem colorkey and accelerated blit function */
-static int SetHWColorKey(_THIS, GAL_Surface *surface, Uint32 key)
-{
-    return(0);
-}
-
-static int FillHWRect(_THIS, GAL_Surface *dst, GAL_Rect *rect, Uint32 color)
+static int FillHWRect(_THIS, GAL_Surface *dst, const GAL_Rect *rect, Uint32 color)
 {
     int bpp;
     char *dst_base;
@@ -106,10 +100,9 @@ static int FillHWRect(_THIS, GAL_Surface *dst, GAL_Rect *rect, Uint32 color)
     return(0);
 }
 
-static int HWAccelBlit(GAL_Surface *src, GAL_Rect *srcrect,
+static int HWAccelBlit(_THIS, GAL_Surface *src, GAL_Rect *srcrect,
                        GAL_Surface *dst, GAL_Rect *dstrect)
 {
-    GAL_VideoDevice *this = __mg_current_video;
     int bpp;
     Uint32 src_format;
     /* Uint32 dst_format; */
@@ -175,8 +168,11 @@ static int HWAccelBlit(GAL_Surface *src, GAL_Rect *srcrect,
     return(0);
 }
 
-static int CheckHWBlit(_THIS, GAL_Surface *src, GAL_Surface *dst)
+static int CheckHWBlit(_THIS, GAL_Surface *src, const GAL_Rect *srcrc,
+        GAL_Surface *dst, const GAL_Rect *dstrc, DWORD op)
 {
+    (void)srcrc;
+    (void)dstrc;
     int accelerated;
 
     /* Set initial acceleration on */
@@ -194,11 +190,24 @@ static int CheckHWBlit(_THIS, GAL_Surface *src, GAL_Surface *dst)
         }
     }
 
+    /* color blend, logical operation, and scaling filter are not supported */
+    if ((op & COLOR_BLEND_MASK) ||
+            ((op & COLOR_LOGICOP_MASK) != COLOR_LOGICOP_COPY) ||
+            (op & SCALING_FILTER_MASK)) {
+        src->flags &= ~GAL_HWACCEL;
+    }
+
     /* Check to see if final surface blit is accelerated */
     accelerated = !!(src->flags & GAL_HWACCEL);
     if ( accelerated ) {
+        src->map->video = this;
         src->map->hw_blit = HWAccelBlit;
     }
+    else {
+        src->map->video = NULL;
+        src->map->hw_blit = NULL;
+    }
+
     return(accelerated);
 }
 
@@ -220,5 +229,4 @@ void FB_3DfxAccel(_THIS, __u32 card)
     /* The 3Dfx has accelerated normal and colorkey blits */
     this->info.blit_hw = 1;
     this->info.blit_hw_CC = 1;
-    this->SetHWColorKey = SetHWColorKey;
 }

src/newgal/fbcon/fbmatrox.c

@@ -74,21 +74,7 @@ static void WaitIdle(_THIS)
     mga_waitidle();
 }
 
-/* Set video mem colorkey and accelerated blit function */
-static int SetHWColorKey(_THIS, GAL_Surface *surface, Uint32 key)
-{
-    return(0);
-}
-
-/* Set per surface hardware alpha value */
-#if 0
-static int SetHWAlpha(_THIS, GAL_Surface *surface, Uint8 value)
-{
-    return(0);
-}
-#endif
-
-static int FillHWRect(_THIS, GAL_Surface *dst, GAL_Rect *rect, Uint32 color)
+static int FillHWRect(_THIS, GAL_Surface *dst, const GAL_Rect *rect, Uint32 color)
 {
     int dstX, dstY;
     Uint32 fxbndry;
@@ -132,10 +118,9 @@ static int FillHWRect(_THIS, GAL_Surface *dst, GAL_Rect *rect, Uint32 color)
     return(0);
 }
 
-static int HWAccelBlit(GAL_Surface *src, GAL_Rect *srcrect,
+static int HWAccelBlit(_THIS, GAL_Surface *src, GAL_Rect *srcrect,
                        GAL_Surface *dst, GAL_Rect *dstrect)
 {
-    GAL_VideoDevice *this = __mg_current_video;
     int pitch, w, h;
     int srcX, srcY;
     int dstX, dstY;
@@ -146,7 +131,7 @@ static int HWAccelBlit(GAL_Surface *src, GAL_Rect *srcrect,
 
     /* FIXME: For now, only blit to display surface */
     if ( dst->pitch != GAL_VideoSurface->pitch ) {
-        return(src->map->sw_blit(src, srcrect, dst, dstrect));
+        return(src->map->sw_blit(this, src, srcrect, dst, dstrect));
     }
 
     /* Calculate source and destination base coordinates (in pixels) */
@@ -224,8 +209,11 @@ static int HWAccelBlit(GAL_Surface *src, GAL_Rect *srcrect,
     return(0);
 }
 
-static int CheckHWBlit(_THIS, GAL_Surface *src, GAL_Surface *dst)
+static int CheckHWBlit(_THIS, GAL_Surface *src, const GAL_Rect *srcrc,
+        GAL_Surface *dst, const GAL_Rect *dstrc, DWORD op)
 {
+    (void)srcrc;
+    (void)dstrc;
     int accelerated;
 
     /* Set initial acceleration on */
@@ -243,11 +231,24 @@ static int CheckHWBlit(_THIS, GAL_Surface *src, GAL_Surface *dst)
         }
     }
 
+    /* color blend, logical operation, and scaling filter are not supported */
+    if ((op & COLOR_BLEND_MASK) ||
+            ((op & COLOR_LOGICOP_MASK) != COLOR_LOGICOP_COPY) ||
+            (op & SCALING_FILTER_MASK)) {
+        src->flags &= ~GAL_HWACCEL;
+    }
+
     /* Check to see if final surface blit is accelerated */
     accelerated = !!(src->flags & GAL_HWACCEL);
     if ( accelerated ) {
+        src->map->video = this;
         src->map->hw_blit = HWAccelBlit;
     }
+    else {
+        src->map->video = NULL;
+        src->map->hw_blit = NULL;
+    }
+
     return(accelerated);
 }
 
@@ -269,7 +270,6 @@ void FB_MatroxAccel(_THIS, __u32 card)
      */
     if ( card != FB_ACCEL_MATROX_MGA2064W ) {
         this->info.blit_hw_CC = 1;
-        this->SetHWColorKey = SetHWColorKey;
     }
 
 #if 0 /* Not yet implemented? */

src/newgal/fbcon/fbneomagic.c

@@ -95,12 +95,6 @@ static void WaitIdle(_THIS)
         ;
 }
 
-/* Set video mem colorkey and accelerated blit function */
-static int SetHWColorKey(_THIS, GAL_Surface *surface, Uint32 key)
-{
-    return 0;
-}
-
 static inline void validate_dst (_THIS, GAL_Surface* dst)
 {
     int bltMode = 0;
@@ -121,7 +115,7 @@ static inline void validate_dst (_THIS, GAL_Surface* dst)
   neo2200->pitch = (dst->pitch << 16) | (dst->pitch & 0xFFFF);
 }
 
-static int FillHWRect(_THIS, GAL_Surface *dst, GAL_Rect *rect, Uint32 color)
+static int FillHWRect(_THIS, GAL_Surface *dst, const GAL_Rect *rect, Uint32 color)
 {
     char *dst_base;
 
@@ -195,9 +189,11 @@ static void make_rects (GAL_Rect *src, GAL_Rect* dst, const RECT* rc, Uint32 x,
     dst->h = src->h;
 }
 
-static int HWAccelBlit (GAL_Surface *src, GAL_Rect *srcrect,
+static int HWAccelBlit (_THIS, GAL_Surface *src, GAL_Rect *srcrect,
                        GAL_Surface *dst, GAL_Rect *dstrect)
 {
+    (void)this;
+
     RECT rc_src = {srcrect->x, srcrect->y, srcrect->x + srcrect->w, srcrect->y + srcrect->h};
     RECT rc_dst = {dstrect->x, dstrect->y, dstrect->x + dstrect->w, dstrect->y + dstrect->h};
     RECT rc_inter, rc_sub [4];
@@ -241,8 +237,11 @@ static int HWAccelBlit (GAL_Surface *src, GAL_Rect *srcrect,
     return(0);
 }
 
-static int CheckHWBlit (_THIS, GAL_Surface *src, GAL_Surface *dst)
+static int CheckHWBlit(_THIS, GAL_Surface *src, const GAL_Rect *srcrc,
+        GAL_Surface *dst, const GAL_Rect *dstrc, DWORD op)
 {
+    (void)srcrc;
+    (void)dstrc;
     int accelerated;
 
     /* Set initial acceleration on */
@@ -260,14 +259,27 @@ static int CheckHWBlit (_THIS, GAL_Surface *src, GAL_Surface *dst)
         }
     }
 
+    /* color blend, logical operation, and scaling filter are not supported */
+    if ((op & COLOR_BLEND_MASK) ||
+            ((op & COLOR_LOGICOP_MASK) != COLOR_LOGICOP_COPY) ||
+            (op & SCALING_FILTER_MASK)) {
+        src->flags &= ~GAL_HWACCEL;
+    }
+
     if (src->format->BitsPerPixel > 16)
         src->flags &= ~GAL_HWACCEL;
 
     /* Check to see if final surface blit is accelerated */
     accelerated = !!(src->flags & GAL_HWACCEL);
     if ( accelerated ) {
+        src->map->video = this;
         src->map->hw_blit = HWAccelBlit;
     }
+    else {
+        src->map->video = NULL;
+        src->map->hw_blit = NULL;
+    }
+
     return(accelerated);
 }
 
@@ -287,7 +299,6 @@ void FB_NeoMagicAccel(_THIS, __u32 card)
     /* The NeoMagic has accelerated normal and colorkey blits */
     this->info.blit_hw = 1;
     this->info.blit_hw_CC = 1;
-    this->SetHWColorKey = SetHWColorKey;
 }
 
 #endif /* FB_ACCEL_NEOMAGIC_NM2070 */

src/newgal/fbcon/fbvideo.c

@@ -99,8 +99,6 @@ static void FB_RequestHWSurface (_THIS, const REQ_HWSURFACE* request,
         REP_HWSURFACE* reply);
 static int FB_AllocHWSurface(_THIS, GAL_Surface *surface);
 static void FB_FreeHWSurface(_THIS, GAL_Surface *surface);
-static void FB_WaitVBL(_THIS);
-static void FB_WaitIdle(_THIS);
 
 #include "../shadow-screen.h"
 #include "debug.h"
@@ -110,22 +108,88 @@ static void FB_WaitIdle(_THIS);
 #define FBIO_ENABLE_CACHE       0x4631
 #endif
 
+#ifdef FBCON_DEBUG
+static void print_vinfo(struct fb_var_screeninfo *vinfo)
+{
+    fprintf(stderr, "Printing vinfo:\n");
+    fprintf(stderr, "txres: %d\n", vinfo->xres);
+    fprintf(stderr, "tyres: %d\n", vinfo->yres);
+    fprintf(stderr, "txres_virtual: %d\n", vinfo->xres_virtual);
+    fprintf(stderr, "tyres_virtual: %d\n", vinfo->yres_virtual);
+    fprintf(stderr, "txoffset: %d\n", vinfo->xoffset);
+    fprintf(stderr, "tyoffset: %d\n", vinfo->yoffset);
+    fprintf(stderr, "tbits_per_pixel: %d\n", vinfo->bits_per_pixel);
+    fprintf(stderr, "tgrayscale: %d\n", vinfo->grayscale);
+    fprintf(stderr, "tnonstd: %d\n", vinfo->nonstd);
+    fprintf(stderr, "tactivate: %d\n", vinfo->activate);
+    fprintf(stderr, "theight: %d\n", vinfo->height);
+    fprintf(stderr, "twidth: %d\n", vinfo->width);
+    fprintf(stderr, "taccel_flags: %d\n", vinfo->accel_flags);
+    fprintf(stderr, "tpixclock: %d\n", vinfo->pixclock);
+    fprintf(stderr, "tleft_margin: %d\n", vinfo->left_margin);
+    fprintf(stderr, "tright_margin: %d\n", vinfo->right_margin);
+    fprintf(stderr, "tupper_margin: %d\n", vinfo->upper_margin);
+    fprintf(stderr, "tlower_margin: %d\n", vinfo->lower_margin);
+    fprintf(stderr, "thsync_len: %d\n", vinfo->hsync_len);
+    fprintf(stderr, "tvsync_len: %d\n", vinfo->vsync_len);
+    fprintf(stderr, "tsync: %d\n", vinfo->sync);
+    fprintf(stderr, "tvmode: %d\n", vinfo->vmode);
+    fprintf(stderr, "tred: %d/%d\n", vinfo->red.length, vinfo->red.offset);
+    fprintf(stderr, "tgreen: %d/%d\n", vinfo->green.length, vinfo->green.offset);
+    fprintf(stderr, "tblue: %d/%d\n", vinfo->blue.length, vinfo->blue.offset);
+    fprintf(stderr, "talpha: %d/%d\n", vinfo->transp.length, vinfo->transp.offset);
+}
+
+static void print_finfo(struct fb_fix_screeninfo *finfo)
+{
+    fprintf(stderr, "Printing finfo:\n");
+    fprintf(stderr, "tsmem_start = %p\n", (char *)finfo->smem_start);
+    fprintf(stderr, "tsmem_len = %d\n", finfo->smem_len);
+    fprintf(stderr, "ttype = %d\n", finfo->type);
+    fprintf(stderr, "ttype_aux = %d\n", finfo->type_aux);
+    fprintf(stderr, "tvisual = %d\n", finfo->visual);
+    fprintf(stderr, "txpanstep = %d\n", finfo->xpanstep);
+    fprintf(stderr, "typanstep = %d\n", finfo->ypanstep);
+    fprintf(stderr, "tywrapstep = %d\n", finfo->ywrapstep);
+    fprintf(stderr, "tline_length = %d\n", finfo->line_length);
+    fprintf(stderr, "tmmio_start = %p\n", (char *)finfo->mmio_start);
+    fprintf(stderr, "tmmio_len = %d\n", finfo->mmio_len);
+    fprintf(stderr, "taccel = %d\n", finfo->accel);
+}
+#endif  /* FBCON_DEBUG */
+
+static BOOL FB_WaitVBlank(_THIS)
+{
+    int dummy;
+    if (wait_vbl) {
+        wait_vbl(this);
+    }
+    else if (ioctl(console_fd, FBIO_WAITFORVSYNC, &dummy)) {
+        _DBG_PRINTF("Failed VSync: %m\n");
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
 static BOOL FB_SyncUpdate (_THIS)
 {
-    if (IsRectEmpty (&this->hidden->dirty_rc))
+    if (IsRectEmpty(&this->hidden->dirty_rc))
         return FALSE;
 
-    if (shadowScreen_BlitToReal (this) == 0) {
+    if (shadowScreen_BlitToReal(this, NULL) == 0) {
 #if defined(__TARGET_R818__)
         uintptr_t args[2];
         args[0] = (uintptr_t)this->hidden->real_screen->pixels;
-        args[0] += this->hidden->real_screen->pitch * this->hidden->dirty_rc.top;
-        args[1] = this->hidden->real_screen->pitch * RECTH(this->hidden->dirty_rc);
+        args[0] += this->hidden->real_screen->pitch *
+            this->hidden->dirty_rc.top;
+        args[1] = this->hidden->real_screen->pitch *
+            RECTH(this->hidden->dirty_rc);
         if (ioctl (console_fd, FBIO_CACHE_SYNC, args) < 0) {
-            _WRN_PRINTF ("failed to sync cache\n");
+            _WRN_PRINTF("failed to flush cache for R818\n");
         }
 #endif
-        SetRectEmpty (&this->hidden->dirty_rc);
+        SetRectEmpty(&this->hidden->dirty_rc);
         return TRUE;
     }
 
@@ -188,8 +252,6 @@ static GAL_VideoDevice *FB_CreateDevice(int devindex)
     memset(this->hidden, 0, (sizeof *this->hidden));
     this->hidden->magic = MAGIC_SHADOW_SCREEN_HEADER;
     this->hidden->version = 0;
-    wait_vbl = FB_WaitVBL;
-    wait_idle = FB_WaitIdle;
 
     /* Set the function pointers */
     this->VideoInit = FB_VideoInit;
@@ -203,8 +265,6 @@ static GAL_VideoDevice *FB_CreateDevice(int devindex)
     this->AllocHWSurface = FB_AllocHWSurface;
     this->CheckHWBlit = NULL;
     this->FillHWRect = NULL;
-    this->SetHWColorKey = NULL;
-    this->SetHWAlpha = NULL;
     this->UpdateRects = NULL;
 #if 0
     this->LockHWSurface = FB_LockHWSurface;
@@ -375,6 +435,12 @@ static int FB_VideoInit(_THIS, GAL_PixelFormat *vformat)
         FB_VideoQuit(this);
         return(-1);
     }
+
+#ifdef FBCON_DEBUG
+    fprintf (stderr, "Printing original finfo:\n");
+    print_finfo(&finfo);
+#endif
+
     switch (finfo.type) {
         case FB_TYPE_PACKED_PIXELS:
             /* Supported, no worries.. */
@@ -523,55 +589,163 @@ static GAL_Rect **FB_ListModes(_THIS, GAL_PixelFormat *format, Uint32 flags)
     return (GAL_Rect**) -1;
 }
 
-#ifdef FBCON_DEBUG
-static void print_vinfo(struct fb_var_screeninfo *vinfo)
+static void* task_do_update(void *data)
 {
-    fprintf(stderr, "Printing vinfo:\n");
-    fprintf(stderr, "txres: %d\n", vinfo->xres);
-    fprintf(stderr, "tyres: %d\n", vinfo->yres);
-    fprintf(stderr, "txres_virtual: %d\n", vinfo->xres_virtual);
-    fprintf(stderr, "tyres_virtual: %d\n", vinfo->yres_virtual);
-    fprintf(stderr, "txoffset: %d\n", vinfo->xoffset);
-    fprintf(stderr, "tyoffset: %d\n", vinfo->yoffset);
-    fprintf(stderr, "tbits_per_pixel: %d\n", vinfo->bits_per_pixel);
-    fprintf(stderr, "tgrayscale: %d\n", vinfo->grayscale);
-    fprintf(stderr, "tnonstd: %d\n", vinfo->nonstd);
-    fprintf(stderr, "tactivate: %d\n", vinfo->activate);
-    fprintf(stderr, "theight: %d\n", vinfo->height);
-    fprintf(stderr, "twidth: %d\n", vinfo->width);
-    fprintf(stderr, "taccel_flags: %d\n", vinfo->accel_flags);
-    fprintf(stderr, "tpixclock: %d\n", vinfo->pixclock);
-    fprintf(stderr, "tleft_margin: %d\n", vinfo->left_margin);
-    fprintf(stderr, "tright_margin: %d\n", vinfo->right_margin);
-    fprintf(stderr, "tupper_margin: %d\n", vinfo->upper_margin);
-    fprintf(stderr, "tlower_margin: %d\n", vinfo->lower_margin);
-    fprintf(stderr, "thsync_len: %d\n", vinfo->hsync_len);
-    fprintf(stderr, "tvsync_len: %d\n", vinfo->vsync_len);
-    fprintf(stderr, "tsync: %d\n", vinfo->sync);
-    fprintf(stderr, "tvmode: %d\n", vinfo->vmode);
-    fprintf(stderr, "tred: %d/%d\n", vinfo->red.length, vinfo->red.offset);
-    fprintf(stderr, "tgreen: %d/%d\n", vinfo->green.length, vinfo->green.offset);
-    fprintf(stderr, "tblue: %d/%d\n", vinfo->blue.length, vinfo->blue.offset);
-    fprintf(stderr, "talpha: %d/%d\n", vinfo->transp.length, vinfo->transp.offset);
+    _THIS = data;
+
+    if (pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL)) {
+        goto error;
+    }
+
+    BOOL vbl_ok = FALSE;
+    if (FB_WaitVBlank(this)) {
+        vbl_ok = TRUE;
+    }
+
+    this->hidden->updater_ready = 1;
+    sem_post(&this->hidden->sync_sem);
+
+#ifdef _DEBUG
+    clock_gettime(CLOCK_REALTIME, &this->hidden->ts_start);
+#endif
+
+    do {
+
+        if (vbl_ok) {
+            FB_WaitVBlank(this);
+        }
+        else {
+            usleep(this->hidden->update_interval * 1000);
+        }
+
+#ifdef _DEBUG
+        this->hidden->frames++;
+#endif
+
+        pthread_mutex_lock(&this->hidden->update_lock);
+        if (RECTH(this->hidden->update_rect)) {
+            if (shadowScreen_BlitToReal(this,
+                        &this->hidden->update_rect) == 0) {
+#if defined(__TARGET_R818__)
+                uintptr_t args[2];
+                args[0] = (uintptr_t)this->hidden->real_screen->pixels;
+                args[0] += this->hidden->real_screen->pitch *
+                    this->hidden->update_rect.top;
+                args[1] = this->hidden->real_screen->pitch *
+                    RECTH(this->hidden->update_rect);
+                if (ioctl(console_fd, FBIO_CACHE_SYNC, args) < 0) {
+                    _WRN_PRINTF("failed to flush cache for R818\n");
+                }
+#endif
+            }
+            else {
+                _ERR_PRINTF("failed shadowScreen_BlitToReal()\n");
+            }
+
+            SetRectEmpty(&this->hidden->update_rect);
+        }
+        pthread_mutex_unlock(&this->hidden->update_lock);
+
+        pthread_testcancel();
+
+    } while (1);
+
+    return NULL;
+
+error:
+    sem_post(&this->hidden->sync_sem);
+    return NULL;
 }
 
-static void print_finfo(struct fb_fix_screeninfo *finfo)
+static int create_async_updater(_THIS)
 {
-    fprintf(stderr, "Printing finfo:\n");
-    fprintf(stderr, "tsmem_start = %p\n", (char *)finfo->smem_start);
-    fprintf(stderr, "tsmem_len = %d\n", finfo->smem_len);
-    fprintf(stderr, "ttype = %d\n", finfo->type);
-    fprintf(stderr, "ttype_aux = %d\n", finfo->type_aux);
-    fprintf(stderr, "tvisual = %d\n", finfo->visual);
-    fprintf(stderr, "txpanstep = %d\n", finfo->xpanstep);
-    fprintf(stderr, "typanstep = %d\n", finfo->ypanstep);
-    fprintf(stderr, "tywrapstep = %d\n", finfo->ywrapstep);
-    fprintf(stderr, "tline_length = %d\n", finfo->line_length);
-    fprintf(stderr, "tmmio_start = %p\n", (char *)finfo->mmio_start);
-    fprintf(stderr, "tmmio_len = %d\n", finfo->mmio_len);
-    fprintf(stderr, "taccel = %d\n", finfo->accel);
+    if (sem_init(&this->hidden->sync_sem, 0, 0)) {
+        _ERR_PRINTF("NEWGAL>FBCON: failed to create sync. semaphore: %m\n");
+        return -1;
+    }
+
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+#ifdef __LINUX__
+    if (geteuid() == 0) {
+        struct sched_param sp = { 99 };
+        pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
+        pthread_attr_setschedpolicy(&attr, SCHED_FIFO);
+        pthread_attr_setschedparam(&attr, &sp);
+    }
+#endif
+
+    if (pthread_create(&this->hidden->update_thd, &attr,
+            task_do_update, this)) {
+        _ERR_PRINTF("NEWGAL>FBCON: failed to create update thread: %m\n");
+        return -1;
+    }
+
+    sem_wait(&this->hidden->sync_sem);
+    pthread_attr_destroy(&attr);
+
+    return this->hidden->updater_ready ? 0 : -1;
+}
+
+static void cancel_async_updater(_THIS)
+{
+    if (this->hidden->updater_ready) {
+        pthread_cancel(this->hidden->update_thd);
+        pthread_join(this->hidden->update_thd, NULL);
+#ifdef _DEBUG
+        double elapsed = get_elapsed_seconds(&this->hidden->ts_start, NULL);
+        _DBG_PRINTF("Frames per second: %f\n", this->hidden->frames / elapsed);
+#endif
+
+        sem_destroy(&this->hidden->sync_sem);
+    }
+}
+
+static int FB_LockHWSurface(_THIS, GAL_Surface *surface)
+{
+    if (surface == this->screen && this->hidden->updater_ready) {
+        pthread_mutex_lock(&this->hidden->update_lock);
+        return 0;
+    }
+
+    return -1;
+}
+
+static void FB_UnlockHWSurface(_THIS, GAL_Surface *surface)
+{
+    if (surface == this->screen && this->hidden->updater_ready) {
+        pthread_mutex_unlock(&this->hidden->update_lock);
+    }
+}
+
+static BOOL FB_SyncUpdateAsync(_THIS)
+{
+    BOOL retval = FALSE;
+    RECT* dirty_rc;
+
+    if (this->hidden->updater_ready) {
+        if (pthread_mutex_lock(&this->hidden->update_lock))
+            _ERR_PRINTF("Failed pthread_mutex_lock(): %m\n");
+    }
+
+    dirty_rc = &this->hidden->dirty_rc;
+    if (IsRectEmpty(dirty_rc))
+        goto ret;
+
+    RECT bound = *dirty_rc;
+    RECT *update_rect = &this->hidden->update_rect;
+    GetBoundRect(update_rect, &bound, update_rect);
+    retval = TRUE;
+    SetRectEmpty(dirty_rc);
+
+ret:
+    if (this->hidden->updater_ready) {
+        if (pthread_mutex_unlock(&this->hidden->update_lock))
+            _ERR_PRINTF("Failed pthread_mutex_lock(): %m\n");
+    }
+
+    return retval;
 }
-#endif  /* FBCON_DEBUG */
 
 static GAL_Surface *FB_SetVideoMode(_THIS, GAL_Surface *current,
                 int width, int height, int bpp, Uint32 flags)
@@ -605,6 +779,11 @@ static GAL_Surface *FB_SetVideoMode(_THIS, GAL_Surface *current,
         FB_RestorePalette (this);
     }
 
+    if (ioctl(console_fd, FBIOGET_FSCREENINFO, &finfo) < 0) {
+        GAL_SetError("NEWGAL>FBCON: Couldn't get console hardware info");
+        return(NULL);
+    }
+
     /* Set the video mode and get the final screen format */
     if (ioctl(console_fd, FBIOGET_VSCREENINFO, &vinfo) < 0) {
         GAL_SetError("NEWGAL>FBCON: Couldn't get console screen info\n");
@@ -612,9 +791,6 @@ static GAL_Surface *FB_SetVideoMode(_THIS, GAL_Surface *current,
     }
 
 #ifdef FBCON_DEBUG
-    fprintf (stderr, "Printing original finfo:\n");
-    print_finfo(&finfo);
-
     fprintf (stderr, "Printing original vinfo:\n");
     print_vinfo(&vinfo);
 #endif
@@ -663,7 +839,6 @@ static GAL_Surface *FB_SetVideoMode(_THIS, GAL_Surface *current,
             vinfo.yres_virtual = maxheight;
         }
     }
-    cache_vinfo = vinfo;
 #ifdef FBCON_DEBUG
     fprintf (stderr, "NEWGAL>FBCON: Printing actual vinfo:\n");
     print_vinfo(&vinfo);
@@ -724,6 +899,30 @@ static GAL_Surface *FB_SetVideoMode(_THIS, GAL_Surface *current,
     current->pitch = finfo.line_length;
     current->pixels = mapped_mem+mapped_offset;
 
+#if 0 /* deprecated code */
+    /* Since 5.0.13, use FBIOPAN_DISPLAY if possible */
+    this->hidden->nr_buffers = finfo.smem_len / (vinfo.yres * current->pitch);
+    if (0 && this->hidden->nr_buffers > 1) {
+        this->hidden->nr_buffers = 2;
+        vinfo.yres_virtual = this->hidden->nr_buffers * vinfo.yres;
+        if (ioctl(console_fd, FBIOPUT_VSCREENINFO, &vinfo) < 0) {
+            GAL_SetError("NEWGAL>FBCON: Couldn't enable virtual yres");
+            this->hidden->nr_buffers = 0;
+        }
+        else {
+            this->hidden->len_buffer = finfo.line_length * vinfo.yres;
+
+            this->hidden->buffers[0] = mapped_mem+mapped_offset;
+            this->hidden->buffers[1] = this->hidden->buffers[0] +
+                this->hidden->len_buffer;
+
+            this->hidden->idx_buffer = 1;
+            current->pixels = this->hidden->buffers[this->hidden->idx_buffer];
+        }
+    }
+#endif
+
+    currt_vinfo = vinfo;
     /* Set up the information for hardware surfaces */
     surfaces_mem = (char *)current->pixels +
                             vinfo.yres_virtual*current->pitch;
@@ -764,12 +963,12 @@ static GAL_Surface *FB_SetVideoMode(_THIS, GAL_Surface *current,
         sigma8654_hdmi_init();
 #endif
 
+    // this is a trick in order that GAL_CreateRGBSurface tries to
+    // allocate hardware surface first.
+    GAL_PublicSurface = current;
+
 #ifdef _MGSCHEMA_COMPOSITING
     if (mgIsServer) {
-        // this is a trick in order that GAL_CreateRGBSurface tries to
-        // allocate hardware surface first.
-        GAL_PublicSurface = current;
-
         dblbuff = TRUE;
     }
     else {
@@ -811,6 +1010,7 @@ static GAL_Surface *FB_SetVideoMode(_THIS, GAL_Surface *current,
             this->UpdateRects = shadowScreen_UpdateRects;
             this->SyncUpdate = FB_SyncUpdate;
 
+            current->video = this;
             this->hidden->real_screen = current;
             current = this->hidden->shadow_screen;
 
@@ -827,6 +1027,54 @@ static GAL_Surface *FB_SetVideoMode(_THIS, GAL_Surface *current,
     else {
         this->hidden->real_screen = current;
         this->hidden->shadow_screen = NULL;
+#if 0 /* deprecated code */
+        if (0 && this->hidden->nr_buffers > 1) {
+            this->UpdateRects = FB_UpdateRectsPanning;
+            this->SyncUpdate = FB_SyncUpdatePanning;
+        }
+#endif
+    }
+
+    if (FB_WaitVBlank(this)) {
+        this->WaitVBlank = FB_WaitVBlank;
+    }
+    else {
+        _WRN_PRINTF("The FBCon device does not support WaitVBlank.\n");
+    }
+
+    if (this->hidden->shadow_screen) {
+        char tmp[8];
+        int async_update;
+        if (GetMgEtcValue ("fbcon", "async_update", tmp, sizeof(tmp)) < 0) {
+                async_update = 0;
+        }
+        else if (strcasecmp(tmp, "true") == 0 ||
+                strcasecmp(tmp, "yes") == 0) {
+            async_update = 1;
+        }
+        else {
+            async_update = 0;
+        }
+
+        if (async_update) {
+            create_async_updater(this);
+
+            if (this->hidden->updater_ready) {
+                if (GetMgEtcIntValue("fbcon", "update_interval",
+                            &this->hidden->update_interval) < 0) {
+                    this->hidden->update_interval = 20;
+                }
+                else if (this->hidden->update_interval < 0 ||
+                        this->hidden->update_interval > 50) {
+                    this->hidden->update_interval = 20;
+                }
+
+                current->flags |= GAL_ASYNCBLIT;
+                this->LockHWSurface = FB_LockHWSurface;
+                this->UnlockHWSurface = FB_UnlockHWSurface;
+                this->SyncUpdate = FB_SyncUpdateAsync;
+            }
+        }
     }
 
     /* We're done */
@@ -1111,19 +1359,6 @@ static void FB_FreeHWSurface(_THIS, GAL_Surface *surface)
     surface->hwdata = NULL;
 }
 
-static void FB_WaitVBL(_THIS)
-{
-#ifdef FBIOWAITRETRACE /* Heheh, this didn't make it into the main kernel */
-    ioctl(console_fd, FBIOWAITRETRACE, 0);
-#endif
-    return;
-}
-
-static void FB_WaitIdle(_THIS)
-{
-    return;
-}
-
 void FB_SavePaletteTo(_THIS, int palette_len, __u16 *area)
 {
     struct fb_cmap cmap;
@@ -1277,6 +1512,8 @@ static void FB_VideoQuit(_THIS)
     }
 #endif
 
+    cancel_async_updater(this);
+
 #ifdef _MGRM_PROCESSES
     if (mgIsServer && this->screen) {
 #else
@@ -1355,3 +1592,36 @@ static void FB_VideoQuit(_THIS)
 #endif
 }
 
+#if 0 /* deprecated code */
+static void FB_UpdateRectsPanning (_THIS, int numrects, GAL_Rect *rects)
+{
+    (void)this;
+    (void)numrects;
+    (void)rects;
+    return;
+}
+
+static BOOL FB_SyncUpdatePanning (_THIS)
+{
+    currt_vinfo.yoffset = this->hidden->idx_buffer * currt_vinfo.yres;
+    if (ioctl(console_fd, FBIOPAN_DISPLAY, &currt_vinfo) < 0) {
+        _WRN_PRINTF("Failed ioctl(): FBIOPAN_DISPLAY: %m\n");
+        return FALSE;
+    }
+
+    int old = this->hidden->idx_buffer;
+    this->hidden->idx_buffer = 1 - this->hidden->idx_buffer;
+    memcpy(this->hidden->buffers[this->hidden->idx_buffer],
+        this->hidden->buffers[old], this->hidden->len_buffer);
+
+    int dummy = 0;
+    if (ioctl(console_fd, FBIO_WAITFORVSYNC, &dummy) < 0) {
+        _WRN_PRINTF("Failed ioctl(): FBIO_WAITFORVSYNC: %m\n");
+    }
+
+    this->hidden->real_screen->pixels =
+        this->hidden->buffers[this->hidden->idx_buffer];
+    return TRUE;
+}
+#endif
+

src/newgal/fbcon/fbvideo.h

@@ -47,6 +47,8 @@
 #ifndef _GAL_fbvideo_h
 #define _GAL_fbvideo_h
 
+#include <pthread.h>
+#include <semaphore.h>
 #include <sys/types.h>
 #include <termios.h>
 #include <linux/fb.h>
@@ -90,11 +92,24 @@ struct GAL_PrivateVideoData {
     /* end of header for shadow screen */
 
     int console_fd;
-    struct fb_var_screeninfo cache_vinfo;
+    struct fb_var_screeninfo currt_vinfo;
     struct fb_var_screeninfo saved_vinfo;
     int saved_cmaplen;
     __u16 *saved_cmap;
 
+    /* Since 5.0.13, async updater */
+    int             updater_ready;
+    int             update_interval;
+    RECT            update_rect;
+    pthread_t       update_thd;
+    pthread_mutex_t update_lock;
+    sem_t           sync_sem;
+
+#ifdef _DEBUG
+    struct timespec ts_start;
+    unsigned        frames;
+
+#endif
 #ifdef _MGHAVE_PCIACCESS
     int pci_accel_driver;
 #endif
@@ -115,13 +130,7 @@ struct GAL_PrivateVideoData {
 
 /* Old variable names */
 #define console_fd          (this->hidden->console_fd)
-#define current_vt          (this->hidden->current_vt)
-#define saved_vt            (this->hidden->saved_vt)
-#define keyboard_fd         (this->hidden->keyboard_fd)
-#define saved_kbd_mode      (this->hidden->saved_kbd_mode)
-#define saved_kbd_termios   (this->hidden->saved_kbd_termios)
-#define mouse_fd            (this->hidden->mouse_fd)
-#define cache_vinfo         (this->hidden->cache_vinfo)
+#define currt_vinfo         (this->hidden->currt_vinfo)
 #define saved_vinfo         (this->hidden->saved_vinfo)
 #define saved_cmaplen       (this->hidden->saved_cmaplen)
 #define saved_cmap          (this->hidden->saved_cmap)

src/newgal/fbcon/pci_smi.c

@@ -715,7 +715,7 @@ static void SMI_SubsequentScreenToScreenCopy (int x1, int y1, int x2,
     WRITE_DPR(pSmi, 0x0C, pSmi->AccelCmd);
 }
 
-static int SMI_FillHWRect (_THIS, GAL_Surface *dst, GAL_Rect *rect, Uint32 color)
+static int SMI_FillHWRect (_THIS, GAL_Surface *dst, const GAL_Rect *rect, Uint32 color)
 {
     SMIPtr pSmi = &smi_rec;
     int x = rect->x;
@@ -770,9 +770,11 @@ static void SMI_BlitTransRect (int srcx, int srcy, int w, int h, int dstx,
 #endif
 }
 
-static int SMI_HWAccelBlit (GAL_Surface *src, GAL_Rect *srcrect,
+static int SMI_HWAccelBlit (_THIS, GAL_Surface *src, GAL_Rect *srcrect,
                        GAL_Surface *dst, GAL_Rect *dstrect)
 {
+    (void)this;
+
     SMIPtr pSmi = &smi_rec;
     int srcx = srcrect->x;
     int srcy = srcrect->y;
@@ -825,14 +827,11 @@ static void SMI_WaitIdle (_THIS)
 #endif
 }
 
-/* Set video mem colorkey and accelerated blit function */
-static int SMI_SetHWColorKey (_THIS, GAL_Surface *surface, Uint32 key)
-{
-    return 0;
-}
-
-static int SMI_CheckHWBlit (_THIS, GAL_Surface *src, GAL_Surface *dst)
+static int SMI_CheckHWBlit (_THIS, GAL_Surface *src, const GAL_Rect *srcrc,
+        GAL_Surface *dst, const GAL_Rect *dstrc, DWORD op)
 {
+    (void)srcrc;
+    (void)dstrc;
     int accelerated;
 
     /* Set initial acceleration on */
@@ -851,11 +850,23 @@ static int SMI_CheckHWBlit (_THIS, GAL_Surface *src, GAL_Surface *dst)
         src->flags &= ~GAL_HWACCEL;
     }
 
+    /* color blend, logical operation, and scaling filter are not supported */
+    if ((op & COLOR_BLEND_MASK) ||
+            ((op & COLOR_LOGICOP_MASK) != COLOR_LOGICOP_COPY) ||
+            (op & SCALING_FILTER_MASK)) {
+        src->flags &= ~GAL_HWACCEL;
+    }
+
     /* Check to see if final surface blit is accelerated */
     accelerated = !!(src->flags & GAL_HWACCEL);
     if (accelerated) {
+        src->map->video = this;
         src->map->hw_blit = SMI_HWAccelBlit;
     }
+    else {
+        src->map->video = NULL;
+        src->map->hw_blit = NULL;
+    }
 
     return (accelerated);
 }
@@ -898,7 +909,6 @@ static int SMI_Init (_THIS, const GAL_Surface* current)
     this->info.blit_hw = 1;
     this->info.blit_hw_A = 0;
     this->info.blit_hw_CC = 1;
-    this->SetHWColorKey = SMI_SetHWColorKey;
     return 0;
 }
 

src/newgal/gdl/gdl_video.c

@@ -116,8 +116,6 @@ static GAL_VideoDevice *GDL_CreateDevice (int devindex)
 
     this->CheckHWBlit = NULL;
     this->FillHWRect = NULL;
-    this->SetHWColorKey = NULL;
-    this->SetHWAlpha = NULL;
 
     this->free = GDL_DeleteDevice;
 

src/newgal/hisi/gal_hi3560a.c

@@ -242,8 +242,6 @@ static GAL_VideoDevice *HI3560A_CreateDevice(int devindex)
     device->AllocHWSurface = HI3560A_AllocHWSurface;
     device->CheckHWBlit = HI3560A_CheckHWBlit;
     device->FillHWRect = NULL;
-    device->SetHWColorKey = NULL;
-    device->SetHWAlpha = NULL;
     device->FillHWRect = HI3560A_FillHWRect;
     device->FreeHWSurface = HI3560A_FreeHWSurface;
 
@@ -994,7 +992,7 @@ static int HI3560A_AllocHWSurface(_THIS, GAL_Surface *surface)
     }
 }
 
-static int HI3560A_FillHWRect(_THIS, GAL_Surface *dst, GAL_Rect *rect, Uint32 color)
+static int HI3560A_FillHWRect(_THIS, GAL_Surface *dst, const GAL_Rect *rect, Uint32 color)
 {
     TDE_HANDLE tdeHandle;
     int ret = 0;

src/newgal/hisi/hi3510_fbvideo.c

@@ -501,7 +501,7 @@ static int HI3510_CheckHWBlit(_THIS, GAL_Surface *src, GAL_Surface *dst)
 }
 
  /* Fills a surface rectangle with the given color */
-static int HI3510_FillHWRect(_THIS, GAL_Surface *dst, GAL_Rect *rect, Uint32 color)
+static int HI3510_FillHWRect(_THIS, GAL_Surface *dst, const GAL_Rect *rect, Uint32 color)
 {
     Uint8 r,g,b;
     Uint8* pvirtual_addr;
@@ -1863,8 +1863,6 @@ static GAL_VideoDevice *HI3510_CreateDevice (int devindex)
 #endif
     this->FreeHWSurface = HI3510_FreeHWSurface;
     this->free = HI3510_DeleteDevice;
-    this->SetHWAlpha = NULL;
-    this->SetHWColorKey = NULL;
 
     return this;
 }

src/newgal/hisi/hi3560_fbvideo.c

@@ -675,7 +675,7 @@ static int HI3560_CheckHWBlit(_THIS, GAL_Surface *src, GAL_Surface *dst)
 
 }
 
-static Sint32 Hi3560_FillHWRect(_THIS, GAL_Surface *dst, GAL_Rect *rect, Uint32 color)
+static Sint32 Hi3560_FillHWRect(_THIS, GAL_Surface *dst, const GAL_Rect *rect, Uint32 color)
 {
     TDE_SURFACE_S surface ={0};
     TDE_OPT_S param;
@@ -1855,8 +1855,6 @@ static GAL_VideoDevice *HI3560_CreateDevice (int devindex)
 //#endif
 #endif
     this->FreeHWSurface = HI3560_FreeHWSurface;
-    this->SetHWAlpha = NULL;
-    this->SetHWColorKey = NULL;
     this->free = HI3560_DeleteDevice;
     //this->SetAttr   = HI3560_SetLayerAttr;
 

src/newgal/mb93493/mb93493video.c

@@ -251,8 +251,6 @@ static GAL_VideoDevice *MB93493_CreateDevice(int devindex)
     device->AllocHWSurface = MB93493_AllocHWSurface;
     device->CheckHWBlit = NULL;
     device->FillHWRect = NULL;
-    device->SetHWColorKey = NULL;
-    device->SetHWAlpha = NULL;
     device->FreeHWSurface = MB93493_FreeHWSurface;
     device->UpdateRects = MB93493_UpdateRects;
     device->free = MB93493_DeleteDevice;

src/newgal/mlshadow/mlshadow-proc.c

@@ -335,8 +335,6 @@ static GAL_VideoDevice *MLSHADOW_CreateDevice (int devindex)
         device->AllocHWSurface = MLSHADOW_AllocHWSurface;
         device->CheckHWBlit = NULL;
         device->FillHWRect = NULL;
-        device->SetHWColorKey = NULL;
-        device->SetHWAlpha = NULL;
         device->FreeHWSurface = MLSHADOW_FreeHWSurface;
         device->UpdateRects = MLSHADOW_UpdateRects;
         device->DeleteSurface = MLSHADOW_DeleteSurface;

src/newgal/mlshadow/mlshadow-ths.c

@@ -485,8 +485,6 @@ static GAL_VideoDevice *MLSHADOW_CreateDevice (int devindex)
         device->AllocHWSurface = MLSHADOW_AllocHWSurface;
         device->CheckHWBlit = NULL;
         device->FillHWRect = NULL;
-        device->SetHWColorKey = NULL;
-        device->SetHWAlpha = NULL;
         device->FreeHWSurface = MLSHADOW_FreeHWSurface;
         device->UpdateRects = MLSHADOW_UpdateRects;
         device->DeleteSurface = MLSHADOW_DeleteSurface;

src/newgal/mstar/mstar_video.c

@@ -106,12 +106,10 @@ static void MStar_VideoQuit(_THIS);
 /* Hardware surface functions */
 static int MStar_InitHWSurfaces(_THIS, GAL_Surface *screen, char *base, int size);
 static int MStar_AllocHWSurface(_THIS, GAL_Surface *surface);
-static int MStar_FillHWRect(_THIS, GAL_Surface *dst, GAL_Rect *dstrect, Uint32 color);
+static int MStar_FillHWRect(_THIS, GAL_Surface *dst, const GAL_Rect *dstrect, Uint32 color);
 static void MStar_FreeHWSurface(_THIS, GAL_Surface *surface);
 static int MStar_CheckHWBlit(_THIS, GAL_Surface *src, GAL_Surface *dst);
 static int MStar_HWAccelBlit(GAL_Surface *src, GAL_Rect *srcrect, GAL_Surface *dst, GAL_Rect *dstrect);
-static int MStar_SetHWColorKey(_THIS, GAL_Surface *surface, Uint32 key);
-static int MStar_SetHWAlpha(_THIS, GAL_Surface *surface, Uint8 alpha);
 
 /* Various screen update functions available */
 static void MStar_DirectUpdate(_THIS, int numrects, GAL_Rect *rects);
@@ -190,8 +188,10 @@ static GAL_VideoDevice * MStar_CreateDevice(int devindex)
     device->AllocHWSurface = MStar_AllocHWSurface;
     device->CheckHWBlit = MStar_CheckHWBlit;
     device->FillHWRect = MStar_FillHWRect;
+#if 0
     device->SetHWColorKey = MStar_SetHWColorKey;
     device->SetHWAlpha = MStar_SetHWAlpha;
+#endif
     device->FreeHWSurface = MStar_FreeHWSurface;
     device->UpdateRects = MStar_DirectUpdate;
     device->UpdateSurfaceRects = NULL;
@@ -725,7 +725,7 @@ void cleanEngineState(MSTARDeviceData *sdev)
     sdev->dst_ge_format = GFX_FMT_ARGB8888;
 }
 
-static int MStar_FillHWRect(_THIS, GAL_Surface *dst, GAL_Rect *rect, Uint32 color)
+static int MStar_FillHWRect(_THIS, GAL_Surface *dst, const GAL_Rect *rect, Uint32 color)
 {
     GFX_RectFillInfo rectInfo;
     GFX_Point v0, v1;
@@ -773,6 +773,7 @@ static int MStar_FillHWRect(_THIS, GAL_Surface *dst, GAL_Rect *rect, Uint32 colo
     return 0;
 }
 
+#if 0
 static int MStar_SetHWColorKey(_THIS, GAL_Surface *src, Uint32 key)
 {
     FUNC_ENTER();
@@ -790,6 +791,7 @@ static int MStar_SetHWAlpha(_THIS, GAL_Surface *surface, Uint8 alpha)
     FUNC_LEAVE();
     return 0;
 }
+#endif
 
 static void MStar_DirectUpdate(_THIS, int numrects, GAL_Rect *rects)
 {

src/newgal/newgal.c

@@ -240,12 +240,14 @@ static GAL_Surface* create_wp_surface(GAL_Surface* screen)
         req.len_data = strlen (SYSSF_WALLPAPER_PATTER) + 1;
 
         if ((ClientRequestEx2 (&req, NULL, 0, -1,
-                &info, sizeof (SHAREDSURFINFO), &fd) < 0) || (fd < 0))
+                &info, sizeof (SHAREDSURFINFO), &fd) < 0) || (fd < 0)) {
+            _WRN_PRINTF ("creating an empty wallpaper pattern surface\n");
             goto empty;
+        }
 
         _DBG_PRINTF ("REQID_GETSHAREDSURFACE: size (%lu), flags (0x%x), fd: %d\n",
                     info.size, info.flags, fd);
-        wp_surf = GAL_AttachSharedRGBSurface (fd, info.size,
+        wp_surf = GAL_AttachSharedRGBSurface (NULL, fd, info.size,
             info.flags, TRUE);
         close (fd);
 
@@ -253,7 +255,6 @@ static GAL_Surface* create_wp_surface(GAL_Surface* screen)
     }
 
 empty:
-    _DBG_PRINTF ("creating an empty wallpaper pattern surface\n");
     if (IsServer()) {
         return GAL_CreateRGBSurface (GAL_SWSURFACE, 0, 0,
                     screen->format->BitsPerPixel,

src/newgal/nexus/nexusvideo.c

@@ -83,9 +83,9 @@ static REP_NEXUS_GETSURFACE reply_primary_surface_info;
 /* Initialization/Query functions */
 static int NEXUS_VideoInit(_THIS, GAL_PixelFormat * vformat);
 static GAL_Rect **NEXUS_ListModes(_THIS, GAL_PixelFormat * format,
-                                  Uint32 flags);
-static GAL_Surface *NEXUS_SetVideoMode(_THIS, GAL_Surface * current, int width,
-                                       int height, int bpp, Uint32 flags);
+        Uint32 flags);
+static GAL_Surface *NEXUS_SetVideoMode(_THIS, GAL_Surface *current,
+        int width, int height, int bpp, Uint32 flags);
 static int NEXUS_SetColors(_THIS, int firstcolor, int ncolors,
                            GAL_Color * colors);
 static void NEXUS_VideoQuit(_THIS);
@@ -93,8 +93,8 @@ static void NEXUS_VideoQuit(_THIS);
 /* Hardware surface functions */
 static int NEXUS_AllocHWSurface(_THIS, GAL_Surface * surface);
 static void NEXUS_FreeHWSurface(_THIS, GAL_Surface * surface);
-static int NEXUS_FillHWRect(_THIS, GAL_Surface * dst, GAL_Rect * rect,
-                            Uint32 color);
+static int NEXUS_FillHWRect(_THIS, GAL_Surface * dst, const GAL_Rect * rect,
+        Uint32 color);
 static void NEXUS_UpdateSurfaceRects(_THIS, GAL_Surface* surface,
         int numrects, GAL_Rect *rects);
 static int NEXUS_CheckHWBlit(_THIS, GAL_Surface * src, GAL_Surface * dst);
@@ -114,11 +114,6 @@ NEXUS_DeleteDevice(GAL_VideoDevice * device)
     free(device);
 }
 
-static int NEXUS_SetHWColorKey(_THIS, GAL_Surface *surface, Uint32 key)
-{
-    return 0;
-}
-
 static GAL_VideoDevice *
 NEXUS_CreateDevice(int devindex)
 {
@@ -152,8 +147,6 @@ NEXUS_CreateDevice(int devindex)
     device->AllocHWSurface = NEXUS_AllocHWSurface;
     device->CheckHWBlit = NEXUS_CheckHWBlit;
     device->FillHWRect = NEXUS_FillHWRect;
-    device->SetHWColorKey = NEXUS_SetHWColorKey;
-    device->SetHWAlpha = NULL;
     device->FreeHWSurface = NEXUS_FreeHWSurface;
     device->UpdateRects = NULL;
     device->UpdateSurfaceRects = NEXUS_UpdateSurfaceRects;
@@ -455,7 +448,7 @@ NEXUS_FreeHWSurface(_THIS, GAL_Surface * surface)
 }
 
 static int
-NEXUS_FillHWRect(_THIS, GAL_Surface * dst, GAL_Rect * rect, Uint32 color)
+NEXUS_FillHWRect(_THIS, GAL_Surface * dst, const GAL_Rect * rect, Uint32 color)
 {
     return NexusPrivate_FillRect(this->hidden->privateData,
                                  (NexusPrivate_HWSurface_hwdata *) dst->hwdata,

src/newgal/pcxvfb/pcxvfb.c

@@ -266,11 +266,11 @@ static BOOL PCXVFB_SyncUpdate (_THIS)
 {
     RECT dirty_rc;
 
-    if (IsRectEmpty (&this->hidden->dirty_rc))
+    if (IsRectEmpty(&this->hidden->dirty_rc))
         return FALSE;
 
 #ifdef WIN32
-    win_PCXVFbLock ();
+    win_PCXVFbLock();
 #else
     shm_lock(semid);
 #endif
@@ -282,10 +282,10 @@ static BOOL PCXVFB_SyncUpdate (_THIS)
     if (dirty_rc.right == -1) dirty_rc.right = 0;
     if (dirty_rc.bottom == -1) dirty_rc.bottom = 0;
 
-    GetBoundRect (&this->hidden->dirty_rc, &dirty_rc,
+    GetBoundRect(&this->hidden->dirty_rc, &dirty_rc,
             &this->hidden->dirty_rc);
 
-    shadowScreen_BlitToReal (this);
+    shadowScreen_BlitToReal(this, NULL);
 
     this->hidden->hdr->dirty_rc_l = this->hidden->dirty_rc.left;
     this->hidden->hdr->dirty_rc_t = this->hidden->dirty_rc.top;
@@ -293,10 +293,10 @@ static BOOL PCXVFB_SyncUpdate (_THIS)
     this->hidden->hdr->dirty_rc_b = this->hidden->dirty_rc.bottom;
     this->hidden->hdr->dirty = TRUE;
 
-    SetRectEmpty (&this->hidden->dirty_rc);
+    SetRectEmpty(&this->hidden->dirty_rc);
 
 #ifdef WIN32
-    win_PCXVFbUnlock ();
+    win_PCXVFbUnlock();
 #else
     shm_unlock(semid);
 #endif
@@ -350,8 +350,6 @@ static GAL_VideoDevice *PCXVFB_CreateDevice (int devindex)
 
     this->CheckHWBlit = NULL;
     this->FillHWRect = NULL;
-    this->SetHWColorKey = NULL;
-    this->SetHWAlpha = NULL;
 
     this->free = PCXVFB_DeleteDevice;
 

src/newgal/pixels.c

@@ -617,7 +617,8 @@ void GAL_InvalidateMap(GAL_BlitMap *map)
     }
 }
 
-int GAL_MapSurface (GAL_Surface *src, GAL_Surface *dst)
+int GAL_MapSurface (GAL_Surface *src, const GAL_Rect *srcrc,
+        GAL_Surface *dst, const GAL_Rect *dstrc, DWORD op)
 {
     GAL_PixelFormat *srcfmt;
     GAL_PixelFormat *dstfmt;
@@ -698,7 +699,7 @@ int GAL_MapSurface (GAL_Surface *src, GAL_Surface *dst)
     map->format_version = (++dst->format_version);
 
     /* Choose your blitters wisely */
-    return(GAL_CalculateBlit(src));
+    return(GAL_CalculateBlit(src, srcrc, dstrc, op));
 }
 
 void GAL_FreeBlitMap(GAL_BlitMap *map)

src/newgal/pixels_c.h

@@ -59,11 +59,14 @@ extern void GAL_FreeFormat(GAL_PixelFormat *format);
 /* Blit mapping functions */
 extern GAL_BlitMap *GAL_AllocBlitMap(void);
 extern void GAL_InvalidateMap(GAL_BlitMap *map);
-extern int GAL_MapSurface (GAL_Surface *src, GAL_Surface *dst);
+extern int GAL_MapSurface (GAL_Surface *src, const GAL_Rect *srcrc,
+        GAL_Surface *dst, const GAL_Rect *dstrc, DWORD op);
 extern void GAL_FreeBlitMap(GAL_BlitMap *map);
 
 /* Miscellaneous functions */
 extern Uint32 GAL_CalculatePitch(GAL_Surface *surface);
 extern void GAL_DitherColors(GAL_Color *colors, int bpp);
 extern Uint8 GAL_FindColor(GAL_Palette *pal, Uint8 r, Uint8 g, Uint8 b);
-extern void GAL_ApplyGamma(Uint16 *gamma, GAL_Color *colors, GAL_Color *output, int ncolors);
+extern void GAL_ApplyGamma(Uint16 *gamma, GAL_Color *colors, GAL_Color *output,
+        int ncolors);
+

src/newgal/qvfb/qvfb.c

@@ -171,8 +171,6 @@ static GAL_VideoDevice *QVFB_CreateDevice (int devindex)
 
     this->CheckHWBlit = NULL;
     this->FillHWRect = NULL;
-    this->SetHWColorKey = NULL;
-    this->SetHWAlpha = NULL;
 
     this->free = QVFB_DeleteDevice;
 

src/newgal/rtos_xvfb/rtos_xvfb.c

@@ -208,8 +208,6 @@ static GAL_VideoDevice *RTOS_XVFB_CreateDevice (int devindex)
 
     this->CheckHWBlit = NULL;
     this->FillHWRect = NULL;
-    this->SetHWColorKey = NULL;
-    this->SetHWAlpha = NULL;
 
     this->free = RTOS_XVFB_DeleteDevice;
 

src/newgal/s3c6410/gal-s3c6410.c

@@ -196,8 +196,6 @@ static GAL_VideoDevice *S3C6410_CreateDevice(int devindex)
     device->AllocHWSurface = S3C6410_AllocHWSurface;
     device->CheckHWBlit = S3C6410_CheckHWBlit;
     device->FillHWRect = NULL;
-    device->SetHWColorKey = NULL;
-    device->SetHWAlpha = NULL;
     device->FreeHWSurface = S3C6410_FreeHWSurface;
 
     device->free = S3C6410_DeleteDevice;

src/newgal/shadow-screen.c

@@ -231,13 +231,16 @@ void shadowScreen_UpdateRects (_THIS, int numrects, GAL_Rect *rects)
 }
 
 /* Blit dirty content from shadow surface to ultimate surface */
-int shadowScreen_BlitToReal (_THIS)
+int shadowScreen_BlitToReal (_THIS, const RECT *dirty_rc)
 {
     RECT bound;
 
     CHECK_VERSION_RETVAL (this, -1);
 
-    bound = this->hidden->dirty_rc;
+    if (dirty_rc == NULL)
+        bound = this->hidden->dirty_rc;
+    else
+        bound = *dirty_rc;
 
     if (this->hidden->real_screen) {
         GAL_Rect src_rect, dst_rect;