Changeset 273 for trunk/src/3rdparty/os2/xsystray/xsystray.c

Timestamp:

Nov 2, 2009, 3:10:29 AM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

3rdparty: os2/xsystray: Use custom shared memory pool for structures posted by the server to the client windows. Process mouse/wheel and context menu messages in the icon area and post them to the respective client windows. Use smaller spacing between icons (one pad unit instead of two).

File:

• trunk/src/3rdparty/os2/xsystray/xsystray.c (modified) (30 diffs)

trunk/src/3rdparty/os2/xsystray/xsystray.c

@@ -111 +111 @@
  */
 
-typedef struct _ICONDATA
+typedef struct
 {
     HWND        hwnd;
                 // associated window
-    ULONG       ulId;
+    USHORT      usId;
                 // icon ID
     HPOINTER    hIcon;
@@ -123 +123 @@
     PSZ         pszToolTip;
                 // icon tooltip (NULL if none)
+    BOOL        bMemoryPoolGiven;
+                // TRUE if SYSTRAYDATA::pvMemoryPool is already given to
+                // the process hwnd belongs to
 
 } ICONDATA, *PICONDATA;
@@ -147 +150 @@
     size_t      cIconsMax;
                 // maximum number of icons pIcons can fit
+    PVOID       pvMemoryPool;
+                // memory pool for NOTIFYDATA structures
 
 } SYSTRAYDATA, *PSYSTRAYDATA;
@@ -154 +159 @@
         // space for the newly added icon
 
-static ULONG QWL_USER_SERVER_DATA = 0;
-             // offset to the PXCENTERWIDGET pointer in the widget data array
+#define SERVER_MEMORYPOOL_SIZE 65536
+        // taking NOTIFYDATA size into account (<=32 B), this is enough for at
+        // least 2048 simultaneous notification messages, which (even taking
+        // slowly responsing clients into account) sounds sane since in most
+        // cases the structure is freed once it reaches the target event queue
+        // and before a message created as a copy of it is sent to the target
+        // window procedure
 
 #define TID_CHECKALIVE          1
@@ -161 +171 @@
 #define TID_CHECKALIVE_TIMEOUT  2000 // ms
          // how often to perform alive checks
+
+static ULONG WM_XST_CREATED = 0;
+             // identity of the WM_XST_CREATED message taken from the atom table
+static ULONG WM_XST_NOTIFY = 0;
+             // identity of the WM_XST_NOTIFY message taken from the atom table
+
+static ULONG QWL_USER_SERVER_DATA = 0;
+             // offset to the PXCENTERWIDGET pointer in the widget data array
 
 static
