Changeset 273 for trunk/src

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).

Location:

trunk/src/3rdparty/os2/xsystray

Files:

• xsystray.c (modified) (30 diffs)
• xsystray.h (modified) (6 diffs)
• xsystray_api.c (modified) (16 diffs)
• xsystray_api.h (modified) (2 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

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

@@ -17 +17 @@
 #define XSYSTRAY_HEADER_INCLUDED
 
+#include "xsystray_api.h"
+
+#include <sys/builtin.h>        // atomics
+
 #define XSYSTRAY_VERSION_MAJOR 0
 #define XSYSTRAY_VERSION_MINOR 1
@@ -26 +30 @@
 #define INTCLASS_WIDGET_XSYSTRAY        "ExtendedSysTray"
 #define HUMANSTR_WIDGET_XSYSTRAY        "Extended system tray"
+
+#define WM_XST_CREATED_ATOM             "ExtendedSysTray.WM_XST_CREATED"
+#define WM_XST_NOTIFY_ATOM              "ExtendedSysTray.WM_XST_NOTIFY"
 
 #define WM_XST_CONTROL  (WM_USER + 0)
@@ -38 +45 @@
     SYSTRAYCMD_HIDEBALLOON,
 } SYSTRAYCMD;
+
+/*
+ *@@ SYSTRAYCTLDATA:
+ *      Structure holding information accompanying WM_XST_CONTROL messages sent
+ *      to the system tray server by clients (windows associated with system
+ *      tray icons).
+ *
+ *      NOTE: When you change the size of this structure, you may also need to
+ *      change CLIENT_MEMORYPOOL_SIZE value (see the comments there for
+ *      details).
+ */
 
 typedef struct
@@ -58 +76 @@
         struct
         {
-            ULONG       ulId;
+            USHORT      usId;
             HPOINTER    hIcon;
             ULONG       ulMsgId;
@@ -66 +84 @@
         struct
         {
-            ULONG   ulId;
+            USHORT  usId;
             CHAR    szText[512];
         } tooltip;
@@ -77 +95 @@
 } SYSTRAYCTLDATA, *PSYSTRAYCTLDATA;
 
+/*
+ *@@ NOTIFYDATA:
+ *      Structure holding information acompanying notification messages
+ *      posted to clients (windows associated with system tray icons) about
+ *      icon events. This structure unions all public notification code
+ *      dependent structures defined in xsystray_api.h (starting with XST*).
+ *
+ *      All messages posted to the client have an ID corresponding to the
+ *      WM_XST_NOTIFY_ATOM in the system atom table. The client-side API
+ *      implementation intercepts these messages (using HK_INPUT), composes a
+ *      new message given the information in NOTIFYDATA, frees the NOTIFYDATA
+ *      pointer using FreeNotifyDataPtr() and then sends the composed message to
+ *      the appropriate window.
+ *
+ *      The layout of the XST_NOTIFY message is as follows:
+ *
+ *          param1
+ *              PNOTIFYDATA pNotifyData     pointer to the NOTIFYDATA structure
+ *
+ *          param2
+ *              PVOID       pvMemoryPool    server memory pool (for the
+ *                                          FreeNotifyDataPtr() call)
+ *
+ *      NOTE: When you change the size of this structure, you may also need to
+ *      change SERVER_MEMORYPOOL_SIZE value in xsystray.c (see the comments
+ *      there for details).
+ */
+
+typedef struct
+{
+    ULONG   msg;
+            // ID of the message that is to be sent to the target window
+    MPARAM  mp1;
+            // message parameter (usually: USHORT usIconId, USHORT usNotifyCode)
+    MPARAM  mp2;
+            // message parameter (usually, a pointer to a struct from the union)
+    union
+    {
+        XSTMOUSEMSG     MouseMsg;
+        XSTCONTEXTMSG   ContextMsg;
+        XSTWHEELMSG     WheelMsg;
+    } u;
+
+} NOTIFYDATA, *PNOTIFYDATA;
+
+// Header of the server-side memory pool
+typedef struct
+{
+    volatile HWND   hwnd;        // owner of the block or NULLHANDLE if free
+    NOTIFYDATA      NotifyData;  // data
+
+} MEMPOOLBLK, *PMEMPOOLBLK;
+
+// allocation unit in the server-side memory pool
+typedef struct
+{
+    ULONG ulBeyond;         // address of the first byte beyond the memory pool
+
+    volatile ULONG ulNeedsCommit;   // address of the first decommitted byte
+    volatile ULONG ulNext;          // address of next possibly free block
+
+    MEMPOOLBLK aBlocks[0];          // fake array for easier addressing
+
+} MEMPOOLHDR, *PMEMPOOLHDR;
+
+/*
+ *@@ FreeNotifyDataPtr:
+ *      Frees the NOTIFYDATA structure allocated by AllocNotifyDataPtr().
+ *
+ *      See AllocNotifyDataPtr() for more details about allocating these
+ *      structures.dd
+ */
+
+inline
+VOID FreeNotifyDataPtr(PVOID pvMemoryPool,  // in: memory pool base address
+                       HWND hwndOwner,      // in: owner of the struct to free
+                       PNOTIFYDATA pData)   // in: address of the struct to free
+{
+    PMEMPOOLHDR pHdr = (PMEMPOOLHDR)pvMemoryPool;
+    PMEMPOOLBLK pBlk = (PMEMPOOLBLK)((ULONG)pData - sizeof(HWND));
+
+    ULONG ulNext = pHdr->ulNext;
+
+    __atomic_cmpxchg32((uint32_t *)&pBlk->hwnd, NULLHANDLE, hwndOwner);
+
+    // if the next possible free block is greater than we just freed,
+    // set it to us (to minimize the amount of committed pages)
+    if (ulNext > (ULONG)pBlk)
+        __atomic_cmpxchg32((uint32_t *)&pHdr->ulNext, (ULONG)pBlk, ulNext);
+}
+
 #endif // XSYSTRAY_HEADER_INCLUDED
 

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

