Changeset 1163 for trunk/dll


Ignore:
Timestamp:
Sep 5, 2008, 11:43:52 PM (17 years ago)
Author:
John Small
Message:

Ticket 187: Draft 1: Functions only

Location:
trunk/dll
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/assoc.c

    r1119 r1163  
    3838#include "errutil.h"                    // Dos_Error...
    3939#include "strutil.h"                    // GetPString
     40#include "assoc.h"
    4041#include "fm3dll.h"
    4142#include "fortify.h"
    … …  
    6970
    7071static PSZ pszSrcFile = __FILE__;
     72
     73static VOID load_associations(VOID);
     74static VOID save_associations(VOID);
    7175
    7276MRESULT EXPENTRY AssocTextProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)

  • trunk/dll/copyf.c

    r1082 r1163  
    1212  14 Oct 02 SHL Drop obsolete debug code
    1313  10 Nov 02 SHL docopyf - don't forget to terminate longname
    14                 optimize longname logic
     14                optimize longname logic
    1515  01 Aug 04 SHL Rework lstrip/rstrip usage
    1616  28 May 05 SHL Drop debug code
    … …  
    3434
    3535#include "fm3str.h"
    36 #include "errutil.h"                    // Dos_Error...
    37 #include "strutil.h"                    // GetPString
     36#include "errutil.h"                    // Dos_Error...
     37#include "strutil.h"                    // GetPString
     38#include "copyf.h"
     39#include "literal.h"                    // fixup
    3840#include "fm3dll.h"
    3941#include "fortify.h"
    … …  
    4143static PSZ pszSrcFile = __FILE__;
    4244
     45//static CHAR default_disk(VOID);
     46//static INT unlink_allf(CHAR * string, ...);
     47
    4348#ifndef WinMoveObject
    4449HOBJECT APIENTRY WinMoveObject(HOBJECT hObjectofObject,
    45                                HOBJECT hObjectofDest, ULONG ulReserved);
     50                               HOBJECT hObjectofDest, ULONG ulReserved);
    4651#endif
    4752#ifndef WinCopyObject
    4853HOBJECT APIENTRY WinCopyObject(HOBJECT hObjectofObject,
    49                                HOBJECT hObjectofDest, ULONG ulReserved);
     54                               HOBJECT hObjectofDest, ULONG ulReserved);
    5055#endif
    5156
    … …  
    9095      (*p)++;
    9196      while (strchr("*?<>\":/\\|+=;,[]. ", *p))
    92         (*p)++;
     97        (*p)++;
    9398      *p = toupper(*p);
    9499    }
    … …  
    96101      p--;
    97102      if (p >= o && *p == '.')
    98         p--;
     103        p--;
    99104      goto Loop;
    100105    }
    … …  
    126131  f = oldname + (f - buffer);
    127132  strupr(buffer);
    128   while (*f == '.')                     /* skip leading '.'s */
     133  while (*f == '.')                     /* skip leading '.'s */
    129134    f++;
    130135  s = f;
    131   while (*f && *f != '.' && f < s + 8) {        /* skip past rootname */
     136  while (*f && *f != '.' && f < s + 8) {        /* skip past rootname */
    132137    *p = toupper(*f);
    133138    p++;
    … …  
    184189      (*p)++;
    185190      while (strchr("*?<>\":/\\|+=;,[]. ", *p))
    186         (*p)++;
     191        (*p)++;
    187192      *p = toupper(*p);
    188193    }
    … …  
    190195      p--;
    191196      if (p >= o && *p == '.')
    192         p--;
     197        p--;
    193198      goto Loop;
    194199    }
    … …  
    218223    while (*value) {
    219224      if (*value == '/')
    220         *value = '\\';
     225        *value = '\\';
    221226      value++;
    222227    }
    … …  
    235240      pfealist = xmallocz(1536, pszSrcFile, __LINE__);
    236241      if (pfealist) {
    237         pfealist->cbList = 1024;
    238         eaop.fpGEA2List = pgealist;
    239         eaop.fpFEA2List = pfealist;
    240         eaop.oError = 0L;
    241         DosError(FERR_DISABLEHARDERR);
    242         rc = DosQueryPathInfo(oldname,
    243                               FIL_QUERYEASFROMLIST,
    244                               (PVOID) & eaop, (ULONG) sizeof(EAOP2));
    245         if (!rc) {
    246           pfea = &eaop.fpFEA2List->list[0];
    247           value = pfea->szName + pfea->cbName + 1;
    248           value[pfea->cbValue] = 0;
    249           if (*(USHORT *) value == EAT_ASCII)
    250             strncat(longname,
    251                     value + (sizeof(USHORT) * 2),
    252                     CCHMAXPATH - strlen(longname));
    253           longname[CCHMAXPATH - 1] = 0;
    254         }
    255         free(pfealist);
     242        pfealist->cbList = 1024;
     243        eaop.fpGEA2List = pgealist;
     244        eaop.fpFEA2List = pfealist;
     245        eaop.oError = 0L;
     246        DosError(FERR_DISABLEHARDERR);
     247        rc = DosQueryPathInfo(oldname,
     248                              FIL_QUERYEASFROMLIST,
     249                              (PVOID) & eaop, (ULONG) sizeof(EAOP2));
     250        if (!rc) {
     251          pfea = &eaop.fpFEA2List->list[0];
     252          value = pfea->szName + pfea->cbName + 1;
     253          value[pfea->cbValue] = 0;
     254          if (*(USHORT *) value == EAT_ASCII)
     255            strncat(longname,
     256                    value + (sizeof(USHORT) * 2),
     257                    CCHMAXPATH - strlen(longname));
     258          longname[CCHMAXPATH - 1] = 0;
     259        }
     260        free(pfealist);
    256261      }
    257262      free(pgealist);
    … …  
    290295    ealen = sizeof(FEALIST) + 10;
    291296  rc = DosAllocMem((PPVOID) & pfealist,
    292                    ealen + 32L, OBJ_TILE | PAG_COMMIT | PAG_READ | PAG_WRITE);
     297                   ealen + 32L, OBJ_TILE | PAG_COMMIT | PAG_READ | PAG_WRITE);
    293298  if (rc)
    294299    Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
    295               GetPString(IDS_OUTOFMEMORY));
     300              GetPString(IDS_OUTOFMEMORY));
    296301  else {
    297302    memset(pfealist, 0, ealen + 1);
    … …  
    317322    DosError(FERR_DISABLEHARDERR);
    318323    rc = xDosSetPathInfo(filename, FIL_QUERYEASIZE,
    319                         &eaop, sizeof(eaop), DSPI_WRTTHRU);
     324                        &eaop, sizeof(eaop), DSPI_WRTTHRU);
    320325    DosFreeMem(pfealist);
    321326    if (rc)
    … …  
    341346      p = strrchr(oldname, '\\');
    342347      if (p && *(p + 1)) {
    343         strcpy(srce, p + 1);
    344         DosError(FERR_DISABLEHARDERR);
    345         if (!DosEditName(1L, srce, dest, result, (ULONG) sizeof(result))) {
    346           p = strrchr(newname, '\\');
    347           p++;
    348           strcpy(p, result);
    349           ret = TRUE;
    350         }
     348        strcpy(srce, p + 1);
     349        DosError(FERR_DISABLEHARDERR);
     350        if (!DosEditName(1L, srce, dest, result, (ULONG) sizeof(result))) {
     351          p = strrchr(newname, '\\');
     352          p++;
     353          strcpy(p, result);
     354          ret = TRUE;
     355        }
    351356      }
    352357    }
    … …  
    355360}
    356361
     362#if 0   // JBS
    357363CHAR default_disk(VOID)
    358364{
    … …  
    363369  return (CHAR) toupper((INT) ulDriveNum) + '@';
    364370}
     371#endif
    365372
    366373#ifdef NEVER
    … …  
    385392
    386393      if (fb.attrFile & FILE_DIRECTORY) {
    387         DosError(FERR_ENABLEHARDERR);
    388         rc = DosCreateDir();
    389         if (rc == ERROR_INVALID_NAME || rc == ERROR_FILENAME_EXCED_RANGE) {
    390 
    391           /* truncate directory name */
    392           /* create that directory */
    393           /* update containers for name used */
    394 
    395         }
    396         rc = docopyallf(type,, "%s",);  /* recurse */
     394        DosError(FERR_ENABLEHARDERR);
     395        rc = DosCreateDir();
     396        if (rc == ERROR_INVALID_NAME || rc == ERROR_FILENAME_EXCED_RANGE) {
     397
     398          /* truncate directory name */
     399          /* create that directory */
     400          /* update containers for name used */
     401
     402        }
     403        rc = docopyallf(type,, "%s",);  /* recurse */
    397404      }
    398405      else
    399         rc = docopyf(type,, "%s",);     /* copy file */
     406        rc = docopyf(type,, "%s",);     /* copy file */
    400407      DosError(FERR_DISABLEHARDERR);
    401408    } while (!rc && !DosFindNext());
    … …  
    434441  va_end(ap);
    435442
    436   if (!oldname || !*oldname || !*fullnewname)   /* bad string args */
     443  if (!oldname || !*oldname || !*fullnewname)   /* bad string args */
    437444    return (APIRET) - 1;
    438445
    439446  DosError(FERR_DISABLEHARDERR);
    440447  if (DosQueryPathInfo(oldname, FIL_STANDARDL, &st, sizeof(FILESTATUS3L)))
    441     return (APIRET) - 2;                /* no source */
     448    return (APIRET) - 2;                /* no source */
    442449
    443450  AdjustWildcardName(oldname, fullnewname);
    444451  MakeFullName(oldname);
    445452  MakeFullName(fullnewname);
    446   olddisk = toupper(*oldname);          /* source drive */
    447   newdisk = toupper(*fullnewname);      /* destination drive */
     453  olddisk = toupper(*oldname);          /* source drive */
     454  newdisk = toupper(*fullnewname);      /* destination drive */
    448455  if (!(driveflags[toupper(*oldname) - 'A'] & DRIVE_NOLONGNAMES))
    449456    *longname = 0;
    … …  
    453460      p = RootName(longname);
    454461      if (p != longname)
    455         memmove(longname, p, strlen(p) + 1);
     462        memmove(longname, p, strlen(p) + 1);
    456463    }
    457464  }
    … …  
    473480      hobjsrc = WinQueryObject(oldname);
    474481      if (hobjsrc) {
    475         strcpy(dir, fullnewname);
    476         p = strrchr(dir, '\\');
    477         if (p < dir + 3)
    478           p++;
    479         *p = 0;
    480         ret = ERROR_PATH_NOT_FOUND;
    481         hobjdest = WinQueryObject(dir);
    482         if (hobjdest) {
    483           ret = ERROR_GEN_FAILURE;
    484           hobjsrc = WinMoveObject(hobjsrc, hobjdest, 0);
    485           if (hobjsrc)
    486             ret = 0;
    487         }
     482        strcpy(dir, fullnewname);
     483        p = strrchr(dir, '\\');
     484        if (p < dir + 3)
     485          p++;
     486        *p = 0;
     487        ret = ERROR_PATH_NOT_FOUND;
     488        hobjdest = WinQueryObject(dir);
     489        if (hobjdest) {
     490          ret = ERROR_GEN_FAILURE;
     491          hobjsrc = WinMoveObject(hobjsrc, hobjdest, 0);
     492          if (hobjsrc)
     493            ret = 0;
     494        }
    488495      }
    489496    }
    … …  
    498505      hobjsrc = WinQueryObject(oldname);
    499506      if (hobjsrc) {
    500         strcpy(dir, fullnewname);
    501         p = strrchr(dir, '\\');
    502         if (p < dir + 3)
    503           p++;
    504         *p = 0;
    505         ret = ERROR_PATH_NOT_FOUND;
    506         hobjdest = WinQueryObject(dir);
    507         if (hobjdest) {
    508           ret = ERROR_GEN_FAILURE;
    509           hobjsrc = WinCopyObject(hobjsrc, hobjdest, 0);
    510           if (hobjsrc)
    511             ret = 0;
    512         }
     507        strcpy(dir, fullnewname);
     508        p = strrchr(dir, '\\');
     509        if (p < dir + 3)
     510          p++;
     511        *p = 0;
     512        ret = ERROR_PATH_NOT_FOUND;
     513        hobjdest = WinQueryObject(dir);
     514        if (hobjdest) {
     515          ret = ERROR_GEN_FAILURE;
     516          hobjsrc = WinCopyObject(hobjsrc, hobjdest, 0);
     517          if (hobjsrc)
     518            ret = 0;
     519        }
    513520      }
    514521    }
    … …  
    517524  case MOVE:
    518525    *dir = 0;
    519     if (olddisk == newdisk) {           /* same drive */
     526    if (olddisk == newdisk) {           /* same drive */
    520527      /* make temporary copy in case move fails */
    521528      if (IsFile(fullnewname) != -1 && stricmp(oldname, fullnewname)) {
    522         strcpy(dir, fullnewname);
    523         p = strrchr(dir, '\\');
    524         if (p)
    525           *p = 0;
    526         strcat(dir, "\\");
    527         MakeTempName(dir, NULL, 0);
    528         if (DosMove(fullnewname, dir))
    529           *dir = 0;
     529        strcpy(dir, fullnewname);
     530        p = strrchr(dir, '\\');
     531        if (p)
     532          *p = 0;
     533        strcat(dir, "\\");
     534        MakeTempName(dir, NULL, 0);
     535        if (DosMove(fullnewname, dir))
     536          *dir = 0;
    530537      }
    531538      DosError(FERR_DISABLEHARDERR);
    532       ret = DosMove(oldname, fullnewname);      /* move it */
    533       if (ret && *dir) {                /* failed -- clean up */
    534         DosError(FERR_DISABLEHARDERR);
    535         if (!DosMove(dir, fullnewname))
    536           Broadcast((HAB) 0, hwndMain, UM_UPDATERECORD, MPFROMP(dir), MPVOID);
     539      ret = DosMove(oldname, fullnewname);      /* move it */
     540      if (ret && *dir) {                /* failed -- clean up */
     541        DosError(FERR_DISABLEHARDERR);
     542        if (!DosMove(dir, fullnewname))
     543          Broadcast((HAB) 0, hwndMain, UM_UPDATERECORD, MPFROMP(dir), MPVOID);
    537544      }
    538545      else if (!ret && *dir) {
    539         if (!IsFile(dir)) {
    540           if (!strchr(dir, '?') && !strchr(dir, '*'))
    541             wipeallf("%s\\*", dir);
    542           DosError(FERR_DISABLEHARDERR);
    543           if (DosDeleteDir(dir)) {
    544             make_deleteable(dir);
    545             DosDeleteDir(dir);
    546           }
    547         }
    548         else if (IsFile(dir) > 0) {
    549           DosError(FERR_DISABLEHARDERR);
    550           if (DosForceDelete(dir)) {
    551             make_deleteable(dir);
    552             DosForceDelete(dir);
    553           }
    554           if (zaplong)
    555             ZapLongName(dir);
    556           Broadcast((HAB) 0, hwndMain, UM_UPDATERECORD, MPFROMP(dir), MPVOID);
    557         }
    558       }
    559     }
    560     else {                              /* different drives */
     546        if (!IsFile(dir)) {
     547          if (!strchr(dir, '?') && !strchr(dir, '*'))
     548            wipeallf("%s\\*", dir);
     549          DosError(FERR_DISABLEHARDERR);
     550          if (DosDeleteDir(dir)) {
     551            make_deleteable(dir);
     552            DosDeleteDir(dir);
     553          }
     554        }
     555        else if (IsFile(dir) > 0) {
     556          DosError(FERR_DISABLEHARDERR);
     557          if (DosForceDelete(dir)) {
     558            make_deleteable(dir);
     559            DosForceDelete(dir);
     560          }
     561          if (zaplong)
     562            ZapLongName(dir);
     563          Broadcast((HAB) 0, hwndMain, UM_UPDATERECORD, MPFROMP(dir), MPVOID);
     564        }
     565      }
     566    }
     567    else {                              /* different drives */
    561568      DosError(FERR_DISABLEHARDERR);
    562       ret = DosCopy(oldname, fullnewname, DCPY_EXISTING);       /* <=-NOTE! */
     569      ret = DosCopy(oldname, fullnewname, DCPY_EXISTING);       /* <=-NOTE! */
    563570      if (ret == ERROR_DISK_CHANGE) {
    564         DosError(FERR_ENABLEHARDERR);
    565         ret = DosCopy(oldname, fullnewname, DCPY_EXISTING);
    566         diskchange = TRUE;
     571        DosError(FERR_ENABLEHARDERR);
     572        ret = DosCopy(oldname, fullnewname, DCPY_EXISTING);
     573        diskchange = TRUE;
    567574      }
    568575      if (ret == ERROR_INVALID_NAME || ret == ERROR_FILENAME_EXCED_RANGE) {
    569         if (TruncName(fullnewname, shortname)) {        /* make 8.3 filename */
    570           DosError(FERR_DISABLEHARDERR);
    571           ret = DosCopy(oldname, shortname, DCPY_EXISTING);
    572           if (!ret) {                   /* success -- write longname ea */
    573             WriteLongName(shortname, fullnewname);
    574             strcpy(fullnewname, shortname);
    575             /* broadcast fixup msg to windows */
    576             Broadcast((HAB) 0,
    577                       hwndMain, UM_UPDATERECORD, MPFROMP(shortname), MPVOID);
    578           }
    579         }
     576        if (TruncName(fullnewname, shortname)) {        /* make 8.3 filename */
     577          DosError(FERR_DISABLEHARDERR);
     578          ret = DosCopy(oldname, shortname, DCPY_EXISTING);
     579          if (!ret) {                   /* success -- write longname ea */
     580            WriteLongName(shortname, fullnewname);
     581            strcpy(fullnewname, shortname);
     582            /* broadcast fixup msg to windows */
     583            Broadcast((HAB) 0,
     584                      hwndMain, UM_UPDATERECORD, MPFROMP(shortname), MPVOID);
     585          }
     586        }
    580587      }
    581588      else if (!ret && *longname) {
    582589
    583         CHAR fixname[CCHMAXPATH];
    584 
    585         strcpy(fixname, fullnewname);
    586         p = strrchr(fixname, '\\');
    587         if (p) {
    588           p++;
    589           *p = 0;
    590         }
    591         strcat(fixname, longname);
    592         DosError(FERR_DISABLEHARDERR);
    593         DosMove(fullnewname, fixname);
    594         strcpy(fullnewname, fixname);
    595         if (zaplong)
    596           ZapLongName(fixname);
    597         Broadcast((HAB) 0,
    598                   hwndMain, UM_UPDATERECORD, MPFROMP(fixname), MPVOID);
    599       }
    600       if (!ret) {                       /* double-check success */
    601         DosError(FERR_DISABLEHARDERR);
    602         rc = DosQueryPathInfo(fullnewname,
    603                               FIL_STANDARDL, &st2, sizeof(FILESTATUS3L));
    604         if (rc == ERROR_DISK_CHANGE) {
    605           DosError(FERR_ENABLEHARDERR);
    606           rc = DosQueryPathInfo(fullnewname,
    607                                 FIL_STANDARDL, &st2, sizeof(FILESTATUS3L));
    608         }
    609         if (!rc && st2.cbFile == st.cbFile) {   /* seems to have worked... */
    610           DosError(FERR_DISABLEHARDERR);
    611           if (diskchange) {
    612             DosError(FERR_ENABLEHARDERR);
    613             DosQueryPathInfo(oldname, FIL_STANDARDL, &dummy, sizeof(FILESTATUS3L));     /* force disk change */
    614           }
    615           if (!(st2.attrFile & FILE_DIRECTORY)) /* erase file */
    616             unlinkf("%s", oldname);
    617           else {                        /* remove directory */
    618             wipeallf("%s\\*", oldname);
    619             DosError(FERR_DISABLEHARDERR);
    620             if (DosDeleteDir(oldname)) {
    621               make_deleteable(oldname);
    622               DosDeleteDir(oldname);
    623             }
    624           }
    625         }
     590        CHAR fixname[CCHMAXPATH];
     591
     592        strcpy(fixname, fullnewname);
     593        p = strrchr(fixname, '\\');
     594        if (p) {
     595          p++;
     596          *p = 0;
     597        }
     598        strcat(fixname, longname);
     599        DosError(FERR_DISABLEHARDERR);
     600        DosMove(fullnewname, fixname);
     601        strcpy(fullnewname, fixname);
     602        if (zaplong)
     603          ZapLongName(fixname);
     604        Broadcast((HAB) 0,
     605                  hwndMain, UM_UPDATERECORD, MPFROMP(fixname), MPVOID);
     606      }
     607      if (!ret) {                       /* double-check success */
     608        DosError(FERR_DISABLEHARDERR);
     609        rc = DosQueryPathInfo(fullnewname,
     610                              FIL_STANDARDL, &st2, sizeof(FILESTATUS3L));
     611        if (rc == ERROR_DISK_CHANGE) {
     612          DosError(FERR_ENABLEHARDERR);
     613          rc = DosQueryPathInfo(fullnewname,
     614                                FIL_STANDARDL, &st2, sizeof(FILESTATUS3L));
     615        }
     616        if (!rc && st2.cbFile == st.cbFile) {   /* seems to have worked... */
     617          DosError(FERR_DISABLEHARDERR);
     618          if (diskchange) {
     619            DosError(FERR_ENABLEHARDERR);
     620            DosQueryPathInfo(oldname, FIL_STANDARDL, &dummy, sizeof(FILESTATUS3L));     /* force disk change */
     621          }
     622          if (!(st2.attrFile & FILE_DIRECTORY)) /* erase file */
     623            unlinkf("%s", oldname);
     624          else {                        /* remove directory */
     625            wipeallf("%s\\*", oldname);
     626            DosError(FERR_DISABLEHARDERR);
     627            if (DosDeleteDir(oldname)) {
     628              make_deleteable(oldname);
     629              DosDeleteDir(oldname);
     630            }
     631          }
     632        }
    626633      }
    627634    }
    … …  
    630637  case COPY:
    631638    DosError(FERR_DISABLEHARDERR);
    632     ret = DosCopy(oldname, fullnewname, DCPY_EXISTING); /* <=-NOTE! */
     639    ret = DosCopy(oldname, fullnewname, DCPY_EXISTING); /* <=-NOTE! */
    633640    if (ret == ERROR_DISK_CHANGE) {
    634641      DosError(FERR_ENABLEHARDERR);
    … …  
    638645    if (ret == ERROR_INVALID_NAME || ret == ERROR_FILENAME_EXCED_RANGE) {
    639646      if (TruncName(fullnewname, shortname)) {
    640         DosError((diskchange) ? FERR_ENABLEHARDERR : FERR_DISABLEHARDERR);
    641         ret = DosCopy(oldname, shortname, DCPY_EXISTING);
    642         if (!ret) {
    643           WriteLongName(shortname, fullnewname);
    644           strcpy(fullnewname, shortname);
    645           Broadcast((HAB) 0,
    646                     hwndMain, UM_UPDATERECORD, MPFROMP(shortname), MPVOID);
    647         }
     647        DosError((diskchange) ? FERR_ENABLEHARDERR : FERR_DISABLEHARDERR);
     648        ret = DosCopy(oldname, shortname, DCPY_EXISTING);
     649        if (!ret) {
     650          WriteLongName(shortname, fullnewname);
     651          strcpy(fullnewname, shortname);
     652          Broadcast((HAB) 0,
     653                    hwndMain, UM_UPDATERECORD, MPFROMP(shortname), MPVOID);
     654        }
    648655      }
    649656    }
    … …  
    655662      p = strrchr(fixname, '\\');
    656663      if (p) {
    657         p++;
    658         *p = 0;
     664        p++;
     665        *p = 0;
    659666      }
    660667      strcat(fixname, longname);
    … …  
    662669      DosMove(fullnewname, fixname);
    663670      if (zaplong)
    664         ZapLongName(fixname);
     671        ZapLongName(fixname);
    665672      Broadcast((HAB) 0, hwndMain, UM_UPDATERECORD, MPFROMP(fixname), MPVOID);
    666673    }
    667674    return ret;
    668675
    669   default:                              /* shouldn't happen */
     676  default:                              /* shouldn't happen */
    670677    Runtime_Error(pszSrcFile, __LINE__, "bad case %u", type);
    671678    break;
    672679  }
    673   return (APIRET) - 3;                  /* bad type */
     680  return (APIRET) - 3;                  /* bad type */
    674681}
    675682
    … …  
    717724    return -1;
    718725
    719   {                                     /* safety net -- disallow deleting a root dir or partial name */
     726  {                                     /* safety net -- disallow deleting a root dir or partial name */
    720727    CHAR temp;
    721728
    … …  
    726733      *p = 0;
    727734      if (IsRoot(str) || !IsFullName(str)) {
    728         /* under no circumstances! */
    729         Runtime_Error(pszSrcFile, __LINE__, "bad name %s", str);
    730         free(str);
    731         return -1;
     735        /* under no circumstances! */
     736        Runtime_Error(pszSrcFile, __LINE__, "bad name %s", str);
     737        free(str);
     738        return -1;
    732739      }
    733740      *p = temp;
    … …  
    736743
    737744  p = s;
    738   p = strrchr(s, '\\');                 /* strip s to just path */
     745  p = strrchr(s, '\\');                 /* strip s to just path */
    739746  if (!p)
    740747    p = strrchr(s, ':');
    … …  
    764771  DosError(FERR_DISABLEHARDERR);
    765772  if (!DosFindFirst(str, &search_handle, FILE_NORMAL | FILE_DIRECTORY |
    766                      FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN | FILE_ARCHIVED,
    767                      f, sizeof(FILEFINDBUF3), &num_matches, FIL_STANDARD)) {
     773                     FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN | FILE_ARCHIVED,
     774                     f, sizeof(FILEFINDBUF3), &num_matches, FIL_STANDARD)) {
    768775
    769776    strcpy(ss, s);
    … …  
    773780      strcpy(p, f->achName);
    774781      if (f->attrFile & FILE_DIRECTORY) {
    775         if (strcmp(f->achName, ".") && strcmp(f->achName, "..")) {
    776           wipeallf("%s/%s", ss, mask);  /* recurse to wipe files */
    777           DosError(FERR_DISABLEHARDERR);
    778           if (DosDeleteDir(ss)) {       /* remove directory */
    779             make_deleteable(ss);
    780             DosError(FERR_DISABLEHARDERR);
    781             DosDeleteDir(ss);
    782           }
    783         }
     782        if (strcmp(f->achName, ".") && strcmp(f->achName, "..")) {
     783          wipeallf("%s/%s", ss, mask);  /* recurse to wipe files */
     784          DosError(FERR_DISABLEHARDERR);
     785          if (DosDeleteDir(ss)) {       /* remove directory */
     786            make_deleteable(ss);
     787            DosError(FERR_DISABLEHARDERR);
     788            DosDeleteDir(ss);
     789          }
     790        }
    784791      }
    785792      else {
    786         DosError(FERR_DISABLEHARDERR);
    787         if (DosForceDelete(ss)) {
    788           make_deleteable(ss);
    789           DosError(FERR_DISABLEHARDERR);
    790           rc = (INT) DosForceDelete(ss);
    791           if (rc)
    792             return rc;
    793         }
     793        DosError(FERR_DISABLEHARDERR);
     794        if (DosForceDelete(ss)) {
     795          make_deleteable(ss);
     796          DosError(FERR_DISABLEHARDERR);
     797          rc = (INT) DosForceDelete(ss);
     798          if (rc)
     799            return rc;
     800        }
    794801      }
    795802      num_matches = 1;
    796803      DosError(FERR_DISABLEHARDERR);
    797804    } while (!DosFindNext(search_handle, f, sizeof(FILEFINDBUF3),
    798                           &num_matches));
     805                          &num_matches));
    799806    DosFindClose(search_handle);
    800807  }
    … …  
    806813}
    807814
     815#if 0   // JBS
    808816INT unlink_allf(CHAR * string, ...)
    809817{
    … …  
    834842
    835843  p = s;
    836   p = strrchr(s, '\\');                 /* strip s to just path */
     844  p = strrchr(s, '\\');                 /* strip s to just path */
    837845  if (!p)
    838846    p = strrchr(s, ':');
    … …  
    858866  DosError(FERR_DISABLEHARDERR);
    859867  if (!DosFindFirst(str, &search_handle, FILE_NORMAL, f,
    860                     sizeof(FILEFINDBUF3), &num_matches, FIL_STANDARD)) {
     868                    sizeof(FILEFINDBUF3), &num_matches, FIL_STANDARD)) {
    861869
    862870    strcpy(ss, s);
    … …  
    869877      DosError(FERR_DISABLEHARDERR);
    870878    } while (!DosFindNext(search_handle, f, sizeof(FILEFINDBUF3),
    871                           &num_matches));
     879                          &num_matches));
    872880    DosFindClose(search_handle);
    873881  }
    … …  
    878886  return 0;
    879887}
     888#endif
    880889
    881890INT unlinkf(CHAR * string, ...)

  • trunk/dll/killproc.c

    r1077 r1163  
    3939#include "strutil.h"                    // GetPString
    4040#include "pathutil.h"                   // BldFullPathName
     41#include "killproc.h"
     42#include "systemf.h"                    // ShowSession
    4143#include "fm3dll.h"
    4244#include "fortify.h"

  • trunk/dll/mkdir.c

    r1104 r1163  
    2727#include "strutil.h"                    // GetPString
    2828#include "notebook.h"                   // targetdirectoy
     29#include "mkdir.h"
     30#include "walkem.h"                     // WalkTargetDlgProc
    2931#include "fm3dll.h"
    3032

  • trunk/dll/notify.c

    r1063 r1163  
    1 
    21/***********************************************************************
    32
    … …  
    2120#include <string.h>
    2221#include <ctype.h>
    23 #include <stddef.h>                     // _threadid
    24 #include <process.h>                    // _beginthread
     22#include <stddef.h>                     // _threadid
     23#include <process.h>                    // _beginthread
    2524
    2625#define INCL_DOS
    2726#define INCL_WIN
    2827#define INCL_GPI
    29 #define INCL_LONGLONG                   // dircnrs.h
     28#define INCL_LONGLONG                   // dircnrs.h
    3029
    3130#include "fm3dlg.h"
    3231#include "fm3str.h"
    33 #include "errutil.h"                    // Dos_Error...
    34 #include "strutil.h"                    // GetPString
     32#include "errutil.h"                    // Dos_Error...
     33#include "strutil.h"                    // GetPString
     34#include "notify.h"
    3535#include "fm3dll.h"
    3636#include "fortify.h"
    … …  
    4040static PSZ pszSrcFile = __FILE__;
    4141
    42 static volatile HWND hwndNotify;        // 16 Apr 08 SHL
     42static volatile HWND hwndNotify;        // 16 Apr 08 SHL
     43
     44VOID StartNotes(CHAR * s);
    4345
    4446/**
    … …  
    5860
    5961      if (!WinStartTimer(WinQueryAnchorBlock(hwnd), hwnd, ID_TIMER2, 5000)) {
    60         Win_Error(hwnd, hwnd, pszSrcFile, __LINE__, "WinStartTimer");
    61         WinDestroyWindow(hwnd);
     62        Win_Error(hwnd, hwnd, pszSrcFile, __LINE__, "WinStartTimer");
     63        WinDestroyWindow(hwnd);
    6264      }
    6365      else {
    6466
    65         RGB2 rgb2F, rgb2;
    66 
    67         memset(&rgb2F, 0, sizeof(RGB2));
    68         rgb2F.bRed = (BYTE)65;
    69         rgb2.bRed = rgb2.bGreen = rgb2.bBlue = (BYTE)255;
    70         rgb2.fcOptions = 0;
    71         SetPresParams(hwnd, &rgb2, &rgb2F, &rgb2, GetPString(IDS_8HELVTEXT));
    72         if (hwndMain) {
    73           if (hwndStatus)
    74             WinShowWindow(hwndStatus, FALSE);
    75           if (hwndStatus2)
    76             WinShowWindow(hwndStatus2, FALSE);
    77         }
    78         PostMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
     67        RGB2 rgb2F, rgb2;
     68
     69        memset(&rgb2F, 0, sizeof(RGB2));
     70        rgb2F.bRed = (BYTE)65;
     71        rgb2.bRed = rgb2.bGreen = rgb2.bBlue = (BYTE)255;
     72        rgb2.fcOptions = 0;
     73        SetPresParams(hwnd, &rgb2, &rgb2F, &rgb2, GetPString(IDS_8HELVTEXT));
     74        if (hwndMain) {
     75          if (hwndStatus)
     76            WinShowWindow(hwndStatus, FALSE);
     77          if (hwndStatus2)
     78            WinShowWindow(hwndStatus2, FALSE);
     79        }
     80        PostMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
    7981      }
    8082      return rc;
    … …  
    105107      HPS hps = WinGetPS(hwnd);
    106108      if (hps) {
    107         if (WinQueryWindowPos(hwnd, &swp)) {
    108           ptl.x = 0;
    109           ptl.y = 0;
    110           GpiMove(hps, &ptl);
    111           GpiSetColor(hps, CLR_RED);
    112           ptl.x = swp.cx - 1;
    113           ptl.y = swp.cy - 1;
    114           GpiBox(hps, DRO_OUTLINE, &ptl, 2, 2);
    115         }
    116         WinReleasePS(hwnd);
     109        if (WinQueryWindowPos(hwnd, &swp)) {
     110          ptl.x = 0;
     111          ptl.y = 0;
     112          GpiMove(hps, &ptl);
     113          GpiSetColor(hps, CLR_RED);
     114          ptl.x = swp.cx - 1;
     115          ptl.y = swp.cy - 1;
     116          GpiBox(hps, DRO_OUTLINE, &ptl, 2, 2);
     117        }
     118        WinReleasePS(hwnd);
    117119      }
    118120      return mr;
    … …  
    132134    if (!showing && hwndMain) {
    133135      if (hwndStatus)
    134         WinShowWindow(hwndStatus, TRUE);
     136        WinShowWindow(hwndStatus, TRUE);
    135137      if (hwndStatus2)
    136         WinShowWindow(hwndStatus2, TRUE);
     138        WinShowWindow(hwndStatus2, TRUE);
    137139    }
    138140    break;
    … …  
    162164      WinQueryWindowPos(hwndStatus2, &swpS2);
    163165    x = hwndMain ? (hwndStatus ? swpS.x - 1 :
    164                       WinQuerySysValue(HWND_DESKTOP, SV_CXSIZEBORDER)) : 0;
     166                      WinQuerySysValue(HWND_DESKTOP, SV_CXSIZEBORDER)) : 0;
    165167    y = hwndMain ? (hwndStatus ? swpS.y - 1 :
    166                       WinQuerySysValue(HWND_DESKTOP, SV_CYSIZEBORDER)) : 0;
     168                      WinQuerySysValue(HWND_DESKTOP, SV_CYSIZEBORDER)) : 0;
    167169    if (hwndMain && hwndStatus) {
    168170      if (hwndStatus2)
    169         cx = swpS2.cx + swpS.cx + 8;
     171        cx = swpS2.cx + swpS.cx + 8;
    170172      else
    171         cx = swpS.cx + 6;
     173        cx = swpS.cx + 6;
    172174    }
    173175    else
    … …  
    179181      p = xmalloc(strlen(str) + 2, pszSrcFile, __LINE__);
    180182      if (!p)
    181         p = str;
     183        p = str;
    182184      else {
    183         strcpy(p + 1, str);
    184         *p = ' ';
     185        strcpy(p + 1, str);
     186        *p = ' ';
    185187      }
    186188    }
    … …  
    189191
    190192    hwnd = WinCreateWindow(hwndP,
    191                            WC_ERRORWND,
    192                            p,
    193                            SS_TEXT | DT_LEFT | DT_VCENTER | WS_VISIBLE,
    194                            x, y, cx, cy, hwndP, HWND_TOP, id++, NULL, NULL);
     193                           WC_ERRORWND,
     194                           p,
     195                           SS_TEXT | DT_LEFT | DT_VCENTER | WS_VISIBLE,
     196                           x, y, cx, cy, hwndP, HWND_TOP, id++, NULL, NULL);
    195197    if (!hwndP)
    196198      Win_Error2(hwndP, hwndP, pszSrcFile, __LINE__, IDS_WINCREATEWINDOW);
    … …  
    244246    else if (status == 107)
    245247      sprintf(&errortext[strlen(errortext)],
    246               GetPString(IDS_PHANTOMTEXT), toupper(*filename));
     248              GetPString(IDS_PHANTOMTEXT), toupper(*filename));
    247249    else if (status == 19)
    248250      strcat(errortext, GetPString(IDS_DISKWRITEPROTEXTTEXT));
    … …  
    270272      // Already have notes dialog - pass message on
    271273      if (mp2) {
    272         WinSendDlgItemMsg(hwndNotify,
    273                           NOTE_LISTBOX,
    274                           LM_INSERTITEM, MPFROM2SHORT(LIT_END, 0), mp2);
    275         PostMsg(hwndNotify, UM_NOTIFY, MPVOID, MPVOID);
    276         free((CHAR *)mp2);
     274        WinSendDlgItemMsg(hwndNotify,
     275                          NOTE_LISTBOX,
     276                          LM_INSERTITEM, MPFROM2SHORT(LIT_END, 0), mp2);
     277        PostMsg(hwndNotify, UM_NOTIFY, MPVOID, MPVOID);
     278        free((CHAR *)mp2);
    277279      }
    278280      WinDismissDlg(hwnd, 0);
    … …  
    285287      BOOL dummy = TRUE;
    286288      PrfWriteProfileData(fmprof,
    287                           FM3Str, "ThreadNotes", &dummy, sizeof(BOOL));
     289                          FM3Str, "ThreadNotes", &dummy, sizeof(BOOL));
    288290    }
    289291    if (mp2) {
    290292      WinSendDlgItemMsg(hwnd,
    291                         NOTE_LISTBOX,
    292                         LM_INSERTITEM, MPFROM2SHORT(LIT_END, 0), mp2);
     293                        NOTE_LISTBOX,
     294                        LM_INSERTITEM, MPFROM2SHORT(LIT_END, 0), mp2);
    293295      free((CHAR *)mp2);
    294296    }
    … …  
    308310    {
    309311      ULONG size = sizeof(SWP),
    310         fl = SWP_ZORDER | SWP_FOCUSDEACTIVATE | SWP_SHOW;
     312        fl = SWP_ZORDER | SWP_FOCUSDEACTIVATE | SWP_SHOW;
    311313      SWP swp;
    312314
    313315      if (PrfQueryProfileData(fmprof,
    314                               FM3Str, "NoteWndSwp", (PVOID) & swp, &size)) {
    315         if (swp.fl & (SWP_HIDE | SWP_MINIMIZE)) {
    316           fl |= SWP_MINIMIZE;
    317           fl &= (~SWP_SHOW);
    318         }
    319         else
    320           fl |= (SWP_MOVE | SWP_SIZE);
     316                              FM3Str, "NoteWndSwp", (PVOID) & swp, &size)) {
     317        if (swp.fl & (SWP_HIDE | SWP_MINIMIZE)) {
     318          fl |= SWP_MINIMIZE;
     319          fl &= (~SWP_SHOW);
     320        }
     321        else
     322          fl |= (SWP_MOVE | SWP_SIZE);
    321323      }
    322324      WinSetWindowPos(hwnd, HWND_BOTTOM, swp.x, swp.y, swp.cx, swp.cy, fl);
    323325      if (fl & SWP_MINIMIZE) {
    324         WinSetWindowUShort(hwnd, QWS_XRESTORE, (USHORT) swp.x);
    325         WinSetWindowUShort(hwnd, QWS_CXRESTORE, (USHORT) swp.cx);
    326         WinSetWindowUShort(hwnd, QWS_YRESTORE, (USHORT) swp.y);
    327         WinSetWindowUShort(hwnd, QWS_CYRESTORE, (USHORT) swp.cy);
     326        WinSetWindowUShort(hwnd, QWS_XRESTORE, (USHORT) swp.x);
     327        WinSetWindowUShort(hwnd, QWS_CXRESTORE, (USHORT) swp.cx);
     328        WinSetWindowUShort(hwnd, QWS_YRESTORE, (USHORT) swp.y);
     329        WinSetWindowUShort(hwnd, QWS_CYRESTORE, (USHORT) swp.cy);
    328330      }
    329331    }
    … …  
    339341      WinQueryWindowPos(hwnd, &swp);
    340342      if (!(swp.fl & (SWP_MINIMIZE | SWP_HIDE))) {
    341         szbx = SysVal(SV_CXSIZEBORDER);
    342         szby = SysVal(SV_CYSIZEBORDER);
    343         titl = SysVal(SV_CYTITLEBAR);
    344         WinSetWindowPos(WinWindowFromID(hwnd, NOTE_LISTBOX),
    345                         HWND_TOP,
    346                         szbx,
    347                         szby,
    348                         swp.cx - (szbx * 2L),
    349                         (swp.cy - titl) - (szby * 2L), SWP_MOVE | SWP_SIZE);
     343        szbx = SysVal(SV_CXSIZEBORDER);
     344        szby = SysVal(SV_CYSIZEBORDER);
     345        titl = SysVal(SV_CYTITLEBAR);
     346        WinSetWindowPos(WinWindowFromID(hwnd, NOTE_LISTBOX),
     347                        HWND_TOP,
     348                        szbx,
     349                        szby,
     350                        swp.cx - (szbx * 2L),
     351                        (swp.cy - titl) - (szby * 2L), SWP_MOVE | SWP_SIZE);
    350352      }
    351353      if (!(swp.fl & SWP_MAXIMIZE)) {
    352         if (swp.fl & (SWP_MINIMIZE | SWP_HIDE)) {
    353           swp.x = WinQueryWindowUShort(hwnd, QWS_XRESTORE);
    354           swp.y = WinQueryWindowUShort(hwnd, QWS_YRESTORE);
    355           swp.cx = WinQueryWindowUShort(hwnd, QWS_CXRESTORE);
    356           swp.cy = WinQueryWindowUShort(hwnd, QWS_CYRESTORE);
    357         }
    358         PrfWriteProfileData(fmprof,
    359                             FM3Str, "NoteWndSwp", (PVOID) & swp, sizeof(SWP));
     354        if (swp.fl & (SWP_MINIMIZE | SWP_HIDE)) {
     355          swp.x = WinQueryWindowUShort(hwnd, QWS_XRESTORE);
     356          swp.y = WinQueryWindowUShort(hwnd, QWS_YRESTORE);
     357          swp.cx = WinQueryWindowUShort(hwnd, QWS_CXRESTORE);
     358          swp.cy = WinQueryWindowUShort(hwnd, QWS_CYRESTORE);
     359        }
     360        PrfWriteProfileData(fmprof,
     361                            FM3Str, "NoteWndSwp", (PVOID) & swp, sizeof(SWP));
    360362      }
    361363    }
    … …  
    370372      SHORT y;
    371373      SHORT x = (SHORT)WinSendDlgItemMsg(hwnd,
    372                                         NOTE_LISTBOX,
    373                                         LM_QUERYITEMCOUNT, MPVOID, MPVOID);
     374                                        NOTE_LISTBOX,
     375                                        LM_QUERYITEMCOUNT, MPVOID, MPVOID);
    374376      if (x > 60) {
    375         for (y = 0; y < x - 50; y++) {
    376           WinSendDlgItemMsg(hwnd,
    377                             NOTE_LISTBOX,
    378                             LM_DELETEITEM, MPFROMSHORT(y), MPVOID);
    379         }
     377        for (y = 0; y < x - 50; y++) {
     378          WinSendDlgItemMsg(hwnd,
     379                            NOTE_LISTBOX,
     380                            LM_DELETEITEM, MPFROMSHORT(y), MPVOID);
     381        }
    380382      }
    381383    }
    … …  
    385387    {
    386388      SHORT x = (SHORT) WinSendDlgItemMsg(hwnd,
    387                                           NOTE_LISTBOX,
    388                                           LM_QUERYITEMCOUNT, MPVOID, MPVOID);
     389                                          NOTE_LISTBOX,
     390                                          LM_QUERYITEMCOUNT, MPVOID, MPVOID);
    389391      if (x > 0)
    390         WinSendDlgItemMsg(hwnd,
    391                           NOTE_LISTBOX,
    392                           LM_SETTOPINDEX, MPFROMSHORT(x), MPVOID);
     392        WinSendDlgItemMsg(hwnd,
     393                          NOTE_LISTBOX,
     394                          LM_SETTOPINDEX, MPFROMSHORT(x), MPVOID);
    393395    }
    394396    return 0;
    … …  
    396398  case UM_SHOWME:
    397399    WinSetWindowPos(hwnd,
    398                     HWND_TOP,
    399                     0,
    400                     0,
    401                     0, 0, SWP_SHOW | SWP_RESTORE | SWP_ZORDER | SWP_ACTIVATE);
     400                    HWND_TOP,
     401                    0,
     402                    0,
     403                    0, 0, SWP_SHOW | SWP_RESTORE | SWP_ZORDER | SWP_ACTIVATE);
    402404    return 0;
    403405
    … …  
    413415      fThreadNotes = FALSE;
    414416      PrfWriteProfileData(fmprof,
    415                           FM3Str, "ThreadNotes", &fThreadNotes, sizeof(BOOL));
     417                          FM3Str, "ThreadNotes", &fThreadNotes, sizeof(BOOL));
    416418      hwndNotify = (HWND) 0;
    417419    }
    … …  
    439441    if (hmq) {
    440442      if (!hwndNotify)
    441         WinDlgBox(HWND_DESKTOP,
    442                   HWND_DESKTOP,
    443                   NoteWndProc, FM3ModHandle, NOTE_FRAME, (CHAR *)args);
     443        WinDlgBox(HWND_DESKTOP,
     444                  HWND_DESKTOP,
     445                  NoteWndProc, FM3ModHandle, NOTE_FRAME, (CHAR *)args);
    444446      WinDestroyMsgQueue(hmq);
    445447    }
    … …  
    463465      USHORT i;
    464466      for (i = 0; !hwndNotify && i < 10; i++)
    465         DosSleep(10);
     467        DosSleep(10);
    466468      if (!hwndNotify)
    467         Runtime_Error(pszSrcFile, __LINE__, "Can not create Notify window");
     469        Runtime_Error(pszSrcFile, __LINE__, "Can not create Notify window");
    468470    }
    469471  }
    … …  
    485487    if (*p) {
    486488      if (!hwndNotify) {
    487         fThreadNotes = FALSE;
    488         StartNotes(NULL);
     489        fThreadNotes = FALSE;
     490        StartNotes(NULL);
    489491      }
    490492      if (hwndNotify) {
    491         s = xmalloc(strlen(p) + 14, pszSrcFile, __LINE__);
    492         if (s) {
    493           sprintf(s, "%08lx  %s", _threadid, p);
    494           while (!once) {
    495             if ((SHORT) WinSendDlgItemMsg(hwndNotify,
    496                                           NOTE_LISTBOX,
    497                                           LM_INSERTITEM,
    498                                           MPFROM2SHORT(LIT_END, 0),
    499                                           MPFROMP(s)) >= 0) {
    500               ret = TRUE;
    501               PostMsg(hwndNotify, UM_NOTIFY, MPVOID, MPVOID);
    502               break;
    503             }
    504             PostMsg(hwndNotify, UM_CONTAINER_FILLED, MPVOID, MPVOID);
    505             once = TRUE;
     493        s = xmalloc(strlen(p) + 14, pszSrcFile, __LINE__);
     494        if (s) {
     495          sprintf(s, "%08lx  %s", _threadid, p);
     496          while (!once) {
     497            if ((SHORT) WinSendDlgItemMsg(hwndNotify,
     498                                          NOTE_LISTBOX,
     499                                          LM_INSERTITEM,
     500                                          MPFROM2SHORT(LIT_END, 0),
     501                                          MPFROMP(s)) >= 0) {
     502              ret = TRUE;
     503              PostMsg(hwndNotify, UM_NOTIFY, MPVOID, MPVOID);
     504              break;
     505            }
     506            PostMsg(hwndNotify, UM_CONTAINER_FILLED, MPVOID, MPVOID);
     507            once = TRUE;
    506508          }
    507509          free(s);
    508         }
     510        }
    509511      }
    510512    }
    … …  
    544546  if (hwndNotify)
    545547    WinSetWindowPos(hwndNotify,
    546                     HWND_BOTTOM,
    547                     0,
    548                     0, 0, 0, SWP_MINIMIZE | SWP_ZORDER | SWP_FOCUSDEACTIVATE);
     548                    HWND_BOTTOM,
     549                    0,
     550                    0, 0, 0, SWP_MINIMIZE | SWP_ZORDER | SWP_FOCUSDEACTIVATE);
    549551}
    550552

  • trunk/dll/objcnr.c

    r1063 r1163  
    2828#include <string.h>
    2929#include <ctype.h>
    30 #include <process.h>                    // _beginthread
     30#include <process.h>                    // _beginthread
    3131
    3232#define INCL_DOS
    … …  
    3737#include "fm3dlg.h"
    3838#include "fm3str.h"
    39 #include "errutil.h"                    // Dos_Error...
    40 #include "strutil.h"                    // GetPString
     39#include "errutil.h"                    // Dos_Error...
     40#include "strutil.h"                    // GetPString
     41#include "objcnr.h"
    4142#include "fm3dll.h"
     43#include "select.h"                     // ExpandAll
    4244
    4345#include "fortify.h"
    … …  
    6769
    6870static VOID ProcessDir(HWND hwndCnr,
    69                        CHAR *filename,
    70                        PCNRITEM pciParent,
    71                        CHAR *stopflag)
     71                       CHAR *filename,
     72                       PCNRITEM pciParent,
     73                       CHAR *stopflag)
    7274{
    7375  CHAR maskstr[CCHMAXPATH], *endpath, *p;
    … …  
    8486  pffbArray = xmalloc(ulBufBytes, pszSrcFile, __LINE__);
    8587  if (!pffbArray)
    86     return;                             // Error already reported
     88    return;                             // Error already reported
    8789  strcpy(maskstr, filename);
    8890  if (maskstr[strlen(maskstr) - 1] != '\\')
    … …  
    9395  ulFindCnt = 1;
    9496  rc = xDosFindFirst(filename, &hdir,
    95                      FILE_NORMAL | FILE_READONLY | FILE_ARCHIVED |
    96                      FILE_SYSTEM | FILE_HIDDEN | MUST_HAVE_DIRECTORY,
    97                      pffbArray, ulBufBytes, &ulFindCnt, FIL_STANDARDL);
     97                     FILE_NORMAL | FILE_READONLY | FILE_ARCHIVED |
     98                     FILE_SYSTEM | FILE_HIDDEN | MUST_HAVE_DIRECTORY,
     99                     pffbArray, ulBufBytes, &ulFindCnt, FIL_STANDARDL);
    98100  if (!rc)
    99101    DosFindClose(hdir);
    … …  
    104106  if ((!rc && (pffbArray->attrFile & FILE_DIRECTORY))) {
    105107    pciP = WinSendMsg(hwndCnr,
    106                       CM_ALLOCRECORD,
    107                       MPFROMLONG(EXTRA_RECORD_BYTES),
    108                       MPFROMLONG(1));
     108                      CM_ALLOCRECORD,
     109                      MPFROMLONG(EXTRA_RECORD_BYTES),
     110                      MPFROMLONG(1));
    109111    if (!pciP) {
    110112      Win_Error(hwndCnr, HWND_DESKTOP, pszSrcFile, __LINE__, "CM_ALLOCRECORD");
    … …  
    121123      p = strrchr(pciP->pszFileName, '\\');
    122124      if (!p)
    123         pciP->pszDisplayName = pciP->pszFileName;
     125        pciP->pszDisplayName = pciP->pszFileName;
    124126      else if (*(p + 1))
    125         p++;
     127        p++;
    126128      pciP->pszDisplayName = p;
    127129    }
    … …  
    136138    free(pffbArray);
    137139    Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
    138               GetPString(IDS_CANTFINDDIRTEXT), filename);
     140              GetPString(IDS_CANTFINDDIRTEXT), filename);
    139141    return;
    140142  }
    … …  
    144146    pciP->rc.hptrIcon = hptr;
    145147
    146   if (!pciP->rc.hptrIcon || pciP->rc.hptrIcon == hptrFile)      /* OS/2 bug bug bug bug */
     148  if (!pciP->rc.hptrIcon || pciP->rc.hptrIcon == hptrFile)      /* OS/2 bug bug bug bug */
    147149    pciP->rc.hptrIcon = hptrDir;
    148150
    … …  
    166168  ulFindCnt = ulFindMax;
    167169  rc = xDosFindFirst(maskstr, &hdir,
    168                      FILE_NORMAL | FILE_READONLY | FILE_ARCHIVED |
    169                      FILE_SYSTEM | FILE_HIDDEN | MUST_HAVE_DIRECTORY,
    170                      pffbArray, ulBufBytes, &ulFindCnt, FIL_STANDARDL);
     170                     FILE_NORMAL | FILE_READONLY | FILE_ARCHIVED |
     171                     FILE_SYSTEM | FILE_HIDDEN | MUST_HAVE_DIRECTORY,
     172                     pffbArray, ulBufBytes, &ulFindCnt, FIL_STANDARDL);
    171173  if (!rc) {
    172174    PFILEFINDBUF3L pffbFile;
    … …  
    176178      pffbFile = pffbArray;
    177179      for (x = 0; x < ulFindCnt; x++) {
    178         if (*stopflag)
    179           break;
    180         if ((pffbFile->attrFile & FILE_DIRECTORY) &&
    181             // Skip . and ..
    182             (pffbFile->achName[0] != '.' ||
    183              (pffbFile->achName[1] &&
    184               (pffbFile->achName[1] != '.' || pffbFile->achName[2])))) {
    185           strcpy(endpath, pffbFile->achName);
    186           ProcessDir(hwndCnr, maskstr, pciP, stopflag);
    187         }
    188         if (!pffbFile->oNextEntryOffset)
    189           break;
    190         pffbFile = (PFILEFINDBUF3L)((PBYTE)pffbFile + pffbFile->oNextEntryOffset);
     180        if (*stopflag)
     181          break;
     182        if ((pffbFile->attrFile & FILE_DIRECTORY) &&
     183            // Skip . and ..
     184            (pffbFile->achName[0] != '.' ||
     185             (pffbFile->achName[1] &&
     186              (pffbFile->achName[1] != '.' || pffbFile->achName[2])))) {
     187          strcpy(endpath, pffbFile->achName);
     188          ProcessDir(hwndCnr, maskstr, pciP, stopflag);
     189        }
     190        if (!pffbFile->oNextEntryOffset)
     191          break;
     192        pffbFile = (PFILEFINDBUF3L)((PBYTE)pffbFile + pffbFile->oNextEntryOffset);
    191193      } // for
    192       DosSleep(0);                      // Let's others at same priority get some work done
     194      DosSleep(0);                      // Let's others at same priority get some work done
    193195      if (*stopflag)
    194         break;
     196        break;
    195197      ulFindCnt = ulFindMax;
    196198      rc = xDosFindNext(hdir, pffbArray, ulBufBytes, &ulFindCnt, FIL_STANDARDL);
    … …  
    201203  if (rc && rc != ERROR_NO_MORE_FILES) {
    202204    Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
    203               GetPString(IDS_CANTFINDDIRTEXT), filename);
     205              GetPString(IDS_CANTFINDDIRTEXT), filename);
    204206  }
    205207
    206208  free(pffbArray);
    207209  WinSendMsg(hwndCnr, CM_INVALIDATERECORD, MPFROMP(&pciP),
    208              MPFROM2SHORT(1, 0));
     210             MPFROM2SHORT(1, 0));
    209211}
    210212
    … …  
    231233      WinCancelShutdown(hmq, TRUE);
    232234      ProcessDir(dirsize->hwndCnr, dirsize->filename, (PCNRITEM) NULL,
    233                 dirsize->stopflag);
     235                dirsize->stopflag);
    234236      DosPostEventSem(CompactSem);
    235237      WinDestroyMsgQueue(hmq);
    … …  
    238240  }
    239241  PostMsg(WinQueryWindow(dirsize->hwndCnr, QW_PARENT), UM_CONTAINER_FILLED,
    240           MPVOID, MPVOID);
     242          MPVOID, MPVOID);
    241243  free(dirsize);
    242244# ifdef FORTIFY
    … …  
    254256      Runtime_Error(pszSrcFile, __LINE__, "objcnrwnd set");
    255257      WinSetWindowPos(objcnrwnd, HWND_TOP, 0, 0, 0, 0,
    256                       SWP_RESTORE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER);
     258                      SWP_RESTORE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER);
    257259      WinDismissDlg(hwnd, 0);
    258260      break;
    … …  
    280282      dirsize = xmalloc(sizeof(DIRSIZE), pszSrcFile, __LINE__);
    281283      if (!dirsize) {
    282         WinDismissDlg(hwnd, 0);
    283         break;
     284        WinDismissDlg(hwnd, 0);
     285        break;
    284286      }
    285287      dirsize->stopflag = (CHAR *)&data->stopflag;
    … …  
    287289      dirsize->hwndCnr = WinWindowFromID(hwnd, OBJCNR_CNR);
    288290      if (_beginthread(FillCnrsThread, NULL, 65536 * 8, (PVOID) dirsize) ==
    289           -1) {
    290         Runtime_Error(pszSrcFile, __LINE__,
    291                       GetPString(IDS_COULDNTSTARTTHREADTEXT));
     291          -1) {
     292        Runtime_Error(pszSrcFile, __LINE__,
     293                      GetPString(IDS_COULDNTSTARTTHREADTEXT));
    292294        free(dirsize);
    293295#       ifdef FORTIFY
    294296        Fortify_LeaveScope();
    295297#        endif
    296         WinDismissDlg(hwnd, 0);
    297         break;
     298        WinDismissDlg(hwnd, 0);
     299        break;
    298300      }
    299301      else
    300         data->working = TRUE;
     302        data->working = TRUE;
    301303    }
    302304    PostMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
    … …  
    311313      cnri.cb = sizeof(CNRINFO);
    312314      WinSendDlgItemMsg(hwnd, OBJCNR_CNR, CM_QUERYCNRINFO,
    313                         MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
     315                        MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
    314316      cnri.cyLineSpacing = 0;
    315317      cnri.cxTreeIndent = 12L;
    316318      cnri.pszCnrTitle = GetPString(IDS_WORKINGTEXT);
    317319      cnri.flWindowAttr = CV_TREE | CV_FLOW |
    318         CA_CONTAINERTITLE | CA_TITLESEPARATOR | CA_TREELINE;
     320        CA_CONTAINERTITLE | CA_TITLESEPARATOR | CA_TREELINE;
    319321      if (WinQueryWindowUShort(hwnd, QWS_ID) == QTREE_FRAME)
    320         cnri.flWindowAttr |= CV_MINI;
     322        cnri.flWindowAttr |= CV_MINI;
    321323      WinSendDlgItemMsg(hwnd, OBJCNR_CNR, CM_SETCNRINFO, MPFROMP(&cnri),
    322                         MPFROMLONG(CMA_FLWINDOWATTR | CMA_LINESPACING |
    323                                    CMA_CXTREEINDENT));
     324                        MPFROMLONG(CMA_FLWINDOWATTR | CMA_LINESPACING |
     325                                   CMA_CXTREEINDENT));
    324326    }
    325327    return 0;
    … …  
    329331//      WinEnableWindowUpdate(WinWindowFromID(hwnd,OBJCNR_CNR),TRUE);
    330332    WinSendDlgItemMsg(hwnd, OBJCNR_CNR, CM_INVALIDATERECORD, MPVOID,
    331                       MPFROM2SHORT(0, CMA_ERASE | CMA_INVALIDATE));
     333                      MPFROM2SHORT(0, CMA_ERASE | CMA_INVALIDATE));
    332334    data = INSTDATA(hwnd);
    333335    if (data) {
    334336      data->working = FALSE;
    335337      if (data->dying)
    336         WinDismissDlg(hwnd, 0);
     338        WinDismissDlg(hwnd, 0);
    337339      {
    338         PCNRITEM pci;
    339         USHORT id;
    340 
    341         id = WinQueryWindowUShort(hwnd, QWS_ID);
    342         pci = (PCNRITEM) WinSendDlgItemMsg(hwnd, OBJCNR_CNR,
    343                                            CM_QUERYRECORD,
    344                                            MPVOID,
    345                                            MPFROM2SHORT(CMA_FIRST,
    346                                                         CMA_ITEMORDER));
    347         if (pci && (INT) pci != -1) {
    348           ExpandAll(WinWindowFromID(hwnd, OBJCNR_CNR), TRUE, pci);
    349           if (id == QTREE_FRAME)
    350             pci = (PCNRITEM) WinSendDlgItemMsg(hwnd, OBJCNR_CNR,
    351                                                CM_QUERYRECORD,
    352                                                MPFROMP(pci),
    353                                                MPFROM2SHORT(CMA_FIRSTCHILD,
    354                                                             CMA_ITEMORDER));
    355         }
    356         if ((!pci || (INT) pci == -1) && id == QTREE_FRAME) {
    357           Notify(GetPString(IDS_NODIRSUNDERTEXT));
    358           WinDismissDlg(hwnd, 0);
    359           break;
    360         }
     340        PCNRITEM pci;
     341        USHORT id;
     342
     343        id = WinQueryWindowUShort(hwnd, QWS_ID);
     344        pci = (PCNRITEM) WinSendDlgItemMsg(hwnd, OBJCNR_CNR,
     345                                           CM_QUERYRECORD,
     346                                           MPVOID,
     347                                           MPFROM2SHORT(CMA_FIRST,
     348                                                        CMA_ITEMORDER));
     349        if (pci && (INT) pci != -1) {
     350          ExpandAll(WinWindowFromID(hwnd, OBJCNR_CNR), TRUE, pci);
     351          if (id == QTREE_FRAME)
     352            pci = (PCNRITEM) WinSendDlgItemMsg(hwnd, OBJCNR_CNR,
     353                                               CM_QUERYRECORD,
     354                                               MPFROMP(pci),
     355                                               MPFROM2SHORT(CMA_FIRSTCHILD,
     356                                                            CMA_ITEMORDER));
     357        }
     358        if ((!pci || (INT) pci == -1) && id == QTREE_FRAME) {
     359          Notify(GetPString(IDS_NODIRSUNDERTEXT));
     360          WinDismissDlg(hwnd, 0);
     361          break;
     362        }
    361363      }
    362364    }
    … …  
    368370      if (SHORT2FROMMP(mp1) == CN_ENTER) {
    369371
    370         PCNRITEM pci = (PCNRITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
    371 
    372         if (pci && (INT) pci != -1)
    373           WinSendDlgItemMsg(hwnd, DID_OK, BM_CLICK, MPVOID, MPVOID);
     372        PCNRITEM pci = (PCNRITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
     373
     374        if (pci && (INT) pci != -1)
     375          WinSendDlgItemMsg(hwnd, DID_OK, BM_CLICK, MPVOID, MPVOID);
    374376      }
    375377      break;
    … …  
    382384      if (hwndHelp) {
    383385
    384         USHORT id;
    385 
    386         id = WinQueryWindowUShort(hwnd, QWS_ID);
    387 
    388         if (id == QTREE_FRAME)
    389           WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
    390                      MPFROM2SHORT(HELP_QUICKTREE, 0),
    391                      MPFROMSHORT(HM_RESOURCEID));
    392         else
    393           WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
    394                      MPFROM2SHORT(HELP_OBJECTPATH, 0),
    395                      MPFROMSHORT(HM_RESOURCEID));
     386        USHORT id;
     387
     388        id = WinQueryWindowUShort(hwnd, QWS_ID);
     389
     390        if (id == QTREE_FRAME)
     391          WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
     392                     MPFROM2SHORT(HELP_QUICKTREE, 0),
     393                     MPFROMSHORT(HM_RESOURCEID));
     394        else
     395          WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
     396                     MPFROM2SHORT(HELP_OBJECTPATH, 0),
     397                     MPFROMSHORT(HM_RESOURCEID));
    396398      }
    397399      break;
    … …  
    402404      if (data) {
    403405
    404         PCNRITEM pci;
    405 
    406         if (data->working) {
    407           Runtime_Error(pszSrcFile, __LINE__, "working unexpected");
    408           break;
    409         }
    410         if (SHORT1FROMMP(mp1) == OBJCNR_DESKTOP) {
    411           WinDismissDlg(hwnd, 2);
    412           break;
    413         }
    414         pci = (PCNRITEM) WinSendDlgItemMsg(hwnd, OBJCNR_CNR,
    415                                            CM_QUERYRECORDEMPHASIS,
    416                                            MPFROMLONG(CMA_FIRST),
    417                                            MPFROMSHORT(CRA_CURSORED));
    418         if (pci && (INT) pci != -1)
    419           strcpy(data->dirname, pci->pszFileName);
    420         WinDismissDlg(hwnd, 1);
     406        PCNRITEM pci;
     407
     408        if (data->working) {
     409          Runtime_Error(pszSrcFile, __LINE__, "working unexpected");
     410          break;
     411        }
     412        if (SHORT1FROMMP(mp1) == OBJCNR_DESKTOP) {
     413          WinDismissDlg(hwnd, 2);
     414          break;
     415        }
     416        pci = (PCNRITEM) WinSendDlgItemMsg(hwnd, OBJCNR_CNR,
     417                                           CM_QUERYRECORDEMPHASIS,
     418                                           MPFROMLONG(CMA_FIRST),
     419                                           MPFROMSHORT(CRA_CURSORED));
     420        if (pci && (INT) pci != -1)
     421          strcpy(data->dirname, pci->pszFileName);
     422        WinDismissDlg(hwnd, 1);
    421423      }
    422424      break;
    … …  
    425427      data = INSTDATA(hwnd);
    426428      if (data) {
    427         if (data->working) {
    428           data->dying = (CHAR)TRUE;
    429           data->stopflag = (CHAR)0xff;
    430           break;
    431         }
    432         WinDismissDlg(hwnd, 0);
     429        if (data->working) {
     430          data->dying = (CHAR)TRUE;
     431          data->stopflag = (CHAR)0xff;
     432          break;
     433        }
     434        WinDismissDlg(hwnd, 0);
    433435      }
    434436      break;

  • trunk/dll/printer.c

    r1063 r1163  
    1 
    21/***********************************************************************
    32
    … …  
    3231#include "errutil.h"                    // Dos_Error...
    3332#include "strutil.h"                    // GetPString
     33#include "notify.h"                     // AddNote
     34#include "defview.h"                    // QuickView
     35#include "printer.h"
    3436#include "fm3dll.h"
    3537#include "fortify.h"
    … …  
    4042
    4143static HMTX PrintSem = 0;
     44
     45static BOOL PrinterReady(CHAR * printdevname);
     46static BOOL SayPrinterReady(HWND hwnd);
    4247
    4348BOOL PrinterReady(CHAR * printdevname)

  • trunk/dll/seticon.c

    r1047 r1163  
    2424#include "fm3dlg.h"
    2525#include "errutil.h"                    // Dos_Error...
     26#include "seticon.h"
    2627#include "fm3dll.h"
    2728#include "fortify.h"

  • trunk/dll/timer.c

    r907 r1163  
    2424#include "errutil.h"                    // Dos_Error...
    2525#include "strutil.h"                    // GetPString
     26#include "timer.h"
    2627#include "fm3dll.h"
    2728

  • trunk/dll/update.c

    r1047 r1163  
    3434#include "filldir.h"                    // FillInRecordFromFFB
    3535#include "dircnrs.h"
     36#include "flesh.h"                      // Flesh, Stubby
     37#include "update.h"
    3638#include "fm3dll.h"
    3739#include "fortify.h"
Note: See TracChangeset for help on using the changeset viewer.