@@ -299 +317 @@
 {
     pData->hwnd = NULLHANDLE;
-    pData->ulId = 0;
+    pData->usId = 0;
     if (pData->hIcon != NULLHANDLE)
     {
@@ -323 +341 @@
 PICONDATA FindIconData(PSYSTRAYDATA pSysTrayData,
                        HWND hwnd,       // in: associated window handle
-                       ULONG ulId,      // in: icon ID
+                       USHORT usId,     // in: icon ID
                        size_t *pIdx)    // out: index of the icon in the icon array
                                         // (optional, may be NULL)
@@ -331 +349 @@
     {
         if (pSysTrayData->pIcons[i].hwnd == hwnd &&
-            pSysTrayData->pIcons[i].ulId == ulId)
+            pSysTrayData->pIcons[i].usId == usId)
         {
             if (pIdx)
@@ -342 +360 @@
         *pIdx = i;
     return NULL;
+}
+
+/*
+ *@@ AllocNotifyDataPtr:
+ *      Allocates a SYSTRAYCTLDATA struct in the pool of shared memory on belalf
+ *      of the client window identified by pIconData->hwnd.
+ *
+ *      If there is no free space in the pool, it returns NULL. On success,
+ *      fills in msg and mp1 fields of the returned structure using the
+ *      information provided in pIconData.
+ *
+ *      Note that the allocated structure is supposed to be freed using
+ *      FreeNotifyDataPtr by the client-side API implementation in another
+ *      process.
+ */
+static
+PNOTIFYDATA AllocNotifyDataPtr(PVOID pvMemoryPool,  // in: memory pool base address
+                               PICONDATA pIconData) // in: icon data
+{
+    // NOTE: we cannot use DosSubAllocMem() and friends since we want to be able
+    // to free blocks allocated to clients which death we detect but we cannot
+    // be sure about the layout of memory DosSub API uses. Therefore, we provide
+    // our own sub-allocation scheme which is rather simple because we need to
+    // allocate equally sized blocks (each is NOTIFYDATA struct). The memory
+    // pool is laid out as follows: MEMPOOLHDR followed by a number of
+    // MEMPOOLBLK.
+
+    APIRET arc;
+    PID pid;
+    TID tid;
+    PMEMPOOLHDR pHdr;
+    ULONG ulMax, ulNeedsCommit, ulNext, ulCurr;
+    PNOTIFYDATA pData;
+
+    LOGF(("pvMemoryPool %p\n", pvMemoryPool));
+    LOGF(("hwnd         %p\n", pIconData->hwnd));
+
+    if (!pIconData->bMemoryPoolGiven)
+    {
+        LOGF(("Giving memory pool to %lx\n", pIconData->hwnd));
+
+        arc = ERROR_INVALID_HANDLE;
+        if (WinQueryWindowProcess(pIconData->hwnd, &pid, &tid))
+            arc = DosGiveSharedMem(pvMemoryPool, pid, PAG_READ | PAG_WRITE);
+        if (arc != NO_ERROR)
+            return NULL;
+
+        pIconData->bMemoryPoolGiven = TRUE;
+    }
+
+    pHdr = (PMEMPOOLHDR)pvMemoryPool;
+
+    // maximum address that is still enough for a block
+    ulMax = pHdr->ulBeyond - sizeof(MEMPOOLBLK);
+
+    ulNeedsCommit = pHdr->ulNeedsCommit;
+    ulNext = pHdr->ulNext;
+    ulCurr = ulNext;
+
+    LOGF(("ulNeedsCommit %p\n", ulNeedsCommit));
+    LOGF(("ulNext        %p\n", ulNext));
+
+    do
+    {
+        if (ulCurr >= ulNeedsCommit)
+        {
+            // commit more memory; it's OK two or more threads will do the same
+            DosSetMem((PVOID)ulNeedsCommit, 4096,
+                      PAG_COMMIT | PAG_READ | PAG_WRITE);
+            // advance the address (only if nobody has already done so -- they
+            // could already commit more than we did)
+            __atomic_cmpxchg32((uint32_t *)&pHdr->ulNeedsCommit,
+                               ulNeedsCommit + 4096, ulNeedsCommit);
+        }
+
+        if (__atomic_cmpxchg32((uint32_t *)ulCurr, pIconData->hwnd, NULLHANDLE))
+            break;
+
+        ulCurr += sizeof(MEMPOOLBLK);
+        if (ulCurr > ulMax)
+            // start over
+            ulCurr = ((ULONG)pvMemoryPool) + sizeof(MEMPOOLHDR);
+
+        if (ulCurr == ulNext)
+            return NULL; // no free blocks!
+    }
+    while (1);
+
+    LOGF(("ulCurr        %p\n", ulCurr));
+
+    // advance to the next possibly free block
+    ulCurr += sizeof(MEMPOOLBLK);
+    if (ulCurr > ulMax)
+        // start over
+        ulCurr = ((ULONG)pvMemoryPool) + sizeof(MEMPOOLHDR);
+
+    // store the new next address until someone else has already done that
+    __atomic_cmpxchg32((uint32_t *)&pHdr->ulNext, ulCurr, ulNext);
+
+    pData = &((PMEMPOOLBLK)ulCurr)->NotifyData;
+    memset(pData, sizeof(*pData), 0);
+
+    pData->msg = pIconData->ulMsgId;
+    pData->mp1 = MPFROMSHORT(pIconData->usId);
+
+    return pData;
+}
+
+/*
+ *@@ PostNotifyMsg:
+ *      Posts WM_XST_NOTIFY to the given client window. Frees pNotifyData if
+ *      posting fails.
+ */
+
+VOID PostNotifyMsg(PSYSTRAYDATA pSysTrayData, HWND hwnd,
+                   PNOTIFYDATA *pNotifyData)
+{
+    if (!WinPostMsg(hwnd, WM_XST_NOTIFY, pNotifyData, pSysTrayData->pvMemoryPool))
+        FreeNotifyDataPtr(pSysTrayData->pvMemoryPool, hwnd, pNotifyData);
 }
 
@@ -404 +541 @@
             {
                 PSIZEL pszl = (PSIZEL)mp2;
-                LONG pad2 = pSysTrayData->lIconPad * 2;
-                pszl->cx = (pSysTrayData->lIconWidth + pad2) * pSysTrayData->cIcons; // desired width
-                pszl->cy = pSysTrayData->lIconHeight + pad2; // desired minimum height
+                LONG pad = pSysTrayData->lIconPad;
+                size_t cnt = pSysTrayData->cIcons;
+                // desired width
+                if (cnt)
+                    pszl->cx = pad + (pSysTrayData->lIconWidth + pad) * cnt;
+                else
+                    pszl->cx = 0;
+                // desired minimum height
+                pszl->cy = pSysTrayData->lIconHeight + pad * 2;
                 brc = TRUE;
             }
@@ -421 +564 @@
  *      implementation for WM_PAINT in fnwpXSysTray.
  *
- *      This really does nothing, except painting a
- *      3D rectangle and printing a question mark.
+ *      Draws all the icons. If the widget's center is located to the left from
+ *      the XCenter's center, icons go left to right. Otherwise, they go right
+ *      to left.
+ */
+/*
+        +---------------------------+  p = lIconPad
+        |     p                     |  w = lIconWidth
+        |   +-------+   +-------+   |  h = lIconHeight
+        | p |   w   | p |   w   | p |
+        |   |      h|   |      h|   |
+        |   |       |   |       |   |  If "Frame around statics" is on in XCenter
+        |   +-------+   +-------+   |  properties, then a 1 px 3D frame is drawn
+        |     p                     |  within the pad area. So, lIconPad must
+        +---------------------------+  be at least 2 px.
  */
 
@@ -438 +593 @@
         RECTL   rcl;
         BOOL    bLeftToRight;
-        LONG    x, y, lTotalWidth;
+        LONG    x, y, lIconStep;
         size_t  i;
 
@@ -481 +636 @@
         // always center the icon vertically (we may be given more height than
         // we requested)
-        y = (swp.cy - pSysTrayData->lIconWidth) / 2;
+        y = (swp.cy - pSysTrayData->lIconHeight) / 2;
 
         if (bLeftToRight)
@@ -488 +643 @@
             x = swp.cx - pSysTrayData->lIconPad - pSysTrayData->lIconWidth;
 
-        lTotalWidth = pSysTrayData->lIconWidth + pSysTrayData->lIconPad * 2;
+        lIconStep = pSysTrayData->lIconWidth + pSysTrayData->lIconPad;
 
         // where to start from?
         if (bLeftToRight)
         {
-            i = rclPaint.xLeft / lTotalWidth;
-            x = pSysTrayData->lIconPad + i * lTotalWidth;
+            i = rclPaint.xLeft / lIconStep;
+            x = pSysTrayData->lIconPad + i * lIconStep;
         }
         else
         {
-            i = (swp.cx - rclPaint.xRight) / lTotalWidth;
-            x = swp.cx - (i + 1) * lTotalWidth + pSysTrayData->lIconPad;
+            i = (swp.cx - rclPaint.xRight) / lIconStep;
+            x = swp.cx - (i + 1) * lIconStep;
+            // negate the step, for convenience
+            lIconStep = -lIconStep;
         }
 
         // draw as many icons as we can / need
-        for (i = 0; i < pSysTrayData->cIcons; ++i)
+        for (; i < pSysTrayData->cIcons; ++i)
         {
             if (x >= rclPaint.xRight)
@@ -509 +666 @@
 
             DrawPointer(hps, x, y, pSysTrayData->pIcons[i].hIcon, DP_MINI);
-            if (bLeftToRight)
-                x += lTotalWidth;
-            else
-                x -= lTotalWidth;
+            x += lIconStep;
         }
 
         WinEndPaint(hps);
     }
+}
+
+/*
+ *@@ WgtMouse:
+ *      implementation for WM_BUTTONxyyy in fnwpXSysTray.
+ *
+ *      Posts a notification to the window associated with the icon and returns
+ *      TRUE if this mouse message is within the icon bounds. Otherwise returns
+ *      FALSE.
+ *
+ *      Refer to WgtPaint for more details about the widget geometry.
+ */
+
+static
+BOOL WgtMouse(HWND hwnd, ULONG msg, MRESULT mp1, MRESULT mp2,
+              PXCENTERWIDGET pWidget)
+{
+    PSYSTRAYDATA pSysTrayData = (PSYSTRAYDATA)pWidget->pUser;
+
+    POINTL  ptl;
+    SWP     swp;
+    RECTL   rcl;
+    BOOL    bLeftToRight;
+    LONG    y, lIconStep;
+    size_t  i;
+
+    PICONDATA   pIconData;
+    PNOTIFYDATA pNotifyData;
+
+    ptl.x = ((PPOINTS)&mp1)->x;
+    ptl.y = ((PPOINTS)&mp1)->y;
+
+    LOGF(("msg %x ptl %ld,%ld\n", msg, ptl.x, ptl.y));
+
+    WinQueryWindowPos(hwnd, &swp);
+    WinQueryWindowRect(pWidget->pGlobals->hwndClient, &rcl);
+
+    y = (swp.cy - pSysTrayData->lIconHeight) / 2;
+    if (ptl.y < y || ptl.y >= y + pSysTrayData->lIconHeight)
+        return FALSE; // hit pad space
+
+    // detect the direction
+    bLeftToRight = swp.x + swp.cx / 2 < (rcl.xRight / 2);
+
+    lIconStep = pSysTrayData->lIconWidth + pSysTrayData->lIconPad;
+
+    // which icon is that?
+    if (bLeftToRight)
+    {
+        i = ptl.x / lIconStep;
+        if (ptl.x % lIconStep < pSysTrayData->lIconPad)
+            return FALSE; // hit pad space
+    }
+    else
+    {
+        i = (swp.cx - ptl.x - 1) / lIconStep;
+        if ((swp.cx - ptl.x - 1) % lIconStep < pSysTrayData->lIconPad)
+            return FALSE; // hit pad space
+    }
+    if (i >= pSysTrayData->cIcons)
+        return FALSE; // hit pad space
+
+    pIconData = &pSysTrayData->pIcons[i];
+
+    LOGF(("hwnd  %x\n", pIconData->hwnd));
+    LOGF(("usId  %d\n", pIconData->usId));
+    LOGF(("hIcon %x\n", pIconData->hIcon));
+
+    // make the coordinates global
+    WinMapWindowPoints(hwnd, HWND_DESKTOP, &ptl, 1);
+
+    // allocate a NOTIFYDATA struct
+    pNotifyData = AllocNotifyDataPtr(pSysTrayData->pvMemoryPool, pIconData);
+    if (!pNotifyData)
+        return FALSE;
+
+    switch (msg)
+    {
+        case WM_HSCROLL:
+        case WM_VSCROLL:
+            pNotifyData->mp1 += XST_IN_WHEEL << 16;
+            pNotifyData->u.WheelMsg.ulWheelMsg = msg;
+            pNotifyData->u.WheelMsg.ptsPointerPos.x = ptl.x;
+            pNotifyData->u.WheelMsg.ptsPointerPos.y = ptl.y;
+            pNotifyData->u.WheelMsg.usCmd = SHORT2FROMMP(mp2);
+            pNotifyData->mp2 = &pNotifyData->u.WheelMsg;
+        break;
+
+        case WM_CONTEXTMENU:
+            pNotifyData->mp1 += XST_IN_CONTEXT << 16;
+            pNotifyData->u.ContextMsg.ptsPointerPos.x = ptl.x;
+            pNotifyData->u.ContextMsg.ptsPointerPos.y = ptl.y;
+            pNotifyData->u.ContextMsg.fPointer = TRUE;
+            pNotifyData->mp2 = &pNotifyData->u.ContextMsg;
+        break;
+
+        default:
+            pNotifyData->mp1 += XST_IN_MOUSE << 16;
+            pNotifyData->u.MouseMsg.ulMouseMsg = msg;
+            pNotifyData->u.MouseMsg.ptsPointerPos.x = ptl.x;
+            pNotifyData->u.MouseMsg.ptsPointerPos.y = ptl.y;
+            pNotifyData->u.MouseMsg.fsHitTestRes = SHORT1FROMMP(mp2);
+            pNotifyData->u.MouseMsg.fsFlags = SHORT2FROMMP(mp2);
+            pNotifyData->mp2 = &pNotifyData->u.MouseMsg;
+        break;
+    }
+
+    PostNotifyMsg(pSysTrayData, hwnd, pNotifyData);
+
+    return TRUE;
+}
+
+static
+VOID FreeSysTrayData(PSYSTRAYDATA pSysTrayData)
+{
+    // destroy the server
+    if (pSysTrayData->hwndServer != NULLHANDLE)
+    {
+        WinDestroyWindow(pSysTrayData->hwndServer);
+        pSysTrayData->hwndServer = NULLHANDLE;
+    }
+
+    // free all system tray data
+    if (pSysTrayData->pvMemoryPool)
+    {
+        DosFreeMem(pSysTrayData->pvMemoryPool);
+    }
+    if (pSysTrayData->pIcons)
+    {
+        size_t i;
+        for (i = 0; i < pSysTrayData->cIcons; ++i)
+            FreeIconData(&pSysTrayData->pIcons[i]);
+        pSysTrayData->cIcons = 0;
+        free(pSysTrayData->pIcons);
+        pSysTrayData->pIcons = NULL;
+    }
+
+    free(pSysTrayData);
 }
 
