Changeset 551 for trunk/dll/draglist.c


Ignore:
Timestamp:
Feb 28, 2007, 2:33:51 AM (19 years ago)
Author:
Gregg Young
Message:

Indentation cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/draglist.c

    r364 r551  
    2929#pragma alloc_text(DRAGLIST,DragOne,DoFileDrag,DragList,PickUp)
    3030
    31 HWND DragOne (HWND hwndCnr,HWND hwndObj,CHAR *filename,BOOL moveok) {
    32 
    33   DRAGITEM    DItem;
    34   HWND        hDrop = 0;
    35   DRAGIMAGE   fakeicon;
    36   PDRAGINFO   pDInfo;
     31HWND DragOne(HWND hwndCnr, HWND hwndObj, CHAR * filename, BOOL moveok)
     32{
     33
     34  DRAGITEM DItem;
     35  HWND hDrop = 0;
     36  DRAGIMAGE fakeicon;
     37  PDRAGINFO pDInfo;
    3738  FILESTATUS3 fs3;
    38   CHAR        szDir[CCHMAXPATH],szFile[CCHMAXPATH],*p;
    39 
    40   if(filename && *filename) {
    41     if((IsRoot(filename) && IsValidDrive(*filename)) ||
    42        !DosQueryPathInfo(filename,FIL_STANDARD,&fs3,sizeof(fs3))) {
    43       strcpy(szDir,filename);
     39  CHAR szDir[CCHMAXPATH], szFile[CCHMAXPATH], *p;
     40
     41  if (filename && *filename) {
     42    if ((IsRoot(filename) && IsValidDrive(*filename)) ||
     43        !DosQueryPathInfo(filename, FIL_STANDARD, &fs3, sizeof(fs3))) {
     44      strcpy(szDir, filename);
    4445      p = szDir;
    45       while(*p) {
    46         if(*p == '/')
    47           *p = '\\';
    48         p++;
    49       }
    50       p = strrchr(szDir,'\\');
    51       if(p) {
    52         *p = 0;
    53         p++;
    54         strcpy(szFile,p);
    55         strcat(szDir,"\\");
     46      while (*p) {
     47        if (*p == '/')
     48          *p = '\\';
     49        p++;
     50      }
     51      p = strrchr(szDir, '\\');
     52      if (p) {
     53        *p = 0;
     54        p++;
     55        strcpy(szFile, p);
     56        strcat(szDir, "\\");
    5657      }
    5758      else {
    58         strcpy(szFile,filename);
    59         *szDir = 0;
    60       }
    61       memset(&fakeicon,0,sizeof(DRAGIMAGE));
     59        strcpy(szFile, filename);
     60        *szDir = 0;
     61      }
     62      memset(&fakeicon, 0, sizeof(DRAGIMAGE));
    6263      fakeicon.hImage = (IsRoot(filename) ||
    63                         (fs3.attrFile & FILE_DIRECTORY) != 0) ?
    64                           hptrDir : hptrFile;
    65       memset(&DItem,0,sizeof(DRAGITEM));
    66       DItem.hwndItem = (hwndObj) ? hwndObj : hwndCnr; /* Initialize DRAGITEM */
     64                        (fs3.attrFile & FILE_DIRECTORY) != 0) ?
     65        hptrDir : hptrFile;
     66      memset(&DItem, 0, sizeof(DRAGITEM));
     67      DItem.hwndItem = (hwndObj) ? hwndObj : hwndCnr;   /* Initialize DRAGITEM */
    6768      // DItem.hwndItem = hwndCnr;
    6869      DItem.ulItemID = 1;
    6970      DItem.hstrType = DrgAddStrHandle(DRT_UNKNOWN);
    70       DItem.hstrRMF =
    71          DrgAddStrHandle(DRMDRFLIST);
     71      DItem.hstrRMF = DrgAddStrHandle(DRMDRFLIST);
    7272      DItem.hstrContainerName = DrgAddStrHandle(szDir);
    7373      DItem.hstrSourceName = DrgAddStrHandle(szFile);
    7474      DItem.hstrTargetName = DrgAddStrHandle(szFile);
    7575      DItem.fsControl = 0;
    76       if(IsRoot(filename) || (fs3.attrFile & FILE_DIRECTORY) != 0)
    77         DItem.fsControl |= DC_CONTAINER;
    78       if(IsFullName(filename) &&
    79          (driveflags[toupper(*filename) - 'A'] & DRIVE_REMOVABLE))
    80         DItem.fsControl |= DC_REMOVEABLEMEDIA;
     76      if (IsRoot(filename) || (fs3.attrFile & FILE_DIRECTORY) != 0)
     77        DItem.fsControl |= DC_CONTAINER;
     78      if (IsFullName(filename) &&
     79          (driveflags[toupper(*filename) - 'A'] & DRIVE_REMOVABLE))
     80        DItem.fsControl |= DC_REMOVEABLEMEDIA;
    8181      DItem.fsSupportedOps = DO_COPYABLE | DO_LINKABLE;
    82       if(moveok && IsFullName(filename) &&
    83          !(driveflags[toupper(*filename) - 'A'] & DRIVE_NOTWRITEABLE))
    84         DItem.fsSupportedOps |= DO_MOVEABLE;
    85       if(IsRoot(filename))
    86         DItem.fsSupportedOps = DO_LINKABLE;
     82      if (moveok && IsFullName(filename) &&
     83          !(driveflags[toupper(*filename) - 'A'] & DRIVE_NOTWRITEABLE))
     84        DItem.fsSupportedOps |= DO_MOVEABLE;
     85      if (IsRoot(filename))
     86        DItem.fsSupportedOps = DO_LINKABLE;
    8787      fakeicon.cb = sizeof(DRAGIMAGE);
    8888      fakeicon.cptl = 0;
    … …  
    9292      fakeicon.cxOffset = -16;
    9393      fakeicon.cyOffset = 0;
    94       pDInfo = DrgAllocDraginfo(1);     /* Allocate DRAGINFO */
    95       if(pDInfo) {
    96         if(IsFullName(filename) &&
    97            (driveflags[toupper(*filename) - 'A'] & DRIVE_NOTWRITEABLE))
    98           pDInfo->usOperation = DO_COPY;
    99         else
    100           pDInfo->usOperation = DO_DEFAULT;
    101         if(IsRoot(filename))
    102           pDInfo->usOperation = DO_LINK;
    103         pDInfo->hwndSource = (hwndObj) ? hwndObj : hwndCnr;
    104         // pDInfo->hwndSource = hwndCnr;
    105         DrgSetDragitem(pDInfo,            /* Set item in DRAGINFO  */
    106                        &DItem,            /* Pointer to DRAGITEM   */
    107                        sizeof(DRAGITEM),  /* Size of DRAGITEM      */
    108                        0);                /* Index of DRAGITEM     */
    109         WinSetFocus(HWND_DESKTOP,HWND_DESKTOP);
    110         hDrop = DrgDrag(hwndCnr,              /* Initiate drag         */
    111                         pDInfo,               /* DRAGINFO structure    */
    112                         &fakeicon,
    113                         1L,
    114                         VK_ENDDRAG,           /* End of drag indicator */
    115                         (PVOID)NULL);         /* Reserved              */
    116 
    117         DrgFreeDraginfo(pDInfo);              /* Free DRAGINFO struct  */
    118         WinSetWindowPos(hwndCnr,HWND_TOP,0,0,0,0,SWP_ACTIVATE);
     94      pDInfo = DrgAllocDraginfo(1);     /* Allocate DRAGINFO */
     95      if (pDInfo) {
     96        if (IsFullName(filename) &&
     97            (driveflags[toupper(*filename) - 'A'] & DRIVE_NOTWRITEABLE))
     98          pDInfo->usOperation = DO_COPY;
     99        else
     100          pDInfo->usOperation = DO_DEFAULT;
     101        if (IsRoot(filename))
     102          pDInfo->usOperation = DO_LINK;
     103        pDInfo->hwndSource = (hwndObj) ? hwndObj : hwndCnr;
     104        // pDInfo->hwndSource = hwndCnr;
     105        DrgSetDragitem(pDInfo,          /* Set item in DRAGINFO  */
     106                       &DItem,          /* Pointer to DRAGITEM   */
     107                       sizeof(DRAGITEM),        /* Size of DRAGITEM      */
     108                       0);              /* Index of DRAGITEM     */
     109        WinSetFocus(HWND_DESKTOP, HWND_DESKTOP);
     110        hDrop = DrgDrag(hwndCnr,        /* Initiate drag         */
     111                        pDInfo,         /* DRAGINFO structure    */
     112                        &fakeicon, 1L, VK_ENDDRAG,      /* End of drag indicator */
     113                        (PVOID) NULL);  /* Reserved              */
     114
     115        DrgFreeDraginfo(pDInfo);        /* Free DRAGINFO struct  */
     116        WinSetWindowPos(hwndCnr, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
    119117      }
    120118    }
    … …  
    123121}
    124122
    125 
    126 HWND DoFileDrag (HWND hwndCnr,HWND hwndObj,PCNRDRAGINIT pcd,CHAR *arcfile,
    127                  CHAR *directory,BOOL moveok)
     123HWND DoFileDrag(HWND hwndCnr, HWND hwndObj, PCNRDRAGINIT pcd, CHAR * arcfile,
     124                CHAR * directory, BOOL moveok)
    128125{
    129126  /* drag files from a container */
    130127
    131   BOOL           isdir,rooting = FALSE;
    132   PCNRITEM       pci;
    133   register CHAR  *p;
    134   INT            attribute = CRA_CURSORED;
    135   PDRAGINFO      pDInfo = NULL;
    136   DRAGITEM       **ppDItem = NULL,**ppTest;
    137   PCNRITEM       pciRec = (PCNRITEM)pcd->pRecord;
    138   HWND           hDrop = 0;
    139   register ULONG ulNumfiles = 0L,numdragalloc = 0L,Select,ulNumIcon = 0;
    140   CHAR           szFile[CCHMAXPATH],szBuffer[CCHMAXPATH];
    141   DRAGIMAGE      *padiIcon = NULL,*padiTest,diFakeIcon;
    142 
    143   if(!pciRec && directory && *directory)
    144     return DragOne(hwndCnr,hwndObj,directory,moveok);
    145 
    146   if(!pciRec) {
    147     pci = (PCNRITEM)WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,
    148                                MPFROMLONG(CMA_FIRST),
    149                                MPFROMSHORT(attribute));
    150     if(pci && (INT)pci > -1) {
    151       if(pci->rc.flRecordAttr & CRA_SELECTED) {
    152         attribute = CRA_SELECTED;
    153         pci = WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,MPFROMLONG(CMA_FIRST),
    154                          MPFROMSHORT(attribute));
     128  BOOL isdir, rooting = FALSE;
     129  PCNRITEM pci;
     130  register CHAR *p;
     131  INT attribute = CRA_CURSORED;
     132  PDRAGINFO pDInfo = NULL;
     133  DRAGITEM **ppDItem = NULL, **ppTest;
     134  PCNRITEM pciRec = (PCNRITEM) pcd->pRecord;
     135  HWND hDrop = 0;
     136  register ULONG ulNumfiles = 0L, numdragalloc = 0L, Select, ulNumIcon = 0;
     137  CHAR szFile[CCHMAXPATH], szBuffer[CCHMAXPATH];
     138  DRAGIMAGE *padiIcon = NULL, *padiTest, diFakeIcon;
     139
     140  if (!pciRec && directory && *directory)
     141    return DragOne(hwndCnr, hwndObj, directory, moveok);
     142
     143  if (!pciRec) {
     144    pci = (PCNRITEM) WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
     145                                MPFROMLONG(CMA_FIRST),
     146                                MPFROMSHORT(attribute));
     147    if (pci && (INT) pci > -1) {
     148      if (pci->rc.flRecordAttr & CRA_SELECTED) {
     149        attribute = CRA_SELECTED;
     150        pci =
     151          WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
     152                     MPFROMSHORT(attribute));
    155153      }
    156154    }
    … …  
    159157    pci = pciRec;
    160158    attribute = (pci->rc.flRecordAttr & CRA_SELECTED) ? CRA_SELECTED : 0;
    161     if(attribute) {
    162       pci = WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,MPFROMLONG(CMA_FIRST),
    163                        MPFROMSHORT(attribute));
     159    if (attribute) {
     160      pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
     161                       MPFROMSHORT(attribute));
    164162    }
    165163  }
    166164
    167165  Select = 0L;
    168   while( pci && (INT)pci > -1) {
    169     if(!(pci->rc.flRecordAttr & CRA_FILTERED)) {
    170       if(IsRoot(pci->szFileName) && !IsValidDrive(*pci->szFileName))
    171         goto Continuing;
    172       if(!arcfile) {
    173         strcpy(szBuffer,pci->szFileName);
    174         p = strrchr(szBuffer,'\\');
    175         if(p) {
    176           p++;
    177           strcpy(szFile,p);
    178           *p = 0;
    179         }
    180         else
    181           goto Continuing;
     166  while (pci && (INT) pci > -1) {
     167    if (!(pci->rc.flRecordAttr & CRA_FILTERED)) {
     168      if (IsRoot(pci->szFileName) && !IsValidDrive(*pci->szFileName))
     169        goto Continuing;
     170      if (!arcfile) {
     171        strcpy(szBuffer, pci->szFileName);
     172        p = strrchr(szBuffer, '\\');
     173        if (p) {
     174          p++;
     175          strcpy(szFile, p);
     176          *p = 0;
     177        }
     178        else
     179          goto Continuing;
    182180      }
    183181      else
    184         strcpy(szFile,pci->szFileName);
    185     }
    186     if(!arcfile) {
     182        strcpy(szFile, pci->szFileName);
     183    }
     184    if (!arcfile) {
    187185      // Filesystem object
    188186      isdir = ((pci->attrFile & FILE_DIRECTORY) != 0);
    189       if(ulNumfiles + 2L > numdragalloc) {
    190         if (!padiIcon) {
    191           padiTest = xrealloc(padiIcon,sizeof(DRAGIMAGE) * (numdragalloc + 4L), pszSrcFile, __LINE__);
    192           if(padiTest)
    193             padiIcon = padiTest;
    194           else
    195             break;
    196         }
    197         else if(!ulNumIcon) {
    198           padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
    199           padiIcon[ulNumfiles].cptl = 0;
    200           padiIcon[ulNumfiles].hImage = hptrLast;
    201           padiIcon[ulNumfiles].fl = DRG_ICON;
    202           padiIcon[ulNumfiles].sizlStretch.cx = 32;
    203           padiIcon[ulNumfiles].sizlStretch.cy = 32;
    204           padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 4);
    205           padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 7);
    206           ulNumIcon = ulNumfiles + 1;
    207         }
    208         ppTest = xrealloc(ppDItem,sizeof(DRAGITEM *) * (numdragalloc + 4L), pszSrcFile, __LINE__);
    209         if (ppTest) {
    210           ppDItem = ppTest;
    211           numdragalloc += 4L;
    212         }
    213         else
    214           break;
     187      if (ulNumfiles + 2L > numdragalloc) {
     188        if (!padiIcon) {
     189          padiTest =
     190            xrealloc(padiIcon, sizeof(DRAGIMAGE) * (numdragalloc + 4L),
     191                     pszSrcFile, __LINE__);
     192          if (padiTest)
     193            padiIcon = padiTest;
     194          else
     195            break;
     196        }
     197        else if (!ulNumIcon) {
     198          padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
     199          padiIcon[ulNumfiles].cptl = 0;
     200          padiIcon[ulNumfiles].hImage = hptrLast;
     201          padiIcon[ulNumfiles].fl = DRG_ICON;
     202          padiIcon[ulNumfiles].sizlStretch.cx = 32;
     203          padiIcon[ulNumfiles].sizlStretch.cy = 32;
     204          padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 4);
     205          padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 7);
     206          ulNumIcon = ulNumfiles + 1;
     207        }
     208        ppTest =
     209          xrealloc(ppDItem, sizeof(DRAGITEM *) * (numdragalloc + 4L),
     210                   pszSrcFile, __LINE__);
     211        if (ppTest) {
     212          ppDItem = ppTest;
     213          numdragalloc += 4L;
     214        }
     215        else
     216          break;
    215217      }
    216218      ppDItem[ulNumfiles] = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
    217219      if (ppDItem[ulNumfiles]) {
    218         if (!ulNumIcon) {
    219           padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
    220           padiIcon[ulNumfiles].cptl = 0;
    221           padiIcon[ulNumfiles].hImage = pci->rc.hptrIcon;
    222           if(!padiIcon[ulNumfiles].hImage)
    223             padiIcon[ulNumfiles].hImage = (isdir) ? hptrDir : hptrFile;
    224           padiIcon[ulNumfiles].fl = DRG_ICON;
    225           padiIcon[ulNumfiles].sizlStretch.cx = 32;
    226           padiIcon[ulNumfiles].sizlStretch.cy = 32;
    227           padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 3);
    228           padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 6);
    229         }
    230         memset(ppDItem[ulNumfiles],0,sizeof(DRAGITEM));
    231         ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwndCnr; /* Initialize DRAGITEM   */
    232         ppDItem[ulNumfiles]->hwndItem = hwndCnr;
    233         ppDItem[ulNumfiles]->ulItemID = (ULONG)pci;
    234         ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
    235         ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFLIST);
    236         ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(szBuffer);
    237         ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
    238         ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
    239         ppDItem[ulNumfiles]->fsControl = (isdir) ? DC_CONTAINER : 0;
    240         if(IsFullName(pci->szFileName) &&
    241            (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE))
    242         ppDItem[ulNumfiles]->fsControl |= DC_REMOVEABLEMEDIA;
    243         ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE | DO_LINKABLE;
    244         if(moveok && IsFullName(pci->szFileName) &&
    245            !(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE))
    246         ppDItem[ulNumfiles]->fsSupportedOps |= DO_MOVEABLE;
    247         if(IsRoot(pci->szFileName)) {
    248           ppDItem[ulNumfiles]->fsSupportedOps = DO_LINKABLE;
    249           rooting = TRUE;
    250         }
    251         ulNumfiles++;
    252         ppDItem[ulNumfiles] = NULL;
     220        if (!ulNumIcon) {
     221          padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
     222          padiIcon[ulNumfiles].cptl = 0;
     223          padiIcon[ulNumfiles].hImage = pci->rc.hptrIcon;
     224          if (!padiIcon[ulNumfiles].hImage)
     225            padiIcon[ulNumfiles].hImage = (isdir) ? hptrDir : hptrFile;
     226          padiIcon[ulNumfiles].fl = DRG_ICON;
     227          padiIcon[ulNumfiles].sizlStretch.cx = 32;
     228          padiIcon[ulNumfiles].sizlStretch.cy = 32;
     229          padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 3);
     230          padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 6);
     231        }
     232        memset(ppDItem[ulNumfiles], 0, sizeof(DRAGITEM));
     233        ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwndCnr;  /* Initialize DRAGITEM   */
     234        ppDItem[ulNumfiles]->hwndItem = hwndCnr;
     235        ppDItem[ulNumfiles]->ulItemID = (ULONG) pci;
     236        ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
     237        ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFLIST);
     238        ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(szBuffer);
     239        ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
     240        ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
     241        ppDItem[ulNumfiles]->fsControl = (isdir) ? DC_CONTAINER : 0;
     242        if (IsFullName(pci->szFileName) &&
     243            (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE))
     244          ppDItem[ulNumfiles]->fsControl |= DC_REMOVEABLEMEDIA;
     245        ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE | DO_LINKABLE;
     246        if (moveok && IsFullName(pci->szFileName) &&
     247            !(driveflags[toupper(*pci->szFileName) - 'A'] &
     248              DRIVE_NOTWRITEABLE))
     249          ppDItem[ulNumfiles]->fsSupportedOps |= DO_MOVEABLE;
     250        if (IsRoot(pci->szFileName)) {
     251          ppDItem[ulNumfiles]->fsSupportedOps = DO_LINKABLE;
     252          rooting = TRUE;
     253        }
     254        ulNumfiles++;
     255        ppDItem[ulNumfiles] = NULL;
    253256      }
    254257      else
    255         break;
     258        break;
    256259    }
    257260    else {
    258261      // Archive object
    259       if(ulNumfiles + 3L > numdragalloc) {
    260         ppTest = xrealloc(ppDItem,sizeof(DRAGITEM *) * (numdragalloc + 5L), pszSrcFile, __LINE__);
    261         if (!ppTest)
    262           break;
     262      if (ulNumfiles + 3L > numdragalloc) {
     263        ppTest =
     264          xrealloc(ppDItem, sizeof(DRAGITEM *) * (numdragalloc + 5L),
     265                   pszSrcFile, __LINE__);
     266        if (!ppTest)
     267          break;
    263268        else {
    264           ppDItem = ppTest;
    265           numdragalloc += 5L;
    266         }
     269          ppDItem = ppTest;
     270          numdragalloc += 5L;
     271        }
    267272      }
    268273      ppDItem[ulNumfiles] = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
    269274      if (!ppDItem[ulNumfiles])
    270         break;
     275        break;
    271276      else {
    272         diFakeIcon.hImage = hptrFile;
    273         memset(ppDItem[ulNumfiles],0,sizeof(DRAGITEM));
    274         ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwndCnr; /* Initialize DRAGITEM   */
    275         ppDItem[ulNumfiles]->hwndItem = hwndCnr;
    276         ppDItem[ulNumfiles]->ulItemID = (ULONG)pci;
    277         ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
    278         ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFOS2FILE);
    279         ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(arcfile);
    280         ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
    281         ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
    282         ppDItem[ulNumfiles]->fsControl = DC_PREPARE;
    283         if(IsFullName(arcfile) &&
    284            (driveflags[toupper(*arcfile) - 'A'] & DRIVE_REMOVABLE))
    285           ppDItem[ulNumfiles]->fsControl |= DC_REMOVEABLEMEDIA;
    286         ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE;
    287         ulNumfiles++;
    288         ppDItem[ulNumfiles] = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
    289         if (ppDItem[ulNumfiles]) {
    290           diFakeIcon.hImage = hptrFile;
    291           memset(ppDItem[ulNumfiles],0,sizeof(DRAGITEM));
    292           ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwndCnr; /* Initialize DRAGITEM   */
    293           ppDItem[ulNumfiles]->hwndItem = hwndCnr;
    294           ppDItem[ulNumfiles]->ulItemID = Select++;
    295           ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
    296           ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFFM2ARC);
    297           ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(arcfile);
    298           ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
    299           ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
    300           ppDItem[ulNumfiles]->fsControl = 0;
    301           if(IsFullName(arcfile) &&
    302              (driveflags[toupper(*arcfile) - 'A'] & DRIVE_REMOVABLE))
    303             ppDItem[ulNumfiles]->fsControl |= DC_REMOVEABLEMEDIA;
    304           ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE;
    305           ulNumfiles++;
    306         }
    307         ppDItem[ulNumfiles] = NULL;
    308       }
    309     }
    310     WinSendMsg(hwndCnr,CM_SETRECORDEMPHASIS,MPFROMP(pci),
    311                MPFROM2SHORT(TRUE,CRA_SOURCE));
    312 
    313 Continuing:
    314 
    315     if(!attribute)
     277        diFakeIcon.hImage = hptrFile;
     278        memset(ppDItem[ulNumfiles], 0, sizeof(DRAGITEM));
     279        ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwndCnr;  /* Initialize DRAGITEM   */
     280        ppDItem[ulNumfiles]->hwndItem = hwndCnr;
     281        ppDItem[ulNumfiles]->ulItemID = (ULONG) pci;
     282        ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
     283        ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFOS2FILE);
     284        ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(arcfile);
     285        ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
     286        ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
     287        ppDItem[ulNumfiles]->fsControl = DC_PREPARE;
     288        if (IsFullName(arcfile) &&
     289            (driveflags[toupper(*arcfile) - 'A'] & DRIVE_REMOVABLE))
     290          ppDItem[ulNumfiles]->fsControl |= DC_REMOVEABLEMEDIA;
     291        ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE;
     292        ulNumfiles++;
     293        ppDItem[ulNumfiles] = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
     294        if (ppDItem[ulNumfiles]) {
     295          diFakeIcon.hImage = hptrFile;
     296          memset(ppDItem[ulNumfiles], 0, sizeof(DRAGITEM));
     297          ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwndCnr;        /* Initialize DRAGITEM   */
     298          ppDItem[ulNumfiles]->hwndItem = hwndCnr;
     299          ppDItem[ulNumfiles]->ulItemID = Select++;
     300          ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
     301          ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFFM2ARC);
     302          ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(arcfile);
     303          ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
     304          ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
     305          ppDItem[ulNumfiles]->fsControl = 0;
     306          if (IsFullName(arcfile) &&
     307              (driveflags[toupper(*arcfile) - 'A'] & DRIVE_REMOVABLE))
     308            ppDItem[ulNumfiles]->fsControl |= DC_REMOVEABLEMEDIA;
     309          ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE;
     310          ulNumfiles++;
     311        }
     312        ppDItem[ulNumfiles] = NULL;
     313      }
     314    }
     315    WinSendMsg(hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     316               MPFROM2SHORT(TRUE, CRA_SOURCE));
     317
     318  Continuing:
     319
     320    if (!attribute)
    316321      break;
    317     pci = WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,MPFROMP(pci),
    318                      MPFROMSHORT(attribute));
    319   } // while
    320 
    321   if(ulNumfiles) {
    322     pDInfo = DrgAllocDraginfo(ulNumfiles);  /* Allocate DRAGINFO */
    323     if(pDInfo) {
    324       if((arcfile && *arcfile) || (IsFullName(szBuffer) &&
    325          (driveflags[toupper(*szBuffer) - 'A'] & DRIVE_NOTWRITEABLE)))
    326         pDInfo->usOperation = DO_COPY;
     322    pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMP(pci),
     323                     MPFROMSHORT(attribute));
     324  }                                     // while
     325
     326  if (ulNumfiles) {
     327    pDInfo = DrgAllocDraginfo(ulNumfiles);      /* Allocate DRAGINFO */
     328    if (pDInfo) {
     329      if ((arcfile && *arcfile) || (IsFullName(szBuffer) &&
     330                                    (driveflags[toupper(*szBuffer) - 'A'] &
     331                                     DRIVE_NOTWRITEABLE)))
     332        pDInfo->usOperation = DO_COPY;
    327333      else
    328         pDInfo->usOperation = DO_DEFAULT;
    329       if((!arcfile || !*arcfile) && rooting)
    330         pDInfo->usOperation = DO_LINK;
     334        pDInfo->usOperation = DO_DEFAULT;
     335      if ((!arcfile || !*arcfile) && rooting)
     336        pDInfo->usOperation = DO_LINK;
    331337      pDInfo->hwndSource = (hwndObj) ? hwndObj : hwndCnr;
    332338      // pDInfo->hwndSource = hwndCnr;
    333       for(Select = 0L;Select < ulNumfiles;Select++) {
    334         DrgSetDragitem(pDInfo,                  /* Set item in DRAGINFO  */
    335                        ppDItem[Select],         /* Pointer to DRAGITEM   */
    336                        sizeof(DRAGITEM),        /* Size of DRAGITEM      */
    337                        Select);                 /* Index of DRAGITEM     */
    338         free(ppDItem[Select]);
     339      for (Select = 0L; Select < ulNumfiles; Select++) {
     340        DrgSetDragitem(pDInfo,          /* Set item in DRAGINFO  */
     341                       ppDItem[Select], /* Pointer to DRAGITEM   */
     342                       sizeof(DRAGITEM),        /* Size of DRAGITEM      */
     343                       Select);         /* Index of DRAGITEM     */
     344        free(ppDItem[Select]);
    339345      }
    340346#ifdef __DEBUG_ALLOC__
    … …  
    345351      DosPostEventSem(CompactSem);
    346352
    347       if(arcfile) {
    348         diFakeIcon.cb = sizeof(DRAGIMAGE);
    349         diFakeIcon.cptl = 0;
    350         if(ulNumfiles > 1)
    351           diFakeIcon.hImage = hptrFile;
    352         diFakeIcon.fl = DRG_ICON;
    353         diFakeIcon.sizlStretch.cx = 32;
    354         diFakeIcon.sizlStretch.cy = 32;
    355         diFakeIcon.cxOffset = -16;
    356         diFakeIcon.cyOffset = 0;
    357         padiIcon = &diFakeIcon;
    358       }
    359       if(!arcfile) {
    360         if(!ulNumIcon)
    361           ulNumIcon = ulNumfiles;
     353      if (arcfile) {
     354        diFakeIcon.cb = sizeof(DRAGIMAGE);
     355        diFakeIcon.cptl = 0;
     356        if (ulNumfiles > 1)
     357          diFakeIcon.hImage = hptrFile;
     358        diFakeIcon.fl = DRG_ICON;
     359        diFakeIcon.sizlStretch.cx = 32;
     360        diFakeIcon.sizlStretch.cy = 32;
     361        diFakeIcon.cxOffset = -16;
     362        diFakeIcon.cyOffset = 0;
     363        padiIcon = &diFakeIcon;
     364      }
     365      if (!arcfile) {
     366        if (!ulNumIcon)
     367          ulNumIcon = ulNumfiles;
    362368      }
    363369      else
    364         ulNumIcon = 1L;
    365 
    366       WinSetFocus(HWND_DESKTOP,HWND_DESKTOP);
    367       hDrop = DrgDrag(hwndCnr,              /* Initiate drag         */
    368                       pDInfo,               /* DRAGINFO structure    */
    369                       padiIcon,
    370                       ulNumIcon,
    371                       VK_ENDDRAG,           /* End of drag indicator */
    372                       (PVOID)NULL);         /* Reserved              */
    373 
    374       DrgFreeDraginfo(pDInfo);              /* Free DRAGINFO struct  */
    375       if(padiIcon && padiIcon != &diFakeIcon)
    376         free(padiIcon);
     370        ulNumIcon = 1L;
     371
     372      WinSetFocus(HWND_DESKTOP, HWND_DESKTOP);
     373      hDrop = DrgDrag(hwndCnr,          /* Initiate drag         */
     374                      pDInfo,           /* DRAGINFO structure    */
     375                      padiIcon, ulNumIcon, VK_ENDDRAG,  /* End of drag indicator */
     376                      (PVOID) NULL);    /* Reserved              */
     377
     378      DrgFreeDraginfo(pDInfo);          /* Free DRAGINFO struct  */
     379      if (padiIcon && padiIcon != &diFakeIcon)
     380        free(padiIcon);
    377381      padiIcon = NULL;
    378       WinSetWindowPos(hwndCnr,HWND_TOP,0,0,0,0,SWP_ACTIVATE);
     382      WinSetWindowPos(hwndCnr, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
    379383      DosPostEventSem(CompactSem);
    380384    }
    381385  }
    382   if(ppDItem)
     386  if (ppDItem)
    383387    free(ppDItem);
    384   if(padiIcon && padiIcon != &diFakeIcon)
     388  if (padiIcon && padiIcon != &diFakeIcon)
    385389    free(padiIcon);
    386   MarkAll(hwndCnr,TRUE,FALSE,TRUE);
     390  MarkAll(hwndCnr, TRUE, FALSE, TRUE);
    387391  return hDrop;
    388392}
    389393
    390 
    391 HWND DragList (HWND hwnd,HWND hwndObj,CHAR **list,BOOL moveok) {
     394HWND DragList(HWND hwnd, HWND hwndObj, CHAR ** list, BOOL moveok)
     395{
    392396
    393397  /* drag a linked list of files */
    394398
    395   BOOL           isdir;
    396   register CHAR  *p;
    397   PDRAGINFO      pDInfo = NULL;
    398   DRAGITEM       **ppDItem = NULL,**ppTest;
    399   HWND           hDrop = (HWND)0;
    400   register ULONG ulNumfiles = 0L,numdragalloc = 0L,Select,ulNumIcon = 0;
    401   CHAR           szFile[CCHMAXPATH],szBuffer[CCHMAXPATH];
    402   DRAGIMAGE      *padiIcon = NULL,*padiTest;
    403   FILESTATUS3    fs3;
    404 
    405   if(!list || !list[0])
     399  BOOL isdir;
     400  register CHAR *p;
     401  PDRAGINFO pDInfo = NULL;
     402  DRAGITEM **ppDItem = NULL, **ppTest;
     403  HWND hDrop = (HWND) 0;
     404  register ULONG ulNumfiles = 0L, numdragalloc = 0L, Select, ulNumIcon = 0;
     405  CHAR szFile[CCHMAXPATH], szBuffer[CCHMAXPATH];
     406  DRAGIMAGE *padiIcon = NULL, *padiTest;
     407  FILESTATUS3 fs3;
     408
     409  if (!list || !list[0])
    406410    return hDrop;
    407   for(Select = 0;list[Select];Select++) {
    408     if((!IsRoot(list[Select]) || !IsValidDrive(*list[Select])) &&
    409        DosQueryPathInfo(list[Select],FIL_STANDARD,&fs3,sizeof(fs3)))
     411  for (Select = 0; list[Select]; Select++) {
     412    if ((!IsRoot(list[Select]) || !IsValidDrive(*list[Select])) &&
     413        DosQueryPathInfo(list[Select], FIL_STANDARD, &fs3, sizeof(fs3)))
    410414      continue;
    411     strcpy(szBuffer,list[Select]);
    412     p = strrchr(szBuffer,'\\');
    413     if(p) {
     415    strcpy(szBuffer, list[Select]);
     416    p = strrchr(szBuffer, '\\');
     417    if (p) {
    414418      p++;
    415       strcpy(szFile,p);
     419      strcpy(szFile, p);
    416420      *p = 0;
    417421    }
    418422    else
    419423      continue;
    420     if(*szFile) {
     424    if (*szFile) {
    421425      isdir = (IsRoot(list[Select])) ? TRUE :
    422                ((fs3.attrFile & FILE_DIRECTORY) != 0);
    423       if(ulNumfiles + 2L > numdragalloc) {
    424         if (!padiIcon) {
    425           padiTest = xrealloc(padiIcon,sizeof(DRAGIMAGE) * (numdragalloc + 4L), pszSrcFile, __LINE__);
    426           if (!padiTest)
    427             break;
    428           else
    429             padiIcon = padiTest;
    430         }
    431         else if(!ulNumIcon) {
    432           padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
    433           padiIcon[ulNumfiles].cptl = 0;
    434           padiIcon[ulNumfiles].hImage = hptrLast;
    435           padiIcon[ulNumfiles].fl = DRG_ICON;
    436           padiIcon[ulNumfiles].sizlStretch.cx = 32;
    437           padiIcon[ulNumfiles].sizlStretch.cy = 32;
    438           padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 4);
    439           padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 7);
    440           ulNumIcon = ulNumfiles + 1;
    441         }
    442         ppTest = xrealloc(ppDItem,sizeof(DRAGITEM *) * (numdragalloc + 4L), pszSrcFile, __LINE__);
    443         if (!ppTest)
    444           break;
    445         else {
    446           ppDItem = ppTest;
    447           numdragalloc += 4L;
    448         }
     426        ((fs3.attrFile & FILE_DIRECTORY) != 0);
     427      if (ulNumfiles + 2L > numdragalloc) {
     428        if (!padiIcon) {
     429          padiTest =
     430            xrealloc(padiIcon, sizeof(DRAGIMAGE) * (numdragalloc + 4L),
     431                     pszSrcFile, __LINE__);
     432          if (!padiTest)
     433            break;
     434          else
     435            padiIcon = padiTest;
     436        }
     437        else if (!ulNumIcon) {
     438          padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
     439          padiIcon[ulNumfiles].cptl = 0;
     440          padiIcon[ulNumfiles].hImage = hptrLast;
     441          padiIcon[ulNumfiles].fl = DRG_ICON;
     442          padiIcon[ulNumfiles].sizlStretch.cx = 32;
     443          padiIcon[ulNumfiles].sizlStretch.cy = 32;
     444          padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 4);
     445          padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 7);
     446          ulNumIcon = ulNumfiles + 1;
     447        }
     448        ppTest =
     449          xrealloc(ppDItem, sizeof(DRAGITEM *) * (numdragalloc + 4L),
     450                   pszSrcFile, __LINE__);
     451        if (!ppTest)
     452          break;
     453        else {
     454          ppDItem = ppTest;
     455          numdragalloc += 4L;
     456        }
    449457      }
    450458      ppDItem[ulNumfiles] = xmalloc(sizeof(DRAGITEM), pszSrcFile, __LINE__);
    451459      if (!ppDItem[ulNumfiles])
    452         break;
     460        break;
    453461      else {
    454         if(!ulNumIcon) {
    455           padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
    456           padiIcon[ulNumfiles].cptl = 0;
    457           padiIcon[ulNumfiles].hImage = (isdir) ? hptrDir : hptrFile;
    458           padiIcon[ulNumfiles].fl = DRG_ICON;
    459           padiIcon[ulNumfiles].sizlStretch.cx = 32;
    460           padiIcon[ulNumfiles].sizlStretch.cy = 32;
    461           padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 3);
    462           padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 6);
    463         }
    464         memset(ppDItem[ulNumfiles],0,sizeof(DRAGITEM));
    465         ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwnd; /* Initialize DRAGITEM */
    466         // ppDItem[ulNumfiles]->hwndItem = hwnd;
    467         ppDItem[ulNumfiles]->ulItemID = (ULONG)Select;
    468         ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
    469         ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFLIST);
    470         ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(szBuffer);
    471         ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
    472         ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
    473         ppDItem[ulNumfiles]->fsControl = (isdir) ? DC_CONTAINER : 0;
    474         if(IsFullName(list[Select]) &&
    475            (driveflags[toupper(*list[Select]) - 'A'] & DRIVE_REMOVABLE))
    476           ppDItem[ulNumfiles]->fsControl |= DC_REMOVEABLEMEDIA;
    477         ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE | DO_LINKABLE;
    478         if(moveok && IsFullName(list[Select]) &&
    479            !(driveflags[toupper(*list[Select]) - 'A'] & DRIVE_NOTWRITEABLE))
    480           ppDItem[ulNumfiles]->fsSupportedOps |= DO_MOVEABLE;
    481         if(IsRoot(list[Select]))
    482           ppDItem[ulNumfiles]->fsControl = DO_LINKABLE;
    483         ulNumfiles++;
    484         ppDItem[ulNumfiles] = NULL;
    485       }
    486     }
    487   } // for
     462        if (!ulNumIcon) {
     463          padiIcon[ulNumfiles].cb = sizeof(DRAGIMAGE);
     464          padiIcon[ulNumfiles].cptl = 0;
     465          padiIcon[ulNumfiles].hImage = (isdir) ? hptrDir : hptrFile;
     466          padiIcon[ulNumfiles].fl = DRG_ICON;
     467          padiIcon[ulNumfiles].sizlStretch.cx = 32;
     468          padiIcon[ulNumfiles].sizlStretch.cy = 32;
     469          padiIcon[ulNumfiles].cxOffset = -16 + (ulNumfiles * 3);
     470          padiIcon[ulNumfiles].cyOffset = 0 + (ulNumfiles * 6);
     471        }
     472        memset(ppDItem[ulNumfiles], 0, sizeof(DRAGITEM));
     473        ppDItem[ulNumfiles]->hwndItem = (hwndObj) ? hwndObj : hwnd;     /* Initialize DRAGITEM */
     474        // ppDItem[ulNumfiles]->hwndItem = hwnd;
     475        ppDItem[ulNumfiles]->ulItemID = (ULONG) Select;
     476        ppDItem[ulNumfiles]->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
     477        ppDItem[ulNumfiles]->hstrRMF = DrgAddStrHandle(DRMDRFLIST);
     478        ppDItem[ulNumfiles]->hstrContainerName = DrgAddStrHandle(szBuffer);
     479        ppDItem[ulNumfiles]->hstrSourceName = DrgAddStrHandle(szFile);
     480        ppDItem[ulNumfiles]->hstrTargetName = DrgAddStrHandle(szFile);
     481        ppDItem[ulNumfiles]->fsControl = (isdir) ? DC_CONTAINER : 0;
     482        if (IsFullName(list[Select]) &&
     483            (driveflags[toupper(*list[Select]) - 'A'] & DRIVE_REMOVABLE))
     484          ppDItem[ulNumfiles]->fsControl |= DC_REMOVEABLEMEDIA;
     485        ppDItem[ulNumfiles]->fsSupportedOps = DO_COPYABLE | DO_LINKABLE;
     486        if (moveok && IsFullName(list[Select]) &&
     487            !(driveflags[toupper(*list[Select]) - 'A'] & DRIVE_NOTWRITEABLE))
     488          ppDItem[ulNumfiles]->fsSupportedOps |= DO_MOVEABLE;
     489        if (IsRoot(list[Select]))
     490          ppDItem[ulNumfiles]->fsControl = DO_LINKABLE;
     491        ulNumfiles++;
     492        ppDItem[ulNumfiles] = NULL;
     493      }
     494    }
     495  }                                     // for
    488496
    489497  if (ulNumfiles) {
    490     pDInfo = DrgAllocDraginfo(ulNumfiles);  /* Allocate DRAGINFO */
     498    pDInfo = DrgAllocDraginfo(ulNumfiles);      /* Allocate DRAGINFO */
    491499    if (pDInfo) {
    492500      if ((IsFullName(szBuffer) &&
    493           (driveflags[toupper(*szBuffer) - 'A'] & DRIVE_NOTWRITEABLE)))
    494         pDInfo->usOperation = DO_COPY;
     501           (driveflags[toupper(*szBuffer) - 'A'] & DRIVE_NOTWRITEABLE)))
     502        pDInfo->usOperation = DO_COPY;
    495503      else
    496         pDInfo->usOperation = DO_DEFAULT;
     504        pDInfo->usOperation = DO_DEFAULT;
    497505      if (IsRoot(list[0]))
    498         pDInfo->usOperation = DO_LINK;
     506        pDInfo->usOperation = DO_LINK;
    499507      pDInfo->hwndSource = (hwndObj) ? hwndObj : hwnd;
    500508      // pDInfo->hwndSource = hwnd;
    501       for (Select = 0L;Select < ulNumfiles;Select++) {
    502         DrgSetDragitem(pDInfo,            /* Set item in DRAGINFO  */
    503                        ppDItem[Select],     /* Pointer to DRAGITEM   */
    504                        sizeof(DRAGITEM),  /* Size of DRAGITEM      */
    505                        Select);           /* Index of DRAGITEM     */
    506         free(ppDItem[Select]);
    507       } // for
     509      for (Select = 0L; Select < ulNumfiles; Select++) {
     510        DrgSetDragitem(pDInfo,          /* Set item in DRAGINFO  */
     511                       ppDItem[Select], /* Pointer to DRAGITEM   */
     512                       sizeof(DRAGITEM),        /* Size of DRAGITEM      */
     513                       Select);         /* Index of DRAGITEM     */
     514        free(ppDItem[Select]);
     515      }                                 // for
    508516#ifdef __DEBUG_ALLOC__
    509517      _heap_check();
    … …  
    513521      DosPostEventSem(CompactSem);
    514522
    515       if(!ulNumIcon)
    516         ulNumIcon = ulNumfiles;
    517 
    518       WinSetFocus(HWND_DESKTOP,HWND_DESKTOP);
    519       hDrop = DrgDrag(hwnd,                 /* Initiate drag         */
    520                       pDInfo,               /* DRAGINFO structure    */
    521                       padiIcon,
    522                       ulNumIcon,
    523                       VK_ENDDRAG,           /* End of drag indicator */
    524                       (PVOID)NULL);         /* Reserved              */
    525 
    526       DrgFreeDraginfo(pDInfo);              /* Free DRAGINFO struct  */
     523      if (!ulNumIcon)
     524        ulNumIcon = ulNumfiles;
     525
     526      WinSetFocus(HWND_DESKTOP, HWND_DESKTOP);
     527      hDrop = DrgDrag(hwnd,             /* Initiate drag         */
     528                      pDInfo,           /* DRAGINFO structure    */
     529                      padiIcon, ulNumIcon, VK_ENDDRAG,  /* End of drag indicator */
     530                      (PVOID) NULL);    /* Reserved              */
     531
     532      DrgFreeDraginfo(pDInfo);          /* Free DRAGINFO struct  */
    527533      free(padiIcon);
    528534      padiIcon = NULL;
    529       WinSetWindowPos(hwnd,HWND_TOP,0,0,0,0,SWP_ACTIVATE);
     535      WinSetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
    530536      DosPostEventSem(CompactSem);
    531537    }
    532538  }
    533   if(ppDItem)
     539  if (ppDItem)
    534540    free(ppDItem);
    535   if(padiIcon)
     541  if (padiIcon)
    536542    free(padiIcon);
    537543  return hDrop;
    538544}
    539545
    540 
    541546#ifdef NEVER
    542547
    543 BOOL PickUp (HWND hwndCnr,HWND hwndObj,PCNRDRAGINIT pcd) {
    544 
    545   PCNRITEM  pci;
    546   BOOL      loop = TRUE;
    547   PDRAGINFO pdinfoOld = NULL,pdinfoCurrent = NULL;
    548   ULONG     cditem = 0;
    549   DRAGITEM  ditem;
     548BOOL PickUp(HWND hwndCnr, HWND hwndObj, PCNRDRAGINIT pcd)
     549{
     550
     551  PCNRITEM pci;
     552  BOOL loop = TRUE;
     553  PDRAGINFO pdinfoOld = NULL, pdinfoCurrent = NULL;
     554  ULONG cditem = 0;
     555  DRAGITEM ditem;
    550556  DRAGIMAGE diFakeIcon;
    551   CHAR      szDir[CCHMAXPATH],szFile[CCHMAXPATH],*p;
    552 
    553   pci = (PCNRITEM)pcd->pRecord;
    554   if(pci && (INT)pci != -1) {
    555     if(pci->rc.flRecordAttr & CRA_SELECTED) {
     557  CHAR szDir[CCHMAXPATH], szFile[CCHMAXPATH], *p;
     558
     559  pci = (PCNRITEM) pcd->pRecord;
     560  if (pci && (INT) pci != -1) {
     561    if (pci->rc.flRecordAttr & CRA_SELECTED) {
    556562      loop = TRUE;
    557       pci = WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,
    558                        MPFROMLONG(CMA_FIRST),MPFROMSHORT(CRA_SELECTED));
    559     }
    560     while(pci && (INT)pci != -1 && *pci->szFileName) {
    561       if(pdinfoOld || DrgQueryDragStatus() & DGS_LAZYDRAGINPROGRESS) {
    562         if(!pdinfoOld)
    563           pdinfoOld = DrgQueryDraginfoPtr(NULL);
    564         if(pdinfoOld) {
    565           cditem = pdinfoOld->cditem + 1;
    566           pdinfoCurrent = DrgReallocDraginfo(pdinfoOld,cditem);
    567           pdinfoOld = pdinfoCurrent;
    568         }
     563      pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
     564                       MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_SELECTED));
     565    }
     566    while (pci && (INT) pci != -1 && *pci->szFileName) {
     567      if (pdinfoOld || DrgQueryDragStatus() & DGS_LAZYDRAGINPROGRESS) {
     568        if (!pdinfoOld)
     569          pdinfoOld = DrgQueryDraginfoPtr(NULL);
     570        if (pdinfoOld) {
     571          cditem = pdinfoOld->cditem + 1;
     572          pdinfoCurrent = DrgReallocDraginfo(pdinfoOld, cditem);
     573          pdinfoOld = pdinfoCurrent;
     574        }
    569575      }
    570576      else
    571         pdinfoCurrent = pdinfoOld = DrgAllocDraginfo(1);
    572       if(pdinfoCurrent) {
    573         strcpy(szDir,pci->szFileName);
    574         p = szDir;
    575         while(*p) {
    576           if(*p == '/')
    577             *p = '\\';
    578           p++;
    579         }
    580         p = strrchr(szDir,'\\');
    581         if(p) {
    582           *p = 0;
    583           p++;
    584           strcpy(szFile,p);
    585           strcat(szDir,"\\");
    586         }
    587         else {
    588           strcpy(szFile,pci->szFileName);
    589           *szDir = 0;
    590         }
    591         ditem.ulItemID = (ULONG)pci;
    592         ditem.hwndItem = (hwndObj) ? hwndObj : hwndCnr;
    593         ditem.hstrType = DrgAddStrHandle(DRT_UNKNOWN);
    594         ditem.hstrRMF =
    595            DrgAddStrHandle(DRMDRFLIST);
    596         ditem.hstrContainerName = DrgAddStrHandle(szDir);
    597         ditem.hstrSourceName = DrgAddStrHandle(szFile);
    598         ditem.hstrTargetName = DrgAddStrHandle(szFile);
    599         ditem.fsControl = 0;
    600         if(IsRoot(pci->szFileName) || (pci->attrFile & FILE_DIRECTORY) != 0)
    601           ditem.fsControl |= DC_CONTAINER;
    602         if(IsFullName(pci->szFileName) &&
    603            (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE))
    604           ditem.fsControl |= DC_REMOVEABLEMEDIA;
    605         ditem.fsSupportedOps = DO_COPYABLE | DO_LINKABLE;
    606         if(IsFullName(pci->szFileName) &&
    607            !(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE))
    608           ditem.fsSupportedOps |= DO_MOVEABLE;
    609         if(IsRoot(pci->szFileName))
    610           ditem.fsSupportedOps = DO_LINKABLE;
    611         memset(&diFakeIcon,0,sizeof(DRAGIMAGE));
    612         diFakeIcon.hImage = pci->rc.hptrIcon;
    613         diFakeIcon.cb = sizeof(DRAGIMAGE);
    614         diFakeIcon.cptl = 0;
    615         diFakeIcon.fl = DRG_ICON;
    616         diFakeIcon.sizlStretch.cx = 32;
    617         diFakeIcon.sizlStretch.cy = 32;
    618         diFakeIcon.cxOffset = -16;
    619         diFakeIcon.cyOffset = 0;
    620         if(IsFullName(pci->szFileName) &&
    621            (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE))
    622           pdinfoCurrent->usOperation = DO_COPY;
    623         else
    624           pdinfoCurrent->usOperation = DO_DEFAULT;
    625         if(IsRoot(pci->szFileName))
    626           pdinfoCurrent->usOperation = DO_LINK;
    627         pdinfoCurrent->hwndSource = (hwndObj) ? hwndObj : hwndCnr;
    628         DrgSetDragitem(pdinfoCurrent,
    629                        &ditem,
    630                        sizeof(DRAGITEM),
    631                        cditem);
    632       }
    633       if(!loop)
    634         break;
    635       pci = WinSendMsg(hwndCnr,CM_QUERYRECORDEMPHASIS,
    636                        MPFROMP(pci),MPFROMSHORT(CRA_SELECTED));
    637     }
    638     if(pdinfoCurrent)
    639       return DrgLazyDrag(hwndCnr,pdinfoCurrent,&diFakeIcon,1,NULL);
     577        pdinfoCurrent = pdinfoOld = DrgAllocDraginfo(1);
     578      if (pdinfoCurrent) {
     579        strcpy(szDir, pci->szFileName);
     580        p = szDir;
     581        while (*p) {
     582          if (*p == '/')
     583            *p = '\\';
     584          p++;
     585        }
     586        p = strrchr(szDir, '\\');
     587        if (p) {
     588          *p = 0;
     589          p++;
     590          strcpy(szFile, p);
     591          strcat(szDir, "\\");
     592        }
     593        else {
     594          strcpy(szFile, pci->szFileName);
     595          *szDir = 0;
     596        }
     597        ditem.ulItemID = (ULONG) pci;
     598        ditem.hwndItem = (hwndObj) ? hwndObj : hwndCnr;
     599        ditem.hstrType = DrgAddStrHandle(DRT_UNKNOWN);
     600        ditem.hstrRMF = DrgAddStrHandle(DRMDRFLIST);
     601        ditem.hstrContainerName = DrgAddStrHandle(szDir);
     602        ditem.hstrSourceName = DrgAddStrHandle(szFile);
     603        ditem.hstrTargetName = DrgAddStrHandle(szFile);
     604        ditem.fsControl = 0;
     605        if (IsRoot(pci->szFileName) || (pci->attrFile & FILE_DIRECTORY) != 0)
     606          ditem.fsControl |= DC_CONTAINER;
     607        if (IsFullName(pci->szFileName) &&
     608            (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE))
     609          ditem.fsControl |= DC_REMOVEABLEMEDIA;
     610        ditem.fsSupportedOps = DO_COPYABLE | DO_LINKABLE;
     611        if (IsFullName(pci->szFileName) &&
     612            !(driveflags[toupper(*pci->szFileName) - 'A'] &
     613              DRIVE_NOTWRITEABLE))
     614          ditem.fsSupportedOps |= DO_MOVEABLE;
     615        if (IsRoot(pci->szFileName))
     616          ditem.fsSupportedOps = DO_LINKABLE;
     617        memset(&diFakeIcon, 0, sizeof(DRAGIMAGE));
     618        diFakeIcon.hImage = pci->rc.hptrIcon;
     619        diFakeIcon.cb = sizeof(DRAGIMAGE);
     620        diFakeIcon.cptl = 0;
     621        diFakeIcon.fl = DRG_ICON;
     622        diFakeIcon.sizlStretch.cx = 32;
     623        diFakeIcon.sizlStretch.cy = 32;
     624        diFakeIcon.cxOffset = -16;
     625        diFakeIcon.cyOffset = 0;
     626        if (IsFullName(pci->szFileName) &&
     627            (driveflags[toupper(*pci->szFileName) - 'A'] &
     628             DRIVE_NOTWRITEABLE))
     629          pdinfoCurrent->usOperation = DO_COPY;
     630        else
     631          pdinfoCurrent->usOperation = DO_DEFAULT;
     632        if (IsRoot(pci->szFileName))
     633          pdinfoCurrent->usOperation = DO_LINK;
     634        pdinfoCurrent->hwndSource = (hwndObj) ? hwndObj : hwndCnr;
     635        DrgSetDragitem(pdinfoCurrent, &ditem, sizeof(DRAGITEM), cditem);
     636      }
     637      if (!loop)
     638        break;
     639      pci = WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
     640                       MPFROMP(pci), MPFROMSHORT(CRA_SELECTED));
     641    }
     642    if (pdinfoCurrent)
     643      return DrgLazyDrag(hwndCnr, pdinfoCurrent, &diFakeIcon, 1, NULL);
    640644  }
    641645  return FALSE;
Note: See TracChangeset for help on using the changeset viewer.