Changeset 242


Ignore:
Timestamp:
Aug 13, 2005, 10:11:31 PM (20 years ago)
Author:
root
Message:

Indent

File:
1 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified trunk/dll/walkem.c

    r186 r242  
    55
    66  Copyright (c) 1993-98 M. Kimes
    7   Copyright (c) 2004, 2004, 2005 Steven H. Levine
     7  Copyright (c) 2005, 2004, 2005 Steven H. Levine
    88
    99  01 Aug 04 SHL Rework lstrip/rstrip usage
    1010  05 Jun 05 SHL Use QWL_USER
     11  13 Aug 05 SHL Run through indent
    1112
    1213***********************************************************************/
    … …  
    3738#pragma alloc_text(UDIRS,remove_setup)
    3839
    39 typedef struct {
    40   USHORT size;
    41   USHORT changed;
    42   BOOL   nounwriteable;
    43   CHAR   szCurrentPath[CCHMAXPATH];
    44   CHAR  *szReturnPath;
    45 } WALKER;
    46 
    47 static CHAR  WalkFont[CCHMAXPATH] = "";
     40typedef struct
     41{
     42    USHORT size;
     43    USHORT changed;
     44    BOOL nounwriteable;
     45    CHAR szCurrentPath[CCHMAXPATH];
     46    CHAR *szReturnPath;
     47}
     48WALKER;
     49
     50static CHAR WalkFont[CCHMAXPATH] = "";
    4851static ULONG WalkFontSize = sizeof(WalkFont);
    4952
    50 
    51 VOID load_setups (VOID) {
    52 
    53   ULONG len = sizeof(lastsetups);
    54 
    55   memset(lastsetups,0,len);
    56   PrfQueryProfileData(fmprof,
    57                       FM3Str,
    58                       "LastSetups",
    59                       lastsetups,
    60                       &len);
    61   len = sizeof(INT);
    62   lastsetup = 0;
    63   PrfQueryProfileData(fmprof,
    64                       FM3Str,
    65                       "LastSetup",
    66                       &lastsetup,
    67                       &len);
    68   loadedsetups = TRUE;
    69 }
    70 
    71 
    72 VOID save_setups (VOID) {
    73 
    74   if(!loadedsetups)
    75     return;
    76   PrfWriteProfileData(fmprof,
    77                       FM3Str,
    78                       "LastSetups",
    79                       lastsetups,
    80                       (ULONG)sizeof(lastsetups));
    81   PrfWriteProfileData(fmprof,
    82                       FM3Str,
    83                       "LastSetup",
    84                       &lastsetup,
    85                       (ULONG)sizeof(INT));
    86 }
    87 
    88 
    89 BOOL add_setup (CHAR *name) {
    90 
    91   INT  x;
    92 
    93   if(!name || !*name)
     53VOID load_setups(VOID)
     54{
     55
     56    ULONG len = sizeof(lastsetups);
     57
     58    memset(lastsetups, 0, len);
     59    PrfQueryProfileData(fmprof,
     60                        FM3Str,
     61                        "LastSetups",
     62                        lastsetups,
     63                        &len);
     64    len = sizeof(INT);
     65    lastsetup = 0;
     66    PrfQueryProfileData(fmprof,
     67                        FM3Str,
     68                        "LastSetup",
     69                        &lastsetup,
     70                        &len);
     71    loadedsetups = TRUE;
     72}
     73
     74VOID save_setups(VOID)
     75{
     76
     77    if (!loadedsetups)
     78        return;
     79    PrfWriteProfileData(fmprof,
     80                        FM3Str,
     81                        "LastSetups",
     82                        lastsetups,
     83                        (ULONG) sizeof(lastsetups));
     84    PrfWriteProfileData(fmprof,
     85                        FM3Str,
     86                        "LastSetup",
     87                        &lastsetup,
     88                        (ULONG) sizeof(INT));
     89}
     90
     91BOOL add_setup(CHAR * name)
     92{
     93
     94    INT x;
     95
     96    if (!name || !*name)
     97        return FALSE;
     98    if (!loadedsetups)
     99        load_setups();
     100    for (x = 0; x < MAXNUMSETUPS; x++)
     101    {
     102        if (!stricmp(lastsetups[x], name))
     103            return FALSE;
     104    }
     105    lastsetup++;
     106    if (lastsetup >= MAXNUMSETUPS)
     107        lastsetup = 0;
     108    strcpy(lastsetups[lastsetup], name);
     109    return TRUE;
     110}
     111
     112BOOL remove_setup(CHAR * name)
     113{
     114
     115    INT x, y;
     116
     117    if (!name || !*name)
     118        return FALSE;
     119    if (!loadedsetups)
     120        load_setups();
     121    for (x = 0; x < MAXNUMSETUPS; x++)
     122    {
     123        if (!stricmp(lastsetups[x], name))
     124        {
     125            *lastsetups[x] = 0;
     126            for (y = x + 1; y < MAXNUMSETUPS; y++)
     127                strcpy(lastsetups[y - 1], lastsetups[y]);
     128            *lastsetups[MAXNUMSETUPS - 1] = 0;
     129            if (lastsetup >= x)
     130                lastsetup--;
     131            return TRUE;
     132        }
     133    }
    94134    return FALSE;
    95   if(!loadedsetups)
    96     load_setups();
    97   for(x = 0;x < MAXNUMSETUPS;x++) {
    98     if(!stricmp(lastsetups[x],name))
    99       return FALSE;
    100   }
    101   lastsetup++;
    102   if(lastsetup >= MAXNUMSETUPS)
    103     lastsetup = 0;
    104   strcpy(lastsetups[lastsetup],name);
    105   return TRUE;
    106 }
    107 
    108 
    109 BOOL remove_setup (CHAR *name) {
    110 
    111   INT x,y;
    112 
    113   if(!name || !*name)
     135}
     136
     137VOID load_udirs(VOID)
     138{
     139
     140    /* load linked list of user directories from USERDIRS.DAT file */
     141
     142    FILE *fp;
     143    LINKDIRS *info, *last = NULL;
     144    CHAR s[CCHMAXPATH + 24];
     145
     146    loadedudirs = TRUE;
     147    fUdirsChanged = FALSE;
     148    save_dir2(s);
     149    if (s[strlen(s) - 1] != '\\')
     150        strcat(s, "\\");
     151    strcat(s, "USERDIRS.DAT");
     152    fp = _fsopen(s, "r", SH_DENYWR);
     153    if (fp)
     154    {
     155        while (!feof(fp))
     156        {
     157            if (!fgets(s, CCHMAXPATH + 24, fp))
     158                break;
     159            s[CCHMAXPATH] = 0;
     160            bstripcr(s);
     161            if (*s && *s != ';')
     162            {
     163                info = malloc(sizeof(LINKDIRS));
     164                if (info)
     165                {
     166                    info -> path = strdup(s);
     167                    if (info -> path)
     168                    {
     169                        info -> next = NULL;
     170                        if (!udirhead)
     171                            udirhead = info;
     172                        else
     173                            last -> next = info;
     174                        last = info;
     175                    }
     176                    else
     177                        free(info);
     178                }
     179            }
     180        }
     181        fclose(fp);
     182    }
     183}
     184
     185VOID save_udirs(VOID)
     186{
     187
     188    FILE *fp;
     189    LINKDIRS *info;
     190    CHAR s[CCHMAXPATH + 14];
     191
     192    if (loadedudirs)
     193    {
     194        fUdirsChanged = FALSE;
     195        if (udirhead)
     196        {
     197            save_dir2(s);
     198            if (s[strlen(s) - 1] != '\\')
     199                strcat(s, "\\");
     200            strcat(s, "USERDIRS.DAT");
     201            fp = fopen(s, "w");
     202            if (fp)
     203            {
     204                fputs(GetPString(IDS_USERDEFDIRSTEXT), fp);
     205                info = udirhead;
     206                while (info)
     207                {
     208                    fprintf(fp,
     209                            "%0.*s\n",
     210                            CCHMAXPATH,
     211                            info -> path);
     212                    info = info -> next;
     213                }
     214                fclose(fp);
     215            }
     216        }
     217    }
     218}
     219
     220BOOL add_udir(BOOL userdirs, CHAR * inpath)
     221{
     222
     223    CHAR path[CCHMAXPATH];
     224    LINKDIRS *info, *last = NULL, *temp = NULL;
     225
     226    if (inpath &&
     227            *inpath)
     228    {
     229        if (DosQueryPathInfo(inpath,
     230                             FIL_QUERYFULLNAME,
     231                             path,
     232                             sizeof(path)))
     233            strcpy(path, inpath);
     234        if (!userdirs &&
     235                IsRoot(path))
     236            return FALSE;
     237        if (IsFullName(path))
     238        {
     239            if (!loadedudirs)
     240                load_udirs();
     241            info = (userdirs) ? udirhead : ldirhead;
     242            while (info)
     243            {
     244                if (!stricmp(info -> path, path))
     245                    return FALSE;
     246                last = info;
     247                info = info -> next;
     248            }
     249            if (!userdirs)
     250            {
     251                info = udirhead;
     252                while (info)
     253                {
     254                    if (!stricmp(info -> path, path))
     255                        return FALSE;
     256                    info = info -> next;
     257                }
     258            }
     259            else
     260            {                           /* if adding manual directory, remove from auto list if present */
     261                info = ldirhead;
     262                while (info)
     263                {
     264                    if (!stricmp(info -> path, path))
     265                    {
     266                        if (temp)
     267                            temp -> next = info -> next;
     268                        else
     269                            ldirhead = info -> next;
     270                        free(info -> path);
     271                        free(info);
     272                        break;
     273                    }
     274                    temp = info;
     275                    info = info -> next;
     276                }
     277            }
     278            info = malloc(sizeof(LINKDIRS));
     279            if (info)
     280            {
     281                info -> path = strdup(path);
     282                if (info -> path)
     283                {
     284                    info -> next = NULL;
     285                    if (userdirs)
     286                    {
     287                        fUdirsChanged = TRUE;
     288                        if (!udirhead)
     289                            udirhead = info;
     290                        else
     291                            last -> next = info;
     292                    }
     293                    else
     294                    {
     295                        if (!ldirhead)
     296                            ldirhead = info;
     297                        else
     298                            last -> next = info;
     299                    }
     300                    return TRUE;
     301                }
     302                else
     303                    free(info);
     304            }
     305        }
     306    }
    114307    return FALSE;
    115   if(!loadedsetups)
    116     load_setups();
    117   for(x = 0;x < MAXNUMSETUPS;x++) {
    118     if(!stricmp(lastsetups[x],name)) {
    119       *lastsetups[x] = 0;
    120       for(y = x + 1;y < MAXNUMSETUPS;y++)
    121         strcpy(lastsetups[y - 1],lastsetups[y]);
    122       *lastsetups[MAXNUMSETUPS - 1] = 0;
    123       if(lastsetup >= x)
    124         lastsetup--;
    125       return TRUE;
    126     }
    127   }
    128   return FALSE;
    129 }
    130 
    131 
    132 VOID load_udirs (VOID) {
    133 
    134   /* load linked list of user directories from USERDIRS.DAT file */
    135 
    136   FILE      *fp;
    137   LINKDIRS  *info,*last = NULL;
    138   CHAR       s[CCHMAXPATH + 24];
    139 
    140   loadedudirs = TRUE;
    141   fUdirsChanged = FALSE;
    142   save_dir2(s);
    143   if(s[strlen(s) - 1] != '\\')
    144     strcat(s,"\\");
    145   strcat(s,"USERDIRS.DAT");
    146   fp = _fsopen(s,"r",SH_DENYWR);
    147   if(fp) {
    148     while(!feof(fp)) {
    149       if(!fgets(s,CCHMAXPATH + 24,fp))
    150         break;
    151       s[CCHMAXPATH] = 0;
    152       bstripcr(s);
    153       if(*s && *s != ';') {
    154         info = malloc(sizeof(LINKDIRS));
    155         if(info) {
    156           info->path = strdup(s);
    157           if(info->path) {
    158             info->next = NULL;
    159             if(!udirhead)
    160               udirhead = info;
    161             else
    162               last->next = info;
    163             last = info;
    164           }
    165           else
    166             free(info);
    167         }
    168       }
    169     }
    170     fclose(fp);
    171   }
    172 }
    173 
    174 
    175 VOID save_udirs (VOID) {
    176 
    177   FILE     *fp;
    178   LINKDIRS *info;
    179   CHAR      s[CCHMAXPATH + 14];
    180 
    181   if(loadedudirs) {
    182     fUdirsChanged = FALSE;
    183     if(udirhead) {
    184       save_dir2(s);
    185       if(s[strlen(s) - 1] != '\\')
    186         strcat(s,"\\");
    187       strcat(s,"USERDIRS.DAT");
    188       fp = fopen(s,"w");
    189       if(fp) {
    190         fputs(GetPString(IDS_USERDEFDIRSTEXT),fp);
    191         info = udirhead;
    192         while(info) {
    193           fprintf(fp,
    194                   "%0.*s\n",
    195                   CCHMAXPATH,
    196                   info->path);
    197           info = info->next;
    198         }
    199         fclose(fp);
    200       }
    201     }
    202   }
    203 }
    204 
    205 
    206 BOOL add_udir (BOOL userdirs,CHAR *inpath) {
    207 
    208   CHAR      path[CCHMAXPATH];
    209   LINKDIRS *info,*last = NULL,*temp = NULL;
    210 
    211   if(inpath &&
    212      *inpath) {
    213     if(DosQueryPathInfo(inpath,
    214                         FIL_QUERYFULLNAME,
    215                         path,
    216                         sizeof(path)))
    217       strcpy(path,inpath);
    218     if(!userdirs &&
    219        IsRoot(path))
    220       return FALSE;
    221     if(IsFullName(path)) {
    222       if(!loadedudirs)
    223         load_udirs();
    224       info = (userdirs) ? udirhead : ldirhead;
    225       while(info) {
    226         if(!stricmp(info->path,path))
    227           return FALSE;
    228         last = info;
    229         info = info->next;
    230       }
    231       if(!userdirs) {
    232         info = udirhead;
    233         while(info) {
    234           if(!stricmp(info->path,path))
    235             return FALSE;
    236           info = info->next;
    237         }
    238       }
    239       else {  /* if adding manual directory, remove from auto list if present */
    240         info = ldirhead;
    241         while(info) {
    242           if(!stricmp(info->path,path)) {
    243             if(temp)
    244               temp->next = info->next;
    245             else
    246               ldirhead = info->next;
    247             free(info->path);
    248             free(info);
    249             break;
    250           }
    251           temp = info;
    252           info = info->next;
    253         }
    254       }
    255       info = malloc(sizeof(LINKDIRS));
    256       if(info) {
    257         info->path = strdup(path);
    258         if(info->path) {
    259           info->next = NULL;
    260           if(userdirs) {
    261             fUdirsChanged = TRUE;
    262             if(!udirhead)
    263               udirhead = info;
    264             else
    265               last->next = info;
    266           }
    267           else {
    268             if(!ldirhead)
    269               ldirhead = info;
    270             else
    271               last->next = info;
    272           }
    273           return TRUE;
    274         }
    275         else
    276           free(info);
    277       }
    278     }
    279   }
    280   return FALSE;
    281 }
    282 
    283 
    284 BOOL remove_udir (CHAR *path) {
    285 
    286   LINKDIRS *info,*last = NULL;
    287 
    288   if(path && *path) {
    289     if(!loadedudirs)
    290       load_udirs();
    291     info = udirhead;
    292     while(info) {
    293       if(!stricmp(info->path,path)) {
    294         if(last)
    295           last->next = info->next;
    296         else
    297           udirhead = info->next;
    298         free(info->path);
    299         free(info);
    300         fUdirsChanged = TRUE;
    301         return TRUE;
    302       }
    303       last = info;
    304       info = info->next;
    305     }
    306     info = ldirhead;
    307     while(info) {
    308       if(!stricmp(info->path,path)) {
    309         if(last)
    310           last->next = info->next;
    311         else
    312           ldirhead = info->next;
    313         free(info->path);
    314         free(info);
    315         return TRUE;
    316       }
    317       last = info;
    318       info = info->next;
    319     }
    320   }
    321   return FALSE;
    322 }
    323 
    324 
    325 BOOL remove_ldir (CHAR *path) {
    326 
    327   LINKDIRS *info,*last = NULL;
    328 
    329   if(path && *path) {
    330     info = ldirhead;
    331     while(info) {
    332       if(!stricmp(info->path,path)) {
    333         if(last)
    334           last->next = info->next;
    335         else
    336           ldirhead = info->next;
    337         free(info->path);
    338         free(info);
    339         return TRUE;
    340       }
    341       last = info;
    342       info = info->next;
    343     }
    344   }
    345   return FALSE;
    346 }
    347 
    348 
    349 VOID FillPathListBox (HWND hwnd,HWND hwnddrive,HWND hwnddir,CHAR *path,
    350                       BOOL nounwriteable) {
     308}
     309
     310BOOL remove_udir(CHAR * path)
     311{
     312
     313    LINKDIRS *info, *last = NULL;
     314
     315    if (path && *path)
     316    {
     317        if (!loadedudirs)
     318            load_udirs();
     319        info = udirhead;
     320        while (info)
     321        {
     322            if (!stricmp(info -> path, path))
     323            {
     324                if (last)
     325                    last -> next = info -> next;
     326                else
     327                    udirhead = info -> next;
     328                free(info -> path);
     329                free(info);
     330                fUdirsChanged = TRUE;
     331                return TRUE;
     332            }
     333            last = info;
     334            info = info -> next;
     335        }
     336        info = ldirhead;
     337        while (info)
     338        {
     339            if (!stricmp(info -> path, path))
     340            {
     341                if (last)
     342                    last -> next = info -> next;
     343                else
     344                    ldirhead = info -> next;
     345                free(info -> path);
     346                free(info);
     347                return TRUE;
     348            }
     349            last = info;
     350            info = info -> next;
     351        }
     352    }
     353    return FALSE;
     354}
     355
     356BOOL remove_ldir(CHAR * path)
     357{
     358
     359    LINKDIRS *info, *last = NULL;
     360
     361    if (path && *path)
     362    {
     363        info = ldirhead;
     364        while (info)
     365        {
     366            if (!stricmp(info -> path, path))
     367            {
     368                if (last)
     369                    last -> next = info -> next;
     370                else
     371                    ldirhead = info -> next;
     372                free(info -> path);
     373                free(info);
     374                return TRUE;
     375            }
     376            last = info;
     377            info = info -> next;
     378        }
     379    }
     380    return FALSE;
     381}
     382
     383VOID FillPathListBox(HWND hwnd, HWND hwnddrive, HWND hwnddir, CHAR * path,
     384                     BOOL nounwriteable)
     385{
    351386
    352387    /*
    … …  
    357392     */
    358393
    359   CHAR         szDrive[] = " :",szTemp[1032];
    360   FILEFINDBUF3 findbuf;
    361   HDIR         hDir = HDIR_CREATE;
    362   SHORT        sDrive;
    363   ULONG        ulDriveNum,ulSearchCount = 1L,ulDriveMap;
    364 
    365   DosError(FERR_DISABLEHARDERR);
    366   DosQCurDisk(&ulDriveNum,&ulDriveMap);
    367   if(hwnddrive)
    368     WinSendMsg(hwnddrive,LM_DELETEALL,MPVOID,MPVOID);
    369   if(hwnddrive != hwnddir && hwnddir)
    370     WinSendMsg(hwnddir,LM_DELETEALL,MPVOID,MPVOID);
    371 
    372   if(hwnddrive) {
    373     for(sDrive = 0;sDrive < 26;sDrive++) {
    374       if(ulDriveMap & (1L << sDrive)) {
    375         *szDrive = (CHAR)(sDrive + 'A');
    376         if((!nounwriteable || !(driveflags[sDrive] & DRIVE_NOTWRITEABLE)) &&
    377            !(driveflags[sDrive] & (DRIVE_IGNORE | DRIVE_INVALID)))
    378           WinSendMsg(hwnddrive,LM_INSERTITEM,MPFROM2SHORT(LIT_END,0),
    379                      MPFROMP(szDrive));
    380       }
    381     }
    382     if(hwnddrive != hwnddir && path && isalpha(*path) && path[1] == ':') {
    383       *szDrive = toupper(*path);
    384       WinSetWindowText(hwnddrive,szDrive);
    385     }
    386   }
    387 
    388   if(hwnddir) {
    389     sprintf(szTemp,
    390             "%s%s*",
    391             path,
    392             (path[strlen(path) - 1] == '\\') ? "" : "\\");
     394    CHAR szDrive[] = " :", szTemp[1032];
     395    FILEFINDBUF3 findbuf;
     396    HDIR hDir = HDIR_CREATE;
     397    SHORT sDrive;
     398    ULONG ulDriveNum, ulSearchCount = 1L, ulDriveMap;
     399
    393400    DosError(FERR_DISABLEHARDERR);
    394     if(!DosFindFirst(szTemp,
    395                      &hDir,
    396                      FILE_DIRECTORY | MUST_HAVE_DIRECTORY |
    397                      FILE_READONLY | FILE_ARCHIVED | FILE_SYSTEM |
    398                      FILE_HIDDEN,
    399                      &findbuf,
    400                      sizeof(FILEFINDBUF3),
    401                      &ulSearchCount,
    402                      FIL_STANDARD)) {
    403       do {
    404         if(findbuf.attrFile & FILE_DIRECTORY) {
    405           if(strcmp(findbuf.achName,"..") ||
    406              strlen(path) > 3 ||
    407              path[1] != ':') {
    408             if(findbuf.achName[0] != '.' ||
    409                 findbuf.achName[1])
    410               WinSendMsg(hwnddir,
    411                          LM_INSERTITEM,
    412                          MPFROM2SHORT(LIT_SORTASCENDING,0),
    413                          MPFROMP(findbuf.achName));
    414           }
    415         }
    416         ulSearchCount = 1L;
    417       } while(!DosFindNext(hDir,
    418                            &findbuf,
    419                            sizeof(FILEFINDBUF3),
    420                            &ulSearchCount));
    421       DosFindClose(hDir);
    422     }
    423     DosError(FERR_DISABLEHARDERR);
    424   }
    425 }
    426 
    427 
    428 MRESULT EXPENTRY TextSubProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2) {
    429 
    430   PFNWP oldproc = (PFNWP)WinQueryWindowPtr(hwnd,0);
    431 
    432   switch(msg) {
     401    DosQCurDisk(&ulDriveNum, &ulDriveMap);
     402    if (hwnddrive)
     403        WinSendMsg(hwnddrive, LM_DELETEALL, MPVOID, MPVOID);
     404    if (hwnddrive != hwnddir && hwnddir)
     405        WinSendMsg(hwnddir, LM_DELETEALL, MPVOID, MPVOID);
     406
     407    if (hwnddrive)
     408    {
     409        for (sDrive = 0; sDrive < 26; sDrive++)
     410        {
     411            if (ulDriveMap & (1L << sDrive))
     412            {
     413                *szDrive = (CHAR) (sDrive + 'A');
     414                if ((!nounwriteable || !(driveflags[sDrive] & DRIVE_NOTWRITEABLE)) &&
     415                     !(driveflags[sDrive] & (DRIVE_IGNORE | DRIVE_INVALID)))
     416                    WinSendMsg(hwnddrive, LM_INSERTITEM, MPFROM2SHORT(LIT_END, 0),
     417                               MPFROMP(szDrive));
     418            }
     419        }
     420        if (hwnddrive != hwnddir && path && isalpha(*path) && path[1] == ':')
     421        {
     422            *szDrive = toupper(*path);
     423            WinSetWindowText(hwnddrive, szDrive);
     424        }
     425    }
     426
     427    if (hwnddir)
     428    {
     429        sprintf(szTemp,
     430                "%s%s*",
     431                path,
     432                (path[strlen(path) - 1] == '\\') ? "" : "\\");
     433        DosError(FERR_DISABLEHARDERR);
     434        if (!DosFindFirst(szTemp,
     435                          &hDir,
     436                          FILE_DIRECTORY | MUST_HAVE_DIRECTORY |
     437                          FILE_READONLY | FILE_ARCHIVED | FILE_SYSTEM |
     438                          FILE_HIDDEN,
     439                          &findbuf,
     440                          sizeof(FILEFINDBUF3),
     441                          &ulSearchCount,
     442                          FIL_STANDARD))
     443        {
     444            do
     445            {
     446                if (findbuf.attrFile & FILE_DIRECTORY)
     447                {
     448                    if (strcmp(findbuf.achName, "..") ||
     449                            strlen(path) > 3 ||
     450                            path[1] != ':')
     451                    {
     452                        if (findbuf.achName[0] != '.' ||
     453                                findbuf.achName[1])
     454                            WinSendMsg(hwnddir,
     455                                       LM_INSERTITEM,
     456                                       MPFROM2SHORT(LIT_SORTASCENDING, 0),
     457                                       MPFROMP(findbuf.achName));
     458                    }
     459                }
     460                ulSearchCount = 1L;
     461            }
     462            while (!DosFindNext(hDir,
     463                                &findbuf,
     464                                sizeof(FILEFINDBUF3),
     465                                &ulSearchCount));
     466            DosFindClose(hDir);
     467        }
     468        DosError(FERR_DISABLEHARDERR);
     469    }
     470}
     471
     472MRESULT EXPENTRY TextSubProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
     473{
     474
     475    PFNWP oldproc = (PFNWP) WinQueryWindowPtr(hwnd, 0);
     476
     477    switch (msg)
     478    {
    433479    case WM_CHAR:
    434       if(SHORT1FROMMP(mp1) & KC_KEYUP) {
    435         if((SHORT1FROMMP(mp1) & KC_VIRTUALKEY) &&
    436            (SHORT1FROMMP(mp2) & 255) == '\r')
    437           PostMsg(WinQueryWindow(hwnd,QW_PARENT),WM_COMMAND,
    438                      MPFROM2SHORT(DID_OK,0),MPVOID);
    439       }
    440       break;
    441   }
    442   return oldproc(hwnd,msg,mp1,mp2);
    443 }
    444 
    445 
    446 MRESULT EXPENTRY WalkDlgProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2) {
    447 
    448   WALKER      *wa;
    449   CHAR         szBuff[CCHMAXPATH + 1],szBuffer[CCHMAXPATH + 1],*p;
    450   SHORT        sSelect;
    451   static BOOL  okay;  /* avoid combobox selecting as filled */
    452   static CHAR  lastdir[CCHMAXPATH + 1];
    453 
    454   switch(msg) {
     480        if (SHORT1FROMMP(mp1) & KC_KEYUP)
     481        {
     482            if ((SHORT1FROMMP(mp1) & KC_VIRTUALKEY) &&
     483                    (SHORT1FROMMP(mp2) & 255) == '\r')
     484                PostMsg(WinQueryWindow(hwnd, QW_PARENT), WM_COMMAND,
     485                        MPFROM2SHORT(DID_OK, 0), MPVOID);
     486        }
     487        break;
     488    }
     489    return oldproc(hwnd, msg, mp1, mp2);
     490}
     491
     492MRESULT EXPENTRY WalkDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
     493{
     494
     495    WALKER *wa;
     496    CHAR szBuff[CCHMAXPATH + 1], szBuffer[CCHMAXPATH + 1], *p;
     497    SHORT sSelect;
     498    static BOOL okay;           /* avoid combobox selecting as filled */
     499    static CHAR lastdir[CCHMAXPATH + 1];
     500
     501    switch (msg)
     502    {
    455503    case UM_SETUP2:
    456504    case WM_INITDLG:
    457       okay = FALSE;
    458       *lastdir = 0;
    459       if(!mp2) {
    460         WinDismissDlg(hwnd,0);
    461         break;
    462       }
    463       wa = malloc(sizeof(WALKER));
    464       if(!wa) {
    465         DosBeep(50,100);
    466         WinDismissDlg(hwnd,0);
    467         break;
    468       }
    469       memset(wa,0,sizeof(WALKER));
    470       wa->size = (USHORT)sizeof(WALKER);
    471       WinSetWindowPtr(hwnd,0,(PVOID)wa);
    472       wa->szReturnPath = (CHAR *)mp2;
    473       {
    474         PFNWP oldproc;
    475 
    476         oldproc = WinSubclassWindow(WinWindowFromID(hwnd,WALK_PATH),
    477                                     (PFNWP)TextSubProc);
    478         if(oldproc)
    479           WinSetWindowPtr(WinWindowFromID(hwnd,WALK_PATH),
    480                           QWL_USER,
    481                           (PVOID)oldproc);
    482         WinSendDlgItemMsg(WinWindowFromID(hwnd,WALK_RECENT),
    483                           CBID_EDIT,
    484                           EM_SETTEXTLIMIT,
    485                           MPFROM2SHORT(CCHMAXPATH,0),
    486                           MPVOID);
    487         WinSendDlgItemMsg(WinWindowFromID(hwnd,WALK_RECENT),
    488                           CBID_EDIT,
    489                           EM_SETREADONLY,
    490                           MPFROM2SHORT(TRUE,0),
    491                           MPVOID);
    492       }
    493       PosOverOkay(hwnd);
    494       if(msg == UM_SETUP2)
    495         wa->nounwriteable = FALSE;
    496       else
    497         wa->nounwriteable = TRUE;
    498       if(!*wa->szReturnPath)
    499         save_dir2(wa->szCurrentPath);
    500       else {
    501         strcpy(wa->szCurrentPath,
    502                wa->szReturnPath);
    503         MakeFullName(wa->szCurrentPath);
    504       }
    505       if(wa->nounwriteable &&
    506          (driveflags[toupper(*wa->szCurrentPath) - 'A'] &
    507           DRIVE_NOTWRITEABLE)) {
    508 
    509         ULONG bd;
    510 
    511         strcpy(wa->szCurrentPath,"C:\\");
    512         if(DosQuerySysInfo(QSV_BOOT_DRIVE,
    513                            QSV_BOOT_DRIVE,
    514                            (PVOID)&bd,
    515                            (ULONG)sizeof(ULONG)))
    516           bd = 3L;
    517         *wa->szCurrentPath = (CHAR)bd + '@';
    518       }
    519       WinSendDlgItemMsg(hwnd,
    520                         WALK_PATH,
    521                         EM_SETTEXTLIMIT,
    522                         MPFROM2SHORT(CCHMAXPATH,0),
    523                         MPVOID);
    524       WinSetDlgItemText(hwnd,
    525                         WALK_PATH,
    526                         wa->szCurrentPath);
    527       if(!loadedudirs)
    528         load_udirs();
    529       {     /* fill user list box */
    530         ULONG        ulDriveNum,ulDriveMap;
    531         ULONG        ulSearchCount;
    532         FILEFINDBUF3 findbuf;
    533         HDIR         hDir;
    534         APIRET       rc;
    535         LINKDIRS    *info,*temp;
    536 
    537         DosError(FERR_DISABLEHARDERR);
    538         DosQCurDisk(&ulDriveNum,&ulDriveMap);
    539         info = udirhead;
    540         while(info) {
    541           if(IsFullName(info->path) &&
    542              !(driveflags[toupper(*info->path) - 'A'] &
    543                (DRIVE_IGNORE | DRIVE_INVALID))) {
    544             DosError(FERR_DISABLEHARDERR);
    545             hDir = HDIR_CREATE;
    546             ulSearchCount = 1L;
    547             if(!IsRoot(info->path))
    548               rc = DosFindFirst(info->path,&hDir,FILE_DIRECTORY |
    549                                 MUST_HAVE_DIRECTORY | FILE_READONLY |
    550                                 FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    551                                 &findbuf,sizeof(FILEFINDBUF3),
    552                                 &ulSearchCount, FIL_STANDARD);
    553             else {
    554               rc = 0;
    555               findbuf.attrFile = FILE_DIRECTORY;
    556             }
    557             if(!rc) {
    558               if(!IsRoot(info->path))
    559                 DosFindClose(hDir);
    560               if(findbuf.attrFile & FILE_DIRECTORY)
    561                 WinSendDlgItemMsg(hwnd,WALK_USERLIST,LM_INSERTITEM,
    562                                   MPFROM2SHORT(LIT_SORTASCENDING,0),
    563                                   MPFROMP(info->path));
    564               else {
    565                 temp = info->next;
    566                 remove_udir(info->path);
    567                 info = temp;
    568                 continue;
    569               }
    570             }
    571             else if(!(ulDriveMap & (1L << (toupper(*info->path) - 'A')))) {
    572               temp = info->next;
    573               remove_udir(info->path);
    574               info = temp;
    575               continue;
    576             }
    577           }
    578           info = info->next;
    579         }
    580         info = ldirhead;
    581         while(info) {
    582           if(IsFullName(info->path) &&
    583              !(driveflags[toupper(*info->path) - 'A'] &
    584                (DRIVE_IGNORE | DRIVE_INVALID))) {
    585             DosError(FERR_DISABLEHARDERR);
    586             hDir = HDIR_CREATE;
    587             ulSearchCount = 1L;
    588             if(!IsRoot(info->path))
    589               rc = DosFindFirst(info->path,&hDir,FILE_DIRECTORY |
    590                                 MUST_HAVE_DIRECTORY | FILE_READONLY |
    591                                 FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    592                                 &findbuf,sizeof(FILEFINDBUF3),
    593                                 &ulSearchCount, FIL_STANDARD);
    594             else {
    595               rc = 0;
    596               findbuf.attrFile = FILE_DIRECTORY;
    597             }
    598             if(!rc) {
    599               if(!IsRoot(info->path))
    600                 DosFindClose(hDir);
    601               if(findbuf.attrFile & FILE_DIRECTORY)
    602                 WinSendDlgItemMsg(hwnd,WALK_RECENT,LM_INSERTITEM,
    603                                   MPFROM2SHORT(LIT_SORTASCENDING,0),
    604                                   MPFROMP(info->path));
    605               else {
    606                 temp = info->next;
    607                 remove_ldir(info->path);
    608                 info = temp;
    609                 continue;
    610               }
    611               WinSetDlgItemText(hwnd,WALK_RECENT,
    612                                 GetPString(IDS_WALKRECENTDIRSTEXT));
    613             }
    614             else if(!(ulDriveMap & (1L << (toupper(*info->path) - 'A')))) {
    615               temp = info->next;
    616               remove_ldir(info->path);
    617               info = temp;
    618               continue;
    619             }
    620           }
    621           info = info->next;
    622         }
    623       }
    624       FillPathListBox(hwnd,
    625                       WinWindowFromID(hwnd,WALK_DRIVELIST),
    626                       WinWindowFromID(hwnd,WALK_DIRLIST),
    627                       wa->szCurrentPath,wa->nounwriteable);
    628       if(!PostMsg(hwnd,
    629                   UM_SETUP4,
    630                   MPVOID,
    631                   MPVOID))
    632         okay = TRUE;
    633       {
    634         MRESULT ret;
    635 
    636         ret = WinDefDlgProc(hwnd,WM_INITDLG,mp1,mp2);
    637         WinSendMsg(hwnd,UM_SETUP,MPVOID,MPVOID);
    638         WinInvalidateRect(WinWindowFromID(hwnd,WALK_PATH),NULL,TRUE);
    639         return ret;
    640       }
     505        okay = FALSE;
     506        *lastdir = 0;
     507        if (!mp2)
     508        {
     509            WinDismissDlg(hwnd, 0);
     510            break;
     511        }
     512        wa = malloc(sizeof(WALKER));
     513        if (!wa)
     514        {
     515            DosBeep(50, 100);
     516            WinDismissDlg(hwnd, 0);
     517            break;
     518        }
     519        memset(wa, 0, sizeof(WALKER));
     520        wa -> size = (USHORT) sizeof(WALKER);
     521        WinSetWindowPtr(hwnd, 0, (PVOID) wa);
     522        wa -> szReturnPath = (CHAR *) mp2;
     523        {
     524            PFNWP oldproc;
     525
     526            oldproc = WinSubclassWindow(WinWindowFromID(hwnd, WALK_PATH),
     527                                        (PFNWP) TextSubProc);
     528            if (oldproc)
     529                WinSetWindowPtr(WinWindowFromID(hwnd, WALK_PATH),
     530                                QWL_USER,
     531                                (PVOID) oldproc);
     532            WinSendDlgItemMsg(WinWindowFromID(hwnd, WALK_RECENT),
     533                              CBID_EDIT,
     534                              EM_SETTEXTLIMIT,
     535                              MPFROM2SHORT(CCHMAXPATH, 0),
     536                              MPVOID);
     537            WinSendDlgItemMsg(WinWindowFromID(hwnd, WALK_RECENT),
     538                              CBID_EDIT,
     539                              EM_SETREADONLY,
     540                              MPFROM2SHORT(TRUE, 0),
     541                              MPVOID);
     542        }
     543        PosOverOkay(hwnd);
     544        if (msg == UM_SETUP2)
     545            wa -> nounwriteable = FALSE;
     546        else
     547            wa -> nounwriteable = TRUE;
     548        if (!*wa -> szReturnPath)
     549            save_dir2(wa -> szCurrentPath);
     550        else
     551        {
     552            strcpy(wa -> szCurrentPath,
     553                   wa -> szReturnPath);
     554            MakeFullName(wa -> szCurrentPath);
     555        }
     556        if (wa -> nounwriteable &&
     557                (driveflags[toupper(*wa -> szCurrentPath) - 'A'] &
     558                 DRIVE_NOTWRITEABLE))
     559        {
     560
     561            ULONG bd;
     562
     563            strcpy(wa -> szCurrentPath, "C:\\");
     564            if (DosQuerySysInfo(QSV_BOOT_DRIVE,
     565                                QSV_BOOT_DRIVE,
     566                                (PVOID) & bd,
     567                                (ULONG) sizeof(ULONG)))
     568                bd = 3L;
     569            *wa -> szCurrentPath = (CHAR) bd + '@';
     570        }
     571        WinSendDlgItemMsg(hwnd,
     572                          WALK_PATH,
     573                          EM_SETTEXTLIMIT,
     574                          MPFROM2SHORT(CCHMAXPATH, 0),
     575                          MPVOID);
     576        WinSetDlgItemText(hwnd,
     577                          WALK_PATH,
     578                          wa -> szCurrentPath);
     579        if (!loadedudirs)
     580            load_udirs();
     581        {                               /* fill user list box */
     582            ULONG ulDriveNum, ulDriveMap;
     583            ULONG ulSearchCount;
     584            FILEFINDBUF3 findbuf;
     585            HDIR hDir;
     586            APIRET rc;
     587            LINKDIRS *info, *temp;
     588
     589            DosError(FERR_DISABLEHARDERR);
     590            DosQCurDisk(&ulDriveNum, &ulDriveMap);
     591            info = udirhead;
     592            while (info)
     593            {
     594                if (IsFullName(info -> path) &&
     595                        !(driveflags[toupper(*info -> path) - 'A'] &
     596                          (DRIVE_IGNORE | DRIVE_INVALID)))
     597                {
     598                    DosError(FERR_DISABLEHARDERR);
     599                    hDir = HDIR_CREATE;
     600                    ulSearchCount = 1L;
     601                    if (!IsRoot(info -> path))
     602                        rc = DosFindFirst(info -> path, &hDir, FILE_DIRECTORY |
     603                                       MUST_HAVE_DIRECTORY | FILE_READONLY |
     604                                  FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
     605                                          &findbuf, sizeof(FILEFINDBUF3),
     606                                          &ulSearchCount, FIL_STANDARD);
     607                    else
     608                    {
     609                        rc = 0;
     610                        findbuf.attrFile = FILE_DIRECTORY;
     611                    }
     612                    if (!rc)
     613                    {
     614                        if (!IsRoot(info -> path))
     615                            DosFindClose(hDir);
     616                        if (findbuf.attrFile & FILE_DIRECTORY)
     617                            WinSendDlgItemMsg(hwnd, WALK_USERLIST, LM_INSERTITEM,
     618                                         MPFROM2SHORT(LIT_SORTASCENDING, 0),
     619                                              MPFROMP(info -> path));
     620                        else
     621                        {
     622                            temp = info -> next;
     623                            remove_udir(info -> path);
     624                            info = temp;
     625                            continue;
     626                        }
     627                    }
     628                    else if (!(ulDriveMap & (1L << (toupper(*info -> path) - 'A'))))
     629                    {
     630                        temp = info -> next;
     631                        remove_udir(info -> path);
     632                        info = temp;
     633                        continue;
     634                    }
     635                }
     636                info = info -> next;
     637            }
     638            info = ldirhead;
     639            while (info)
     640            {
     641                if (IsFullName(info -> path) &&
     642                        !(driveflags[toupper(*info -> path) - 'A'] &
     643                          (DRIVE_IGNORE | DRIVE_INVALID)))
     644                {
     645                    DosError(FERR_DISABLEHARDERR);
     646                    hDir = HDIR_CREATE;
     647                    ulSearchCount = 1L;
     648                    if (!IsRoot(info -> path))
     649                        rc = DosFindFirst(info -> path, &hDir, FILE_DIRECTORY |
     650                                       MUST_HAVE_DIRECTORY | FILE_READONLY |
     651                                  FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
     652                                          &findbuf, sizeof(FILEFINDBUF3),
     653                                          &ulSearchCount, FIL_STANDARD);
     654                    else
     655                    {
     656                        rc = 0;
     657                        findbuf.attrFile = FILE_DIRECTORY;
     658                    }
     659                    if (!rc)
     660                    {
     661                        if (!IsRoot(info -> path))
     662                            DosFindClose(hDir);
     663                        if (findbuf.attrFile & FILE_DIRECTORY)
     664                            WinSendDlgItemMsg(hwnd, WALK_RECENT, LM_INSERTITEM,
     665                                         MPFROM2SHORT(LIT_SORTASCENDING, 0),
     666                                              MPFROMP(info -> path));
     667                        else
     668                        {
     669                            temp = info -> next;
     670                            remove_ldir(info -> path);
     671                            info = temp;
     672                            continue;
     673                        }
     674                        WinSetDlgItemText(hwnd, WALK_RECENT,
     675                                        GetPString(IDS_WALKRECENTDIRSTEXT));
     676                    }
     677                    else if (!(ulDriveMap & (1L << (toupper(*info -> path) - 'A'))))
     678                    {
     679                        temp = info -> next;
     680                        remove_ldir(info -> path);
     681                        info = temp;
     682                        continue;
     683                    }
     684                }
     685                info = info -> next;
     686            }
     687        }
     688        FillPathListBox(hwnd,
     689                        WinWindowFromID(hwnd, WALK_DRIVELIST),
     690                        WinWindowFromID(hwnd, WALK_DIRLIST),
     691                        wa -> szCurrentPath, wa -> nounwriteable);
     692        if (!PostMsg(hwnd,
     693                     UM_SETUP4,
     694                     MPVOID,
     695                     MPVOID))
     696            okay = TRUE;
     697        {
     698            MRESULT ret;
     699
     700            ret = WinDefDlgProc(hwnd, WM_INITDLG, mp1, mp2);
     701            WinSendMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
     702            WinInvalidateRect(WinWindowFromID(hwnd, WALK_PATH), NULL, TRUE);
     703            return ret;
     704        }
    641705
    642706    case UM_SETUP4:
    643       okay = TRUE;
    644       return 0;
     707        okay = TRUE;
     708        return 0;
    645709
    646710    case WM_ADJUSTWINDOWPOS:
    647       PostMsg(hwnd,UM_SETDIR,MPVOID,MPVOID);
    648       break;
     711        PostMsg(hwnd, UM_SETDIR, MPVOID, MPVOID);
     712        break;
    649713
    650714    case UM_SETDIR:
    651       PaintRecessedWindow(WinWindowFromID(hwnd,WALK_HELP),(HPS)0,FALSE,TRUE);
    652       return 0;
     715        PaintRecessedWindow(WinWindowFromID(hwnd, WALK_HELP), (HPS) 0, FALSE, TRUE);
     716        return 0;
    653717
    654718    case WM_PRESPARAMCHANGED:
    655       {
    656         ULONG AttrFound,AttrValue[64],cbRetLen;
    657 
    658         cbRetLen = WinQueryPresParam(hwnd,(ULONG)mp1,0,&AttrFound,
    659                                      (ULONG)sizeof(AttrValue),
    660                                      &AttrValue,0);
    661         if(cbRetLen) {
    662           switch(AttrFound) {
    663             case PP_FONTNAMESIZE:
    664               PrfWriteProfileData(fmprof,
    665                                   appname,
    666                                   "WalkFont",
    667                                   (PVOID)AttrValue,
    668                                   cbRetLen);
    669               *WalkFont = 0;
    670               WalkFontSize = sizeof(WalkFont);
    671               WinInvalidateRect(WinWindowFromID(hwnd,WALK_PATH),
    672                                 NULL,
    673                                 TRUE);
    674               break;
    675           }
    676         }
    677       }
    678       break;
     719        {
     720            ULONG AttrFound, AttrValue[64], cbRetLen;
     721
     722            cbRetLen = WinQueryPresParam(hwnd, (ULONG) mp1, 0, &AttrFound,
     723                                         (ULONG) sizeof(AttrValue),
     724                                         &AttrValue, 0);
     725            if (cbRetLen)
     726            {
     727                switch (AttrFound)
     728                {
     729                case PP_FONTNAMESIZE:
     730                    PrfWriteProfileData(fmprof,
     731                                        appname,
     732                                        "WalkFont",
     733                                        (PVOID) AttrValue,
     734                                        cbRetLen);
     735                    *WalkFont = 0;
     736                    WalkFontSize = sizeof(WalkFont);
     737                    WinInvalidateRect(WinWindowFromID(hwnd, WALK_PATH),
     738                                      NULL,
     739                                      TRUE);
     740                    break;
     741                }
     742            }
     743        }
     744        break;
    679745
    680746    case UM_SETUP3:
    681       save_udirs();
    682       if(hwndMain)
    683         PostMsg(hwndMain,
    684                 UM_FILLUSERLIST,
    685                 MPVOID,
    686                 MPVOID);
    687       return 0;
     747        save_udirs();
     748        if (hwndMain)
     749            PostMsg(hwndMain,
     750                    UM_FILLUSERLIST,
     751                    MPVOID,
     752                    MPVOID);
     753        return 0;
    688754
    689755    case UM_SETUP:
    690       {
    691         INT    x;
    692         USHORT id[] = {WALK_PATH,WALK_DIRLIST,WALK_USERLIST,
    693                        WALK_RECENT,0};
    694 
    695         if(*WalkFont ||
    696            (PrfQueryProfileData(fmprof,
    697                                 appname,
    698                                 "WalkFont",
    699                                 (PVOID)WalkFont,
    700                                 &WalkFontSize) &&
    701             WalkFontSize)) {
    702           for(x = 0;id[x];x++)
    703             WinSetPresParam(WinWindowFromID(hwnd,id[x]),
    704                             PP_FONTNAMESIZE,
    705                             WalkFontSize,
    706                             (PVOID)WalkFont);
    707         }
    708       }
    709       return 0;
     756        {
     757            INT x;
     758            USHORT id[] =
     759            {WALK_PATH, WALK_DIRLIST, WALK_USERLIST,
     760             WALK_RECENT, 0};
     761
     762            if (*WalkFont ||
     763                    (PrfQueryProfileData(fmprof,
     764                                         appname,
     765                                         "WalkFont",
     766                                         (PVOID) WalkFont,
     767                                         &WalkFontSize) &&
     768                     WalkFontSize))
     769            {
     770                for (x = 0; id[x]; x++)
     771                    WinSetPresParam(WinWindowFromID(hwnd, id[x]),
     772                                    PP_FONTNAMESIZE,
     773                                    WalkFontSize,
     774                                    (PVOID) WalkFont);
     775            }
     776        }
     777        return 0;
    710778
    711779    case UM_CONTROL:
    712780    case WM_CONTROL:
    713       wa = WinQueryWindowPtr(hwnd,0);
    714       if(SHORT1FROMMP(mp1) == WALK_DRIVELIST ||
    715          SHORT1FROMMP(mp1) == WALK_DIRLIST ||
    716          SHORT1FROMMP(mp1) == WALK_USERLIST ||
    717          SHORT1FROMMP(mp1) == WALK_RECENT) {
    718         sSelect = (USHORT)WinSendDlgItemMsg(hwnd,
    719                                             SHORT1FROMMP(mp1),
    720                                             LM_QUERYSELECTION,
    721                                             MPVOID,MPVOID);
    722         *szBuffer = 0;
    723         if(sSelect >= 0)
    724           WinSendDlgItemMsg(hwnd,SHORT1FROMMP(mp1),LM_QUERYITEMTEXT,
    725                             MPFROM2SHORT(sSelect,CCHMAXPATH),
    726                             MPFROMP(szBuffer));
    727       }
    728       switch(SHORT1FROMMP(mp1)) {
    729         case WALK_PATH:
    730           if(SHORT2FROMMP(mp1) == EN_SETFOCUS)
    731             WinSetDlgItemText(hwnd,WALK_HELP,
    732                               GetPString(IDS_WALKCURRDIRTEXT));
    733           else if(SHORT2FROMMP(mp1) == EN_KILLFOCUS)
    734             WinSetDlgItemText(hwnd,WALK_HELP,
    735                               GetPString(IDS_WALKDEFAULTHELPTEXT));
    736           break;
    737 
    738         case WALK_RECENT:
    739           if(okay && SHORT2FROMMP(mp1) == CBN_LBSELECT) {
    740 
    741             ULONG        ulSearchCount;
    742             FILEFINDBUF3 findbuf;
    743             HDIR         hDir;
    744             APIRET       rc;
     781        wa = WinQueryWindowPtr(hwnd, 0);
     782        if (SHORT1FROMMP(mp1) == WALK_DRIVELIST ||
     783                SHORT1FROMMP(mp1) == WALK_DIRLIST ||
     784                SHORT1FROMMP(mp1) == WALK_USERLIST ||
     785                SHORT1FROMMP(mp1) == WALK_RECENT)
     786        {
     787            sSelect = (USHORT) WinSendDlgItemMsg(hwnd,
     788                                                 SHORT1FROMMP(mp1),
     789                                                 LM_QUERYSELECTION,
     790                                                 MPVOID, MPVOID);
     791            *szBuffer = 0;
     792            if (sSelect >= 0)
     793                WinSendDlgItemMsg(hwnd, SHORT1FROMMP(mp1), LM_QUERYITEMTEXT,
     794                                  MPFROM2SHORT(sSelect, CCHMAXPATH),
     795                                  MPFROMP(szBuffer));
     796        }
     797        switch (SHORT1FROMMP(mp1))
     798        {
     799        case WALK_PATH:
     800            if (SHORT2FROMMP(mp1) == EN_SETFOCUS)
     801                WinSetDlgItemText(hwnd, WALK_HELP,
     802                                  GetPString(IDS_WALKCURRDIRTEXT));
     803            else if (SHORT2FROMMP(mp1) == EN_KILLFOCUS)
     804                WinSetDlgItemText(hwnd, WALK_HELP,
     805                                  GetPString(IDS_WALKDEFAULTHELPTEXT));
     806            break;
     807
     808        case WALK_RECENT:
     809            if (okay && SHORT2FROMMP(mp1) == CBN_LBSELECT)
     810            {
     811
     812                ULONG ulSearchCount;
     813                FILEFINDBUF3 findbuf;
     814                HDIR hDir;
     815                APIRET rc;
    745816
    746817//            *szBuffer = 0;
    747 //            WinQueryDlgItemText(hwnd,WALK_RECENT,CCHMAXPATH,szBuffer);
    748             if(!*szBuffer)
    749               break;
    750             DosError(FERR_DISABLEHARDERR);
    751             hDir = HDIR_CREATE;
    752             ulSearchCount = 1L;
    753             if(!IsRoot(szBuffer)) {
    754               rc = DosFindFirst(szBuffer,&hDir,FILE_DIRECTORY |
    755                                 MUST_HAVE_DIRECTORY | FILE_READONLY |
    756                                 FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    757                                 &findbuf,sizeof(FILEFINDBUF3),
    758                                 &ulSearchCount, FIL_STANDARD);
    759               if(!rc)
    760                 DosFindClose(hDir);
    761             }
    762             else {
    763               findbuf.attrFile = FILE_DIRECTORY;
    764               rc = 0;
    765             }
    766             if(!rc && (findbuf.attrFile & FILE_DIRECTORY)) {
    767               strcpy(wa->szCurrentPath,szBuffer);
    768               WinSetDlgItemText(hwnd,WALK_PATH,wa->szCurrentPath);
    769               WinSetDlgItemText(hwnd,WALK_RECENT,wa->szCurrentPath);
    770               FillPathListBox(hwnd,
    771                               WinWindowFromID(hwnd,WALK_DRIVELIST),
    772                               WinWindowFromID(hwnd,WALK_DIRLIST),
    773                               wa->szCurrentPath,FALSE);
    774             }
    775             else
    776               DosBeep(50,100);
    777           }
    778           else if(SHORT2FROMMP(mp1) == CBN_ENTER)
    779             PostMsg(hwnd,WM_COMMAND,MPFROM2SHORT(DID_OK,0),MPVOID);
    780           else if(SHORT2FROMMP(mp1) == CBN_SHOWLIST)
    781             WinSetDlgItemText(hwnd,WALK_HELP,
    782                               GetPString(IDS_WALKRECENTDIRSHELPTEXT));
    783           break;
    784 
    785         case WALK_USERLIST:
    786           if(okay && *szBuffer && SHORT2FROMMP(mp1) == LN_SELECT) {
    787 
    788             ULONG        ulSearchCount;
    789             FILEFINDBUF3 findbuf;
    790             HDIR         hDir;
    791             APIRET       rc;
    792 
    793             DosError(FERR_DISABLEHARDERR);
    794             hDir = HDIR_CREATE;
    795             ulSearchCount = 1L;
    796             if(!IsRoot(szBuffer)) {
    797               rc = DosFindFirst(szBuffer,
    798                                 &hDir,
    799                                 FILE_DIRECTORY |
    800                                 MUST_HAVE_DIRECTORY | FILE_READONLY |
    801                                 FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    802                                 &findbuf,
    803                                 sizeof(FILEFINDBUF3),
    804                                 &ulSearchCount,
    805                                 FIL_STANDARD);
    806               if(!rc)
    807                 DosFindClose(hDir);
    808             }
    809             else {
    810               findbuf.attrFile = FILE_DIRECTORY;
    811               rc = 0;
    812             }
    813             if(!rc && (findbuf.attrFile & FILE_DIRECTORY)) {
    814               strcpy(wa->szCurrentPath,szBuffer);
    815               WinSetDlgItemText(hwnd,WALK_PATH,wa->szCurrentPath);
    816               FillPathListBox(hwnd,
    817                               WinWindowFromID(hwnd,WALK_DRIVELIST),
    818                               WinWindowFromID(hwnd,WALK_DIRLIST),
    819                               wa->szCurrentPath,FALSE);
    820             }
    821             else
    822               DosBeep(50,100);
    823           }
    824           else if(SHORT2FROMMP(mp1) == LN_ENTER)
    825             PostMsg(hwnd,
    826                     WM_COMMAND,
    827                     MPFROM2SHORT(DID_OK,0),
    828                     MPVOID);
    829           else if(SHORT2FROMMP(mp1) == LN_SETFOCUS)
    830             WinSetDlgItemText(hwnd,
    831                               WALK_HELP,
    832                               GetPString(IDS_WALKUSERDIRSHELPTEXT));
    833           else if(SHORT2FROMMP(mp1) == LN_KILLFOCUS)
    834             WinSetDlgItemText(hwnd,
    835                               WALK_HELP,
    836                               GetPString(IDS_WALKDEFAULTHELPTEXT));
    837           break;
    838 
    839         case WALK_DRIVELIST:
    840           if(okay && *szBuffer && SHORT2FROMMP(mp1) == LN_ENTER) {
    841 
    842             ULONG  ulDirLen = CCHMAXPATH;
    843             APIRET rc;
    844 
    845             rc = DosQCurDir(toupper(*szBuffer) - '@',
    846                             &szBuff[3],&ulDirLen);
    847             if(!rc) {
    848               strcpy(wa->szCurrentPath,"C:\\");
    849               *wa->szCurrentPath = toupper(*szBuffer);
    850               WinSetDlgItemText(hwnd,
    851                                 WALK_PATH,
    852                                 wa->szCurrentPath);
    853               FillPathListBox(hwnd,
    854                               WinWindowFromID(hwnd,WALK_DRIVELIST),
    855                               WinWindowFromID(hwnd,WALK_DIRLIST),
    856                               wa->szCurrentPath,FALSE);
    857             }
    858           }
    859           else if(SHORT2FROMMP(mp1) == LN_SETFOCUS)
    860             WinSetDlgItemText(hwnd,WALK_HELP,
    861                               GetPString(IDS_WALKDRIVELISTHELPTEXT));
    862           else if(SHORT2FROMMP(mp1) == LN_KILLFOCUS)
    863             WinSetDlgItemText(hwnd,WALK_HELP,
    864                               GetPString(IDS_WALKDEFAULTHELPTEXT));
    865           break;
    866 
    867         case WALK_DIRLIST:
    868           if(okay && SHORT2FROMMP(mp1) == LN_ENTER) {
    869 
    870             ULONG        ulSearchCount;
    871             FILEFINDBUF3 findbuf;
    872             HDIR         hDir;
    873             APIRET       rc;
    874 
    875             bstrip(szBuffer);
    876             if(*szBuffer) {
    877               strcpy(szBuff,wa->szCurrentPath);
    878               if(szBuff[strlen(szBuff) - 1] != '\\')
    879                 strcat(szBuff,"\\");
    880               strcat(szBuff,
    881                      szBuffer);
    882               MakeFullName(szBuff);
    883               DosError(FERR_DISABLEHARDERR);
    884               hDir = HDIR_CREATE;
    885               ulSearchCount = 1L;
    886               if(!IsRoot(szBuff)) {
    887                 rc = DosFindFirst(szBuff,
    888                                   &hDir,
    889                                   FILE_DIRECTORY |
    890                                   MUST_HAVE_DIRECTORY | FILE_READONLY |
    891                                   FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    892                                   &findbuf,
    893                                   sizeof(FILEFINDBUF3),
    894                                   &ulSearchCount,
    895                                   FIL_STANDARD);
    896                 if(!rc)
    897                   DosFindClose(hDir);
    898               }
    899               else {
    900                 findbuf.attrFile = FILE_DIRECTORY;
    901                 rc = 0;
    902               }
    903               if(!rc && (findbuf.attrFile & FILE_DIRECTORY)) {
    904                 strcpy(wa->szCurrentPath,szBuff);
    905                 WinSetDlgItemText(hwnd,WALK_PATH,wa->szCurrentPath);
    906                 FillPathListBox(hwnd,
    907                                 WinWindowFromID(hwnd,WALK_DRIVELIST),
    908                                 WinWindowFromID(hwnd,WALK_DIRLIST),
    909                                 wa->szCurrentPath,FALSE);
    910               }
    911             }
    912           }
    913           else if(SHORT2FROMMP(mp1) == LN_SETFOCUS)
    914             WinSetDlgItemText(hwnd,WALK_HELP,
    915                               GetPString(IDS_WALKDIRLISTHELPTEXT));
    916           else if(SHORT2FROMMP(mp1) == LN_KILLFOCUS)
    917             WinSetDlgItemText(hwnd,WALK_HELP,
    918                               GetPString(IDS_WALKDEFAULTHELPTEXT));
    919           break;
    920       }
    921       return 0;
     818                //            WinQueryDlgItemText(hwnd,WALK_RECENT,CCHMAXPATH,szBuffer);
     819                if (!*szBuffer)
     820                    break;
     821                DosError(FERR_DISABLEHARDERR);
     822                hDir = HDIR_CREATE;
     823                ulSearchCount = 1L;
     824                if (!IsRoot(szBuffer))
     825                {
     826                    rc = DosFindFirst(szBuffer, &hDir, FILE_DIRECTORY |
     827                                      MUST_HAVE_DIRECTORY | FILE_READONLY |
     828                                  FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
     829                                      &findbuf, sizeof(FILEFINDBUF3),
     830                                      &ulSearchCount, FIL_STANDARD);
     831                    if (!rc)
     832                        DosFindClose(hDir);
     833                }
     834                else
     835                {
     836                    findbuf.attrFile = FILE_DIRECTORY;
     837                    rc = 0;
     838                }
     839                if (!rc && (findbuf.attrFile & FILE_DIRECTORY))
     840                {
     841                    strcpy(wa -> szCurrentPath, szBuffer);
     842                    WinSetDlgItemText(hwnd, WALK_PATH, wa -> szCurrentPath);
     843                    WinSetDlgItemText(hwnd, WALK_RECENT, wa -> szCurrentPath);
     844                    FillPathListBox(hwnd,
     845                                    WinWindowFromID(hwnd, WALK_DRIVELIST),
     846                                    WinWindowFromID(hwnd, WALK_DIRLIST),
     847                                    wa -> szCurrentPath, FALSE);
     848                }
     849                else
     850                    DosBeep(50, 100);
     851            }
     852            else if (SHORT2FROMMP(mp1) == CBN_ENTER)
     853                PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(DID_OK, 0), MPVOID);
     854            else if (SHORT2FROMMP(mp1) == CBN_SHOWLIST)
     855                WinSetDlgItemText(hwnd, WALK_HELP,
     856                                  GetPString(IDS_WALKRECENTDIRSHELPTEXT));
     857            break;
     858
     859        case WALK_USERLIST:
     860            if (okay && *szBuffer && SHORT2FROMMP(mp1) == LN_SELECT)
     861            {
     862
     863                ULONG ulSearchCount;
     864                FILEFINDBUF3 findbuf;
     865                HDIR hDir;
     866                APIRET rc;
     867
     868                DosError(FERR_DISABLEHARDERR);
     869                hDir = HDIR_CREATE;
     870                ulSearchCount = 1L;
     871                if (!IsRoot(szBuffer))
     872                {
     873                    rc = DosFindFirst(szBuffer,
     874                                      &hDir,
     875                                      FILE_DIRECTORY |
     876                                      MUST_HAVE_DIRECTORY | FILE_READONLY |
     877                                  FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
     878                                      &findbuf,
     879                                      sizeof(FILEFINDBUF3),
     880                                      &ulSearchCount,
     881                                      FIL_STANDARD);
     882                    if (!rc)
     883                        DosFindClose(hDir);
     884                }
     885                else
     886                {
     887                    findbuf.attrFile = FILE_DIRECTORY;
     888                    rc = 0;
     889                }
     890                if (!rc && (findbuf.attrFile & FILE_DIRECTORY))
     891                {
     892                    strcpy(wa -> szCurrentPath, szBuffer);
     893                    WinSetDlgItemText(hwnd, WALK_PATH, wa -> szCurrentPath);
     894                    FillPathListBox(hwnd,
     895                                    WinWindowFromID(hwnd, WALK_DRIVELIST),
     896                                    WinWindowFromID(hwnd, WALK_DIRLIST),
     897                                    wa -> szCurrentPath, FALSE);
     898                }
     899                else
     900                    DosBeep(50, 100);
     901            }
     902            else if (SHORT2FROMMP(mp1) == LN_ENTER)
     903                PostMsg(hwnd,
     904                        WM_COMMAND,
     905                        MPFROM2SHORT(DID_OK, 0),
     906                        MPVOID);
     907            else if (SHORT2FROMMP(mp1) == LN_SETFOCUS)
     908                WinSetDlgItemText(hwnd,
     909                                  WALK_HELP,
     910                                  GetPString(IDS_WALKUSERDIRSHELPTEXT));
     911            else if (SHORT2FROMMP(mp1) == LN_KILLFOCUS)
     912                WinSetDlgItemText(hwnd,
     913                                  WALK_HELP,
     914                                  GetPString(IDS_WALKDEFAULTHELPTEXT));
     915            break;
     916
     917        case WALK_DRIVELIST:
     918            if (okay && *szBuffer && SHORT2FROMMP(mp1) == LN_ENTER)
     919            {
     920
     921                ULONG ulDirLen = CCHMAXPATH;
     922                APIRET rc;
     923
     924                rc = DosQCurDir(toupper(*szBuffer) - '@',
     925                                &szBuff[3], &ulDirLen);
     926                if (!rc)
     927                {
     928                    strcpy(wa -> szCurrentPath, "C:\\");
     929                    *wa -> szCurrentPath = toupper(*szBuffer);
     930                    WinSetDlgItemText(hwnd,
     931                                      WALK_PATH,
     932                                      wa -> szCurrentPath);
     933                    FillPathListBox(hwnd,
     934                                    WinWindowFromID(hwnd, WALK_DRIVELIST),
     935                                    WinWindowFromID(hwnd, WALK_DIRLIST),
     936                                    wa -> szCurrentPath, FALSE);
     937                }
     938            }
     939            else if (SHORT2FROMMP(mp1) == LN_SETFOCUS)
     940                WinSetDlgItemText(hwnd, WALK_HELP,
     941                                  GetPString(IDS_WALKDRIVELISTHELPTEXT));
     942            else if (SHORT2FROMMP(mp1) == LN_KILLFOCUS)
     943                WinSetDlgItemText(hwnd, WALK_HELP,
     944                                  GetPString(IDS_WALKDEFAULTHELPTEXT));
     945            break;
     946
     947        case WALK_DIRLIST:
     948            if (okay && SHORT2FROMMP(mp1) == LN_ENTER)
     949            {
     950
     951                ULONG ulSearchCount;
     952                FILEFINDBUF3 findbuf;
     953                HDIR hDir;
     954                APIRET rc;
     955
     956                bstrip(szBuffer);
     957                if (*szBuffer)
     958                {
     959                    strcpy(szBuff, wa -> szCurrentPath);
     960                    if (szBuff[strlen(szBuff) - 1] != '\\')
     961                        strcat(szBuff, "\\");
     962                    strcat(szBuff,
     963                           szBuffer);
     964                    MakeFullName(szBuff);
     965                    DosError(FERR_DISABLEHARDERR);
     966                    hDir = HDIR_CREATE;
     967                    ulSearchCount = 1L;
     968                    if (!IsRoot(szBuff))
     969                    {
     970                        rc = DosFindFirst(szBuff,
     971                                          &hDir,
     972                                          FILE_DIRECTORY |
     973                                       MUST_HAVE_DIRECTORY | FILE_READONLY |
     974                                  FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
     975                                          &findbuf,
     976                                          sizeof(FILEFINDBUF3),
     977                                          &ulSearchCount,
     978                                          FIL_STANDARD);
     979                        if (!rc)
     980                            DosFindClose(hDir);
     981                    }
     982                    else
     983                    {
     984                        findbuf.attrFile = FILE_DIRECTORY;
     985                        rc = 0;
     986                    }
     987                    if (!rc && (findbuf.attrFile & FILE_DIRECTORY))
     988                    {
     989                        strcpy(wa -> szCurrentPath, szBuff);
     990                        WinSetDlgItemText(hwnd, WALK_PATH, wa -> szCurrentPath);
     991                        FillPathListBox(hwnd,
     992                                      WinWindowFromID(hwnd, WALK_DRIVELIST),
     993                                        WinWindowFromID(hwnd, WALK_DIRLIST),
     994                                        wa -> szCurrentPath, FALSE);
     995                    }
     996                }
     997            }
     998            else if (SHORT2FROMMP(mp1) == LN_SETFOCUS)
     999                WinSetDlgItemText(hwnd, WALK_HELP,
     1000                                  GetPString(IDS_WALKDIRLISTHELPTEXT));
     1001            else if (SHORT2FROMMP(mp1) == LN_KILLFOCUS)
     1002                WinSetDlgItemText(hwnd, WALK_HELP,
     1003                                  GetPString(IDS_WALKDEFAULTHELPTEXT));
     1004            break;
     1005        }
     1006        return 0;
    9221007
    9231008    case WM_COMMAND:
    924       wa = WinQueryWindowPtr(hwnd,0);
    925       if(!wa)
    926         WinDismissDlg(hwnd,0);
    927       *szBuff = 0;
    928       WinQueryDlgItemText(hwnd,
    929                           WALK_PATH,
    930                           CCHMAXPATH,
    931                           szBuff);
    932       bstrip(szBuff);
    933       while((p = strchr(szBuff,'/')) != NULL)
    934         *p = '\\';
    935       while(strlen(szBuff) > 3 &&
    936             szBuff[strlen(szBuff) - 1] == '\\')
    937         szBuff[strlen(szBuff) - 1] = 0;
    938       MakeFullName(szBuff);
    939       if(*szBuff &&
    940          stricmp(szBuff,wa->szCurrentPath)) {
    941         if(!SetDir(WinQueryWindow(WinQueryWindow(hwnd,QW_PARENT),
    942                                   QW_OWNER),
    943                    hwnd,
    944                    szBuff,
    945                    0))
    946           strcpy(wa->szCurrentPath,
    947                  szBuff);
    948         else if(SHORT1FROMMP(mp1) != DID_CANCEL)
    949           return 0;
    950       }
    951       WinSetDlgItemText(hwnd,
    952                         WALK_PATH,
    953                         wa->szCurrentPath);
    954       switch(SHORT1FROMMP(mp1)) {
    955         case WALK_ADD:
    956           *szBuff = 0;
    957           WinQueryDlgItemText(hwnd,
    958                               WALK_PATH,
    959                               CCHMAXPATH,
    960                               szBuff);
    961           bstrip(szBuff);
    962           while((p = strchr(szBuff,'/')) != NULL)
    963             *p = '\\';
    964           if(*szBuff &&
    965              !IsFile(szBuff)) {
    966             MakeFullName(szBuff);
    967             if(add_udir(TRUE,
    968                         szBuff)) {
    969               WinSendDlgItemMsg(hwnd,
    970                                 WALK_USERLIST,
    971                                 LM_INSERTITEM,
    972                                 MPFROM2SHORT(LIT_SORTASCENDING,0),
    973                                 MPFROMP(szBuff));
    974               wa->changed = 1;
    975             }
    976             else
    977               DosBeep(50,100);
    978           }
    979           break;
    980 
    981         case WALK_DELETE:
    982           *szBuff = 0;
    983           WinQueryDlgItemText(hwnd,WALK_PATH,CCHMAXPATH,szBuff);
    984           bstrip(szBuff);
    985           while((p = strchr(szBuff,'/')) != NULL)
    986             *p = '\\';
    987           if(*szBuff &&
    988              !IsFile(szBuff)) {
    989             MakeFullName(szBuff);
    990             sSelect = (SHORT)WinSendDlgItemMsg(hwnd,
    991                                                WALK_USERLIST,
    992                                                LM_SEARCHSTRING,
    993                                                MPFROM2SHORT(0,LIT_FIRST),
    994                                                MPFROMP(szBuff));
    995             if(sSelect >= 0) {
    996               WinSendDlgItemMsg(hwnd,
    997                                 WALK_USERLIST,
    998                                 LM_DELETEITEM,
    999                                 MPFROM2SHORT(sSelect,0),
    1000                                 MPVOID);
    1001               remove_udir(szBuff);
    1002               wa->changed = 1;
    1003             }
    1004           }
    1005           break;
    1006 
    1007         case DID_OK:
    1008           if(*wa->szCurrentPath) {
    1009             strcpy(wa->szReturnPath,
    1010                    wa->szCurrentPath);
    1011             MakeValidDir(wa->szReturnPath);
    1012             if(fAutoAddAllDirs)
    1013               add_udir(FALSE,
    1014                        wa->szReturnPath);
    1015             if(fChangeTarget) {
    1016               strcpy(targetdir,
    1017                      wa->szReturnPath);
    1018               PrfWriteProfileString(fmprof,
    1019                                     appname,
    1020                                     "Targetdir",
    1021                                     targetdir);
    1022             }
    1023           }
    1024           if(wa->changed)
    1025             WinSendMsg(hwnd,
    1026                        UM_SETUP3,
    1027                        MPVOID,
    1028                        MPVOID);
    1029           WinDismissDlg(hwnd,1);
    1030           break;
    1031 
    1032         case IDM_HELP:
    1033           if(hwndHelp)
    1034             WinSendMsg(hwndHelp,
    1035                        HM_DISPLAY_HELP,
    1036                        MPFROM2SHORT(HELP_WALKEM,0),
    1037                        MPFROMSHORT(HM_RESOURCEID));
    1038           break;
    1039 
    1040         case DID_CANCEL:
    1041           if(wa->changed)
    1042             WinSendMsg(hwnd,
    1043                        UM_SETUP3,
    1044                        MPVOID,
    1045                        MPVOID);
    1046           free(wa);
    1047           WinDismissDlg(hwnd,0);
    1048           break;
    1049       }
    1050       return 0;
     1009        wa = WinQueryWindowPtr(hwnd, 0);
     1010        if (!wa)
     1011            WinDismissDlg(hwnd, 0);
     1012        *szBuff = 0;
     1013        WinQueryDlgItemText(hwnd,
     1014                            WALK_PATH,
     1015                            CCHMAXPATH,
     1016                            szBuff);
     1017        bstrip(szBuff);
     1018        while ((p = strchr(szBuff, '/')) != NULL)
     1019            *p = '\\';
     1020        while (strlen(szBuff) > 3 &&
     1021                szBuff[strlen(szBuff) - 1] == '\\')
     1022            szBuff[strlen(szBuff) - 1] = 0;
     1023        MakeFullName(szBuff);
     1024        if (*szBuff &&
     1025                stricmp(szBuff, wa -> szCurrentPath))
     1026        {
     1027            if (!SetDir(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
     1028                                       QW_OWNER),
     1029                        hwnd,
     1030                        szBuff,
     1031                        0))
     1032                strcpy(wa -> szCurrentPath,
     1033                       szBuff);
     1034            else if (SHORT1FROMMP(mp1) != DID_CANCEL)
     1035                return 0;
     1036        }
     1037        WinSetDlgItemText(hwnd,
     1038                          WALK_PATH,
     1039                          wa -> szCurrentPath);
     1040        switch (SHORT1FROMMP(mp1))
     1041        {
     1042        case WALK_ADD:
     1043            *szBuff = 0;
     1044            WinQueryDlgItemText(hwnd,
     1045                                WALK_PATH,
     1046                                CCHMAXPATH,
     1047                                szBuff);
     1048            bstrip(szBuff);
     1049            while ((p = strchr(szBuff, '/')) != NULL)
     1050                *p = '\\';
     1051            if (*szBuff &&
     1052                    !IsFile(szBuff))
     1053            {
     1054                MakeFullName(szBuff);
     1055                if (add_udir(TRUE,
     1056                             szBuff))
     1057                {
     1058                    WinSendDlgItemMsg(hwnd,
     1059                                      WALK_USERLIST,
     1060                                      LM_INSERTITEM,
     1061                                      MPFROM2SHORT(LIT_SORTASCENDING, 0),
     1062                                      MPFROMP(szBuff));
     1063                    wa -> changed = 1;
     1064                }
     1065                else
     1066                    DosBeep(50, 100);
     1067            }
     1068            break;
     1069
     1070        case WALK_DELETE:
     1071            *szBuff = 0;
     1072            WinQueryDlgItemText(hwnd, WALK_PATH, CCHMAXPATH, szBuff);
     1073            bstrip(szBuff);
     1074            while ((p = strchr(szBuff, '/')) != NULL)
     1075                *p = '\\';
     1076            if (*szBuff &&
     1077                    !IsFile(szBuff))
     1078            {
     1079                MakeFullName(szBuff);
     1080                sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
     1081                                                    WALK_USERLIST,
     1082                                                    LM_SEARCHSTRING,
     1083                                                 MPFROM2SHORT(0, LIT_FIRST),
     1084                                                    MPFROMP(szBuff));
     1085                if (sSelect >= 0)
     1086                {
     1087                    WinSendDlgItemMsg(hwnd,
     1088                                      WALK_USERLIST,
     1089                                      LM_DELETEITEM,
     1090                                      MPFROM2SHORT(sSelect, 0),
     1091                                      MPVOID);
     1092                    remove_udir(szBuff);
     1093                    wa -> changed = 1;
     1094                }
     1095            }
     1096            break;
     1097
     1098        case DID_OK:
     1099            if (*wa -> szCurrentPath)
     1100            {
     1101                strcpy(wa -> szReturnPath,
     1102                       wa -> szCurrentPath);
     1103                MakeValidDir(wa -> szReturnPath);
     1104                if (fAutoAddAllDirs)
     1105                    add_udir(FALSE,
     1106                             wa -> szReturnPath);
     1107                if (fChangeTarget)
     1108                {
     1109                    strcpy(targetdir,
     1110                           wa -> szReturnPath);
     1111                    PrfWriteProfileString(fmprof,
     1112                                          appname,
     1113                                          "Targetdir",
     1114                                          targetdir);
     1115                }
     1116            }
     1117            if (wa -> changed)
     1118                WinSendMsg(hwnd,
     1119                           UM_SETUP3,
     1120                           MPVOID,
     1121                           MPVOID);
     1122            WinDismissDlg(hwnd, 1);
     1123            break;
     1124
     1125        case IDM_HELP:
     1126            if (hwndHelp)
     1127                WinSendMsg(hwndHelp,
     1128                           HM_DISPLAY_HELP,
     1129                           MPFROM2SHORT(HELP_WALKEM, 0),
     1130                           MPFROMSHORT(HM_RESOURCEID));
     1131            break;
     1132
     1133        case DID_CANCEL:
     1134            if (wa -> changed)
     1135                WinSendMsg(hwnd,
     1136                           UM_SETUP3,
     1137                           MPVOID,
     1138                           MPVOID);
     1139            free(wa);
     1140            WinDismissDlg(hwnd, 0);
     1141            break;
     1142        }
     1143        return 0;
    10511144
    10521145    case WM_CLOSE:
    1053       break;
    1054   }
    1055   return WinDefDlgProc(hwnd,msg,mp1,mp2);
    1056 }
    1057 
    1058 
    1059 MRESULT EXPENTRY WalkAllDlgProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2) {
    1060 
    1061   switch(msg) {
     1146        break;
     1147    }
     1148    return WinDefDlgProc(hwnd, msg, mp1, mp2);
     1149}
     1150
     1151MRESULT EXPENTRY WalkAllDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
     1152{
     1153
     1154    switch (msg)
     1155    {
    10621156    case WM_INITDLG:
    1063       return WalkDlgProc(hwnd,
    1064                          UM_SETUP2,
    1065                          mp1,
    1066                          mp2);
    1067   }
    1068   return WalkDlgProc(hwnd,msg,mp1,mp2);
    1069 }
    1070 
    1071 
    1072 MRESULT EXPENTRY WalkCopyDlgProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2) {
    1073 
    1074   switch(msg) {
     1157        return WalkDlgProc(hwnd,
     1158                           UM_SETUP2,
     1159                           mp1,
     1160                           mp2);
     1161    }
     1162    return WalkDlgProc(hwnd, msg, mp1, mp2);
     1163}
     1164
     1165MRESULT EXPENTRY WalkCopyDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
     1166{
     1167
     1168    switch (msg)
     1169    {
    10751170    case WM_INITDLG:
    1076       WinSetWindowText(hwnd,
    1077                        GetPString(IDS_WALKCOPYDLGTEXT));
    1078       return WalkDlgProc(hwnd,
    1079                          UM_SETUP2,
    1080                          mp1,
    1081                          mp2);
    1082   }
    1083   return WalkDlgProc(hwnd,msg,mp1,mp2);
    1084 }
    1085 
    1086 
    1087 MRESULT EXPENTRY WalkMoveDlgProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2) {
    1088 
    1089   switch(msg) {
     1171        WinSetWindowText(hwnd,
     1172                         GetPString(IDS_WALKCOPYDLGTEXT));
     1173        return WalkDlgProc(hwnd,
     1174                           UM_SETUP2,
     1175                           mp1,
     1176                           mp2);
     1177    }
     1178    return WalkDlgProc(hwnd, msg, mp1, mp2);
     1179}
     1180
     1181MRESULT EXPENTRY WalkMoveDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
     1182{
     1183
     1184    switch (msg)
     1185    {
    10901186    case WM_INITDLG:
    1091       WinSetWindowText(hwnd,
    1092                        GetPString(IDS_WALKMOVEDLGTEXT));
    1093       return WalkDlgProc(hwnd,
    1094                          UM_SETUP2,
    1095                          mp1,
    1096                          mp2);
    1097   }
    1098   return WalkDlgProc(hwnd,msg,mp1,mp2);
    1099 }
    1100 
    1101 
    1102 MRESULT EXPENTRY WalkExtractDlgProc (HWND hwnd,ULONG msg,MPARAM mp1,
    1103                                      MPARAM mp2) {
    1104 
    1105   switch(msg) {
     1187        WinSetWindowText(hwnd,
     1188                         GetPString(IDS_WALKMOVEDLGTEXT));
     1189        return WalkDlgProc(hwnd,
     1190                           UM_SETUP2,
     1191                           mp1,
     1192                           mp2);
     1193    }
     1194    return WalkDlgProc(hwnd, msg, mp1, mp2);
     1195}
     1196
     1197MRESULT EXPENTRY WalkExtractDlgProc(HWND hwnd, ULONG msg, MPARAM mp1,
     1198                                    MPARAM mp2)
     1199{
     1200
     1201    switch (msg)
     1202    {
    11061203    case WM_INITDLG:
    1107       WinSetWindowText(hwnd,
    1108                        GetPString(IDS_WALKEXTRACTDLGTEXT));
    1109       return WalkDlgProc(hwnd,
    1110                          UM_SETUP2,
    1111                          mp1,
    1112                          mp2);
    1113   }
    1114   return WalkDlgProc(hwnd,msg,mp1,mp2);
    1115 }
    1116 
    1117 
    1118 MRESULT EXPENTRY WalkTargetDlgProc (HWND hwnd,ULONG msg,MPARAM mp1,
    1119                                     MPARAM mp2) {
    1120 
    1121   switch(msg) {
     1204        WinSetWindowText(hwnd,
     1205                         GetPString(IDS_WALKEXTRACTDLGTEXT));
     1206        return WalkDlgProc(hwnd,
     1207                           UM_SETUP2,
     1208                           mp1,
     1209                           mp2);
     1210    }
     1211    return WalkDlgProc(hwnd, msg, mp1, mp2);
     1212}
     1213
     1214MRESULT EXPENTRY WalkTargetDlgProc(HWND hwnd, ULONG msg, MPARAM mp1,
     1215                                   MPARAM mp2)
     1216{
     1217
     1218    switch (msg)
     1219    {
    11221220    case WM_INITDLG:
    1123       {
    1124         char s[CCHMAXPATH + 32];
    1125 
    1126         sprintf(s,
    1127                 GetPString(IDS_WALKTARGETDLGTEXT),
    1128                 (*targetdir) ?
    1129                  NullStr :
    1130                  " (",
    1131                 (*targetdir) ?
    1132                  NullStr :
    1133                  GetPString(IDS_NONE),
    1134                 (*targetdir) ?
    1135                  NullStr :
    1136                  ")");
    1137         WinSetWindowText(hwnd,s);
    1138       }
    1139       return WalkDlgProc(hwnd,
    1140                          UM_SETUP2,
    1141                          mp1,
    1142                          mp2);
    1143   }
    1144   return WalkDlgProc(hwnd,msg,mp1,mp2);
    1145 }
    1146 
    1147 
    1148 MRESULT EXPENTRY WalkTwoDlgProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2) {
    1149 
    1150   WALK2       *wa;
    1151   CHAR         szBuff[CCHMAXPATH + 1],szBuffer[CCHMAXPATH + 1],*p;
    1152   SHORT        sSelect;
    1153   static BOOL  okay;  /* avoid combobox selecting as filled */
    1154 
    1155   switch(msg) {
     1221        {
     1222            char s[CCHMAXPATH + 32];
     1223
     1224            sprintf(s,
     1225                    GetPString(IDS_WALKTARGETDLGTEXT),
     1226                    (*targetdir) ?
     1227                    NullStr :
     1228                    " (",
     1229                    (*targetdir) ?
     1230                    NullStr :
     1231                    GetPString(IDS_NONE),
     1232                    (*targetdir) ?
     1233                    NullStr :
     1234                    ")");
     1235            WinSetWindowText(hwnd, s);
     1236        }
     1237        return WalkDlgProc(hwnd,
     1238                           UM_SETUP2,
     1239                           mp1,
     1240                           mp2);
     1241    }
     1242    return WalkDlgProc(hwnd, msg, mp1, mp2);
     1243}
     1244
     1245MRESULT EXPENTRY WalkTwoDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
     1246{
     1247
     1248    WALK2 *wa;
     1249    CHAR szBuff[CCHMAXPATH + 1], szBuffer[CCHMAXPATH + 1], *p;
     1250    SHORT sSelect;
     1251    static BOOL okay;           /* avoid combobox selecting as filled */
     1252
     1253    switch (msg)
     1254    {
    11561255    case UM_SETUP2:
    11571256    case WM_INITDLG:
    1158       okay = FALSE;
    1159       if(!mp2) {
    1160         WinDismissDlg(hwnd,0);
    1161         break;
    1162       }
    1163       WinSetWindowPtr(hwnd,0,mp2);
    1164       wa = mp2;
    1165       {
    1166         PFNWP oldproc;
    1167 
    1168         oldproc = WinSubclassWindow(WinWindowFromID(hwnd,WALK_PATH),
    1169                                     (PFNWP)TextSubProc);
    1170         if(oldproc)
    1171           WinSetWindowPtr(WinWindowFromID(hwnd,WALK_PATH),
    1172                           QWL_USER,
    1173                           (PVOID)oldproc);
    1174         oldproc = WinSubclassWindow(WinWindowFromID(hwnd,WALK2_PATH),
    1175                                     (PFNWP)TextSubProc);
    1176         if(oldproc)
    1177           WinSetWindowPtr(WinWindowFromID(hwnd,WALK2_PATH),
    1178                           QWL_USER,
    1179                           (PVOID)oldproc);
    1180       }
    1181       if(!*wa->szCurrentPath1)
    1182         save_dir2(wa->szCurrentPath1);
    1183       MakeFullName(wa->szCurrentPath1);
    1184       if(!*wa->szCurrentPath2)
    1185         save_dir2(wa->szCurrentPath2);
    1186       MakeFullName(wa->szCurrentPath2);
    1187       WinSendDlgItemMsg(hwnd,
    1188                         WALK_PATH,
    1189                         EM_SETTEXTLIMIT,
    1190                         MPFROM2SHORT(CCHMAXPATH,0),
    1191                         MPVOID);
    1192       WinSetDlgItemText(hwnd,WALK_PATH,wa->szCurrentPath1);
    1193       WinSendDlgItemMsg(hwnd,WALK2_PATH,EM_SETTEXTLIMIT,
    1194                         MPFROM2SHORT(CCHMAXPATH,0),MPVOID);
    1195       WinSetDlgItemText(hwnd,WALK2_PATH,wa->szCurrentPath2);
    1196       FillPathListBox(hwnd,
    1197                       WinWindowFromID(hwnd,WALK_DRIVELIST),
    1198                       WinWindowFromID(hwnd,WALK_DIRLIST),
    1199                       wa->szCurrentPath1,FALSE);
    1200       FillPathListBox(hwnd,
    1201                       WinWindowFromID(hwnd,WALK2_DRIVELIST),
    1202                       WinWindowFromID(hwnd,WALK2_DIRLIST),
    1203                       wa->szCurrentPath2,FALSE);
    1204       if(!PostMsg(hwnd,UM_SETUP4,MPVOID,MPVOID))
    1205         okay = TRUE;
    1206       {
    1207         MRESULT ret;
    1208 
    1209         ret = WinDefDlgProc(hwnd,WM_INITDLG,mp1,mp2);
    1210         WinSendMsg(hwnd,UM_SETUP,MPVOID,MPVOID);
    1211         WinInvalidateRect(WinWindowFromID(hwnd,WALK_PATH),NULL,TRUE);
    1212         WinInvalidateRect(WinWindowFromID(hwnd,WALK2_PATH),NULL,TRUE);
    1213         return ret;
    1214       }
     1257        okay = FALSE;
     1258        if (!mp2)
     1259        {
     1260            WinDismissDlg(hwnd, 0);
     1261            break;
     1262        }
     1263        WinSetWindowPtr(hwnd, 0, mp2);
     1264        wa = mp2;
     1265        {
     1266            PFNWP oldproc;
     1267
     1268            oldproc = WinSubclassWindow(WinWindowFromID(hwnd, WALK_PATH),
     1269                                        (PFNWP) TextSubProc);
     1270            if (oldproc)
     1271                WinSetWindowPtr(WinWindowFromID(hwnd, WALK_PATH),
     1272                                QWL_USER,
     1273                                (PVOID) oldproc);
     1274            oldproc = WinSubclassWindow(WinWindowFromID(hwnd, WALK2_PATH),
     1275                                        (PFNWP) TextSubProc);
     1276            if (oldproc)
     1277                WinSetWindowPtr(WinWindowFromID(hwnd, WALK2_PATH),
     1278                                QWL_USER,
     1279                                (PVOID) oldproc);
     1280        }
     1281        if (!*wa -> szCurrentPath1)
     1282            save_dir2(wa -> szCurrentPath1);
     1283        MakeFullName(wa -> szCurrentPath1);
     1284        if (!*wa -> szCurrentPath2)
     1285            save_dir2(wa -> szCurrentPath2);
     1286        MakeFullName(wa -> szCurrentPath2);
     1287        WinSendDlgItemMsg(hwnd,
     1288                          WALK_PATH,
     1289                          EM_SETTEXTLIMIT,
     1290                          MPFROM2SHORT(CCHMAXPATH, 0),
     1291                          MPVOID);
     1292        WinSetDlgItemText(hwnd, WALK_PATH, wa -> szCurrentPath1);
     1293        WinSendDlgItemMsg(hwnd, WALK2_PATH, EM_SETTEXTLIMIT,
     1294                          MPFROM2SHORT(CCHMAXPATH, 0), MPVOID);
     1295        WinSetDlgItemText(hwnd, WALK2_PATH, wa -> szCurrentPath2);
     1296        FillPathListBox(hwnd,
     1297                        WinWindowFromID(hwnd, WALK_DRIVELIST),
     1298                        WinWindowFromID(hwnd, WALK_DIRLIST),
     1299                        wa -> szCurrentPath1, FALSE);
     1300        FillPathListBox(hwnd,
     1301                        WinWindowFromID(hwnd, WALK2_DRIVELIST),
     1302                        WinWindowFromID(hwnd, WALK2_DIRLIST),
     1303                        wa -> szCurrentPath2, FALSE);
     1304        if (!PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID))
     1305            okay = TRUE;
     1306        {
     1307            MRESULT ret;
     1308
     1309            ret = WinDefDlgProc(hwnd, WM_INITDLG, mp1, mp2);
     1310            WinSendMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
     1311            WinInvalidateRect(WinWindowFromID(hwnd, WALK_PATH), NULL, TRUE);
     1312            WinInvalidateRect(WinWindowFromID(hwnd, WALK2_PATH), NULL, TRUE);
     1313            return ret;
     1314        }
    12151315
    12161316    case UM_SETUP4:
    1217       okay = TRUE;
    1218       return 0;
     1317        okay = TRUE;
     1318        return 0;
    12191319
    12201320    case WM_PRESPARAMCHANGED:
    1221       {
    1222         ULONG AttrFound,AttrValue[64],cbRetLen;
    1223 
    1224         cbRetLen = WinQueryPresParam(hwnd,(ULONG)mp1,0,&AttrFound,
    1225                                      (ULONG)sizeof(AttrValue),
    1226                                      &AttrValue,0);
    1227         if(cbRetLen) {
    1228           switch(AttrFound) {
    1229             case PP_FONTNAMESIZE:
    1230               PrfWriteProfileData(fmprof,
    1231                                   appname,
    1232                                   "WalkFont",
    1233                                   (PVOID)AttrValue,
    1234                                   cbRetLen);
    1235               *WalkFont = 0;
    1236               WalkFontSize = sizeof(WalkFont);
    1237               WinInvalidateRect(WinWindowFromID(hwnd,WALK_PATH),
    1238                                 NULL,
    1239                                 TRUE);
    1240               break;
    1241           }
    1242         }
    1243       }
    1244       break;
     1321        {
     1322            ULONG AttrFound, AttrValue[64], cbRetLen;
     1323
     1324            cbRetLen = WinQueryPresParam(hwnd, (ULONG) mp1, 0, &AttrFound,
     1325                                         (ULONG) sizeof(AttrValue),
     1326                                         &AttrValue, 0);
     1327            if (cbRetLen)
     1328            {
     1329                switch (AttrFound)
     1330                {
     1331                case PP_FONTNAMESIZE:
     1332                    PrfWriteProfileData(fmprof,
     1333                                        appname,
     1334                                        "WalkFont",
     1335                                        (PVOID) AttrValue,
     1336                                        cbRetLen);
     1337                    *WalkFont = 0;
     1338                    WalkFontSize = sizeof(WalkFont);
     1339                    WinInvalidateRect(WinWindowFromID(hwnd, WALK_PATH),
     1340                                      NULL,
     1341                                      TRUE);
     1342                    break;
     1343                }
     1344            }
     1345        }
     1346        break;
    12451347
    12461348    case UM_SETUP:
    1247       {
    1248         INT     x;
    1249         USHORT  id[] = {WALK_PATH,WALK_DIRLIST,
    1250                         WALK2_PATH,WALK2_DIRLIST,0};
    1251 
    1252         if(*WalkFont ||
    1253            (PrfQueryProfileData(fmprof,
    1254                                 appname,
    1255                                 "WalkFont",
    1256                                 (PVOID)WalkFont,
    1257                                 &WalkFontSize) &&
    1258              WalkFontSize)) {
    1259           for(x = 0;id[x];x++)
    1260             WinSetPresParam(WinWindowFromID(hwnd,id[x]),
    1261                             PP_FONTNAMESIZE,
    1262                             WalkFontSize,
    1263                             (PVOID)WalkFont);
    1264         }
    1265       }
    1266       return 0;
     1349        {
     1350            INT x;
     1351            USHORT id[] =
     1352            {WALK_PATH, WALK_DIRLIST,
     1353             WALK2_PATH, WALK2_DIRLIST, 0};
     1354
     1355            if (*WalkFont ||
     1356                    (PrfQueryProfileData(fmprof,
     1357                                         appname,
     1358                                         "WalkFont",
     1359                                         (PVOID) WalkFont,
     1360                                         &WalkFontSize) &&
     1361                     WalkFontSize))
     1362            {
     1363                for (x = 0; id[x]; x++)
     1364                    WinSetPresParam(WinWindowFromID(hwnd, id[x]),
     1365                                    PP_FONTNAMESIZE,
     1366                                    WalkFontSize,
     1367                                    (PVOID) WalkFont);
     1368            }
     1369        }
     1370        return 0;
    12671371
    12681372    case UM_CONTROL:
    12691373    case WM_CONTROL:
    1270       wa = WinQueryWindowPtr(hwnd,0);
    1271       if(SHORT1FROMMP(mp1) == WALK_DRIVELIST ||
    1272          SHORT1FROMMP(mp1) == WALK_DIRLIST ||
    1273          SHORT1FROMMP(mp1) == WALK2_DRIVELIST ||
    1274          SHORT1FROMMP(mp1) == WALK2_DIRLIST) {
    1275         sSelect = (USHORT)WinSendDlgItemMsg(hwnd,
    1276                                             SHORT1FROMMP(mp1),
    1277                                             LM_QUERYSELECTION,
    1278                                             MPVOID,MPVOID);
    1279         *szBuffer = 0;
    1280         if(sSelect >= 0)
    1281           WinSendDlgItemMsg(hwnd,SHORT1FROMMP(mp1),LM_QUERYITEMTEXT,
    1282                             MPFROM2SHORT(sSelect,CCHMAXPATH),
    1283                             MPFROMP(szBuffer));
    1284       }
    1285       switch(SHORT1FROMMP(mp1)) {
    1286         case WALK_DRIVELIST:
    1287           if(okay && *szBuffer && SHORT2FROMMP(mp1) == LN_ENTER) {
    1288 
    1289             ULONG  ulDirLen = CCHMAXPATH;
    1290             APIRET rc;
    1291 
    1292             rc = DosQCurDir(toupper(*szBuffer) - '@',
    1293                             &szBuff[3],&ulDirLen);
    1294             if(!rc) {
    1295               strcpy(wa->szCurrentPath1,"C:\\");
    1296               *wa->szCurrentPath1 = toupper(*szBuffer);
    1297               WinSetDlgItemText(hwnd,
    1298                                 WALK_PATH,
    1299                                 wa->szCurrentPath1);
    1300               FillPathListBox(hwnd,
    1301                               WinWindowFromID(hwnd,WALK_DRIVELIST),
    1302                               WinWindowFromID(hwnd,WALK_DIRLIST),
    1303                               wa->szCurrentPath1,FALSE);
    1304             }
    1305           }
    1306           break;
    1307 
    1308         case WALK_DIRLIST:
    1309           if(okay && SHORT2FROMMP(mp1) == LN_ENTER) {
    1310 
    1311             ULONG        ulSearchCount;
    1312             FILEFINDBUF3 findbuf;
    1313             HDIR         hDir;
    1314             APIRET       rc;
    1315 
    1316             bstrip(szBuffer);
    1317             if(*szBuffer) {
    1318               strcpy(szBuff,wa->szCurrentPath1);
    1319               if(szBuff[strlen(szBuff) - 1] != '\\')
    1320                 strcat(szBuff,"\\");
    1321               strcat(szBuff,szBuffer);
    1322               MakeFullName(szBuff);
    1323               DosError(FERR_DISABLEHARDERR);
    1324               hDir = HDIR_CREATE;
    1325               ulSearchCount = 1L;
    1326               if(!IsRoot(szBuff)) {
    1327                 rc = DosFindFirst(szBuff,
    1328                                   &hDir,
    1329                                   FILE_DIRECTORY |
    1330                                   MUST_HAVE_DIRECTORY | FILE_READONLY |
    1331                                   FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    1332                                   &findbuf,
    1333                                   sizeof(FILEFINDBUF3),
    1334                                   &ulSearchCount,
    1335                                   FIL_STANDARD);
    1336                 if(!rc)
    1337                   DosFindClose(hDir);
    1338               }
    1339               else {
    1340                 findbuf.attrFile = FILE_DIRECTORY;
    1341                 rc = 0;
    1342               }
    1343               if(!rc && (findbuf.attrFile & FILE_DIRECTORY)) {
    1344                 strcpy(wa->szCurrentPath1,szBuff);
    1345                 WinSetDlgItemText(hwnd,WALK_PATH,wa->szCurrentPath1);
    1346                 FillPathListBox(hwnd,
    1347                                 WinWindowFromID(hwnd,WALK_DRIVELIST),
    1348                                 WinWindowFromID(hwnd,WALK_DIRLIST),
    1349                                 wa->szCurrentPath1,FALSE);
    1350               }
    1351             }
    1352           }
    1353           break;
    1354 
    1355         case WALK2_DRIVELIST:
    1356           if(okay && *szBuffer && SHORT2FROMMP(mp1) == LN_ENTER) {
    1357 
    1358             ULONG  ulDirLen = CCHMAXPATH;
    1359             APIRET rc;
    1360 
    1361             rc = DosQCurDir(toupper(*szBuffer) - '@',
    1362                             &szBuff[3],&ulDirLen);
    1363             if(!rc) {
    1364               strcpy(wa->szCurrentPath2,"C:\\");
    1365               *wa->szCurrentPath2 = toupper(*szBuffer);
    1366               WinSetDlgItemText(hwnd,
    1367                                 WALK2_PATH,
    1368                                 wa->szCurrentPath2);
    1369               FillPathListBox(hwnd,
    1370                               WinWindowFromID(hwnd,WALK2_DRIVELIST),
    1371                               WinWindowFromID(hwnd,WALK2_DIRLIST),
    1372                               wa->szCurrentPath2,FALSE);
    1373             }
    1374           }
    1375           break;
    1376 
    1377         case WALK2_DIRLIST:
    1378           if(okay && SHORT2FROMMP(mp1) == LN_ENTER) {
    1379 
    1380             ULONG        ulSearchCount;
    1381             FILEFINDBUF3 findbuf;
    1382             HDIR         hDir;
    1383             APIRET       rc;
    1384 
    1385             bstrip(szBuffer);
    1386             if(*szBuffer) {
    1387               strcpy(szBuff,wa->szCurrentPath2);
    1388               if(szBuff[strlen(szBuff) - 1] != '\\')
    1389                 strcat(szBuff,"\\");
    1390               strcat(szBuff,szBuffer);
    1391               MakeFullName(szBuff);
    1392               DosError(FERR_DISABLEHARDERR);
    1393               hDir = HDIR_CREATE;
    1394               ulSearchCount = 1L;
    1395               if(!IsRoot(szBuff)) {
    1396                 rc = DosFindFirst(szBuff,
    1397                                   &hDir,
    1398                                   FILE_DIRECTORY |
    1399                                   MUST_HAVE_DIRECTORY | FILE_READONLY |
    1400                                   FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
    1401                                   &findbuf,
    1402                                   sizeof(FILEFINDBUF3),
    1403                                   &ulSearchCount,
    1404                                   FIL_STANDARD);
    1405                 if(!rc)
    1406                   DosFindClose(hDir);
    1407               }
    1408               else {
    1409                 findbuf.attrFile = FILE_DIRECTORY;
    1410                 rc = 0;
    1411               }
    1412               if(!rc && (findbuf.attrFile & FILE_DIRECTORY)) {
    1413                 strcpy(wa->szCurrentPath2,szBuff);
    1414                 WinSetDlgItemText(hwnd,WALK2_PATH,wa->szCurrentPath2);
    1415                 FillPathListBox(hwnd,
    1416                                 WinWindowFromID(hwnd,WALK2_DRIVELIST),
    1417                                 WinWindowFromID(hwnd,WALK2_DIRLIST),
    1418                                 wa->szCurrentPath2,FALSE);
    1419               }
    1420             }
    1421           }
    1422           break;
    1423       }
    1424       return 0;
     1374        wa = WinQueryWindowPtr(hwnd, 0);
     1375        if (SHORT1FROMMP(mp1) == WALK_DRIVELIST ||
     1376                SHORT1FROMMP(mp1) == WALK_DIRLIST ||
     1377                SHORT1FROMMP(mp1) == WALK2_DRIVELIST ||
     1378                SHORT1FROMMP(mp1) == WALK2_DIRLIST)
     1379        {
     1380            sSelect = (USHORT) WinSendDlgItemMsg(hwnd,
     1381                                                 SHORT1FROMMP(mp1),
     1382                                                 LM_QUERYSELECTION,
     1383                                                 MPVOID, MPVOID);
     1384            *szBuffer = 0;
     1385            if (sSelect >= 0)
     1386                WinSendDlgItemMsg(hwnd, SHORT1FROMMP(mp1), LM_QUERYITEMTEXT,
     1387                                  MPFROM2SHORT(sSelect, CCHMAXPATH),
     1388                                  MPFROMP(szBuffer));
     1389        }
     1390        switch (SHORT1FROMMP(mp1))
     1391        {
     1392        case WALK_DRIVELIST:
     1393            if (okay && *szBuffer && SHORT2FROMMP(mp1) == LN_ENTER)
     1394            {
     1395
     1396                ULONG ulDirLen = CCHMAXPATH;
     1397                APIRET rc;
     1398
     1399                rc = DosQCurDir(toupper(*szBuffer) - '@',
     1400                                &szBuff[3], &ulDirLen);
     1401                if (!rc)
     1402                {
     1403                    strcpy(wa -> szCurrentPath1, "C:\\");
     1404                    *wa -> szCurrentPath1 = toupper(*szBuffer);
     1405                    WinSetDlgItemText(hwnd,
     1406                                      WALK_PATH,
     1407                                      wa -> szCurrentPath1);
     1408                    FillPathListBox(hwnd,
     1409                                    WinWindowFromID(hwnd, WALK_DRIVELIST),
     1410                                    WinWindowFromID(hwnd, WALK_DIRLIST),
     1411                                    wa -> szCurrentPath1, FALSE);
     1412                }
     1413            }
     1414            break;
     1415
     1416        case WALK_DIRLIST:
     1417            if (okay && SHORT2FROMMP(mp1) == LN_ENTER)
     1418            {
     1419
     1420                ULONG ulSearchCount;
     1421                FILEFINDBUF3 findbuf;
     1422                HDIR hDir;
     1423                APIRET rc;
     1424
     1425                bstrip(szBuffer);
     1426                if (*szBuffer)
     1427                {
     1428                    strcpy(szBuff, wa -> szCurrentPath1);
     1429                    if (szBuff[strlen(szBuff) - 1] != '\\')
     1430                        strcat(szBuff, "\\");
     1431                    strcat(szBuff, szBuffer);
     1432                    MakeFullName(szBuff);
     1433                    DosError(FERR_DISABLEHARDERR);
     1434                    hDir = HDIR_CREATE;
     1435                    ulSearchCount = 1L;
     1436                    if (!IsRoot(szBuff))
     1437                    {
     1438                        rc = DosFindFirst(szBuff,
     1439                                          &hDir,
     1440                                          FILE_DIRECTORY |
     1441                                       MUST_HAVE_DIRECTORY | FILE_READONLY |
     1442                                  FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
     1443                                          &findbuf,
     1444                                          sizeof(FILEFINDBUF3),
     1445                                          &ulSearchCount,
     1446                                          FIL_STANDARD);
     1447                        if (!rc)
     1448                            DosFindClose(hDir);
     1449                    }
     1450                    else
     1451                    {
     1452                        findbuf.attrFile = FILE_DIRECTORY;
     1453                        rc = 0;
     1454                    }
     1455                    if (!rc && (findbuf.attrFile & FILE_DIRECTORY))
     1456                    {
     1457                        strcpy(wa -> szCurrentPath1, szBuff);
     1458                        WinSetDlgItemText(hwnd, WALK_PATH, wa -> szCurrentPath1);
     1459                        FillPathListBox(hwnd,
     1460                                      WinWindowFromID(hwnd, WALK_DRIVELIST),
     1461                                        WinWindowFromID(hwnd, WALK_DIRLIST),
     1462                                        wa -> szCurrentPath1, FALSE);
     1463                    }
     1464                }
     1465            }
     1466            break;
     1467
     1468        case WALK2_DRIVELIST:
     1469            if (okay && *szBuffer && SHORT2FROMMP(mp1) == LN_ENTER)
     1470            {
     1471
     1472                ULONG ulDirLen = CCHMAXPATH;
     1473                APIRET rc;
     1474
     1475                rc = DosQCurDir(toupper(*szBuffer) - '@',
     1476                                &szBuff[3], &ulDirLen);
     1477                if (!rc)
     1478                {
     1479                    strcpy(wa -> szCurrentPath2, "C:\\");
     1480                    *wa -> szCurrentPath2 = toupper(*szBuffer);
     1481                    WinSetDlgItemText(hwnd,
     1482                                      WALK2_PATH,
     1483                                      wa -> szCurrentPath2);
     1484                    FillPathListBox(hwnd,
     1485                                    WinWindowFromID(hwnd, WALK2_DRIVELIST),
     1486                                    WinWindowFromID(hwnd, WALK2_DIRLIST),
     1487                                    wa -> szCurrentPath2, FALSE);
     1488                }
     1489            }
     1490            break;
     1491
     1492        case WALK2_DIRLIST:
     1493            if (okay && SHORT2FROMMP(mp1) == LN_ENTER)
     1494            {
     1495
     1496                ULONG ulSearchCount;
     1497                FILEFINDBUF3 findbuf;
     1498                HDIR hDir;
     1499                APIRET rc;
     1500
     1501                bstrip(szBuffer);
     1502                if (*szBuffer)
     1503                {
     1504                    strcpy(szBuff, wa -> szCurrentPath2);
     1505                    if (szBuff[strlen(szBuff) - 1] != '\\')
     1506                        strcat(szBuff, "\\");
     1507                    strcat(szBuff, szBuffer);
     1508                    MakeFullName(szBuff);
     1509                    DosError(FERR_DISABLEHARDERR);
     1510                    hDir = HDIR_CREATE;
     1511                    ulSearchCount = 1L;
     1512                    if (!IsRoot(szBuff))
     1513                    {
     1514                        rc = DosFindFirst(szBuff,
     1515                                          &hDir,
     1516                                          FILE_DIRECTORY |
     1517                                       MUST_HAVE_DIRECTORY | FILE_READONLY |
     1518                                  FILE_ARCHIVED | FILE_SYSTEM | FILE_HIDDEN,
     1519                                          &findbuf,
     1520                                          sizeof(FILEFINDBUF3),
     1521                                          &ulSearchCount,
     1522                                          FIL_STANDARD);
     1523                        if (!rc)
     1524                            DosFindClose(hDir);
     1525                    }
     1526                    else
     1527                    {
     1528                        findbuf.attrFile = FILE_DIRECTORY;
     1529                        rc = 0;
     1530                    }
     1531                    if (!rc && (findbuf.attrFile & FILE_DIRECTORY))
     1532                    {
     1533                        strcpy(wa -> szCurrentPath2, szBuff);
     1534                        WinSetDlgItemText(hwnd, WALK2_PATH, wa -> szCurrentPath2);
     1535                        FillPathListBox(hwnd,
     1536                                     WinWindowFromID(hwnd, WALK2_DRIVELIST),
     1537                                        WinWindowFromID(hwnd, WALK2_DIRLIST),
     1538                                        wa -> szCurrentPath2, FALSE);
     1539                    }
     1540                }
     1541            }
     1542            break;
     1543        }
     1544        return 0;
    14251545
    14261546    case WM_COMMAND:
    1427       wa = WinQueryWindowPtr(hwnd,0);
    1428       if(!wa)
    1429         WinDismissDlg(hwnd,0);
    1430       *szBuff = 0;
    1431       WinQueryDlgItemText(hwnd,
    1432                           WALK_PATH,
    1433                           CCHMAXPATH,
    1434                           szBuff);
    1435       bstrip(szBuff);
    1436       while((p = strchr(szBuff,'/')) != NULL)
    1437         *p = '\\';
    1438       while(strlen(szBuff) > 3 &&
    1439             szBuff[strlen(szBuff) - 1] == '\\')
    1440         szBuff[strlen(szBuff) - 1] = 0;
    1441       MakeFullName(szBuff);
    1442       if(*szBuff &&
    1443          stricmp(szBuff,wa->szCurrentPath1)) {
    1444         if(!SetDir(WinQueryWindow(WinQueryWindow(hwnd,QW_PARENT),
    1445                                   QW_OWNER),
    1446                    hwnd,
    1447                    szBuff,
    1448                    0))
    1449           strcpy(wa->szCurrentPath1,szBuff);
    1450         else if(SHORT1FROMMP(mp1) != DID_CANCEL)
    1451           return 0;
    1452       }
    1453       WinSetDlgItemText(hwnd,
    1454                         WALK_PATH,
    1455                         wa->szCurrentPath1);
    1456       *szBuff = 0;
    1457       WinQueryDlgItemText(hwnd,
    1458                           WALK2_PATH,
    1459                           CCHMAXPATH,
    1460                           szBuff);
    1461       bstrip(szBuff);
    1462       while((p = strchr(szBuff,'/')) != NULL)
    1463         *p = '\\';
    1464       while(strlen(szBuff) > 3 &&
    1465             szBuff[strlen(szBuff) - 1] == '\\')
    1466         szBuff[strlen(szBuff) - 1] = 0;
    1467       MakeFullName(szBuff);
    1468       if(*szBuff &&
    1469          stricmp(szBuff,wa->szCurrentPath2)) {
    1470         if(!SetDir(WinQueryWindow(WinQueryWindow(hwnd,QW_PARENT),
    1471                                   QW_OWNER),
    1472                    hwnd,
    1473                    szBuff,
    1474                    0))
    1475           strcpy(wa->szCurrentPath2,szBuff);
    1476         else if(SHORT1FROMMP(mp1) != DID_CANCEL)
    1477           return 0;
    1478       }
    1479       WinSetDlgItemText(hwnd,
    1480                         WALK2_PATH,
    1481                         wa->szCurrentPath2);
    1482       switch(SHORT1FROMMP(mp1)) {
    1483         case DID_OK:
    1484           WinDismissDlg(hwnd,1);
    1485           break;
    1486 
    1487         case IDM_HELP:
    1488           if(hwndHelp)
    1489             WinSendMsg(hwndHelp,
    1490                        HM_DISPLAY_HELP,
    1491                        MPFROM2SHORT(HELP_WALKEM2,0),
    1492                        MPFROMSHORT(HM_RESOURCEID));
    1493           break;
    1494 
    1495         case DID_CANCEL:
    1496           WinDismissDlg(hwnd,0);
    1497           break;
    1498       }
    1499       return 0;
     1547        wa = WinQueryWindowPtr(hwnd, 0);
     1548        if (!wa)
     1549            WinDismissDlg(hwnd, 0);
     1550        *szBuff = 0;
     1551        WinQueryDlgItemText(hwnd,
     1552                            WALK_PATH,
     1553                            CCHMAXPATH,
     1554                            szBuff);
     1555        bstrip(szBuff);
     1556        while ((p = strchr(szBuff, '/')) != NULL)
     1557            *p = '\\';
     1558        while (strlen(szBuff) > 3 &&
     1559                szBuff[strlen(szBuff) - 1] == '\\')
     1560            szBuff[strlen(szBuff) - 1] = 0;
     1561        MakeFullName(szBuff);
     1562        if (*szBuff &&
     1563                stricmp(szBuff, wa -> szCurrentPath1))
     1564        {
     1565            if (!SetDir(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
     1566                                       QW_OWNER),
     1567                        hwnd,
     1568                        szBuff,
     1569                        0))
     1570                strcpy(wa -> szCurrentPath1, szBuff);
     1571            else if (SHORT1FROMMP(mp1) != DID_CANCEL)
     1572                return 0;
     1573        }
     1574        WinSetDlgItemText(hwnd,
     1575                          WALK_PATH,
     1576                          wa -> szCurrentPath1);
     1577        *szBuff = 0;
     1578        WinQueryDlgItemText(hwnd,
     1579                            WALK2_PATH,
     1580                            CCHMAXPATH,
     1581                            szBuff);
     1582        bstrip(szBuff);
     1583        while ((p = strchr(szBuff, '/')) != NULL)
     1584            *p = '\\';
     1585        while (strlen(szBuff) > 3 &&
     1586                szBuff[strlen(szBuff) - 1] == '\\')
     1587            szBuff[strlen(szBuff) - 1] = 0;
     1588        MakeFullName(szBuff);
     1589        if (*szBuff &&
     1590                stricmp(szBuff, wa -> szCurrentPath2))
     1591        {
     1592            if (!SetDir(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
     1593                                       QW_OWNER),
     1594                        hwnd,
     1595                        szBuff,
     1596                        0))
     1597                strcpy(wa -> szCurrentPath2, szBuff);
     1598            else if (SHORT1FROMMP(mp1) != DID_CANCEL)
     1599                return 0;
     1600        }
     1601        WinSetDlgItemText(hwnd,
     1602                          WALK2_PATH,
     1603                          wa -> szCurrentPath2);
     1604        switch (SHORT1FROMMP(mp1))
     1605        {
     1606        case DID_OK:
     1607            WinDismissDlg(hwnd, 1);
     1608            break;
     1609
     1610        case IDM_HELP:
     1611            if (hwndHelp)
     1612                WinSendMsg(hwndHelp,
     1613                           HM_DISPLAY_HELP,
     1614                           MPFROM2SHORT(HELP_WALKEM2, 0),
     1615                           MPFROMSHORT(HM_RESOURCEID));
     1616            break;
     1617
     1618        case DID_CANCEL:
     1619            WinDismissDlg(hwnd, 0);
     1620            break;
     1621        }
     1622        return 0;
    15001623
    15011624    case WM_CLOSE:
    1502       break;
    1503   }
    1504   return WinDefDlgProc(hwnd,msg,mp1,mp2);
    1505 }
    1506 
    1507 
    1508 MRESULT EXPENTRY WalkTwoCmpDlgProc (HWND hwnd,ULONG msg,MPARAM mp1,
    1509                                     MPARAM mp2) {
    1510 
    1511   switch(msg) {
     1625        break;
     1626    }
     1627    return WinDefDlgProc(hwnd, msg, mp1, mp2);
     1628}
     1629
     1630MRESULT EXPENTRY WalkTwoCmpDlgProc(HWND hwnd, ULONG msg, MPARAM mp1,
     1631                                   MPARAM mp2)
     1632{
     1633
     1634    switch (msg)
     1635    {
    15121636    case WM_INITDLG:
    1513       WinSetWindowText(hwnd,
    1514                        GetPString(IDS_WALKCOMPAREDLGTEXT));
    1515       return WalkTwoDlgProc(hwnd,
    1516                             UM_SETUP2,
    1517                             mp1,
    1518                             mp2);
    1519   }
    1520   return WalkTwoDlgProc(hwnd,msg,mp1,mp2);
    1521 }
    1522 
    1523 
    1524 MRESULT EXPENTRY WalkTwoSetDlgProc (HWND hwnd,ULONG msg,MPARAM mp1,
    1525                                     MPARAM mp2) {
    1526 
    1527   switch(msg) {
     1637        WinSetWindowText(hwnd,
     1638                         GetPString(IDS_WALKCOMPAREDLGTEXT));
     1639        return WalkTwoDlgProc(hwnd,
     1640                              UM_SETUP2,
     1641                              mp1,
     1642                              mp2);
     1643    }
     1644    return WalkTwoDlgProc(hwnd, msg, mp1, mp2);
     1645}
     1646
     1647MRESULT EXPENTRY WalkTwoSetDlgProc(HWND hwnd, ULONG msg, MPARAM mp1,
     1648                                   MPARAM mp2)
     1649{
     1650
     1651    switch (msg)
     1652    {
    15281653    case WM_INITDLG:
    1529       WinSetWindowText(hwnd,
    1530                        GetPString(IDS_WALKSETDIRSDLGTEXT));
    1531       return WalkTwoDlgProc(hwnd,
    1532                             UM_SETUP2,
    1533                             mp1,
    1534                             mp2);
    1535   }
    1536   return WalkTwoDlgProc(hwnd,msg,mp1,mp2);
    1537 }
    1538 
     1654        WinSetWindowText(hwnd,
     1655                         GetPString(IDS_WALKSETDIRSDLGTEXT));
     1656        return WalkTwoDlgProc(hwnd,
     1657                              UM_SETUP2,
     1658                              mp1,
     1659                              mp2);
     1660    }
     1661    return WalkTwoDlgProc(hwnd, msg, mp1, mp2);
     1662}
Note: See TracChangeset for help on using the changeset viewer.