@@ -562 +854 @@
 
             PSYSTRAYDATA pSysTrayData = NULL;
+            APIRET arc;
 
             WinSetWindowPtr(hwnd, QWL_USER, mp1);
@@ -575 +868 @@
 
             // initialize the SYSTRAYDATA structure
+            memset(pSysTrayData, sizeof(*pSysTrayData), 0);
             pSysTrayData->lIconWidth = WinQuerySysValue(HWND_DESKTOP, SV_CXICON) / 2;
             pSysTrayData->lIconHeight = WinQuerySysValue(HWND_DESKTOP, SV_CYICON) / 2;
@@ -583 +877 @@
             if (pSysTrayData->pIcons == NULL)
             {
-                free(pSysTrayData);
+                FreeSysTrayData(pSysTrayData);
                 return (MRESULT)TRUE;
             }
             pSysTrayData->cIcons = 0;
+
+            // Allocate the memory pool for NOTIFYDATA structs (we don't
+            // PAG_COMMIT all memory, AllocNotifyDataPtr() will do so as needed)
+            arc = DosAllocSharedMem((PVOID)&pSysTrayData->pvMemoryPool, NULL,
+                                    SERVER_MEMORYPOOL_SIZE,
+                                    PAG_READ | PAG_WRITE | OBJ_GIVEABLE);
+            if (arc == NO_ERROR)
+            {
+                PMEMPOOLHDR pHdr = (PMEMPOOLHDR)pSysTrayData->pvMemoryPool;
+                arc = DosSetMem(pSysTrayData->pvMemoryPool, 4096,
+                                PAG_COMMIT | PAG_READ | PAG_WRITE);
+                if (arc == NO_ERROR)
+                {
+                    pHdr->ulBeyond = (ULONG)pSysTrayData->pvMemoryPool +
+                                     SERVER_MEMORYPOOL_SIZE;
+                    pHdr->ulNeedsCommit = (ULONG)pSysTrayData->pvMemoryPool +
+                                           4096;
+                    pHdr->ulNext = (ULONG)pSysTrayData->pvMemoryPool +
+                                   sizeof(MEMPOOLHDR);
+                }
+            }
+            if (arc != NO_ERROR)
+            {
+                FreeSysTrayData(pSysTrayData);
+                return (MRESULT)TRUE;
+            }
 
             // create the "server" window (note that we pass the XCENTERWIDGET