@@ -28 +28 @@
 #include <sys/builtin.h>        // atomics
 
-static HWND G_hwndSysTray = NULLHANDLE;
-            // window handle of the system tray server
-
-static PVOID G_pvMemoryPool = NULL;
-             // memory pool for SYSTRAYCTLDATA structs used by WM_XST_CONTROL
-             // messages. Note that once allocated, this memory is never freed:
-             // it is intentional since the memory is assumed to be always in
-             // need and that the system will free it when the application
-             // terminates
-
-#define MEMORYPOOL_SIZE 65536
-        // taking SYSTRAYCTLDATA size into account, this is enough for at least
-        // 64 threads sending WM_XST_CONTROL simultaneously, which sounds sane
+static
+volatile HWND G_hwndSysTray = NULLHANDLE;
+              // window handle of the system tray server
+
+static
+volatile PVOID G_pvMemoryPool = NULL;
+               // shared memory pool for SYSTRAYCTLDATA structs used by
+               // WM_XST_CONTROL messages. Note that once allocated, this memory
+               // is never freed: it is intentional since the memory is assumed
+               // to be always in need and that the system will free it when the
+               // application terminates
+
+#define CLIENT_MEMORYPOOL_SIZE 65536
+        // taking SYSTRAYCTLDATA size into account (<=1024 B), this is enough
+        // for at least 64 threads sending WM_XST_CONTROL simultaneously, which
+        // sounds sane
 
 // @todo to be on the safe side with casting in __atomic_cmpxchg32() we need
@@ -116 +119 @@
 }
 
