Changeset 739 for trunk/dll


Ignore:
Timestamp:
Jul 24, 2007, 6:06:59 AM (18 years ago)
Author:
Steven Levine
Message:

More ticket #24 updates

Location:
trunk/dll
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/arccnrs.c

    r730 r739  
    586586                pai->flags = ARCFLAGS_REALDIR;
    587587              pai->pszFileName = xstrdup(fname,pszSrcFile, __LINE__);
     588              // 23 Jul 07 SHL fixme to set pszDisplayName
     589              // 23 Jul 07 SHL fixme to set pszIcon after pszFileName allocated
    588590              if (fdate)
    589591                strcpy(pai->szDate, fdate);
    … …  
    22322234            pfi->flTitle = CFA_CENTER;
    22332235            pfi->pTitleData = GetPString(IDS_FILENAMECOLTEXT);
    2234             pfi->offStruct = FIELDOFFSET(ARCITEM, pszFileName);
     2236            pfi->offStruct = FIELDOFFSET(ARCITEM, pszDisplayName);
    22352237            pfiLastLeftCol = pfi;
    22362238            pfi = pfi->pNextFieldInfo;
    … …  
    29202922          USHORT cmd = 0;
    29212923
    2922           if (!pfi || pfi->offStruct == FIELDOFFSET(ARCITEM, pszFileName))
     2924          if (!pfi || pfi->offStruct == FIELDOFFSET(ARCITEM, pszDisplayName))
    29232925            cmd = IDM_SORTSMARTNAME;
    29242926          else if (pfi->offStruct == FIELDOFFSET(ARCITEM, cbFile))

  • trunk/dll/comp.c

    r731 r739  
    10261026          pcir->hwndCnr = hwndRight;
    10271027          //pcir->pszFileName = pcir->szFileName;
     1028          // 23 Jul 07 SHL fixme to set pszIcon after pszFileName allocated
     1029          // 23 Jul 07 SHL fixme to set pszLongName after pszFileName allocated
    10281030          pcir->rc.pszIcon = pcir->pszFileName;
    10291031          pcir->rc.hptrIcon = (HPOINTER) 0;
     1032          pcir->pszDisplayName = NULL;  // Not used here
    10301033          //pcir->pszSubject = pcir->szSubject;
    10311034          //pcir->pszLongname = pcir->szLongname;
    … …  
    10361039          pcil->rc.hptrIcon = (HPOINTER) 0;
    10371040          pcil->pszDispAttr = pcil->szDispAttr;
     1041          pcil->pszDisplayName = NULL;  // Not used here
    10381042          //pcil->pszSubject = pcil->szSubject;
    10391043          //pcil->pszLongname = pcil->szLongname;

  • trunk/dll/dirsize.c

    r738 r739  
    147147    else
    148148      DosError(FERR_DISABLEHARDERR);
    149     // fixme to not double free when pointers match
    150     pci->pszLongname = pci->pszFileName;
    151149    pci->rc.hptrIcon = hptrDir;
    152150    *pci->szDispAttr = 0;
    … …  
    171169      p = pszFileName;
    172170    else
    173       p++;
    174     sp = (strchr(pszFileName, ' ') != NULL) ? "\"" : NullStr;
     171      p++;                              // After last backslash
     172    // Handle quoted names?
     173    sp = strchr(pszFileName, ' ') != NULL ? "\"" : NullStr;
     174    pci->pszFileName = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);       // fixme to optimize alloc
    175175    pp = pci->pszFileName;
    176176    if (*sp) {
    177       *pp = *sp;
     177      *pp = *sp;                        // Need quotes
    178178      pp++;
    179179      *pp = 0;
    … …  
    183183      strcat(pp, sp);
    184184  }
     185  pci->pszLongname = pci->pszFileName;
    185186  pci->rc.pszIcon = pci->pszLongname;
    186187  pci->rc.flRecordAttr |= CRA_RECORDREADONLY;
    … …  
    189190  else if (fForceLower)
    190191    strlwr(pci->pszFileName);
    191   // fixme to work - code is hiding file name from container but... 23 Jul 07 SHL
    192   pci->pszFileName = pci->pszFileName + strlen(pci->pszFileName);
     192  pci->pszDisplayName = pci->pszFileName + strlen(pci->pszFileName);
    193193  memset(&ri, 0, sizeof(RECORDINSERT));
    194194  ri.cb = sizeof(RECORDINSERT);

  • trunk/dll/filldir.c

    r737 r739  
    393393  pci->szDispAttr[5] = 0;
    394394  pci->pszDispAttr = pci->szDispAttr;
    395   pci->rc.pszIcon = pci->pszFileName;
     395  pci->rc.pszIcon = pci->pszDisplayName;
    396396  pci->rc.hptrIcon = hptr;
    397397
    … …  
    612612  pci->szDispAttr[5] = 0;
    613613  pci->pszDispAttr = pci->szDispAttr;
    614   pci->rc.pszIcon = pci->pszFileName;
     614  pci->rc.pszIcon = pci->pszDisplayName;
    615615  pci->rc.hptrIcon = hptr;
    616616
    … …  
    983983  INT x, removable;
    984984  CHAR suggest[32];
    985   CHAR szDrive[] = " :\\", FileSystem[CCHMAXPATH];
     985  CHAR szDrive[] = " :\\";
     986  CHAR szFileSystem[CCHMAXPATH];
    986987  FILESTATUS4 fsa4;
    987988  APIRET rc;
    988989  BOOL drivesbuilt = FALSE;
     990  ULONG startdrive = 3;
     991
    989992  static BOOL didonce = FALSE;
    990993
    … …  
    9971000  }
    9981001  memset(driveserial, -1, sizeof(driveserial));
     1002
     1003  DosError(FERR_DISABLEHARDERR);
     1004  if (!DosQuerySysInfo(QSV_BOOT_DRIVE,
     1005                       QSV_BOOT_DRIVE,
     1006                       (PVOID) &startdrive,
     1007                       (ULONG) sizeof(ULONG)) &&
     1008      startdrive)
    9991009  {
    1000     ULONG startdrive = 3L;
    1001 
    1002     DosError(FERR_DISABLEHARDERR);
    1003     if (!DosQuerySysInfo(QSV_BOOT_DRIVE,
    1004                          QSV_BOOT_DRIVE,
    1005                          (PVOID) & startdrive,
    1006                          (ULONG) sizeof(ULONG)) && startdrive)
    1007       driveflags[startdrive - 1] |= DRIVE_BOOT;
    1008   }
     1010    driveflags[startdrive - 1] |= DRIVE_BOOT;
     1011  }
     1012
    10091013  DosError(FERR_DISABLEHARDERR);
    10101014  rc = DosQCurDisk(&ulCurDriveNum, &ulDriveMap);
    … …  
    10161020    exit(0);
    10171021  }
     1022
    10181023  // Calc number of drive items to create
    10191024  for (x = 0; x < 26; x++) {
    … …  
    10211026      numtoinsert++;
    10221027  }
     1028
    10231029  if (numtoinsert) {
    10241030    pciFirst = WinSendMsg(hwndCnr,
    … …  
    10271033                          MPFROMLONG((ULONG) numtoinsert));
    10281034  }
     1035
    10291036  if (!pciFirst) {
    10301037    Win_Error2(hwndCnr, hwndCnr, pszSrcFile, __LINE__, IDS_CMALLOCRECERRTEXT);
    10311038    exit(0);
    10321039  }
    1033   else {
    1034 
    1035     pci = pciFirst;
    1036     for (x = 0; x < 26; x++) {
    1037       if ((ulDriveMap & (1L << x)) && !(driveflags[x] & DRIVE_IGNORE)) {
    1038 
    1039         CHAR s[80];
    1040         ULONG flags = 0;
    1041         ULONG size = sizeof(ULONG);
    1042 
    1043         *szDrive = (CHAR)x + 'A';               // Build path spec
    1044 
    1045         sprintf(s, "%c.DriveFlags", toupper(*szDrive));
    1046         if (PrfQueryProfileData(fmprof, appname, s, &flags, &size) &&
    1047             size == sizeof(ULONG)) {
    1048           driveflags[toupper(*szDrive) - 'A'] |= flags;
    1049         }
    1050 
    1051         if (x > 1) {
    1052           // Hard drive (2..N)
    1053           if (!(driveflags[x] & DRIVE_NOPRESCAN)) {
    1054             *FileSystem = 0;
    1055             drvtype = 0;
    1056             removable = CheckDrive(*szDrive, FileSystem, &drvtype);
    1057             driveserial[x] = -1;
    1058             if (removable != -1) {
    1059               struct {
    1060                 ULONG serial;
    1061                 CHAR volumelength;
    1062                 CHAR volumelabel[CCHMAXPATH];
    1063               } volser;
    1064 
    1065               DosError(FERR_DISABLEHARDERR);
    1066               if (!DosQueryFSInfo((ULONG) x,
    1067                                   FSIL_VOLSER, &volser, sizeof(volser))) {
    1068                 driveserial[x] = volser.serial;
    1069               }
     1040
     1041  pci = pciFirst;
     1042  for (x = 0; x < 26; x++) {
     1043    if ((ulDriveMap & (1L << x)) && !(driveflags[x] & DRIVE_IGNORE)) {
     1044
     1045      CHAR s[80];
     1046      ULONG flags = 0;
     1047      ULONG size = sizeof(ULONG);
     1048
     1049      *szDrive = (CHAR)x + 'A';         // Build path spec
     1050
     1051      sprintf(s, "%c.DriveFlags", toupper(*szDrive));
     1052      if (PrfQueryProfileData(fmprof, appname, s, &flags, &size) &&
     1053          size == sizeof(ULONG)) {
     1054        driveflags[toupper(*szDrive) - 'A'] |= flags;
     1055      }
     1056
     1057      if (x > 1) {
     1058        // Hard drive (2..N)
     1059        if (!(driveflags[x] & DRIVE_NOPRESCAN)) {
     1060          *szFileSystem = 0;
     1061          drvtype = 0;
     1062          removable = CheckDrive(*szDrive, szFileSystem, &drvtype);
     1063          driveserial[x] = -1;
     1064          if (removable != -1) {
     1065            struct {
     1066              ULONG serial;
     1067              CHAR volumelength;
     1068              CHAR volumelabel[CCHMAXPATH];
     1069            } volser;
     1070
     1071            DosError(FERR_DISABLEHARDERR);
     1072            if (!DosQueryFSInfo((ULONG) x,
     1073                                FSIL_VOLSER, &volser, sizeof(volser))) {
     1074              driveserial[x] = volser.serial;
    10701075            }
    1071             else
    1072               driveflags[x] |= DRIVE_INVALID;
    1073 
    1074             memset(&fsa4, 0, sizeof(FILESTATUS4));
    1075             driveflags[x] |= removable == -1 || removable == 1 ?
    1076                               DRIVE_REMOVABLE : 0;
    1077             if (drvtype & DRIVE_REMOTE)
    1078               driveflags[x] |= DRIVE_REMOTE;
    1079             if (!stricmp(FileSystem,RAMFS)) {
    1080               driveflags[x] |= DRIVE_RAMDISK;
    1081               driveflags[x] &= ~DRIVE_REMOTE;
    1082             }
    1083             if (!stricmp(FileSystem,NDFS32)) {
    1084               driveflags[x] |= DRIVE_VIRTUAL;
    1085               driveflags[x] &= ~DRIVE_REMOTE;
    1086             }
    1087             if (!stricmp(FileSystem,NTFS))
    1088               driveflags[x] |= DRIVE_NOTWRITEABLE;
    1089             if (strcmp(FileSystem, HPFS) &&
    1090                 strcmp(FileSystem, JFS) &&
    1091                 strcmp(FileSystem, ISOFS) &&
    1092                 strcmp(FileSystem, CDFS) &&
    1093                 strcmp(FileSystem, FAT32) &&
    1094                 strcmp(FileSystem, NDFS32) &&
    1095                 strcmp(FileSystem, RAMFS) &&
    1096                 strcmp(FileSystem, NTFS) &&
    1097                 strcmp(FileSystem, HPFS386)) {
    1098               driveflags[x] |= DRIVE_NOLONGNAMES;
    1099             }
    1100 
    1101             if (!strcmp(FileSystem, CDFS) || !strcmp(FileSystem,ISOFS)) {
    1102               removable = 1;
    1103               driveflags[x] |= DRIVE_REMOVABLE | DRIVE_NOTWRITEABLE |
    1104                                DRIVE_CDROM;
    1105             }
    1106             else if (!stricmp(FileSystem, CBSIFS)) {
    1107               driveflags[x] |= DRIVE_ZIPSTREAM;
    1108               driveflags[x] &= ~DRIVE_REMOTE;
    1109               if (drvtype & DRIVE_REMOVABLE)
    1110                 driveflags[x] |= DRIVE_REMOVABLE;
    1111               if (!(drvtype & DRIVE_NOLONGNAMES))
    1112                 driveflags[x] &= ~DRIVE_NOLONGNAMES;
    1113             }
    1114 
    1115             pci->rc.flRecordAttr |= CRA_RECORDREADONLY;
    1116             // if ((ULONG) (toupper(*pci->pszFileName) - '@') == ulCurDriveNum) // 23 Jul 07 SHL
    1117             if ((ULONG)(toupper(*szDrive) - '@') == ulCurDriveNum)
    1118               pci->rc.flRecordAttr |= (CRA_CURSORED | CRA_SELECTED);
    1119 
    1120             if (removable == 0) {
    1121               // Fixed volume
    1122               pci->attrFile |= FILE_DIRECTORY;
     1076          }
     1077          else
     1078            driveflags[x] |= DRIVE_INVALID;
     1079
     1080          memset(&fsa4, 0, sizeof(FILESTATUS4));
     1081          driveflags[x] |= removable == -1 || removable == 1 ?
     1082                            DRIVE_REMOVABLE : 0;
     1083          if (drvtype & DRIVE_REMOTE)
     1084            driveflags[x] |= DRIVE_REMOTE;
     1085          if (!stricmp(szFileSystem,RAMFS)) {
     1086            driveflags[x] |= DRIVE_RAMDISK;
     1087            driveflags[x] &= ~DRIVE_REMOTE;
     1088          }
     1089          if (!stricmp(szFileSystem,NDFS32)) {
     1090            driveflags[x] |= DRIVE_VIRTUAL;
     1091            driveflags[x] &= ~DRIVE_REMOTE;
     1092          }
     1093          if (!stricmp(szFileSystem,NTFS))
     1094            driveflags[x] |= DRIVE_NOTWRITEABLE;
     1095          if (strcmp(szFileSystem, HPFS) &&
     1096              strcmp(szFileSystem, JFS) &&
     1097              strcmp(szFileSystem, ISOFS) &&
     1098              strcmp(szFileSystem, CDFS) &&
     1099              strcmp(szFileSystem, FAT32) &&
     1100              strcmp(szFileSystem, NDFS32) &&
     1101              strcmp(szFileSystem, RAMFS) &&
     1102              strcmp(szFileSystem, NTFS) &&
     1103              strcmp(szFileSystem, HPFS386)) {
     1104            driveflags[x] |= DRIVE_NOLONGNAMES;
     1105          }
     1106
     1107          if (!strcmp(szFileSystem, CDFS) || !strcmp(szFileSystem,ISOFS)) {
     1108            removable = 1;
     1109            driveflags[x] |= DRIVE_REMOVABLE | DRIVE_NOTWRITEABLE |
     1110                             DRIVE_CDROM;
     1111          }
     1112          else if (!stricmp(szFileSystem, CBSIFS)) {
     1113            driveflags[x] |= DRIVE_ZIPSTREAM;
     1114            driveflags[x] &= ~DRIVE_REMOTE;
     1115            if (drvtype & DRIVE_REMOVABLE)
     1116              driveflags[x] |= DRIVE_REMOVABLE;
     1117            if (!(drvtype & DRIVE_NOLONGNAMES))
     1118              driveflags[x] &= ~DRIVE_NOLONGNAMES;
     1119          }
     1120
     1121          pci->rc.flRecordAttr |= CRA_RECORDREADONLY;
     1122          // if ((ULONG) (toupper(*pci->pszFileName) - '@') == ulCurDriveNum)   // 23 Jul 07 SHL
     1123          if ((ULONG)(toupper(*szDrive) - '@') == ulCurDriveNum)
     1124            pci->rc.flRecordAttr |= (CRA_CURSORED | CRA_SELECTED);
     1125
     1126          if (removable == 0) {
     1127            // Fixed volume
     1128            pci->attrFile |= FILE_DIRECTORY;
     1129            DosError(FERR_DISABLEHARDERR);
     1130            rc = DosQueryPathInfo(szDrive,
     1131                                  FIL_QUERYEASIZE,
     1132                                  &fsa4, (ULONG) sizeof(FILESTATUS4));
     1133            // ERROR_BAD_NET_RSP = 58
     1134            if (rc == 58) {
    11231135              DosError(FERR_DISABLEHARDERR);
    11241136              rc = DosQueryPathInfo(szDrive,
    1125                                     FIL_QUERYEASIZE,
    1126                                     &fsa4, (ULONG) sizeof(FILESTATUS4));
    1127               // ERROR_BAD_NET_RSP = 58
    1128               if (rc == 58) {
    1129                 DosError(FERR_DISABLEHARDERR);
    1130                 rc = DosQueryPathInfo(szDrive,
    1131                                       FIL_STANDARD,
    1132                                       &fsa4, (ULONG) sizeof(FILESTATUS3));
    1133                 fsa4.cbList = 0;
     1137                                    FIL_STANDARD,
     1138                                    &fsa4, (ULONG) sizeof(FILESTATUS3));
     1139              fsa4.cbList = 0;
     1140            }
     1141            if (rc && !didonce) {
     1142              // Guess drive letter
     1143              if (!*suggest) {
     1144                *suggest = '/';
     1145                suggest[1] = 0;
    11341146              }
    1135               if (rc && !didonce) {
    1136                 // Guess drive letter
    1137                 if (!*suggest) {
    1138                   *suggest = '/';
    1139                   suggest[1] = 0;
    1140                 }
    1141                 sprintf(suggest + strlen(suggest), "%c" , toupper(*szDrive));
    1142                 pci->pszFileName = xstrdup(szDrive, pszSrcFile, __LINE__);
    1143                 pci->rc.pszIcon = pci->pszFileName;
    1144                 pci->attrFile = FILE_DIRECTORY;
    1145                 strcpy(pci->szDispAttr, "----D-");
    1146                 pci->pszDispAttr = pci->szDispAttr;
    1147                 driveserial[x] = -1;
    1148               }
    1149               else
    1150                 FillInRecordFromFSA(hwndCnr, pci, szDrive, &fsa4, TRUE, NULL);
    1151             }
    1152             else {
    1153               // Removable volume
     1147              sprintf(suggest + strlen(suggest), "%c" , toupper(*szDrive));
    11541148              pci->pszFileName = xstrdup(szDrive, pszSrcFile, __LINE__);
    1155               pci->rc.pszIcon = pci->pszFileName;
     1149              pci->pszDisplayName = pci->pszFileName;
     1150              pci->rc.pszIcon = pci->pszDisplayName;
    11561151              pci->attrFile = FILE_DIRECTORY;
    11571152              strcpy(pci->szDispAttr, "----D-");
    11581153              pci->pszDispAttr = pci->szDispAttr;
     1154              driveserial[x] = -1;
    11591155            }
    1160             SelectDriveIcon(pci);
     1156            else
     1157              FillInRecordFromFSA(hwndCnr, pci, szDrive, &fsa4, TRUE, NULL);
    11611158          }
    11621159          else {
    1163             pci->rc.hptrIcon = hptrDunno;
     1160            // Removable volume
    11641161            pci->pszFileName = xstrdup(szDrive, pszSrcFile, __LINE__);
    1165             pci->rc.pszIcon = pci->pszFileName;
     1162            pci->pszDisplayName = pci->pszFileName;
     1163            pci->rc.pszIcon = pci->pszDisplayName;
    11661164            pci->attrFile = FILE_DIRECTORY;
    11671165            strcpy(pci->szDispAttr, "----D-");
    11681166            pci->pszDispAttr = pci->szDispAttr;
    1169             driveserial[x] = -1;
    1170           }
     1167          }
     1168          SelectDriveIcon(pci);
    11711169        }
    11721170        else {
    1173           // diskette drive (A or B)
    1174           pci->rc.hptrIcon = hptrFloppy;
     1171          pci->rc.hptrIcon = hptrDunno;
    11751172          pci->pszFileName = xstrdup(szDrive, pszSrcFile, __LINE__);
     1173          pci->pszDisplayName = pci->pszFileName;
    11761174          pci->rc.pszIcon = pci->pszFileName;
    11771175          pci->attrFile = FILE_DIRECTORY;
    11781176          strcpy(pci->szDispAttr, "----D-");
    11791177          pci->pszDispAttr = pci->szDispAttr;
    1180           driveflags[x] |= (DRIVE_REMOVABLE | DRIVE_NOLONGNAMES);
    11811178          driveserial[x] = -1;
    11821179        }
    1183         pci->rc.flRecordAttr |= CRA_RECORDREADONLY;
    1184         pci = (PCNRITEM) pci->rc.preccNextRecord;       /* next rec */
    1185       }
    1186       else if (!(ulDriveMap & (1L << x)))
    1187         driveflags[x] |= DRIVE_INVALID;
    1188     } // for drives
    1189 
    1190     PostMsg(hwndMain, UM_BUILDDRIVEBAR, MPVOID, MPVOID);
    1191     drivesbuilt = TRUE;
    1192     /* insert the drives */
    1193     if (numtoinsert && pciFirst) {
    1194       RECORDINSERT ri;
    1195 
     1180      }
     1181      else {
     1182        // diskette drive (A or B)
     1183        pci->rc.hptrIcon = hptrFloppy;
     1184        pci->pszFileName = xstrdup(szDrive, pszSrcFile, __LINE__);
     1185        pci->pszDisplayName = pci->pszFileName;
     1186        pci->rc.pszIcon = pci->pszDisplayName;
     1187        pci->attrFile = FILE_DIRECTORY;
     1188        strcpy(pci->szDispAttr, "----D-");
     1189        pci->pszDispAttr = pci->szDispAttr;
     1190        driveflags[x] |= (DRIVE_REMOVABLE | DRIVE_NOLONGNAMES);
     1191        driveserial[x] = -1;
     1192      }
     1193      pci->rc.flRecordAttr |= CRA_RECORDREADONLY;
     1194      pci = (PCNRITEM) pci->rc.preccNextRecord; /* next rec */
     1195    }
     1196    else if (!(ulDriveMap & (1L << x)))
     1197      driveflags[x] |= DRIVE_INVALID;
     1198  } // for drives
     1199
     1200  PostMsg(hwndMain, UM_BUILDDRIVEBAR, MPVOID, MPVOID);
     1201  drivesbuilt = TRUE;
     1202
     1203  /* insert the drives */
     1204  if (numtoinsert && pciFirst) {
     1205    RECORDINSERT ri;
     1206
     1207    memset(&ri, 0, sizeof(RECORDINSERT));
     1208    ri.cb = sizeof(RECORDINSERT);
     1209    ri.pRecordOrder = (PRECORDCORE) CMA_END;
     1210    ri.pRecordParent = (PRECORDCORE) NULL;
     1211    ri.zOrder = (ULONG) CMA_TOP;
     1212    ri.cRecordsInsert = numtoinsert;
     1213    ri.fInvalidateRecord = FALSE;
     1214    if (!WinSendMsg(hwndCnr,
     1215                    CM_INSERTRECORD, MPFROMP(pciFirst), MPFROMP(&ri)))
     1216    {
     1217      Win_Error2(hwndCnr, hwndCnr, pszSrcFile, __LINE__,
     1218                 IDS_CMINSERTERRTEXT);
     1219    }
     1220  }
     1221
     1222  /* move cursor onto the default drive rather than the first drive */
     1223  if (!fSwitchTree) {
     1224    pci = (PCNRITEM) WinSendMsg(hwndCnr,
     1225                                CM_QUERYRECORD,
     1226                                MPVOID,
     1227                                MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
     1228    while (pci && (INT) pci != -1) {
     1229      if ((ULONG) (toupper(*pci->pszFileName) - '@') == ulCurDriveNum) {
     1230        WinSendMsg(hwndCnr,
     1231                   CM_SETRECORDEMPHASIS,
     1232                   MPFROMP(pci), MPFROM2SHORT(TRUE, CRA_CURSORED));
     1233        break;
     1234      }
     1235      pci = (PCNRITEM) WinSendMsg(hwndCnr,
     1236                                  CM_QUERYRECORD,
     1237                                  MPFROMP(pci),
     1238                                  MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
     1239    }
     1240  }
     1241
     1242  if (hwndParent) {
     1243    WinSendMsg(WinWindowFromID(WinQueryWindow(hwndParent, QW_PARENT),
     1244                               MAIN_DRIVELIST),
     1245               LM_DELETEALL, MPVOID, MPVOID);
     1246  }
     1247
     1248  if (fShowEnv) {
     1249    RECORDINSERT ri;
     1250
     1251    pciParent = WinSendMsg(hwndCnr,
     1252                           CM_ALLOCRECORD,
     1253                           MPFROMLONG(EXTRA_RECORD_BYTES2), MPFROMLONG(1));
     1254    if (pciParent) {
     1255      pciParent->flags |= RECFLAGS_ENV;
     1256      pciParent->pszFileName = xstrdup(GetPString(IDS_ENVVARSTEXT), pszSrcFile, __LINE__);
     1257      //pciParent->pszFileName = pciParent->szFileName;
     1258      pciParent->rc.hptrIcon = hptrEnv;
     1259      pciParent->rc.pszIcon = pciParent->pszFileName;
     1260      strcpy(pciParent->szDispAttr, "------");
     1261      pciParent->pszDispAttr = pciParent->szDispAttr;
    11961262      memset(&ri, 0, sizeof(RECORDINSERT));
    11971263      ri.cb = sizeof(RECORDINSERT);
    … …  
    11991265      ri.pRecordParent = (PRECORDCORE) NULL;
    12001266      ri.zOrder = (ULONG) CMA_TOP;
    1201       ri.cRecordsInsert = numtoinsert;
     1267      ri.cRecordsInsert = 1;
    12021268      ri.fInvalidateRecord = FALSE;
    1203       if (!WinSendMsg(hwndCnr,
    1204                       CM_INSERTRECORD, MPFROMP(pciFirst), MPFROMP(&ri)))
    1205         Win_Error2(hwndCnr, hwndCnr, pszSrcFile, __LINE__,
    1206                    IDS_CMINSERTERRTEXT);
    1207     }
    1208 
    1209     /* move cursor onto the default drive rather than the first drive */
    1210     if (!fSwitchTree) {
     1269      if (WinSendMsg(hwndCnr,
     1270                     CM_INSERTRECORD, MPFROMP(pciParent), MPFROMP(&ri))) {
     1271
     1272        char *p, *pp;
     1273
     1274        p = GetPString(IDS_ENVVARNAMES);
     1275        while (*p == ' ')
     1276          p++;
     1277        while (*p) {
     1278          *szFileSystem = 0;
     1279          pp = szFileSystem;
     1280          while (*p && *p != ' ')
     1281            *pp++ = *p++;
     1282          *pp = 0;
     1283          while (*p == ' ')
     1284            p++;
     1285          if (*szFileSystem &&
     1286              (!stricmp(szFileSystem, "LIBPATH") || getenv(szFileSystem))) {
     1287            pci = WinSendMsg(hwndCnr,
     1288                             CM_ALLOCRECORD,
     1289                             MPFROMLONG(EXTRA_RECORD_BYTES2),
     1290                             MPFROMLONG(1));
     1291            if (pci) {
     1292              CHAR fname[CCHMAXPATH];
     1293              pci->flags |= RECFLAGS_ENV;
     1294              sprintf(fname, "%%%s%%", szFileSystem);
     1295              pci->pszFileName = xstrdup(fname, pszSrcFile, __LINE__);
     1296              pci->rc.hptrIcon = hptrEnv;
     1297              pci->rc.pszIcon = pci->pszFileName;
     1298              strcpy(pci->szDispAttr, "------");
     1299              pci->pszDispAttr = pci->szDispAttr;
     1300              memset(&ri, 0, sizeof(RECORDINSERT));
     1301              ri.cb = sizeof(RECORDINSERT);
     1302              ri.pRecordOrder = (PRECORDCORE) CMA_END;
     1303              ri.pRecordParent = (PRECORDCORE) pciParent;
     1304              ri.zOrder = (ULONG) CMA_TOP;
     1305              ri.cRecordsInsert = 1;
     1306              ri.fInvalidateRecord = FALSE;
     1307              if (!WinSendMsg(hwndCnr,
     1308                              CM_INSERTRECORD,
     1309                              MPFROMP(pci), MPFROMP(&ri))) {
     1310                Win_Error2(hwndCnr, hwndCnr, pszSrcFile, __LINE__,
     1311                           IDS_CMINSERTERRTEXT);
     1312                WinSendMsg(hwndCnr, CM_FREERECORD, MPFROMP(&pci),
     1313                           MPFROMSHORT(1));
     1314              }
     1315            }
     1316          }
     1317        }
     1318        WinSendMsg(hwndCnr,
     1319                   CM_INVALIDATERECORD,
     1320                   MPFROMP(&pciParent),
     1321                   MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
     1322      }
     1323      else
     1324        WinSendMsg(hwndCnr,
     1325                   CM_FREERECORD, MPFROMP(&pciParent), MPFROMSHORT(1));
     1326    }
     1327  } // if show env
     1328
     1329  x = 0;
     1330  pci = (PCNRITEM) WinSendMsg(hwndCnr,
     1331                              CM_QUERYRECORD,
     1332                              MPVOID,
     1333                              MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
     1334  while (pci && (INT) pci != -1) {
     1335    pciNext = (PCNRITEM) WinSendMsg(hwndCnr,
     1336                                    CM_QUERYRECORD,
     1337                                    MPFROMP(pci),
     1338                                    MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
     1339    if (!(pci->flags & RECFLAGS_ENV)) {
     1340      if ((ULONG) (toupper(*pci->pszFileName) - '@') == ulCurDriveNum ||
     1341          toupper(*pci->pszFileName) > 'B')
     1342      {
     1343        if (!(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_INVALID) &&
     1344            !(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_NOPRESCAN) &&
     1345            (!fNoRemovableScan ||
     1346             !(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_REMOVABLE)))
     1347        {
     1348          if (!Stubby(hwndCnr, pci) && !DRIVE_RAMDISK) {
     1349            WinSendMsg(hwndCnr,
     1350                       CM_INVALIDATERECORD,
     1351                       MPFROMP(&pci),
     1352                       MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
     1353            goto SkipBadRec;
     1354          }
     1355        }
     1356      }
     1357      else {
     1358        WinSendMsg(hwndCnr,
     1359                   CM_INVALIDATERECORD,
     1360                   MPFROMP(&pci),
     1361                   MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
     1362      }
     1363
     1364      WinSendMsg(WinWindowFromID(WinQueryWindow(hwndParent, QW_PARENT),
     1365                                 MAIN_DRIVELIST),
     1366                 LM_INSERTITEM,
     1367                 MPFROM2SHORT(LIT_SORTASCENDING, 0),
     1368                 MPFROMP(pci->pszFileName));
     1369    }
     1370  SkipBadRec:
     1371    x++;
     1372    pci = pciNext;
     1373  }
     1374  if (hwndParent)
     1375    WinSendMsg(WinWindowFromID(WinQueryWindow(hwndParent, QW_PARENT),
     1376                               MAIN_DRIVELIST), LM_SELECTITEM,
     1377               MPFROM2SHORT(0, 0), MPFROMLONG(TRUE));
     1378
     1379  pci = (PCNRITEM) WinSendMsg(hwndCnr,
     1380                              CM_QUERYRECORD,
     1381                              MPVOID,
     1382                              MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
     1383  while (pci && (INT) pci != -1) {
     1384    pciNext = (PCNRITEM) WinSendMsg(hwndCnr,
     1385                                    CM_QUERYRECORD,
     1386                                    MPFROMP(pci),
     1387                                    MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
     1388    if (pci->flags & RECFLAGS_ENV) {
    12111389      pci = (PCNRITEM) WinSendMsg(hwndCnr,
    12121390                                  CM_QUERYRECORD,
    1213                                   MPVOID,
    1214                                   MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
     1391                                  MPFROMP(pci),
     1392                                  MPFROM2SHORT(CMA_FIRSTCHILD,
     1393                                               CMA_ITEMORDER));
    12151394      while (pci && (INT) pci != -1) {
    1216         if ((ULONG) (toupper(*pci->pszFileName) - '@') == ulCurDriveNum) {
    1217           WinSendMsg(hwndCnr,
    1218                      CM_SETRECORDEMPHASIS,
    1219                      MPFROMP(pci), MPFROM2SHORT(TRUE, CRA_CURSORED));
    1220           break;
    1221         }
     1395        if (pci->flags & RECFLAGS_ENV)
     1396          FleshEnv(hwndCnr, pci);
    12221397        pci = (PCNRITEM) WinSendMsg(hwndCnr,
    12231398                                    CM_QUERYRECORD,
    … …  
    12251400                                    MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    12261401      }
    1227     }
    1228 
    1229     if (hwndParent) {
    1230       WinSendMsg(WinWindowFromID(WinQueryWindow(hwndParent, QW_PARENT),
    1231                                  MAIN_DRIVELIST),
    1232                  LM_DELETEALL, MPVOID, MPVOID);
    1233     }
    1234 
    1235     if (fShowEnv) {
    1236       RECORDINSERT ri;
    1237 
    1238       pciParent = WinSendMsg(hwndCnr,
    1239                              CM_ALLOCRECORD,
    1240                              MPFROMLONG(EXTRA_RECORD_BYTES2), MPFROMLONG(1));
    1241       if (pciParent) {
    1242         pciParent->flags |= RECFLAGS_ENV;
    1243         pciParent->pszFileName = xstrdup(GetPString(IDS_ENVVARSTEXT), pszSrcFile, __LINE__);
    1244         //pciParent->pszFileName = pciParent->szFileName;
    1245         pciParent->rc.hptrIcon = hptrEnv;
    1246         pciParent->rc.pszIcon = pciParent->pszFileName;
    1247         strcpy(pciParent->szDispAttr, "------");
    1248         pciParent->pszDispAttr = pciParent->szDispAttr;
    1249         memset(&ri, 0, sizeof(RECORDINSERT));
    1250         ri.cb = sizeof(RECORDINSERT);
    1251         ri.pRecordOrder = (PRECORDCORE) CMA_END;
    1252         ri.pRecordParent = (PRECORDCORE) NULL;
    1253         ri.zOrder = (ULONG) CMA_TOP;
    1254         ri.cRecordsInsert = 1;
    1255         ri.fInvalidateRecord = FALSE;
    1256         if (WinSendMsg(hwndCnr,
    1257                        CM_INSERTRECORD, MPFROMP(pciParent), MPFROMP(&ri))) {
    1258 
    1259           char *p, *pp;
    1260 
    1261           p = GetPString(IDS_ENVVARNAMES);
    1262           while (*p == ' ')
    1263             p++;
    1264           while (*p) {
    1265             *FileSystem = 0;
    1266             pp = FileSystem;
    1267             while (*p && *p != ' ')
    1268               *pp++ = *p++;
    1269             *pp = 0;
    1270             while (*p == ' ')
    1271               p++;
    1272             if (*FileSystem &&
    1273                 (!stricmp(FileSystem, "LIBPATH") || getenv(FileSystem))) {
    1274               pci = WinSendMsg(hwndCnr,
    1275                                CM_ALLOCRECORD,
    1276                                MPFROMLONG(EXTRA_RECORD_BYTES2),
    1277                                MPFROMLONG(1));
    1278               if (pci) {
    1279                 CHAR fname[CCHMAXPATH];
    1280                 pci->flags |= RECFLAGS_ENV;
    1281                 sprintf(fname, "%%%s%%", FileSystem);
    1282                 pci->pszFileName = xstrdup(fname, pszSrcFile, __LINE__);
    1283                 pci->rc.hptrIcon = hptrEnv;
    1284                 pci->rc.pszIcon = pci->pszFileName;
    1285                 strcpy(pci->szDispAttr, "------");
    1286                 pci->pszDispAttr = pci->szDispAttr;
    1287                 memset(&ri, 0, sizeof(RECORDINSERT));
    1288                 ri.cb = sizeof(RECORDINSERT);
    1289                 ri.pRecordOrder = (PRECORDCORE) CMA_END;
    1290                 ri.pRecordParent = (PRECORDCORE) pciParent;
    1291                 ri.zOrder = (ULONG) CMA_TOP;
    1292                 ri.cRecordsInsert = 1;
    1293                 ri.fInvalidateRecord = FALSE;
    1294                 if (!WinSendMsg(hwndCnr,
    1295                                 CM_INSERTRECORD,
    1296                                 MPFROMP(pci), MPFROMP(&ri))) {
    1297                   Win_Error2(hwndCnr, hwndCnr, pszSrcFile, __LINE__,
    1298                              IDS_CMINSERTERRTEXT);
    1299                   WinSendMsg(hwndCnr, CM_FREERECORD, MPFROMP(&pci),
    1300                              MPFROMSHORT(1));
    1301                 }
    1302               }
    1303             }
    1304           }
    1305           WinSendMsg(hwndCnr,
    1306                      CM_INVALIDATERECORD,
    1307                      MPFROMP(&pciParent),
    1308                      MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
    1309         }
    1310         else
    1311           WinSendMsg(hwndCnr,
    1312                      CM_FREERECORD, MPFROMP(&pciParent), MPFROMSHORT(1));
    1313       }
    1314     } // if show env
    1315 
    1316     x = 0;
     1402      break;
     1403    }
    13171404    pci = (PCNRITEM) WinSendMsg(hwndCnr,
    13181405                                CM_QUERYRECORD,
    1319                                 MPVOID,
    1320                                 MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    1321     while (pci && (INT) pci != -1) {
    1322       pciNext = (PCNRITEM) WinSendMsg(hwndCnr,
    1323                                       CM_QUERYRECORD,
    1324                                       MPFROMP(pci),
    1325                                       MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    1326       if (!(pci->flags & RECFLAGS_ENV)) {
    1327         if ((ULONG) (toupper(*pci->pszFileName) - '@') == ulCurDriveNum ||
    1328             toupper(*pci->pszFileName) > 'B') {
    1329           if (!(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_INVALID)
    1330               && !(driveflags[toupper(*pci->pszFileName) - 'A'] &
    1331                    DRIVE_NOPRESCAN) && (!fNoRemovableScan
    1332                                         ||
    1333                                         !(driveflags
    1334                                           [toupper(*pci->pszFileName) -
    1335                                            'A'] & DRIVE_REMOVABLE))) {
    1336             if (!Stubby(hwndCnr, pci) && !DRIVE_RAMDISK) {
    1337               WinSendMsg(hwndCnr,
    1338                          CM_INVALIDATERECORD,
    1339                          MPFROMP(&pci),
    1340                          MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
    1341               goto SkipBadRec;
    1342             }
    1343           }
    1344         }
    1345         else {
    1346           WinSendMsg(hwndCnr,
    1347                      CM_INVALIDATERECORD,
    1348                      MPFROMP(&pci),
    1349                      MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
    1350         }
    1351 
    1352         WinSendMsg(WinWindowFromID(WinQueryWindow(hwndParent, QW_PARENT),
    1353                                    MAIN_DRIVELIST),
    1354                    LM_INSERTITEM,
    1355                    MPFROM2SHORT(LIT_SORTASCENDING, 0),
    1356                    MPFROMP(pci->pszFileName));
    1357       }
    1358     SkipBadRec:
    1359       x++;
    1360       pci = pciNext;
    1361     }
    1362     if (hwndParent)
    1363       WinSendMsg(WinWindowFromID(WinQueryWindow(hwndParent, QW_PARENT),
    1364                                  MAIN_DRIVELIST), LM_SELECTITEM,
    1365                  MPFROM2SHORT(0, 0), MPFROMLONG(TRUE));
    1366 
    1367     pci = (PCNRITEM) WinSendMsg(hwndCnr,
    1368                                 CM_QUERYRECORD,
    1369                                 MPVOID,
    1370                                 MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
    1371     while (pci && (INT) pci != -1) {
    1372       pciNext = (PCNRITEM) WinSendMsg(hwndCnr,
    1373                                       CM_QUERYRECORD,
    1374                                       MPFROMP(pci),
    1375                                       MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    1376       if (pci->flags & RECFLAGS_ENV) {
    1377         pci = (PCNRITEM) WinSendMsg(hwndCnr,
    1378                                     CM_QUERYRECORD,
    1379                                     MPFROMP(pci),
    1380                                     MPFROM2SHORT(CMA_FIRSTCHILD,
    1381                                                  CMA_ITEMORDER));
    1382         while (pci && (INT) pci != -1) {
    1383           if (pci->flags & RECFLAGS_ENV)
    1384             FleshEnv(hwndCnr, pci);
    1385           pci = (PCNRITEM) WinSendMsg(hwndCnr,
    1386                                       CM_QUERYRECORD,
    1387                                       MPFROMP(pci),
    1388                                       MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    1389         }
    1390         break;
    1391       }
    1392       pci = (PCNRITEM) WinSendMsg(hwndCnr,
    1393                                   CM_QUERYRECORD,
    1394                                   MPFROMP(pci),
    1395                                   MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    1396     }
    1397 
    1398   }
     1406                                MPFROMP(pci),
     1407                                MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
     1408  }
     1409
    13991410  if (!drivesbuilt && hwndMain)
    14001411    PostMsg(hwndMain, UM_BUILDDRIVEBAR, MPVOID, MPVOID);
    … …  
    14021413  fDummy = FALSE;
    14031414  DosPostEventSem(CompactSem);
     1415
    14041416  {
    14051417    BYTE info;
    … …  
    14511463    }
    14521464  }
     1465
    14531466  didonce = TRUE;
    14541467

  • trunk/dll/flesh.c

    r736 r739  
    430430          pci->pszFileName = xstrdup(NullStr, pszSrcFile, __LINE__);
    431431          pci->rc.pszIcon = pci->pszFileName;
     432          // 23 Jul 07 SHL fixme to ensure pszDisplay set appropriately
    432433          memset(&ri, 0, sizeof(RECORDINSERT));
    433434          ri.cb = sizeof(RECORDINSERT);

  • trunk/dll/fm3dll.h

    r737 r739  
    433433  MINIRECORDCORE rc;            // Base information
    434434  HWND hwndCnr;                 /* Container holding this record */
    435   PSZ pszFileName;              // Pointer to file name
    436   CHAR szFileName[CCHMAXPATH];  // File name
     435  PSZ pszFileName;              // Pointer to full path name
     436  PSZ pszDisplayName;           // Points to displayable part of path name  - used by CFA_STRING
     437  // CHAR szFileName[CCHMAXPATH];       // File name
    437438  CHAR szDate[40];              // File's assembled date
    438439  PSZ pszDate;                  // Pointer to date

  • trunk/dll/treecnr.c

    r730 r739  
    29442944                              WinQuerySysValue(HWND_DESKTOP,
    29452945                                               SV_CXMINMAXBUTTON) / 2) -
    2946                              WinQuerySysValue(HWND_DESKTOP, SV_CXSIZEBORDER),
     2946                              WinQuerySysValue(HWND_DESKTOP, SV_CXSIZEBORDER),
    29472947                             (swp.cy -
    29482948                              WinQuerySysValue(HWND_DESKTOP,
    29492949                                               SV_CYMINMAXBUTTON)) -
    2950                              WinQuerySysValue(HWND_DESKTOP, SV_CYSIZEBORDER),
     2950                              WinQuerySysValue(HWND_DESKTOP, SV_CYSIZEBORDER),
    29512951                             WinQuerySysValue(HWND_DESKTOP,
    29522952                                              SV_CXMINMAXBUTTON) / 2,
    29532953                             WinQuerySysValue(HWND_DESKTOP,
    29542954                                              SV_CYMINMAXBUTTON), hwndFrame,
    2955                              HWND_TOP, IDM_OPENWINDOW, NULL, NULL)) {
     2955                                              HWND_TOP, IDM_OPENWINDOW, NULL, NULL)) {
    29562956          Win_Error2(hwndFrame, hwndParent, pszSrcFile, __LINE__,
    29572957                     IDS_WINCREATEWINDOW);
Note: See TracChangeset for help on using the changeset viewer.