@@ -598 +918 @@
             if (pSysTrayData->hwndServer == NULLHANDLE)
             {
-                free(pSysTrayData->pIcons);
-                free(pSysTrayData);
+                FreeSysTrayData(pSysTrayData);
                 return (MRESULT)TRUE;
             }
@@ -606 +925 @@
 
             // inform all interested parties that we are fired up
-            // (NOTE: keep in sync with xstGetSysTrayCreatedMsgId())
-            WinBroadcastMsg(HWND_DESKTOP,
-                            WinAddAtom(WinQuerySystemAtomTable(),
-                                       "ExtendedSysTray.WM_XST_CREATED"),
-                            NULL, NULL,
-                            BMSG_POST);
+            WinBroadcastMsg(HWND_DESKTOP, WM_XST_CREATED,
+                            NULL, NULL, BMSG_POST);
 
             return FALSE; // confirm success
@@ -628 +943 @@
 
             PSYSTRAYDATA pSysTrayData = (PSYSTRAYDATA)pWidget->pUser;
-            size_t i;
-
-            // destroy the server
-            WinDestroyWindow(pSysTrayData->hwndServer);
-            pSysTrayData->hwndServer = NULLHANDLE;
-
-            // free all system tray data
-            for (i = 0; i < pSysTrayData->cIcons; ++i)
-                FreeIconData(&pSysTrayData->pIcons[i]);
-            pSysTrayData->cIcons = 0;
-            free(pSysTrayData->pIcons);
-            pSysTrayData->pIcons = NULL;
-
-            // make sure we remove the check alive timer
-            WgtXSysTrayUpdateAfterIconAddRemove(pWidget);
-
-            free(pSysTrayData);
+
+            // stop the check alive timer
+            WinStopTimer(pWidget->habWidget, pSysTrayData->hwndServer,
+                         TID_CHECKALIVE);
+
+            FreeSysTrayData(pSysTrayData);
             pWidget->pUser = NULL;
 