-// This function allocates a SYSTRAYCTLDATA struct in the pool of shared memory.
-// If there is no free space in the pool, it returns NULL. The allocated memory
-// must be freed by FreeSysTrayCtlDataPtr() when not needed.
+/*
+ *@@ AllocSysTrayCtlDataPtr:
+ *      Allocates a SYSTRAYCTLDATA struct in the pool of shared memory.
+ *
+ *      If there is no free space in the pool, it returns NULL. The allocated
+ *      memory must be freed by FreeSysTrayCtlDataPtr() when not needed.
+ */
+
 static PSYSTRAYCTLDATA AllocSysTrayCtlDataPtr()
 {
@@ -128 +136 @@
     {
         // Note: we don't PAG_COMMIT, DosSubAllocMem will do so when needed
-        arc = DosAllocSharedMem((PVOID)&pvPool, NULL, MEMORYPOOL_SIZE,
+        arc = DosAllocSharedMem((PVOID)&pvPool, NULL, CLIENT_MEMORYPOOL_SIZE,
                                 PAG_READ | PAG_WRITE | OBJ_GIVEABLE);
         if (arc == NO_ERROR)
             arc = DosSubSetMem(pvPool,
                                DOSSUB_INIT | DOSSUB_SPARSE_OBJ,
-                               MEMORYPOOL_SIZE);
+                               CLIENT_MEMORYPOOL_SIZE);
         if (!__atomic_cmpxchg32((uint32_t *)&G_pvMemoryPool,
                                 (uint32_t)pvPool, (uint32_t)NULL))
@@ -149 +157 @@
     }
 
-    arc = DosSubAllocMem(G_pvMemoryPool, (PVOID)&pData, sizeof(SYSTRAYCTLDATA));
+    arc = DosSubAllocMem(G_pvMemoryPool, (PVOID)&pData, sizeof(*pData));
     if (arc != NO_ERROR)
         return NULL;
@@ -158 +166 @@
 static VOID FreeSysTrayCtlDataPtr(PSYSTRAYCTLDATA pData)
 {
-    DosSubFreeMem(G_pvMemoryPool, pData, sizeof(SYSTRAYCTLDATA));
+    DosSubFreeMem(G_pvMemoryPool, pData, sizeof(*pData));
 }
 
@@ -220 +228 @@
  *
  *          param1
- *              USHORT  usID        icon ID
- *              USHORT  usCode      notify code, one of XST_IN_ constants
+ *              USHORT  usIconID        icon ID
+ *              USHORT  usNotifyCode    notify code, one of XST_IN_ constants
  *
  *          param2
- *              PVOID   pData       notify code specific data (see below)
+ *              PVOID   pData           notify code specific data (see below)
  *
  *      The following notify codes are currently recognized:
@@ -232 +240 @@
  *              messages are recognized. param2 is a pointer to the XSTMOUSEMSG
  *              structure containing full mouse message details.
+ *
+ *          XST_IN_CONTEXT:
+ *              Context menu event in the icon area. param2 is a pointer to the
+ *              XSTCONTEXTMSG structure containing full message details.
+ *
+ *          XST_IN_WHEEL:
+ *              Mouse wheel event in the icon area. param2 is a pointer to the
+ *              XSTWHEELTMSG structure containing full message details.
  */
 
 BOOL xstAddSysTrayIcon(HWND hwnd,       // in: window handle associated with the icon
-                       ULONG ulId,      // in: icon ID to add
+                       USHORT usId,     // in: icon ID to add
                        HPOINTER hIcon,  // in: icon handle
                        ULONG ulMsgId,   // in: message ID for notifications
@@ -252 +268 @@
         pData->ulCommand = SYSTRAYCMD_ADDICON;
         pData->hwndSender = hwnd;
-        pData->u.icon.ulId = ulId;
+        pData->u.icon.usId = usId;
         pData->u.icon.hIcon = hIcon;
         pData->u.icon.ulMsgId = ulMsgId;
@@ -278 +294 @@
 
 BOOL xstRemoveSysTrayIcon(HWND hwnd,    // in: window handle associated with the icon
-                          ULONG ulId)   // in: icon ID to remove
+                          USHORT usId)  // in: icon ID to remove
 {
     BOOL brc;
@@ -287 +303 @@
     pData->ulCommand = SYSTRAYCMD_REMOVEICON;
     pData->hwndSender = hwnd;
-    pData->u.icon.ulId = ulId;
+    pData->u.icon.usId = usId;
 
     brc = SendSysTrayCtlMsg(pData);
@@ -314 +330 @@
 
 BOOL xstSetSysTrayIconToolTip(HWND hwnd,    // in: window handle associated with the icon
-                              ULONG ulId,   // in: icon ID to set the tooltip for
+                              USHORT usId,  // in: icon ID to set the tooltip for
                               PSZ pszText)  // in: tooltip text
 {
@@ -324 +340 @@
     pData->ulCommand = SYSTRAYCMD_SETTOOLTIP;
     pData->hwndSender = hwnd;
-    pData->u.tooltip.ulId = ulId;
+    pData->u.tooltip.usId = usId;
 
     if (pszText == NULL)
@@ -343 +359 @@
 }
 
-BOOL xstShowSysTrayIconBalloon(HWND hwnd, ULONG ulId, PSZ pszTitle, PSZ pszText,
+BOOL xstShowSysTrayIconBalloon(HWND hwnd, USHORT usId, PSZ pszTitle, PSZ pszText,
                                ULONG ulFlags, ULONG ulTimeout)
 {
@@ -350 +366 @@
 }
 
-BOOL xstHideSysTrayIconBalloon(HWND hwnd, ULONG ulId)
+BOOL xstHideSysTrayIconBalloon(HWND hwnd, USHORT usId)
 {
     // @todo implement
@@ -364 +380 @@
  *      Returns TRUE on success and FALSE otherwise.
  */
-BOOL xstQuerySysTrayIconRect(HWND hwnd, ULONG ulId, PRECTL prclRect)
+BOOL xstQuerySysTrayIconRect(HWND hwnd, USHORT usId, PRECTL prclRect)
 {
     // @todo implement
@@ -384 +400 @@
 ULONG xstGetSysTrayCreatedMsgId()
 {
-    // NOTE: keep in sync with fnwpXSysTray()::WM_CREATED
-
     static ULONG WM_XST_CREATED = 0;
     if (WM_XST_CREATED == 0)
         WM_XST_CREATED = WinAddAtom(WinQuerySystemAtomTable(),
-                                    "ExtendedSysTray.WM_XST_CREATED");
+                                    WM_XST_CREATED_ATOM);
     return WM_XST_CREATED;
 }

trunk/src/3rdparty/os2/xsystray/xsystray_api.h

@@ -24 +24 @@
 // tray (refer to xstAddSysTrayIcon() for details)
 #define XST_IN_MOUSE    0x0001
+#define XST_IN_CONTEXT  0x0002
+#define XST_IN_WHEEL    0x0003
 
 // structure for XST_IN_MOUSE
@@ -29 +31 @@
 {
     ULONG  ulMouseMsg;
+           // mouse message (one of WM_BUTTONxyyy)
     POINTS ptsPointerPos;
+           // global pointer position at the time of the mouse event
     USHORT fsHitTestRes;
+           // hit-test result (see WM_BUTTONxyyy description in PM)
     USHORT fsFlags;
+           // keyboard control codes (see WM_BUTTONxyyy description in PM)
 
 } XSTMOUSEMSG, *PXSTMOUSEMSG;
 
+// structure for XST_IN_CONTEXT
+typedef struct
+{
+    POINTS ptsPointerPos;
+           // global pointer position at the time of the mouse event
+    USHORT fPointer;
+           // input device flag (see WM_CONTEXTMENU description in PM)
+
+} XSTCONTEXTMSG, *PXSTCONTEXTMSG;
+
+// structure for XST_IN_WHEEL
+typedef struct
+{
+    ULONG  ulWheelMsg;
+           // mouse message (one of WM_HSCROLL or WM_VSCROLL)
+    POINTS ptsPointerPos;
+           // global pointer position at the time of the mouse event
+    USHORT usCmd;
+           // command (see WM_HSCROLL/WM_VSCROLL description in PM)
+
+} XSTWHEELMSG, *PXSTWHEELMSG;
+
 BOOL xstQuerySysTrayVersion(PULONG pulMajor, PULONG pulMinor, PULONG pulRevision);
-BOOL xstAddSysTrayIcon(HWND hwnd, ULONG ulId, HPOINTER hIcon, ULONG ulMsgId,
+BOOL xstAddSysTrayIcon(HWND hwnd, USHORT usId, HPOINTER hIcon, ULONG ulMsgId,
                        ULONG ulFlags);
-BOOL xstRemoveSysTrayIcon(HWND hwnd, ULONG ulId);
-BOOL xstSetSysTrayIconToolTip(HWND hwnd, ULONG ulId, PSZ pszText);
-BOOL xstShowSysTrayIconBalloon(HWND hwnd, ULONG ulId, PSZ pszTitle, PSZ pszText,
+BOOL xstRemoveSysTrayIcon(HWND hwnd, USHORT usId);
+BOOL xstSetSysTrayIconToolTip(HWND hwnd, USHORT usId, PSZ pszText);
+BOOL xstShowSysTrayIconBalloon(HWND hwnd, USHORT usId, PSZ pszTitle, PSZ pszText,
                                ULONG ulFlags, ULONG ulTimeout);
-BOOL xstHideSysTrayIconBalloon(HWND hwnd, ULONG ulId);
+BOOL xstHideSysTrayIconBalloon(HWND hwnd, USHORT usId);
 
-BOOL xstQuerySysTrayIconRect(HWND hwnd, ULONG ulId, PRECTL prclRect);
+BOOL xstQuerySysTrayIconRect(HWND hwnd, USHORT usId, PRECTL prclRect);
 
 ULONG xstGetSysTrayCreatedMsgId();