Changeset 618 for trunk/dll/draglist.c


Ignore:
Timestamp:
Apr 20, 2007, 9:19:03 PM (18 years ago)
Author:
Steven Levine
Message:

Add more drag/drop error checking
Use FreeDragInfoData
Sync with NumItemsToUnhilite AcceptOneDrop GetOneDrop mods

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/draglist.c

    r606 r618  
    1414  06 Apr 07 GKY Add DeleteDragitemStrHandles
    1515  06 Apr 07 GKY Add some error checking in drag/drop
     16  19 Apr 07 SHL Rework DeleteDragitemStrHandles to be FreeDragInfoData
     17  19 Apr 07 SHL Add more drag/drop error checking
     18  19 Apr 07 SHL Optimize DRAGITEM DRAGIMAGE array access
    1619
    1720***********************************************************************/
    … …  
    1922#define INCL_DOS
    2023#define INCL_WIN
     24#define INCL_SHLERRORS
    2125#include <os2.h>
    2226
    … …  
    3034static PSZ pszSrcFile = __FILE__;
    3135
    32 #pragma alloc_text(DRAGLIST,DragOne,DoFileDrag,DragList,PickUp,DeleteDragitemStrHandles)
    33 /* work around for DrgDeleteDraginfoStrHandles
    34 which seems to fail with a large number of strings */
    35 BOOL DeleteDragitemStrHandles (PDRAGINFO pDInfo)
     36#pragma alloc_text(DRAGLIST,DragOne,DoFileDrag,DragList,PickUp,FreeDragInfoData)
     37
     38/**
     39 * Delete drag item string handles.
     40 * Work around for DrgDeleteDraginfoStrHandles
     41 * which seems to fail with a large number of strings
     42 * Assume called after successful DrgAccessDraginfo
     43 */
     44
     45
     46// #define USE_FAST_FREE                // Define to let PM do free
     47
     48VOID FreeDragInfoData (HWND hwnd, PDRAGINFO pDInfo)
    3649{
    37     PDRAGITEM  pDItem;
    38     ULONG cDitem;
    39     UINT  i = 0;
    40     APIRET rc;
    41 
    42     cDitem = DrgQueryDragitemCount(pDInfo);
    43      for (; i < (UINT)cDitem; i++){
    44          pDItem = DrgQueryDragitemPtr(pDInfo, i);
    45      if (!pDItem)
    46         return FALSE;
    47      else {
    48         DrgDeleteStrHandle(pDItem->hstrType);
    49         DrgDeleteStrHandle(pDItem->hstrRMF);
    50         DrgDeleteStrHandle(pDItem->hstrContainerName);
    51         rc = DrgDeleteStrHandle(pDItem->hstrSourceName);
    52         if (!rc)
    53                Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
    54                         "DrgDeleteStrHandle");
    55         DrgDeleteStrHandle(pDItem->hstrTargetName);
    56      }
    57    } // for
    58    return TRUE;
     50  PDRAGITEM pDItem;
     51  ULONG cDitem;
     52  ULONG curitem;
     53  APIRET ok;
     54
     55# ifdef USE_FAST_FREE
     56  if (!DrgDeleteDraginfoStrHandles(pDInfo)) {
     57    Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
     58              "DrgDeleteDraginfoStrHandles");
     59  }
     60# else // The slow way
     61  cDitem = DrgQueryDragitemCount(pDInfo);
     62  for (curitem = 0; curitem < cDitem; curitem++) {
     63    pDItem = DrgQueryDragitemPtr(pDInfo, curitem);
     64    if (!pDItem) {
     65      Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
     66                "DrgQueryDragitemPtr(%u)", curitem);
     67    }
     68    else {
     69      ok = DrgDeleteStrHandle(pDItem->hstrType);
     70      if (!ok) {
     71        Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
     72                      "DrgDeleteStrHandle(0x%x) hstrType",pDItem->hstrType);
     73      }
     74      ok = DrgDeleteStrHandle(pDItem->hstrRMF);
     75      if (!ok) {
     76        Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
     77                      "DrgDeleteStrHandle(0x%x) hstrRMF",pDItem->hstrRMF);
     78      }
     79      ok = DrgDeleteStrHandle(pDItem->hstrContainerName);
     80      if (!ok) {
     81        Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
     82                      "DrgDeleteStrHandle(0x%x) hstrContainerName",pDItem->hstrContainerName);
     83      }
     84      ok = DrgDeleteStrHandle(pDItem->hstrSourceName);
     85      if (!ok) {
     86        Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
     87                      "DrgDeleteStrHandle(0x%x) hstrSourceName",pDItem->hstrSourceName);
     88      }
     89      ok = DrgDeleteStrHandle(pDItem->hstrTargetName);
     90      if (!ok) {
     91        Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
     92                      "DrgDeleteStrHandle(0x%x) hstrTargetName",pDItem->hstrTargetName);
     93      }
     94    }
     95  } // for
     96# endif
     97  if (!DrgFreeDraginfo(pDInfo)) {
     98    // fixme to find callers responsible for PMERR_SOURCE_SAME_AS_TARGET
     99    if ((WinGetLastError(WinQueryAnchorBlock(hwnd)) & 0xffff) != PMERR_SOURCE_SAME_AS_TARGET) {
     100      Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
     101               "DrgFreeDraginfo");
     102    }
     103    else
     104      DbgMsg(pszSrcFile, __LINE__, "DrgFreeDraginfo PMERR_SOURCE_SAME_AS_TARGET");
     105  }
    59106}
    60107
    … …  
    95142        hptrDir : hptrFile;
    96143      memset(&DItem, 0, sizeof(DRAGITEM));
    97       DItem.hwndItem = (hwndObj) ? hwndObj : hwndCnr;   /* Initialize DRAGITEM */
     144      DItem.hwndItem = (hwndObj) ? hwndObj : hwndCnr;   // Initialize DRAGITEM
    98145      // DItem.hwndItem = hwndCnr;
    99146      DItem.ulItemID = 1;
    … …  
    103150      DItem.hstrSourceName = DrgAddStrHandle(szFile);
    104151      if (!DItem.hstrSourceName)
    105         Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
    106         "DrgQueryStrName");
     152        Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
     153        "DrgQueryStrName");
    107154      DItem.hstrTargetName = DrgAddStrHandle(szFile);
    108155      DItem.fsControl = 0;
    … …  
    125172      fakeicon.cxOffset = -16;
    126173      fakeicon.cyOffset = 0;
    127       pDInfo = DrgAllocDraginfo(1);     /* Allocate DRAGINFO */
     174      pDInfo = DrgAllocDraginfo(1);
    128175      if (pDInfo) {
    129176        if (IsFullName(filename) &&
    … …  
    136183        pDInfo->hwndSource = (hwndObj) ? hwndObj : hwndCnr;
    137184        // pDInfo->hwndSource = hwndCnr;
    138         DrgSetDragitem(pDInfo,          /* Set item in DRAGINFO  */
    139                        &DItem,          /* Pointer to DRAGITEM   */
    140                        sizeof(DRAGITEM),        /* Size of DRAGITEM      */
    141                        0);              /* Index of DRAGITEM     */
     185        DrgSetDragitem(pDInfo, &DItem, sizeof(DRAGITEM), 0);
    142186        WinSetFocus(HWND_DESKTOP, HWND_DESKTOP);
    143         hDrop = DrgDrag(hwndCnr,        /* Initiate drag         */
    144                         pDInfo,         /* DRAGINFO structure    */
    145                         &fakeicon, 1L, VK_ENDDRAG,      /* End of drag indicator */
    146                         (PVOID) NULL);  /* Reserved              */
    147         //if (hDrop == NULLHANDLE)
    148         if (!DeleteDragitemStrHandles(pDInfo)) //)
    149             Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
    150                       "DeleteDragistr");
    151         DrgDeleteDraginfoStrHandles (pDInfo);
    152         DrgFreeDraginfo(pDInfo);        /* Free DRAGINFO struct  */
     187        hDrop = DrgDrag(hwndCnr,
     188                        pDInfo,
     189                        &fakeicon,
     190                        1,              // DragImage count
     191                        VK_ENDDRAG,     // Drag end button
     192                        NULL);
     193        if (hDrop == NULLHANDLE)
     194          FreeDragInfoData(hwndCnr, pDInfo);
    153195        WinSetWindowPos(hwndCnr, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
    154196      }
    … …  
    161203                CHAR * directory, BOOL moveok)
    162204{
    163   /* drag files from a container */
     205  // Drag files from a container
    164206
    165207  BOOL isdir, rooting = FALSE;
    166208  PCNRITEM pci;
    167   register CHAR *p;
     209  CHAR *p;
    168210  INT attribute = CRA_CURSORED;
    169211  PDRAGINFO pDInfo = NULL;
    170   DRAGITEM **ppDItem = NULL, **ppTest;
     212  DRAGITEM **ppDItem = NULL, **ppDITest;
     213  DRAGITEM *pDItem;
    171214  PCNRITEM pciRec = (PCNRITEM) pcd->pRecord;
    172   HWND hDrop = 0;
    173   register ULONG ulNumfiles = 0L, numdragalloc = 0L, Select, ulNumIcon = 0;
     215  HWND hDrop = NULLHANDLE;
     216  ULONG ulNumfiles = 0, ulNumDIAlloc = 0, ulSelect, ulNumIcon = 0;
    174217  CHAR szFile[CCHMAXPATH], szBuffer[CCHMAXPATH];
    175   DRAGIMAGE *padiIcon = NULL, *padiTest, diFakeIcon;
    176   APIRET rc;
    177 
    178   fExceedPMDrgLimit = 0;
     218  DRAGIMAGE *paDImgIcons = NULL, *pDImg, dimgFakeIcon;
     219  BOOL ok;
     220
     221  // fixme to be multi-drag safe - count needs to be in DCD etc. and passed to UnHilite
     222  NumItemsToUnhilite = 0;
    179223  if (!pciRec && directory && *directory)
    180224    return DragOne(hwndCnr, hwndObj, directory, moveok);
    … …  
    202246  }
    203247
    204   Select = 0L;
     248  ulSelect = 0;
    205249  while (pci && (INT) pci > -1) {
    206250    if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
    … …  
    223267    if (!arcfile) {
    224268      // Filesystem object
    225       isdir = ((pci->attrFile & FILE_DIRECTORY) != 0);
    226       if (ulNumfiles + 2L > numdragalloc) {
    227         if (!padiIcon) {
    228           padiTest =
    229             xrealloc(padiIcon, sizeof(DRAGIMAGE) * (numdragalloc + 4L),
     269      isdir = pci->attrFile & FILE_DIRECTORY;
     270      // fixme to expand smarter - expand fast at first - do same for similar code
     271      if (ulNumfiles + 2 > ulNumDIAlloc) {
     272        // Expand
     273        if (!paDImgIcons) {
     274          pDImg =
     275            xrealloc(paDImgIcons, sizeof(DRAGIMAGE) * (ulNumDIAlloc + 4L),
    230276                     pszSrcFile, __LINE__);
    231           if (padiTest)
    232             padiIcon = padiTest;
    233           else
     277          if (!pDImg)
    234278            break;
     279          paDImgIcons = pDImg;
    235280        }
    236281        else if (!ulNumIcon) {
    237           padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
    238           padiIcon[ulNumfiles].cptl = 0;
    239           padiIcon[ulNumfiles].hImage = hptrLast;
    240           padiIcon[ulNumfiles].fl = DRG_ICON;
    241           padiIcon[ulNumfiles].sizlStretch.cx = 32;
    242           padiIcon[ulNumfiles].sizlStretch.cy = 32;
    243           padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 4);
    244           padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 7);
     282          pDImg = &paDImgIcons[ulNumfiles];
     283          pDImg->cb = sizeof(DRAGIMAGE);
     284          pDImg->cptl = 0;
     285          pDImg->hImage = hptrLast;
     286          pDImg->fl = DRG_ICON;
     287          pDImg->sizlStretch.cx = 32;
     288          pDImg->sizlStretch.cy = 32;
     289          pDImg->cxOffset = -16 + (ulNumfiles * 4);
     290          pDImg->cyOffset = 0 + (ulNumfiles * 7);
    245291          ulNumIcon = ulNumfiles + 1;
    246292        }
    247         ppTest =
    248           xrealloc(ppDItem, sizeof(DRAGITEM *) * (numdragalloc + 4L),
     293        ppDITest =
     294          xrealloc(ppDItem, sizeof(DRAGITEM *) * (ulNumDIAlloc + 4L),
    249295                   pszSrcFile, __LINE__);
    250         if (ppTest) {
    251           ppDItem = ppTest;
    252           numdragalloc += 4L;
    253         }
    254         else
     296        if (!ppDITest)
    255297          break;
    256       }
    257       ppDItem[ulNumfiles] = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
    258       if (ppDItem[ulNumfiles]) {
    259         if (!ulNumIcon) {
    260           padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
    261           padiIcon[ulNumfiles].cptl = 0;
    262           padiIcon[ulNumfiles].hImage = pci->rc.hptrIcon;
    263           if (!padiIcon[ulNumfiles].hImage)
    264             padiIcon[ulNumfiles].hImage = (isdir) ? hptrDir : hptrFile;
    265           padiIcon[ulNumfiles].fl = DRG_ICON;
    266           padiIcon[ulNumfiles].sizlStretch.cx = 32;
    267           padiIcon[ulNumfiles].sizlStretch.cy = 32;
    268           padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 3);
    269           padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 6);
    270         }
    271         memset(ppDItem[ulNumfiles], 0, sizeof(DRAGITEM));
    272         ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwndCnr;  /* Initialize DRAGITEM   */
    273         ppDItem[ulNumfiles]->hwndItem = hwndCnr;
    274         ppDItem[ulNumfiles]->ulItemID = (ULONG) pci;
    275         ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
    276         ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFLIST);
    277         ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(szBuffer);
    278              ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
    279         if (!ppDItem[ulNumfiles]->hstrSourceName){
    280             DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrType);
    281             DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrRMF);
    282             DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrContainerName);
    283             DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrSourceName);
    284             xfree(ppDItem[ulNumfiles]);
    285             fExceedPMDrgLimit = ulNumfiles - 1;
    286             break;
    287         }
    288         /*Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
    289                   "DrgAddStrHandle");*/
    290         ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
    291         ppDItem[ulNumfiles]->fsControl = (isdir) ? DC_CONTAINER : 0;
    292         if (IsFullName(pci->szFileName) &&
    293             (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE))
    294           ppDItem[ulNumfiles]->fsControl |= DC_REMOVEABLEMEDIA;
    295         ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE | DO_LINKABLE;
    296         if (moveok && IsFullName(pci->szFileName) &&
    297             !(driveflags[toupper(*pci->szFileName) - 'A'] &
    298               DRIVE_NOTWRITEABLE))
    299           ppDItem[ulNumfiles]->fsSupportedOps |= DO_MOVEABLE;
    300         if (IsRoot(pci->szFileName)) {
    301           ppDItem[ulNumfiles]->fsSupportedOps = DO_LINKABLE;
    302           rooting = TRUE;
    303         }
    304    //if (ulNumfiles >= 2000){
    305      // pDInfo = DrgAllocDraginfo(ulNumfiles);
    306      // fExceedPMDrgLimit = TRUE;
    307      // goto Thatsall;
    308      //   }
    309         ulNumfiles++;
    310         ppDItem[ulNumfiles] = NULL;
    311       }
    312       else
     298        ppDItem = ppDITest;
     299        ulNumDIAlloc += 4L;
     300      }
     301      pDItem = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
     302      if (!pDItem)
     303        break;                          // Already complained
     304      ppDItem[ulNumfiles] = pDItem;
     305      if (!ulNumIcon) {
     306        pDImg = &paDImgIcons[ulNumfiles];
     307        pDImg->cb = sizeof(DRAGIMAGE);
     308        pDImg->cptl = 0;
     309        pDImg->hImage = pci->rc.hptrIcon;
     310        if (!pDImg->hImage)
     311          pDImg->hImage = isdir ? hptrDir : hptrFile;
     312        pDImg->fl = DRG_ICON;
     313        pDImg->sizlStretch.cx = 32;
     314        pDImg->sizlStretch.cy = 32;
     315        pDImg->cxOffset = -16 + (ulNumfiles * 3);
     316        pDImg->cyOffset = 0 + (ulNumfiles * 6);
     317      }
     318      // Initialize DRAGITEM
     319      memset(pDItem, 0, sizeof(DRAGITEM));
     320      pDItem->hwndItem = (hwndObj) ? hwndObj : hwndCnr;
     321      pDItem->hwndItem = hwndCnr;
     322      pDItem->ulItemID = (ULONG) pci;
     323      pDItem->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
     324      ok = pDItem->hstrType;
     325      pDItem->hstrRMF = DrgAddStrHandle(DRMDRFLIST);
     326      ok = ok && pDItem->hstrRMF;
     327      pDItem->hstrContainerName = DrgAddStrHandle(szBuffer);
     328      ok = ok && pDItem->hstrContainerName;
     329      pDItem->hstrSourceName = DrgAddStrHandle(szFile);
     330      ok = ok && pDItem->hstrSourceName;
     331      pDItem->hstrTargetName = DrgAddStrHandle(szFile);
     332      ok = ok && pDItem->hstrTargetName;
     333      if (!ok) {
     334        DbgMsg(pszSrcFile, __LINE__, "DrgAddStrHandle failed at %lu for %s", ulNumfiles, szFile);
     335        // Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,"DrgAddStrHandle");
     336        if (pDItem->hstrType)
     337          DrgDeleteStrHandle(pDItem->hstrType);
     338        if (pDItem->hstrRMF)
     339          DrgDeleteStrHandle(pDItem->hstrRMF);
     340        if (pDItem->hstrContainerName)
     341          DrgDeleteStrHandle(pDItem->hstrContainerName);
     342        if (pDItem->hstrSourceName)
     343          DrgDeleteStrHandle(pDItem->hstrSourceName);
     344        if (pDItem->hstrTargetName)
     345          DrgDeleteStrHandle(pDItem->hstrTargetName);
     346        xfree(pDItem);
     347        // ppDItem[ulNumfiles] = NULL;  // Why bother - we can count - fixme to be gone
     348        NumItemsToUnhilite = ulNumfiles + 1;    // Use +1 to ensure non-zero on any failure
    313349        break;
     350      }
     351      pDItem->fsControl = isdir ? DC_CONTAINER : 0;
     352      if (IsFullName(pci->szFileName) &&
     353          (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE))
     354        pDItem->fsControl |= DC_REMOVEABLEMEDIA;
     355      pDItem->fsSupportedOps = DO_COPYABLE | DO_LINKABLE;
     356      if (moveok && IsFullName(pci->szFileName) &&
     357          !(driveflags[toupper(*pci->szFileName) - 'A'] &
     358            DRIVE_NOTWRITEABLE))
     359        pDItem->fsSupportedOps |= DO_MOVEABLE;
     360      if (IsRoot(pci->szFileName)) {
     361        pDItem->fsSupportedOps = DO_LINKABLE;
     362        rooting = TRUE;
     363      }
     364      ulNumfiles++;
     365      // ppDItem[ulNumfiles] = NULL;    // Why bother - can't we count - fixme to be gone?
    314366    }
    315367    else {
    316368      // Archive object
    317       if (ulNumfiles + 3L > numdragalloc) {
    318         ppTest =
    319           xrealloc(ppDItem, sizeof(DRAGITEM *) * (numdragalloc + 5L),
     369      if (ulNumfiles + 3L > ulNumDIAlloc) {
     370        ppDITest =
     371          xrealloc(ppDItem, sizeof(DRAGITEM *) * (ulNumDIAlloc + 5L),
    320372                   pszSrcFile, __LINE__);
    321         if (!ppTest)
     373        if (!ppDITest)
    322374          break;
    323         else {
    324           ppDItem = ppTest;
    325           numdragalloc += 5L;
    326         }
    327       }
    328       ppDItem[ulNumfiles] = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
    329       if (!ppDItem[ulNumfiles])
     375        ppDItem = ppDITest;
     376        ulNumDIAlloc += 5L;
     377      }
     378      pDItem = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
     379      if (!pDItem)
    330380        break;
    331       else {
    332         diFakeIcon.hImage = hptrFile;
    333         memset(ppDItem[ulNumfiles], 0, sizeof(DRAGITEM));
    334         ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwndCnr;  /* Initialize DRAGITEM   */
    335         ppDItem[ulNumfiles]->hwndItem = hwndCnr;
    336         ppDItem[ulNumfiles]->ulItemID = (ULONG) pci;
    337         ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
    338         ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFOS2FILE);
    339         ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(arcfile);
    340         ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
    341         if (!ppDItem[ulNumfiles]->hstrSourceName){
    342           DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrType);
    343           DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrRMF);
    344           DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrContainerName);
    345           DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrSourceName);
    346           xfree(ppDItem[ulNumfiles]);
    347           fExceedPMDrgLimit = ulNumfiles - 1;
    348           break;
    349        }
    350         ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
    351         ppDItem[ulNumfiles]->fsControl = DC_PREPARE;
     381      ppDItem[ulNumfiles] = pDItem;
     382      dimgFakeIcon.hImage = hptrFile;
     383      // Initialize DRAGITEM
     384      memset(pDItem, 0, sizeof(DRAGITEM));
     385      pDItem->hwndItem = (hwndObj) ? hwndObj : hwndCnr;
     386      pDItem->hwndItem = hwndCnr;
     387      pDItem->ulItemID = (ULONG) pci;
     388      pDItem->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
     389      ok = pDItem->hstrType;
     390      pDItem->hstrRMF = DrgAddStrHandle(DRMDRFOS2FILE);
     391      ok = ok && pDItem->hstrRMF;
     392      pDItem->hstrContainerName = DrgAddStrHandle(arcfile);
     393      ok = ok && pDItem->hstrContainerName;
     394      pDItem->hstrSourceName = DrgAddStrHandle(szFile);
     395      ok = ok && pDItem->hstrSourceName;
     396      pDItem->hstrTargetName = DrgAddStrHandle(szFile);
     397      ok = ok && pDItem->hstrTargetName;
     398      if (!ok){
     399        if (pDItem->hstrType)
     400          DrgDeleteStrHandle(pDItem->hstrType);
     401        if (pDItem->hstrRMF)
     402          DrgDeleteStrHandle(pDItem->hstrRMF);
     403        if (pDItem->hstrContainerName)
     404          DrgDeleteStrHandle(pDItem->hstrContainerName);
     405        if (pDItem->hstrSourceName)
     406          DrgDeleteStrHandle(pDItem->hstrSourceName);
     407        if (pDItem->hstrTargetName)
     408          DrgDeleteStrHandle(pDItem->hstrTargetName);
     409        xfree(pDItem);
     410        NumItemsToUnhilite = ulNumfiles + 1;    // +1 to ensure non-zero
     411        break;
     412     }
     413      pDItem->fsControl = DC_PREPARE;
     414      if (IsFullName(arcfile) &&
     415          (driveflags[toupper(*arcfile) - 'A'] & DRIVE_REMOVABLE))
     416        pDItem->fsControl |= DC_REMOVEABLEMEDIA;
     417      pDItem->fsSupportedOps = DO_COPYABLE;
     418      ulNumfiles++;
     419
     420      pDItem = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
     421      if (pDItem) {
     422        ppDItem[ulNumfiles] = pDItem;
     423        dimgFakeIcon.hImage = hptrFile;
     424        // Initialize DRAGITEM
     425        memset(pDItem, 0, sizeof(DRAGITEM));
     426        pDItem->hwndItem = (hwndObj) ? hwndObj : hwndCnr;
     427        pDItem->hwndItem = hwndCnr;
     428        pDItem->ulItemID = ulSelect++;
     429        pDItem->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
     430        ok = ok && pDItem->hstrType;
     431        pDItem->hstrRMF = DrgAddStrHandle(DRMDRFFM2ARC);
     432        ok = ok && pDItem->hstrRMF;
     433        pDItem->hstrContainerName = DrgAddStrHandle(arcfile);
     434        ok = ok && pDItem->hstrContainerName;
     435        pDItem->hstrSourceName = DrgAddStrHandle(szFile);
     436        ok = ok && pDItem->hstrSourceName;
     437        pDItem->hstrTargetName = DrgAddStrHandle(szFile);
     438        ok = ok && pDItem->hstrTargetName;
     439        if (!ok) {
     440          DbgMsg(pszSrcFile, __LINE__, "DrgAddStrHandle failed at %lu for %s", ulNumfiles, szFile);
     441          if (pDItem->hstrType)
     442            DrgDeleteStrHandle(pDItem->hstrType);
     443          if (pDItem->hstrRMF)
     444            DrgDeleteStrHandle(pDItem->hstrRMF);
     445          if (pDItem->hstrContainerName)
     446            DrgDeleteStrHandle(pDItem->hstrContainerName);
     447          if (pDItem->hstrSourceName)
     448            DrgDeleteStrHandle(pDItem->hstrSourceName);
     449          if (pDItem->hstrTargetName)
     450            DrgDeleteStrHandle(pDItem->hstrTargetName);
     451          xfree(pDItem);
     452          // pDItem = NULL;             // Why bother - fixme to be gone?
     453          NumItemsToUnhilite = ulNumfiles + 1;
     454          break;
     455        }
     456        pDItem->fsControl = 0;
    352457        if (IsFullName(arcfile) &&
    353458            (driveflags[toupper(*arcfile) - 'A'] & DRIVE_REMOVABLE))
    354           ppDItem[ulNumfiles]->fsControl |= DC_REMOVEABLEMEDIA;
    355         ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE;
     459          pDItem->fsControl |= DC_REMOVEABLEMEDIA;
     460        pDItem->fsSupportedOps = DO_COPYABLE;
    356461        ulNumfiles++;
    357         ppDItem[ulNumfiles] = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
    358         if (ppDItem[ulNumfiles]) {
    359           diFakeIcon.hImage = hptrFile;
    360           memset(ppDItem[ulNumfiles], 0, sizeof(DRAGITEM));
    361           ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwndCnr;        /* Initialize DRAGITEM   */
    362           ppDItem[ulNumfiles]->hwndItem = hwndCnr;
    363           ppDItem[ulNumfiles]->ulItemID = Select++;
    364           ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
    365           ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFFM2ARC);
    366           ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(arcfile);
    367           ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
    368           if (!ppDItem[ulNumfiles]->hstrSourceName){
    369             DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrType);
    370             DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrRMF);
    371             DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrContainerName);
    372             DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrSourceName);
    373             xfree(ppDItem[ulNumfiles]);
    374             fExceedPMDrgLimit = ulNumfiles - 1;
    375             break;
    376         }
    377           ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
    378           ppDItem[ulNumfiles]->fsControl = 0;
    379           if (IsFullName(arcfile) &&
    380               (driveflags[toupper(*arcfile) - 'A'] & DRIVE_REMOVABLE))
    381             ppDItem[ulNumfiles]->fsControl |= DC_REMOVEABLEMEDIA;
    382           ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE;
    383      //if (ulNumfiles >= 1000){
    384        // pDInfo = DrgAllocDraginfo(ulNumfiles);
    385        // fexceedpmdrglimit = TRUE;
    386        // goto Thatsall;
    387        //   }
    388           ulNumfiles++;
    389         }
    390         ppDItem[ulNumfiles] = NULL;
    391       }
     462      }
     463      // ppDItem[ulNumfiles] = NULL;    // Why bother - fixme to be gone?
    392464    }
    393465    WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
    … …  
    400472    pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMP(pci),
    401473                     MPFROMSHORT(attribute));
    402   }                                     // while
    403   if (fExceedPMDrgLimit)
    404     ulNumfiles = ulNumfiles - 1;
     474  } // while
     475
    405476  if (ulNumfiles) {
    406     pDInfo = DrgAllocDraginfo(ulNumfiles);      /* Allocate DRAGINFO */
     477    pDInfo = DrgAllocDraginfo(ulNumfiles);
    407478    if (pDInfo) {
    408479      if ((arcfile && *arcfile) || (IsFullName(szBuffer) &&
    … …  
    416487      pDInfo->hwndSource = (hwndObj) ? hwndObj : hwndCnr;
    417488      // pDInfo->hwndSource = hwndCnr;
    418       for (Select = 0L; Select < ulNumfiles; Select++) {
    419         DrgSetDragitem(pDInfo,          /* Set item in DRAGINFO  */
    420                        ppDItem[Select], /* Pointer to DRAGITEM   */
    421                        sizeof(DRAGITEM),        /* Size of DRAGITEM      */
    422                        Select);         /* Index of DRAGITEM     */
    423         xfree(ppDItem[Select]);
     489      for (ulSelect = 0; ulSelect < ulNumfiles; ulSelect++) {
     490        DrgSetDragitem(pDInfo, ppDItem[ulSelect], sizeof(DRAGITEM), ulSelect);
     491        xfree(ppDItem[ulSelect]);
    424492      }
    425493#ifdef __DEBUG_ALLOC__
    … …  
    427495#endif
    428496      xfree(ppDItem);
    429       ppDItem = NULL;
     497      ppDItem = NULL;                   // Remember gone
    430498      DosPostEventSem(CompactSem);
    431499
    432500      if (arcfile) {
    433         diFakeIcon.cb = sizeof(DRAGIMAGE);
    434         diFakeIcon.cptl = 0;
     501        dimgFakeIcon.cb = sizeof(DRAGIMAGE);
     502        dimgFakeIcon.cptl = 0;
    435503        if (ulNumfiles > 1)
    436           diFakeIcon.hImage = hptrFile;
    437         diFakeIcon.fl = DRG_ICON;
    438         diFakeIcon.sizlStretch.cx = 32;
    439         diFakeIcon.sizlStretch.cy = 32;
    440         diFakeIcon.cxOffset = -16;
    441         diFakeIcon.cyOffset = 0;
    442         padiIcon = &diFakeIcon;
     504          dimgFakeIcon.hImage = hptrFile;
     505        dimgFakeIcon.fl = DRG_ICON;
     506        dimgFakeIcon.sizlStretch.cx = 32;
     507        dimgFakeIcon.sizlStretch.cy = 32;
     508        dimgFakeIcon.cxOffset = -16;
     509        dimgFakeIcon.cyOffset = 0;
     510        paDImgIcons = &dimgFakeIcon;
    443511      }
    444512      if (!arcfile) {
    … …  
    447515      }
    448516      else
    449         ulNumIcon = 1L;
     517        ulNumIcon = 1;
    450518
    451519      WinSetFocus(HWND_DESKTOP, HWND_DESKTOP);
    452       hDrop = DrgDrag(hwndCnr,          /* Initiate drag         */
    453                       pDInfo,           /* DRAGINFO structure    */
    454                       padiIcon, ulNumIcon, VK_ENDDRAG,  /* End of drag indicator */
    455                       (PVOID) NULL);    /* Reserved              */
    456       rc = DeleteDragitemStrHandles(pDInfo);
    457       if (!rc)
    458           Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
    459                     "DeleteDragistr");
    460       DrgDeleteDraginfoStrHandles (pDInfo);
    461       rc = DrgFreeDraginfo(pDInfo);             /* Free DRAGINFO struct  */
    462       if (!rc)
    463       Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
    464                 "DrgFreeDraginfo");
    465       if (padiIcon && padiIcon != &diFakeIcon)
    466         xfree(padiIcon);
    467       padiIcon = NULL;
     520      hDrop = DrgDrag(hwndCnr,
     521                      pDInfo,
     522                      paDImgIcons,
     523                      ulNumIcon,
     524                      VK_ENDDRAG,       // Drag end button
     525                      NULL);
    468526      WinSetWindowPos(hwndCnr, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
    469       DosPostEventSem(CompactSem);
    470527    }
    471528  }
     529
     530  if (hDrop == NULLHANDLE ) {
     531    NumItemsToUnhilite = 0;
     532    if (pDInfo)
     533      FreeDragInfoData(hwndCnr, pDInfo);
     534  }
     535
    472536  if (ppDItem)
    473537    xfree(ppDItem);
    474   if (padiIcon && padiIcon != &diFakeIcon)
    475     xfree(padiIcon);
     538  if (paDImgIcons && paDImgIcons != &dimgFakeIcon)
     539    xfree(paDImgIcons);
     540  DosPostEventSem(CompactSem);
    476541  MarkAll(hwndCnr, TRUE, FALSE, TRUE);
    477542  return hDrop;
    … …  
    480545HWND DragList(HWND hwnd, HWND hwndObj, CHAR ** list, BOOL moveok)
    481546{
    482 
    483   /* drag a linked list of files */
     547  // Drag a linked list of files
    484548
    485549  BOOL isdir;
    486550  register CHAR *p;
    487551  PDRAGINFO pDInfo = NULL;
    488   DRAGITEM **ppDItem = NULL, **ppTest;
     552  DRAGITEM **ppDItem = NULL, **ppDITest;
     553  DRAGITEM *pDItem;
    489554  HWND hDrop = (HWND) 0;
    490   register ULONG ulNumfiles = 0L, numdragalloc = 0L, Select, ulNumIcon = 0;
     555  ULONG ulNumfiles = 0, ulNumDIAlloc = 0, ulSelect, ulNumIcon = 0;
    491556  CHAR szFile[CCHMAXPATH], szBuffer[CCHMAXPATH];
    492   DRAGIMAGE *padiIcon = NULL, *padiTest;
     557  DRAGIMAGE *paDImgIcons = NULL, *pDImg;
    493558  FILESTATUS3 fs3;
     559  BOOL ok;
    494560
    495561  if (!list || !list[0])
    496562    return hDrop;
    497   for (Select = 0; list[Select]; Select++) {
    498     if ((!IsRoot(list[Select]) || !IsValidDrive(*list[Select])) &&
    499         DosQueryPathInfo(list[Select], FIL_STANDARD, &fs3, sizeof(fs3)))
     563  for (ulSelect = 0; list[ulSelect]; ulSelect++) {
     564    if ((!IsRoot(list[ulSelect]) || !IsValidDrive(*list[ulSelect])) &&
     565        DosQueryPathInfo(list[ulSelect], FIL_STANDARD, &fs3, sizeof(fs3)))
    500566      continue;
    501     strcpy(szBuffer, list[Select]);
     567    strcpy(szBuffer, list[ulSelect]);
    502568    p = strrchr(szBuffer, '\\');
    503569    if (p) {
    … …  
    509575      continue;
    510576    if (*szFile) {
    511       isdir = (IsRoot(list[Select])) ? TRUE :
    512         ((fs3.attrFile & FILE_DIRECTORY) != 0);
    513       if (ulNumfiles + 2L > numdragalloc) {
    514         if (!padiIcon) {
    515           padiTest =
    516             xrealloc(padiIcon, sizeof(DRAGIMAGE) * (numdragalloc + 4L),
     577      isdir = IsRoot(list[ulSelect]) || fs3.attrFile & FILE_DIRECTORY;
     578      // fixme to expand smarter - expand fast at first - do same for similar code
     579      if (ulNumfiles + 2 > ulNumDIAlloc) {
     580        if (!paDImgIcons) {
     581          pDImg =
     582            xrealloc(paDImgIcons, sizeof(DRAGIMAGE) * (ulNumDIAlloc + 4L),
    517583                     pszSrcFile, __LINE__);
    518           if (!padiTest)
     584          if (!pDImg)
    519585            break;
    520           else
    521             padiIcon = padiTest;
     586          paDImgIcons = pDImg;
    522587        }
    523588        else if (!ulNumIcon) {
    524           padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
    525           padiIcon[ulNumfiles].cptl = 0;
    526           padiIcon[ulNumfiles].hImage = hptrLast;
    527           padiIcon[ulNumfiles].fl = DRG_ICON;
    528           padiIcon[ulNumfiles].sizlStretch.cx = 32;
    529           padiIcon[ulNumfiles].sizlStretch.cy = 32;
    530           padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 4);
    531           padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 7);
     589          pDImg = &paDImgIcons[ulNumfiles];
     590          pDImg->cb = sizeof(DRAGIMAGE);
     591          pDImg->cptl = 0;
     592          pDImg->hImage = hptrLast;
     593          pDImg->fl = DRG_ICON;
     594          pDImg->sizlStretch.cx = 32;
     595          pDImg->sizlStretch.cy = 32;
     596          pDImg->cxOffset = -16 + (ulNumfiles * 4);
     597          pDImg->cyOffset = 0 + (ulNumfiles * 7);
    532598          ulNumIcon = ulNumfiles + 1;
    533599        }
    534         ppTest =
    535           xrealloc(ppDItem, sizeof(DRAGITEM *) * (numdragalloc + 4L),
     600        ppDITest =
     601          xrealloc(ppDItem, sizeof(DRAGITEM *) * (ulNumDIAlloc + 4L),
    536602                   pszSrcFile, __LINE__);
    537         if (!ppTest)
     603        if (!ppDITest)
    538604          break;
    539         else {
    540           ppDItem = ppTest;
    541           numdragalloc += 4L;
    542         }
    543       }
    544       ppDItem[ulNumfiles] = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
    545       if (!ppDItem[ulNumfiles])
     605        ppDItem = ppDITest;
     606        ulNumDIAlloc += 4L;
     607      }
     608      pDItem = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
     609      if (!pDItem)
    546610        break;
    547       else {
    548         if (!ulNumIcon) {
    549           padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
    550           padiIcon[ulNumfiles].cptl = 0;
    551           padiIcon[ulNumfiles].hImage = (isdir) ? hptrDir : hptrFile;
    552           padiIcon[ulNumfiles].fl = DRG_ICON;
    553           padiIcon[ulNumfiles].sizlStretch.cx = 32;
    554           padiIcon[ulNumfiles].sizlStretch.cy = 32;
    555           padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 3);
    556           padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 6);
    557         }
    558         memset(ppDItem[ulNumfiles], 0, sizeof(DRAGITEM));
    559         ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwnd;     /* Initialize DRAGITEM */
    560         // ppDItem[ulNumfiles]->hwndItem = hwnd;
    561         ppDItem[ulNumfiles]->ulItemID = (ULONG) Select;
    562         ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
    563         ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFLIST);
    564         ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(szBuffer);
    565         ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
    566         if (!ppDItem[ulNumfiles]->hstrSourceName){
    567             DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrType);
    568             DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrRMF);
    569             DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrContainerName);
    570             DrgDeleteStrHandle(ppDItem[ulNumfiles]->hstrSourceName);
    571             xfree(ppDItem[ulNumfiles]);
    572             fExceedPMDrgLimit = ulNumfiles - 1;
    573             break;
    574         }
    575         ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
    576         ppDItem[ulNumfiles]->fsControl = (isdir) ? DC_CONTAINER : 0;
    577         if (IsFullName(list[Select]) &&
    578             (driveflags[toupper(*list[Select]) - 'A'] & DRIVE_REMOVABLE))
    579           ppDItem[ulNumfiles]->fsControl |= DC_REMOVEABLEMEDIA;
    580         ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE | DO_LINKABLE;
    581         if (moveok && IsFullName(list[Select]) &&
    582             !(driveflags[toupper(*list[Select]) - 'A'] & DRIVE_NOTWRITEABLE))
    583           ppDItem[ulNumfiles]->fsSupportedOps |= DO_MOVEABLE;
    584         if (IsRoot(list[Select]))
    585           ppDItem[ulNumfiles]->fsControl = DO_LINKABLE;
    586         ulNumfiles++;
    587         ppDItem[ulNumfiles] = NULL;
    588       }
    589     }
    590   }                                     // for
    591   if (fExceedPMDrgLimit)
    592     ulNumfiles = ulNumfiles - 1;
     611      ppDItem[ulNumfiles] = pDItem;
     612      if (!ulNumIcon) {
     613        pDImg = &paDImgIcons[ulNumfiles];
     614        pDImg->cb = sizeof(DRAGIMAGE);
     615        pDImg->cptl = 0;
     616        pDImg->hImage = isdir ? hptrDir : hptrFile;
     617        pDImg->fl = DRG_ICON;
     618        pDImg->sizlStretch.cx = 32;
     619        pDImg->sizlStretch.cy = 32;
     620        pDImg->cxOffset = -16 + (ulNumfiles * 3);
     621        pDImg->cyOffset = 0 + (ulNumfiles * 6);
     622      }
     623      memset(pDItem, 0, sizeof(DRAGITEM));
     624      pDItem->hwndItem = (hwndObj) ? hwndObj : hwnd;
     625      // pDItem->hwndItem = hwnd;
     626      pDItem->ulItemID = (ULONG) ulSelect;
     627      pDItem->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
     628      ok = pDItem->hstrType;
     629      pDItem->hstrRMF = DrgAddStrHandle(DRMDRFLIST);
     630      ok = ok && pDItem->hstrRMF;
     631      pDItem->hstrContainerName = DrgAddStrHandle(szBuffer);
     632      ok = ok && pDItem->hstrContainerName;
     633      pDItem->hstrSourceName = DrgAddStrHandle(szFile);
     634      ok = ok && pDItem->hstrSourceName;
     635      pDItem->hstrTargetName = DrgAddStrHandle(szFile);
     636      ok = ok && pDItem->hstrTargetName;
     637      if (!ok) {
     638        if (pDItem->hstrType)
     639          DrgDeleteStrHandle(pDItem->hstrType);
     640        if (pDItem->hstrRMF)
     641          DrgDeleteStrHandle(pDItem->hstrRMF);
     642        if (pDItem->hstrContainerName)
     643          DrgDeleteStrHandle(pDItem->hstrContainerName);
     644        if (pDItem->hstrSourceName)
     645          DrgDeleteStrHandle(pDItem->hstrSourceName);
     646        if (pDItem->hstrTargetName)
     647          DrgDeleteStrHandle(pDItem->hstrTargetName);
     648        xfree(pDItem);
     649        // pDItem = NULL;       // Why bother, we can count - fixme to be gone
     650        NumItemsToUnhilite = ulNumfiles + 1;
     651        break;
     652      }
     653      pDItem->fsControl = isdir ? DC_CONTAINER : 0;
     654      if (IsFullName(list[ulSelect]) &&
     655          (driveflags[toupper(*list[ulSelect]) - 'A'] & DRIVE_REMOVABLE))
     656        pDItem->fsControl |= DC_REMOVEABLEMEDIA;
     657      pDItem->fsSupportedOps = DO_COPYABLE | DO_LINKABLE;
     658      if (moveok && IsFullName(list[ulSelect]) &&
     659          !(driveflags[toupper(*list[ulSelect]) - 'A'] & DRIVE_NOTWRITEABLE))
     660        pDItem->fsSupportedOps |= DO_MOVEABLE;
     661      if (IsRoot(list[ulSelect]))
     662        pDItem->fsControl = DO_LINKABLE;
     663      ulNumfiles++;
     664      // ppDItem[ulNumfiles] = NULL;    // Why bother - fixme to be gone
     665    }
     666  } // for
    593667  if (ulNumfiles) {
    594     pDInfo = DrgAllocDraginfo(ulNumfiles);      /* Allocate DRAGINFO */
     668    pDInfo = DrgAllocDraginfo(ulNumfiles);
    595669    if (pDInfo) {
    596670      if ((IsFullName(szBuffer) &&
    … …  
    601675      if (IsRoot(list[0]))
    602676        pDInfo->usOperation = DO_LINK;
    603       pDInfo->hwndSource = (hwndObj) ? hwndObj : hwnd;
     677      pDInfo->hwndSource = hwndObj ? hwndObj : hwnd;
    604678      // pDInfo->hwndSource = hwnd;
    605       for (Select = 0L; Select < ulNumfiles; Select++) {
    606         DrgSetDragitem(pDInfo,          /* Set item in DRAGINFO  */
    607                        ppDItem[Select], /* Pointer to DRAGITEM   */
    608                        sizeof(DRAGITEM),        /* Size of DRAGITEM      */
    609                        Select);         /* Index of DRAGITEM     */
    610         free(ppDItem[Select]);
    611       }                                 // for
     679      for (ulSelect = 0; ulSelect < ulNumfiles; ulSelect++) {
     680        if (!DrgSetDragitem(pDInfo, ppDItem[ulSelect], sizeof(DRAGITEM), ulSelect)) {
     681          Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
     682                   "DrgSetDragitem");
     683        }
     684        free(ppDItem[ulSelect]);
     685      } // for
    612686#ifdef __DEBUG_ALLOC__
    613687      _heap_check();
    614688#endif
    615689      free(ppDItem);
    616       ppDItem = NULL;
     690      ppDItem = NULL;                   // Remember gone
    617691      DosPostEventSem(CompactSem);
    618692
    … …  
    621695
    622696      WinSetFocus(HWND_DESKTOP, HWND_DESKTOP);
    623       hDrop = DrgDrag(hwnd,             /* Initiate drag         */
    624                       pDInfo,           /* DRAGINFO structure    */
    625                       padiIcon, ulNumIcon, VK_ENDDRAG,  /* End of drag indicator */
    626                       (PVOID) NULL);    /* Reserved              */
    627       if (!DeleteDragitemStrHandles(pDInfo))
    628         Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
    629                   "DeleteDragistr");
    630       DrgDeleteDraginfoStrHandles (pDInfo);
    631       if (!DrgFreeDraginfo(pDInfo));            /* Free DRAGINFO struct  */
    632         Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
    633                   "DrgFreeDraginfo");
    634       xfree(padiIcon);
    635       padiIcon = NULL;
     697      hDrop = DrgDrag(hwnd,
     698                      pDInfo,
     699                      paDImgIcons,
     700                      ulNumIcon,
     701                      VK_ENDDRAG,       // Drag end button
     702                      (PVOID) NULL);
     703      if (hDrop == NULLHANDLE) {
     704        NumItemsToUnhilite = 0;
     705        FreeDragInfoData(hwnd, pDInfo);
     706      }
     707      xfree(paDImgIcons);
     708      paDImgIcons = NULL;               // Remember gone
    636709      WinSetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
    637710      DosPostEventSem(CompactSem);
    … …  
    640713  if (ppDItem)
    641714    free(ppDItem);
    642   if (padiIcon)
    643     free(padiIcon);
     715  if (paDImgIcons)
     716    free(paDImgIcons);
    644717  return hDrop;
    645718}
    646719
    647 #ifdef NEVER
     720#ifdef NEVER                            // fixme to be enabled someday?
    648721
    649722BOOL PickUp(HWND hwndCnr, HWND hwndObj, PCNRDRAGINIT pcd)
    … …  
    655728  ULONG cditem = 0;
    656729  DRAGITEM ditem;
    657   DRAGIMAGE diFakeIcon;
     730  DRAGIMAGE dimgFakeIcon;
    658731  CHAR szDir[CCHMAXPATH], szFile[CCHMAXPATH], *p;
    659732
    … …  
    702775        ditem.hstrContainerName = DrgAddStrHandle(szDir);
    703776        ditem.hstrSourceName = DrgAddStrHandle(szFile);
    704         if (!ditem.hstrSourceName)
    705         Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
    706                  "DrgAddStrHandle");
     777        // fixme to check better if code ever enabled
     778        if (!ditem.hstrSourceName) {
     779          Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
     780                   "DrgAddStrHandle");
     781        }
    707782        ditem.hstrTargetName = DrgAddStrHandle(szFile);
    708783        ditem.fsControl = 0;
    … …  
    719794        if (IsRoot(pci->szFileName))
    720795          ditem.fsSupportedOps = DO_LINKABLE;
    721         memset(&diFakeIcon, 0, sizeof(DRAGIMAGE));
    722         diFakeIcon.hImage = pci->rc.hptrIcon;
    723         diFakeIcon.cb = sizeof(DRAGIMAGE);
    724         diFakeIcon.cptl = 0;
    725         diFakeIcon.fl = DRG_ICON;
    726         diFakeIcon.sizlStretch.cx = 32;
    727         diFakeIcon.sizlStretch.cy = 32;
    728         diFakeIcon.cxOffset = -16;
    729         diFakeIcon.cyOffset = 0;
     796        memset(&dimgFakeIcon, 0, sizeof(DRAGIMAGE));
     797        dimgFakeIcon.hImage = pci->rc.hptrIcon;
     798        dimgFakeIcon.cb = sizeof(DRAGIMAGE);
     799        dimgFakeIcon.cptl = 0;
     800        dimgFakeIcon.fl = DRG_ICON;
     801        dimgFakeIcon.sizlStretch.cx = 32;
     802        dimgFakeIcon.sizlStretch.cy = 32;
     803        dimgFakeIcon.cxOffset = -16;
     804        dimgFakeIcon.cyOffset = 0;
    730805        if (IsFullName(pci->szFileName) &&
    731806            (driveflags[toupper(*pci->szFileName) - 'A'] &
    … …  
    743818      pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
    744819                       MPFROMP(pci), MPFROMSHORT(CRA_SELECTED));
    745     }
     820    } // while
    746821    if (pdinfoCurrent)
    747       return DrgLazyDrag(hwndCnr, pdinfoCurrent, &diFakeIcon, 1, NULL);
     822      return DrgLazyDrag(hwndCnr, pdinfoCurrent, &dimgFakeIcon, 1, NULL);
    748823  }
    749824  return FALSE;
Note: See TracChangeset for help on using the changeset viewer.