@@ -680 +984 @@
         break; */
 
+        /*
+         * All mouse click and wheel events:
+         *      Note that we hide WM_CONTEXTMENU from XCenter when it is within
+         *      the icon bounds as it's a responsibility of the application
+         *      owning the icon to show it.
+         */
+
+        case WM_BUTTON1UP:
+        case WM_BUTTON1DOWN:
+        case WM_BUTTON1CLICK:
+        case WM_BUTTON1DBLCLK:
+        case WM_BUTTON2UP:
+        case WM_BUTTON2DOWN:
+        case WM_BUTTON2CLICK:
+        case WM_BUTTON2DBLCLK:
+        case WM_BUTTON3UP:
+        case WM_BUTTON3DOWN:
+        case WM_BUTTON3CLICK:
+        case WM_BUTTON3DBLCLK:
+        case WM_CONTEXTMENU:
+        case WM_VSCROLL:
+        case WM_HSCROLL:
+        {
+            if (WgtMouse(hwnd, msg, mp1, mp2, pWidget))
+                return (MRESULT)TRUE;
+            // we didn't hit the icon, pass it on to XCenter
+        }
+        break;
+
         default:
             break;
@@ -713 +1046 @@
     }
 
-    if (pSysTrayData->pIcons != NULL)
-    {
-        // ask XCenter to take our new size into account (this will also
-        // invalidate us). If pIcons is NULL it means that we are in WM_DESTROY,
-        // in which case XCenter will do everything for us
-        WinPostMsg(pWidget->pGlobals->hwndClient,
-                   XCM_REFORMAT,
-                   (MPARAM)XFMF_GETWIDGETSIZES,
-                   0);
-    }
+    // ask XCenter to take our new size into account (this will also
+    // invalidate us)
+    WinPostMsg(pWidget->pGlobals->hwndClient,
+               XCM_REFORMAT,
+               (MPARAM)XFMF_GETWIDGETSIZES,
+               0);
 }
 
@@ -767 +1096 @@
             LOGF(("SYSTRAYCMD_ADDICON\n"));
             LOGF((" hwnd  %x\n", pCtlData->hwndSender));
-            LOGF((" ulId  %ld\n", pCtlData->u.icon.ulId));
+            LOGF((" usId  %d\n", pCtlData->u.icon.usId));
             LOGF((" hIcon %x\n", pCtlData->u.icon.hIcon));
 
@@ -785 +1114 @@
 
             pData = FindIconData(pSysTrayData, pCtlData->hwndSender,
-                                 pCtlData->u.icon.ulId, &i);
+                                 pCtlData->u.icon.usId, &i);
             if (pData)
             {
@@ -825 +1154 @@
 
                 pData = &pSysTrayData->pIcons[i];
+                memset(pData, sizeof(*pData), 0);
+
                 pData->hwnd = pCtlData->hwndSender;
-                pData->ulId = pCtlData->u.icon.ulId;
+                pData->usId = pCtlData->u.icon.usId;
                 pData->hIcon = hIcon;
                 pData->ulMsgId = pCtlData->u.icon.ulMsgId;
@@ -844 +1175 @@
             LOGF(("SYSTRAYCMD_REMOVEICON\n"));
             LOGF((" hwnd  %x\n", pCtlData->hwndSender));
-            LOGF((" ulId  %ld\n", pCtlData->u.icon.ulId));
+            LOGF((" usId  %d\n", pCtlData->u.icon.usId));
 
             pCtlData->bAcknowledged = TRUE;
 
             pData = FindIconData(pSysTrayData, pCtlData->hwndSender,
-                                 pCtlData->u.icon.ulId, &i);
+                                 pCtlData->u.icon.usId, &i);
             if (pData)
             {
@@ -893 +1224 @@
 {
     PSYSTRAYDATA pSysTrayData = (PSYSTRAYDATA)pWidget->pUser;
+    PMEMPOOLHDR pMemPoolHdr = (PMEMPOOLHDR)pSysTrayData->pvMemoryPool;
+    PMEMPOOLBLK pMemPoolBlk;
+    ULONG ulMemPoolMax;
 
     if (usTimerId == TID_CHECKALIVE)
@@ -904 +1238 @@
             if (!WinIsWindow(pWidget->habWidget, pSysTrayData->pIcons[i].hwnd))
             {
+                PICONDATA pData = &pSysTrayData->pIcons[i];
+
                 LOGF(("Removing icon of dead window!\n"));
-                LOGF((" hwnd  %x\n", pSysTrayData->pIcons[i].hwnd));
-                LOGF((" ulId  %ld\n", pSysTrayData->pIcons[i].ulId));
-                LOGF((" hIcon %x\n", pSysTrayData->pIcons[i].hIcon));
+                LOGF((" hwnd  %x\n", pData->hwnd));
+                LOGF((" usId  %ld\n", pData->usId));
+                LOGF((" hIcon %x\n", pData->hIcon));
+
+                // free memory blocks from the pool allocated for this client
+                ulMemPoolMax = pMemPoolHdr->ulBeyond;
+                if (ulMemPoolMax > pMemPoolHdr->ulNeedsCommit)
+                    ulMemPoolMax = pMemPoolHdr->ulNeedsCommit;
+                ulMemPoolMax -= sizeof(MEMPOOLBLK);
+
+                pMemPoolBlk = pMemPoolHdr->aBlocks;
+                while ((ULONG)pMemPoolBlk <= ulMemPoolMax)
+                {
+                    if (pMemPoolBlk->hwnd == pData->hwnd)
+                    {
+                        LOGF((" freeing memory block %p\n", pMemPoolBlk));
+                        __atomic_cmpxchg32((uint32_t *)&pMemPoolBlk->hwnd,
+                                           NULLHANDLE, hwnd);
+                    }
+                    ++pMemPoolBlk;
+                }
 
                 bAnyDead = TRUE;
-                FreeIconData(&pSysTrayData->pIcons[i]);
-                // hwnd is NULLHANDLE here
+                FreeIconData(pData);
+                // pData->hwnd is NULLHANDLE here
             }
         }
@@ -1128 +1482 @@
         }
 
+        if (WM_XST_CREATED == 0)
+            WM_XST_CREATED = WinAddAtom(WinQuerySystemAtomTable(),
+                                        WM_XST_CREATED_ATOM);
+        if (WM_XST_NOTIFY == 0)
+            WM_XST_NOTIFY = WinAddAtom(WinQuerySystemAtomTable(),
+                                       WM_XST_NOTIFY_ATOM);
+
         // no error:
         // return widget classes array