Changeset 1156 for trunk/dll/init.c


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

Ticket 187: Draft 1: Functions only

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/init.c

    r1130 r1156  
    4444  29 Feb 08 GKY Refactor global command line variables to notebook.h
    4545  08 Mar 08 JBS Ticket 230: Replace prefixless INI keys for default directory containers with
    46                 keys using a "DirCnr." prefix
     46                keys using a "DirCnr." prefix
    4747  20 Apr 08 GKY Change default cmd line length to 1024 Ask once if user wants to reset it.
    4848  11 Jul 08 JBS Ticket 230: Simplified code and eliminated some local variables by incorporating
    49                 all the details view settings (both the global variables and those in the
    50                 DIRCNRDATA struct) into a new struct: DETAILS_SETTINGS.
     49                all the details view settings (both the global variables and those in the
     50                DIRCNRDATA struct) into a new struct: DETAILS_SETTINGS.
    5151  16 JUL 08 GKY Use TMP directory for temp files
    5252  17 Jul 08 SHL Reduce code bulk in fUseTmp setup
    … …  
    8282#include "fm3str.h"
    8383#include "version.h"
    84 #include "pathutil.h"                   // BldFullPathName
    85 #include "arccnrs.h"                    // ArcClientWndProc
    86 #include "errutil.h"                    // Dos_Error...
    87 #include "strutil.h"                    // GetPString
     84#include "pathutil.h"                   // BldFullPathName
     85#include "arccnrs.h"                    // ArcClientWndProc
     86#include "errutil.h"                    // Dos_Error...
     87#include "strutil.h"                    // GetPString
     88#include "valid.h"                      // ArgDriveFlags
     89#include "autoview.h"                   // AutoViewProc
     90#include "mainwnd.h"                    // BubbleProc, ChildButtonProc, DriveBackProc,
     91                                        // DriveProc, LEDProc, MainWndProc, StatusProc
     92                                        // ToolBackProc
     93#include "collect.h"                    // CollectorClientWndProc, CollectorTextProc
     94#include "getnames.h"                   // CustomFileDlg
     95#include "notify.h"                     // EndNote
     96#include "valid.h"                      // FillInDriveFlags, IsValidDir
     97#include "inis.h"                       // IniProc
     98#include "viewer.h"                     // MLEEditorProc
     99#include "mainwnd2.h"                   // MainWndProc2
     100#include "notify.h"                     // NotifyWndProc
     101#include "treecnr.h"                    // OpenButtonProc
     102#include "seeall.h"                     // SeeAllWndProc, SeeStatusProc
     103#include "init.h"
     104#include "timer.h"                      // StartTimer, StopTimer
     105#include "treecnr.h"                    // TreeClientWndProc, TreeStatProc
     106#include "newview.h"                    // ViewStatusProc, ViewWndProc
    88107#include "fm3dll.h"
    89 #include "notebook.h"                   // command line variables (editor etc)
     108#include "misc.h"                       // HeapThread, LoadDetailsSwitches
     109#include "notebook.h"                   // command line variables (editor etc)
    90110#include "fortify.h"
    91111
    92112#ifdef __IBMC__
    93113#pragma alloc_text(INIT,LibMain,InitFM3DLL,DeInitFM3DLL)
    94 #pragma alloc_text(INIT1,StartFM3,FindSwapperDat)
     114#pragma alloc_text(INIT1,StartFM3)
    95115#endif
    96116
    … …  
    108128
    109129static PSZ pszSrcFile = __FILE__;
     130
     131VOID FindSwapperDat(VOID);
    110132
    111133BOOL CheckFileHeader(CHAR *filespec, CHAR *signature, LONG offset);
    … …  
    130152    nm = 1;
    131153    rc = DosFindFirst(SwapperDat,
    132                       &hdir,
    133                       FILE_NORMAL | FILE_ARCHIVED |
    134                       FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
    135                       &ffb, sizeof(ffb), &nm, FIL_STANDARDL);
     154                      &hdir,
     155                      FILE_NORMAL | FILE_ARCHIVED |
     156                      FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
     157                      &ffb, sizeof(ffb), &nm, FIL_STANDARDL);
    136158    if (rc && rc != ERROR_FILE_NOT_FOUND && rc != ERROR_PATH_NOT_FOUND) {
    137159      FILEFINDBUF3 ffb;
    138160      rc = DosFindFirst(SwapperDat,
    139                         &hdir,
    140                         FILE_NORMAL | FILE_ARCHIVED |
    141                         FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
    142                         &ffb, sizeof(ffb), &nm, FIL_STANDARD);
     161                        &hdir,
     162                        FILE_NORMAL | FILE_ARCHIVED |
     163                        FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
     164                        &ffb, sizeof(ffb), &nm, FIL_STANDARD);
    143165      fNoLargeFileSupport = TRUE;
    144166    }
    … …  
    147169      fp = fopen(SwapperDat, "r");
    148170      if (fp) {
    149         fclose(fp);
    150         *SwapperDat = 0;
    151         rc = 1;                         // Force config.sys scan
     171        fclose(fp);
     172        *SwapperDat = 0;
     173        rc = 1;                         // Force config.sys scan
    152174      }
    153175    }
    … …  
    158180  if (rc) {
    159181    if (DosQuerySysInfo(QSV_BOOT_DRIVE,
    160                         QSV_BOOT_DRIVE,
    161                         &nm,
    162                         sizeof(ULONG))) {
    163       nm = 3;                           // Assume drive C:
     182                        QSV_BOOT_DRIVE,
     183                        &nm,
     184                        sizeof(ULONG))) {
     185      nm = 3;                           // Assume drive C:
    164186    }
    165187    *filename = (CHAR) nm + '@';
    … …  
    167189    if (fp) {
    168190      while (!feof(fp)) {
    169         if (!xfgets(input, sizeof(input), fp, pszSrcFile, __LINE__))
    170           break;
    171         lstrip(input);
    172         if (!strnicmp(input, "SWAPPATH", 8)) {
    173           p = input + 8;
    174           while (*p == ' ')
    175             p++;
    176           if (*p == '=') {
    177             p++;
    178             stripcr(p);
    179             rstrip(p);
    180             while (*p == ' ')
    181               p++;
    182             if (*p == '\"') {
    183               p++;
    184               pp = p;
    185               while (*pp && *pp != '\"')
    186                 *pp += 1;
    187               if (*pp)
    188                 *pp = 0;
    189             }
    190             else {
    191               pp = strchr(p, ' ');
    192               if (pp)
    193                 *pp = 0;
    194             }
    195             if (*p) {
    196               strncpy(SwapperDat, p, CCHMAXPATH);
    197               SwapperDat[CCHMAXPATH - 1] = 0;
    198               BldFullPathName(SwapperDat, SwapperDat, "SWAPPER.DAT");
    199               hdir = HDIR_CREATE;
    200               nm = 1;
    201               rc = DosFindFirst(SwapperDat,
    202                                 &hdir,
    203                                 FILE_NORMAL | FILE_ARCHIVED |
    204                                 FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
    205                                 &ffb, sizeof(ffb), &nm, FIL_STANDARD);
    206               if (rc){
    207                 FILEFINDBUF3 ffb;
    208                 rc = DosFindFirst(SwapperDat,
    209                                   &hdir,
    210                                   FILE_NORMAL | FILE_ARCHIVED |
    211                                   FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
    212                                   &ffb, sizeof(ffb), &nm, FIL_STANDARD);
    213                 fNoLargeFileSupport = TRUE;
    214               }
    215               if (!rc) {
    216                 DosFindClose(hdir);
    217                 PrfWriteProfileString(fmprof,
    218                                       FM3Str, "SwapperDat", SwapperDat);
    219               }
    220               else
    221                 *SwapperDat = 0;
    222               break;
    223             }
    224           }
    225         }                               // if SWAPPATH
    226       }                                 // while
     191        if (!xfgets(input, sizeof(input), fp, pszSrcFile, __LINE__))
     192          break;
     193        lstrip(input);
     194        if (!strnicmp(input, "SWAPPATH", 8)) {
     195          p = input + 8;
     196          while (*p == ' ')
     197            p++;
     198          if (*p == '=') {
     199            p++;
     200            stripcr(p);
     201            rstrip(p);
     202            while (*p == ' ')
     203              p++;
     204            if (*p == '\"') {
     205              p++;
     206              pp = p;
     207              while (*pp && *pp != '\"')
     208                *pp += 1;
     209              if (*pp)
     210                *pp = 0;
     211            }
     212            else {
     213              pp = strchr(p, ' ');
     214              if (pp)
     215                *pp = 0;
     216            }
     217            if (*p) {
     218              strncpy(SwapperDat, p, CCHMAXPATH);
     219              SwapperDat[CCHMAXPATH - 1] = 0;
     220              BldFullPathName(SwapperDat, SwapperDat, "SWAPPER.DAT");
     221              hdir = HDIR_CREATE;
     222              nm = 1;
     223              rc = DosFindFirst(SwapperDat,
     224                                &hdir,
     225                                FILE_NORMAL | FILE_ARCHIVED |
     226                                FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
     227                                &ffb, sizeof(ffb), &nm, FIL_STANDARD);
     228              if (rc){
     229                FILEFINDBUF3 ffb;
     230                rc = DosFindFirst(SwapperDat,
     231                                  &hdir,
     232                                  FILE_NORMAL | FILE_ARCHIVED |
     233                                  FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
     234                                  &ffb, sizeof(ffb), &nm, FIL_STANDARD);
     235                fNoLargeFileSupport = TRUE;
     236              }
     237              if (!rc) {
     238                DosFindClose(hdir);
     239                PrfWriteProfileString(fmprof,
     240                                      FM3Str, "SwapperDat", SwapperDat);
     241              }
     242              else
     243                *SwapperDat = 0;
     244              break;
     245            }
     246          }
     247        }                               // if SWAPPATH
     248      }                                 // while
    227249      fclose(fp);
    228250    }
    … …  
    233255
    234256unsigned APIENTRY LibMain(unsigned hModule,
    235                           unsigned ulFlag)
     257                          unsigned ulFlag)
    236258{
    237259  CHAR *env;
    … …  
    252274      rc = DosQueryPathInfo(env, FIL_STANDARD, &fsa, sizeof(fsa));
    253275      if (!rc) {
    254         if (fsa.attrFile & FILE_DIRECTORY) {
    255           BldFullPathName(stringfile, env, "FM3RES.STR");
    256           DosError(FERR_DISABLEHARDERR);
    257           if (DosQueryPathInfo(stringfile, FIL_STANDARD, &fsa, sizeof(fsa)))
    258             strcpy(stringfile, "FM3RES.STR");
    259         }
     276        if (fsa.attrFile & FILE_DIRECTORY) {
     277          BldFullPathName(stringfile, env, "FM3RES.STR");
     278          DosError(FERR_DISABLEHARDERR);
     279          if (DosQueryPathInfo(stringfile, FIL_STANDARD, &fsa, sizeof(fsa)))
     280            strcpy(stringfile, "FM3RES.STR");
     281        }
    260282      }
    261283    }
    … …  
    347369
    348370unsigned long _System _DLL_InitTerm(unsigned long hModule,
    349                                     unsigned long ulFlag)
     371                                    unsigned long ulFlag)
    350372{
    351373  CHAR *env;
    … …  
    365387      rc = DosQueryPathInfo(env, FIL_STANDARD, &fsa, sizeof(fsa));
    366388      if (!rc) {
    367         if (fsa.attrFile & FILE_DIRECTORY) {
    368           BldFullPathName(stringfile, env, "FM3RES.STR");
    369           DosError(FERR_DISABLEHARDERR);
    370           if (DosQueryPathInfo(stringfile, FIL_STANDARD, &fsa, sizeof(fsa)))
    371             strcpy(stringfile, "FM3RES.STR");
    372         }
     389        if (fsa.attrFile & FILE_DIRECTORY) {
     390          BldFullPathName(stringfile, env, "FM3RES.STR");
     391          DosError(FERR_DISABLEHARDERR);
     392          if (DosQueryPathInfo(stringfile, FIL_STANDARD, &fsa, sizeof(fsa)))
     393            strcpy(stringfile, "FM3RES.STR");
     394        }
    373395      }
    374396    }
    … …  
    501523    num_matches = 1L;
    502524    if (!DosFindFirst(s,
    503                       &search_handle,
    504                       FILE_NORMAL | FILE_DIRECTORY |
    505                       FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
    506                       FILE_ARCHIVED,
    507                       &ffb, sizeof(ffb), &num_matches, FIL_STANDARD)) {
     525                      &search_handle,
     526                      FILE_NORMAL | FILE_DIRECTORY |
     527                      FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
     528                      FILE_ARCHIVED,
     529                      &ffb, sizeof(ffb), &num_matches, FIL_STANDARD)) {
    508530      do {
    509         strcpy(enddir, ffb.achName);
    510         if (ffb.attrFile & FILE_DIRECTORY) {
    511           wipeallf("%s\\*", s);
    512           DosDeleteDir(s);
    513         }
    514         else
    515           unlinkf("%s", s);
     531        strcpy(enddir, ffb.achName);
     532        if (ffb.attrFile & FILE_DIRECTORY) {
     533          wipeallf("%s\\*", s);
     534          DosDeleteDir(s);
     535        }
     536        else
     537          unlinkf("%s", s);
    516538      }
    517539      while (!DosFindNext(search_handle,
    518                           &ffb, sizeof(ffb), &num_matches));
     540                          &ffb, sizeof(ffb), &num_matches));
    519541      DosFindClose(search_handle);
    520542    }
    … …  
    532554  num_matches = 1;
    533555  if (!DosFindFirst(s,
    534                     &search_handle,
    535                     FILE_NORMAL | FILE_DIRECTORY |
    536                     FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
    537                     FILE_ARCHIVED,
    538                     &ffb, sizeof(ffb), &num_matches, FIL_STANDARD)) {
     556                    &search_handle,
     557                    FILE_NORMAL | FILE_DIRECTORY |
     558                    FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
     559                    FILE_ARCHIVED,
     560                    &ffb, sizeof(ffb), &num_matches, FIL_STANDARD)) {
    539561    do {
    540562      if (!(ffb.attrFile & FILE_DIRECTORY)) {
    541         strcpy(enddir, ffb.achName);
    542         unlinkf("%s", s);
     563        strcpy(enddir, ffb.achName);
     564        unlinkf("%s", s);
    543565      }
    544566    }
    545567    while (!DosFindNext(search_handle,
    546                         &ffb, sizeof(ffb), &num_matches));
     568                        &ffb, sizeof(ffb), &num_matches));
    547569    DosFindClose(search_handle);
    548570  }
    … …  
    575597  ULONG RVMinor = 0;
    576598  ULONG ret = 0;
    577   FILESTATUS3 fs3;                      // 25 Aug 07 SHL
     599  FILESTATUS3 fs3;                      // 25 Aug 07 SHL
    578600  PSZ env;
    579601  CHAR dllfile[CCHMAXPATH];
    … …  
    582604  if (!StringsLoaded()) {
    583605    saymsg(MB_ENTER,
    584            HWND_DESKTOP,
    585            "Error",
    586            "FM3RES.STR isn't in right format, at least "
    587            "for this version of FM/2.");
     606           HWND_DESKTOP,
     607           "Error",
     608           "FM3RES.STR isn't in right format, at least "
     609           "for this version of FM/2.");
    588610    return FALSE;
    589611  }
    … …  
    596618    if (!rc) {
    597619      if (fs3.attrFile & FILE_DIRECTORY) {
    598         BldFullPathName(dllfile, env, "FM3RES");        // 23 Aug 07 SHL
    599         DosError(FERR_DISABLEHARDERR);
    600         if (DosQueryPathInfo(dllfile, FIL_STANDARD, &fs3, sizeof(fs3)))
    601           strcpy(dllfile, "FM3RES");
     620        BldFullPathName(dllfile, env, "FM3RES");        // 23 Aug 07 SHL
     621        DosError(FERR_DISABLEHARDERR);
     622        if (DosQueryPathInfo(dllfile, FIL_STANDARD, &fs3, sizeof(fs3)))
     623          strcpy(dllfile, "FM3RES");
    602624      }
    603625    }
    … …  
    606628  if (rcl) {
    607629    saymsg(MB_CANCEL | MB_ICONEXCLAMATION,
    608            HWND_DESKTOP,
    609            GetPString(IDS_ERRORTEXT), GetPString(IDS_FM3RESERROR1TEXT));
     630           HWND_DESKTOP,
     631           GetPString(IDS_ERRORTEXT), GetPString(IDS_FM3RESERROR1TEXT));
    610632    return FALSE;
    611633  }
    … …  
    614636    if (rc) {
    615637      Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
    616                "DosExitList");
     638               "DosExitList");
    617639    }
    618640    rcq = DosQueryProcAddr(FM3ModHandle, 1, "ResVersion", &pfnResVersion);
    … …  
    622644  if (RVMajor < VERMAJOR || (RVMajor == VERMAJOR && RVMinor < VERMINOR)) {
    623645    saymsg(MB_ENTER,
    624            HWND_DESKTOP,
    625            GetPString(IDS_ERRORTEXT),
    626            GetPString(IDS_FM3RESERROR2TEXT),
    627            !rcq ?
    628            GetPString(IDS_FM3RESERROR3TEXT) :
    629            !rcl ?
    630            GetPString(IDS_FM3RESERROR4TEXT) :
    631            GetPString(IDS_FM3RESERROR5TEXT), RVMajor, RVMinor, rcl, rcq, ret);
     646           HWND_DESKTOP,
     647           GetPString(IDS_ERRORTEXT),
     648           GetPString(IDS_FM3RESERROR2TEXT),
     649           !rcq ?
     650           GetPString(IDS_FM3RESERROR3TEXT) :
     651           !rcl ?
     652           GetPString(IDS_FM3RESERROR4TEXT) :
     653           GetPString(IDS_FM3RESERROR5TEXT), RVMajor, RVMinor, rcl, rcq, ret);
    632654    return FALSE;
    633655  }
    … …  
    647669    DosSetMaxFH(100);
    648670  else if (!strcmp(appname, "VDir") ||
    649            !strcmp(appname, "VTree") ||
    650            !strcmp(appname, "VCollect") ||
    651            !strcmp(appname, "SEEALL") || !strcmp(appname, "FM/4"))
     671           !strcmp(appname, "VTree") ||
     672           !strcmp(appname, "VCollect") ||
     673           !strcmp(appname, "SEEALL") || !strcmp(appname, "FM/4"))
    652674    DosSetMaxFH(60);
    653675  else
    … …  
    655677
    656678  if (DosQuerySysInfo(QSV_VERSION_MAJOR,
    657                       QSV_VERSION_MINOR,
    658                       OS2ver,
    659                       sizeof(OS2ver))) {
     679                      QSV_VERSION_MINOR,
     680                      OS2ver,
     681                      sizeof(OS2ver))) {
    660682    OS2ver[0] = 2;
    661683    OS2ver[1] = 1;
    … …  
    684706      num_matches = 1;
    685707      if (!DosFindFirst(szTempName,
    686                         &search_handle,
    687                         FILE_NORMAL | FILE_DIRECTORY |
    688                         FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
    689                         FILE_ARCHIVED,
    690                         &ffb, sizeof(ffb), &num_matches, FIL_STANDARD)) {
     708                        &search_handle,
     709                        FILE_NORMAL | FILE_DIRECTORY |
     710                        FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
     711                        FILE_ARCHIVED,
     712                        &ffb, sizeof(ffb), &num_matches, FIL_STANDARD)) {
    691713        do {
    692714          strcpy(enddir, ffb.achName);
    … …  
    704726        }
    705727      while (!DosFindNext(search_handle,
    706                           &ffb, sizeof(ffb), &num_matches));
     728                          &ffb, sizeof(ffb), &num_matches));
    707729      DosFindClose(search_handle);
    708730    }
    … …  
    763785  if (_beginthread(HeapThread, NULL, 32768, NULL) == -1) {
    764786    Runtime_Error(pszSrcFile, __LINE__,
    765                   GetPString(IDS_COULDNTSTARTTHREADTEXT));
     787                  GetPString(IDS_COULDNTSTARTTHREADTEXT));
    766788    return FALSE;
    767789  }
    … …  
    770792  if (!StartTimer()) {
    771793    Runtime_Error(pszSrcFile, __LINE__,
    772                   GetPString(IDS_COULDNTSTARTTHREADTEXT));
     794                  GetPString(IDS_COULDNTSTARTTHREADTEXT));
    773795    return FALSE;
    774796  }
    … …  
    777799  env = getenv("WORKPLACE_PROCESS");
    778800  fWorkPlace = env != NULL &&
    779                (stricmp(env, "YES") == 0 || atoi(env) == 1);
     801               (stricmp(env, "YES") == 0 || atoi(env) == 1);
    780802
    781803  if ((!strchr(profile, '\\') && !strchr(profile, ':')) ||
    … …  
    796818      rc = DosQueryPathInfo(inipath, FIL_STANDARD, &fs3, sizeof(fs3));
    797819      if (!rc) {
    798         if (fs3.attrFile & FILE_DIRECTORY)
    799           BldFullPathName(inipath, inipath, profile);
     820        if (fs3.attrFile & FILE_DIRECTORY)
     821          BldFullPathName(inipath, inipath, profile);
    800822      }
    801823    }
    … …  
    803825      env = searchpath(profile);
    804826      if (!env)
    805         env = profile;
     827        env = profile;
    806828      strcpy(inipath, env);
    807829    }
    … …  
    820842    else {
    821843      if (!CheckFileHeader(inipath, "\xff\xff\xff\xff\x14\x00\x00\x00", 0L)) {
    822         saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,
    823                "Check INI header failed will attempt to replace with backup \\
    824                if backup fails or not found will open with new ini");
    825         DosCopy("FM3.INI", "FM3INI.BAD", DCPY_EXISTING);
    826         DosCopy("FM3INI.BAK", "FM3.INI", DCPY_EXISTING);
    827         if (!CheckFileHeader(inipath, "\xff\xff\xff\xff\x14\x00\x00\x00", 0L)) {
    828           DosCopy("FM3.INI", "FM3INI2.BAD", DCPY_EXISTING);
    829           fWantFirstTimeInit = TRUE;
    830         }
     844        saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,
     845               "Check INI header failed will attempt to replace with backup \\
     846               if backup fails or not found will open with new ini");
     847        DosCopy("FM3.INI", "FM3INI.BAD", DCPY_EXISTING);
     848        DosCopy("FM3INI.BAK", "FM3.INI", DCPY_EXISTING);
     849        if (!CheckFileHeader(inipath, "\xff\xff\xff\xff\x14\x00\x00\x00", 0L)) {
     850          DosCopy("FM3.INI", "FM3INI2.BAD", DCPY_EXISTING);
     851          fWantFirstTimeInit = TRUE;
     852        }
    831853      }
    832854      if (!fWantFirstTimeInit) {
    833         fIniExisted = TRUE;
    834         if (fs3.attrFile & (FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM)) {
    835           fs3.attrFile &= ~(FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM);
    836           rc = xDosSetPathInfo(inipath, FIL_STANDARD, &fs3, sizeof(fs3), 0);
    837           if (rc) {
    838             Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
    839                         GetPString(IDS_INIREADONLYTEXT), inipath);
    840           }
    841         }
     855        fIniExisted = TRUE;
     856        if (fs3.attrFile & (FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM)) {
     857          fs3.attrFile &= ~(FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM);
     858          rc = xDosSetPathInfo(inipath, FIL_STANDARD, &fs3, sizeof(fs3), 0);
     859          if (rc) {
     860            Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
     861                        GetPString(IDS_INIREADONLYTEXT), inipath);
     862          }
     863        }
    842864      }
    843865    }
    … …  
    852874    if (!fmprof) {
    853875      Win_Error(NULLHANDLE, NULLHANDLE, pszSrcFile, __LINE__,
    854                 "PrfOpenProfile");
     876                "PrfOpenProfile");
    855877      return FALSE;
    856878    }
    … …  
    861883  size = sizeof(BOOL);
    862884  PrfQueryProfileData(fmprof,
    863                       FM3Str,
    864                       "SeparateParms",
    865                       &fSeparateParms,
    866                       &size);
     885                      FM3Str,
     886                      "SeparateParms",
     887                      &fSeparateParms,
     888                      &size);
    867889  if (!fSeparateParms)
    868890    strcpy(appname, FM3Str);
    … …  
    882904  hwndHelp = WinCreateHelpInstance(hab, &hini);
    883905  if (!hwndHelp) {
    884     static CHAR helppath[CCHMAXPATH];   // fixme to be local?
     906    static CHAR helppath[CCHMAXPATH];   // fixme to be local?
    885907
    886908    env = getenv("FM3INI");
    … …  
    890912      rc = DosQueryPathInfo(helppath, FIL_STANDARD, &fs3, sizeof(fs3));
    891913      if (!rc) {
    892         if (fs3.attrFile & FILE_DIRECTORY) {
    893           BldFullPathName(helppath, helppath, "FM3.HLP");
    894           hini.pszHelpLibraryName = helppath;
    895           hwndHelp = WinCreateHelpInstance(hab, &hini);
    896         }
     914        if (fs3.attrFile & FILE_DIRECTORY) {
     915          BldFullPathName(helppath, helppath, "FM3.HLP");
     916          hini.pszHelpLibraryName = helppath;
     917          hwndHelp = WinCreateHelpInstance(hab, &hini);
     918        }
    897919      }
    898920    }
    … …  
    900922  if (!hwndHelp) {
    901923    saymsg(MB_ENTER | MB_ICONEXCLAMATION,
    902            HWND_DESKTOP,
    903            GetPString(IDS_FM2TROUBLETEXT),
    904            GetPString(IDS_CANTLOADHELPTEXT),
    905            GetPString(IDS_NOHELPACCEPTTEXT));
     924           HWND_DESKTOP,
     925           GetPString(IDS_FM2TROUBLETEXT),
     926           GetPString(IDS_CANTLOADHELPTEXT),
     927           GetPString(IDS_NOHELPACCEPTTEXT));
    906928  }
    907929
    … …  
    929951  /* register window classes we use */
    930952  WinRegisterClass(hab,
    931                    WC_MAINWND,
    932                    MainWndProc,
    933                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 8);
    934   WinRegisterClass(hab,
    935                    WC_MAINWND2,
    936                    MainWndProc2,
    937                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 4);
    938   WinRegisterClass(hab,
    939                    WC_TREECONTAINER,
    940                    TreeClientWndProc,
    941                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
    942   WinRegisterClass(hab,
    943                    WC_DIRCONTAINER,
    944                    DirClientWndProc,
    945                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
    946   WinRegisterClass(hab,
    947                    WC_COLLECTOR,
    948                    CollectorClientWndProc,
    949                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
    950   WinRegisterClass(hab,
    951                    WC_ARCCONTAINER,
    952                    ArcClientWndProc,
    953                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
    954   WinRegisterClass(hab,
    955                    WC_MLEEDITOR,
    956                    MLEEditorProc,
    957                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
    958   WinRegisterClass(hab,
    959                    WC_INIEDITOR,
    960                    IniProc,
    961                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
    962   WinRegisterClass(hab,
    963                    WC_TOOLBACK,
    964                    ToolBackProc,
    965                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    966                    sizeof(PVOID));
    967   WinRegisterClass(hab,
    968                    WC_DRIVEBACK,
    969                    DriveBackProc,
    970                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    971                    sizeof(PVOID));
    972   WinRegisterClass(hab,
    973                    WC_SEEALL,
    974                    SeeAllWndProc,
    975                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID));
    976   WinRegisterClass(hab,
    977                    WC_NEWVIEW,
    978                    ViewWndProc,
    979                    CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID));
    980   WinRegisterClass(hab,
    981                    WC_TOOLBUTTONS,
    982                    ChildButtonProc,
    983                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    984                    sizeof(PVOID));
    985   WinRegisterClass(hab,
    986                    WC_DRIVEBUTTONS,
    987                    DriveProc,
    988                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    989                    sizeof(PVOID));
    990   WinRegisterClass(hab,
    991                    WC_BUBBLE,
    992                    BubbleProc,
    993                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    994                    sizeof(ULONG) * 2);
    995   WinRegisterClass(hab,
    996                    WC_STATUS,
    997                    StatusProc,
    998                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    999                    sizeof(ULONG));
    1000   WinRegisterClass(hab,
    1001                    WC_DIRSTATUS,
    1002                    DirTextProc,
    1003                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1004                    sizeof(ULONG));
    1005   WinRegisterClass(hab,
    1006                    WC_TREESTATUS,
    1007                    TreeStatProc,
    1008                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1009                    sizeof(ULONG));
    1010   WinRegisterClass(hab,
    1011                    WC_ARCSTATUS,
    1012                    ArcTextProc,
    1013                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1014                    sizeof(ULONG));
    1015   WinRegisterClass(hab,
    1016                    WC_COLSTATUS,
    1017                    CollectorTextProc,
    1018                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1019                    sizeof(ULONG));
    1020   WinRegisterClass(hab,
    1021                    WC_SEESTATUS,
    1022                    SeeStatusProc,
    1023                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1024                    sizeof(ULONG));
    1025   WinRegisterClass(hab,
    1026                    WC_VIEWSTATUS,
    1027                    ViewStatusProc,
    1028                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1029                    sizeof(ULONG));
    1030   WinRegisterClass(hab,
    1031                    WC_ERRORWND,
    1032                    NotifyWndProc,
    1033                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1034                    sizeof(PVOID));
    1035   WinRegisterClass(hab,
    1036                    WC_MINITIME,
    1037                    MiniTimeProc,
    1038                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1039                    sizeof(PVOID) * 2);
    1040   WinRegisterClass(hab,
    1041                    WC_DATABAR,
    1042                    DataProc, CS_SIZEREDRAW, sizeof(PVOID));
    1043   WinRegisterClass(hab,
    1044                    WC_TREEOPENBUTTON,
    1045                    OpenButtonProc,
    1046                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1047                    sizeof(PVOID));
    1048   WinRegisterClass(hab,
    1049                    WC_AUTOVIEW,
    1050                    AutoViewProc,
    1051                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1052                    sizeof(PVOID));
    1053   WinRegisterClass(hab,
    1054                    WC_LED,
    1055                    LEDProc,
    1056                    CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
    1057                    sizeof(PVOID));
     953                   WC_MAINWND,
     954                   MainWndProc,
     955                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 8);
     956  WinRegisterClass(hab,
     957                   WC_MAINWND2,
     958                   MainWndProc2,
     959                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 4);
     960  WinRegisterClass(hab,
     961                   WC_TREECONTAINER,
     962                   TreeClientWndProc,
     963                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
     964  WinRegisterClass(hab,
     965                   WC_DIRCONTAINER,
     966                   DirClientWndProc,
     967                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
     968  WinRegisterClass(hab,
     969                   WC_COLLECTOR,
     970                   CollectorClientWndProc,
     971                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
     972  WinRegisterClass(hab,
     973                   WC_ARCCONTAINER,
     974                   ArcClientWndProc,
     975                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
     976  WinRegisterClass(hab,
     977                   WC_MLEEDITOR,
     978                   MLEEditorProc,
     979                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
     980  WinRegisterClass(hab,
     981                   WC_INIEDITOR,
     982                   IniProc,
     983                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
     984  WinRegisterClass(hab,
     985                   WC_TOOLBACK,
     986                   ToolBackProc,
     987                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     988                   sizeof(PVOID));
     989  WinRegisterClass(hab,
     990                   WC_DRIVEBACK,
     991                   DriveBackProc,
     992                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     993                   sizeof(PVOID));
     994  WinRegisterClass(hab,
     995                   WC_SEEALL,
     996                   SeeAllWndProc,
     997                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID));
     998  WinRegisterClass(hab,
     999                   WC_NEWVIEW,
     1000                   ViewWndProc,
     1001                   CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID));
     1002  WinRegisterClass(hab,
     1003                   WC_TOOLBUTTONS,
     1004                   ChildButtonProc,
     1005                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1006                   sizeof(PVOID));
     1007  WinRegisterClass(hab,
     1008                   WC_DRIVEBUTTONS,
     1009                   DriveProc,
     1010                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1011                   sizeof(PVOID));
     1012  WinRegisterClass(hab,
     1013                   WC_BUBBLE,
     1014                   BubbleProc,
     1015                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1016                   sizeof(ULONG) * 2);
     1017  WinRegisterClass(hab,
     1018                   WC_STATUS,
     1019                   StatusProc,
     1020                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1021                   sizeof(ULONG));
     1022  WinRegisterClass(hab,
     1023                   WC_DIRSTATUS,
     1024                   DirTextProc,
     1025                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1026                   sizeof(ULONG));
     1027  WinRegisterClass(hab,
     1028                   WC_TREESTATUS,
     1029                   TreeStatProc,
     1030                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1031                   sizeof(ULONG));
     1032  WinRegisterClass(hab,
     1033                   WC_ARCSTATUS,
     1034                   ArcTextProc,
     1035                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1036                   sizeof(ULONG));
     1037  WinRegisterClass(hab,
     1038                   WC_COLSTATUS,
     1039                   CollectorTextProc,
     1040                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1041                   sizeof(ULONG));
     1042  WinRegisterClass(hab,
     1043                   WC_SEESTATUS,
     1044                   SeeStatusProc,
     1045                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1046                   sizeof(ULONG));
     1047  WinRegisterClass(hab,
     1048                   WC_VIEWSTATUS,
     1049                   ViewStatusProc,
     1050                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1051                   sizeof(ULONG));
     1052  WinRegisterClass(hab,
     1053                   WC_ERRORWND,
     1054                   NotifyWndProc,
     1055                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1056                   sizeof(PVOID));
     1057  WinRegisterClass(hab,
     1058                   WC_MINITIME,
     1059                   MiniTimeProc,
     1060                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1061                   sizeof(PVOID) * 2);
     1062  WinRegisterClass(hab,
     1063                   WC_DATABAR,
     1064                   DataProc, CS_SIZEREDRAW, sizeof(PVOID));
     1065  WinRegisterClass(hab,
     1066                   WC_TREEOPENBUTTON,
     1067                   OpenButtonProc,
     1068                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1069                   sizeof(PVOID));
     1070  WinRegisterClass(hab,
     1071                   WC_AUTOVIEW,
     1072                   AutoViewProc,
     1073                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1074                   sizeof(PVOID));
     1075  WinRegisterClass(hab,
     1076                   WC_LED,
     1077                   LEDProc,
     1078                   CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
     1079                   sizeof(PVOID));
    10581080
    10591081  /*
    … …  
    10941116
    10951117  DosQueryCtryInfo(sizeof(CtryInfo), &Country,
    1096                    &CtryInfo, &ulInfoLen);
     1118                   &CtryInfo, &ulInfoLen);
    10971119  *ThousandsSeparator = CtryInfo.szThousandsSeparator[0];
    10981120  }
    … …  
    11091131    if (!MaxComLineChecked) {
    11101132      ret = saymsg(MB_YESNO,
    1111                    HWND_DESKTOP,
    1112                    NullStr,
    1113                    GetPString(IDS_CHANGECMDLINELENGTHDEFAULT));
     1133                   HWND_DESKTOP,
     1134                   NullStr,
     1135                   GetPString(IDS_CHANGECMDLINELENGTHDEFAULT));
    11141136      if (ret == MBID_YES)
    1115         MaxComLineStrg = 1024;
     1137        MaxComLineStrg = 1024;
    11161138      MaxComLineChecked = TRUE;
    11171139      PrfWriteProfileData(fmprof, appname, "MaxComLineChecked", &MaxComLineChecked, sizeof(BOOL));
    … …  
    11811203  size = sizeof(BOOL);
    11821204  PrfQueryProfileData(fmprof, FM3Str, "Prnformfeedbefore",
    1183                       &prnformfeedbefore, &size);
     1205                      &prnformfeedbefore, &size);
    11841206  size = sizeof(BOOL);
    11851207  PrfQueryProfileData(fmprof, FM3Str,
    1186                       "Prnformfeedafter",&prnformfeedafter, &size);
     1208                      "Prnformfeedafter",&prnformfeedafter, &size);
    11871209  size = sizeof(ULONG);
    11881210  PrfQueryProfileData(fmprof, FM3Str, "Prntabspaces", &prntabspaces, &size);
    … …  
    12091231  size = sizeof(BOOL);
    12101232  PrfQueryProfileData(fmprof, appname, "SwitchTreeExpand",
    1211                       &fSwitchTreeExpand, &size);
     1233                      &fSwitchTreeExpand, &size);
    12121234  size = sizeof(BOOL);
    12131235  PrfQueryProfileData(fmprof, appname, "SwitchTreeOnFocus",
    1214                       &fSwitchTreeOnFocus, &size);
     1236                      &fSwitchTreeOnFocus, &size);
    12151237  size = sizeof(BOOL);
    12161238  PrfQueryProfileData(fmprof, appname, "CollapseFirst",
    1217                       &fCollapseFirst, &size);
     1239                      &fCollapseFirst, &size);
    12181240  size = sizeof(BOOL);
    12191241  PrfQueryProfileData(fmprof, appname, "FilesInTree",
    1220                       &fFilesInTree, &size);
     1242                      &fFilesInTree, &size);
    12211243  size = sizeof(BOOL);
    12221244  PrfQueryProfileData(fmprof, FM3Str, "TopDir", &fTopDir, &size);
    … …  
    12241246  PrfQueryProfileData(fmprof, FM3Str, "LookInDir", &fLookInDir, &size);
    12251247  PrfQueryProfileString(fmprof, appname, "DefArc", NULL, szDefArc,
    1226                         sizeof(szDefArc));
     1248                        sizeof(szDefArc));
    12271249  size = sizeof(ULONG);
    12281250  PrfQueryProfileData(fmprof, FM3Str, "AutoviewHeight",
    1229                       &AutoviewHeight, &size);
     1251                      &AutoviewHeight, &size);
    12301252  size = sizeof(BOOL);
    12311253  PrfQueryProfileData(fmprof, FM3Str, "KeepCmdLine", &fKeepCmdLine, &size);
    … …  
    12591281  size = sizeof(BOOL);
    12601282  PrfQueryProfileData(fmprof, appname, "SelectedAlways",
    1261                       &fSelectedAlways, &size);
     1283                      &fSelectedAlways, &size);
    12621284  size = sizeof(BOOL);
    12631285  PrfQueryProfileData(fmprof, FM3Str, "ToolbarHelp", &fToolbarHelp, &size);
    … …  
    12701292  size = sizeof(BOOL);
    12711293  PrfQueryProfileData(fmprof, appname,
    1272                       "AutoAddAllDirs", &fAutoAddAllDirs, &size);
     1294                      "AutoAddAllDirs", &fAutoAddAllDirs, &size);
    12731295  size = sizeof(BOOL);
    12741296  PrfQueryProfileData(fmprof, FM3Str, "UserListSwitches",
    1275                       &fUserListSwitches, &size);
     1297                      &fUserListSwitches, &size);
    12761298  size = sizeof(BOOL);
    12771299  PrfQueryProfileData(fmprof, appname, "UseNewViewer",
    1278                       &fUseNewViewer, &size);
     1300                      &fUseNewViewer, &size);
    12791301  size = sizeof(BOOL);
    12801302  PrfQueryProfileData(fmprof, appname, "DefaultDeletePerm",
    1281                       &fDefaultDeletePerm, &size);
     1303                      &fDefaultDeletePerm, &size);
    12821304  size = sizeof(BOOL);
    12831305  PrfQueryProfileData(fmprof, FM3Str, "ExternalINIs",
    1284                       &fExternalINIs, &size);
     1306                      &fExternalINIs, &size);
    12851307  size = sizeof(BOOL);
    12861308  PrfQueryProfileData(fmprof, FM3Str, "ExternalCollector",
    1287                       &fExternalCollector, &size);
     1309                      &fExternalCollector, &size);
    12881310  size = sizeof(BOOL);
    12891311  PrfQueryProfileData(fmprof, FM3Str, "ExternalArcboxes",
    1290                       &fExternalArcboxes, &size);
     1312                      &fExternalArcboxes, &size);
    12911313  size = sizeof(BOOL);
    12921314  PrfQueryProfileData(fmprof, FM3Str, "ExternalViewer",
    1293                       &fExternalViewer, &size);
     1315                      &fExternalViewer, &size);
    12941316  size = sizeof(BOOL);
    12951317  PrfQueryProfileData(fmprof, FM3Str, "UseQProcStat",
    1296                       &fUseQProcStat, &size);
     1318                      &fUseQProcStat, &size);
    12971319  size = sizeof(BOOL);
    12981320  PrfQueryProfileData(fmprof, FM3Str, "UseQSysState",
    1299                       &fUseQSysState, &size);
     1321                      &fUseQSysState, &size);
    13001322  size = sizeof(BOOL);
    13011323  PrfQueryProfileData(fmprof, FM3Str, "DataMin", &fDataMin, &size);
    … …  
    13041326  size = sizeof(BOOL);
    13051327  PrfQueryProfileData(fmprof, appname, "DataShowDrives",
    1306                       &fDataShowDrives, &size);
     1328                      &fDataShowDrives, &size);
    13071329  size = sizeof(BOOL);
    13081330  PrfQueryProfileData(fmprof, appname, "DataInclRemote",
    1309                       &fDataInclRemote, &size);
     1331                      &fDataInclRemote, &size);
    13101332  size = sizeof(BOOL);
    13111333  PrfQueryProfileData(fmprof, FM3Str, "SplitStatus", &fSplitStatus, &size);
    13121334  size = sizeof(BOOL);
    13131335  PrfQueryProfileData(fmprof, appname, "FolderAfterExtract",
    1314                       &fFolderAfterExtract, &size);
     1336                      &fFolderAfterExtract, &size);
    13151337  size = sizeof(BOOL);
    13161338  PrfQueryProfileData(fmprof, FM3Str, "DullDatabar", &fDullMin, &size);
    … …  
    13191341  size = sizeof(BOOL);
    13201342  PrfQueryProfileData(fmprof, appname, "ConfirmDelete",
    1321                       &fConfirmDelete, &size);
     1343                      &fConfirmDelete, &size);
    13221344  size = sizeof(BOOL);
    13231345  PrfQueryProfileData(fmprof, FM3Str, "SaveState", &fSaveState, &size);
    … …  
    13591381  size = sizeof(INT);
    13601382  PrfQueryProfileData(fmprof, appname,
    1361                       "CollectorSort", &CollectorsortFlags, &size);
     1383                      "CollectorSort", &CollectorsortFlags, &size);
    13621384  size = sizeof(targetdir);
    13631385  PrfQueryProfileData(fmprof, appname, "Targetdir", targetdir, &size);
    … …  
    13701392  size = MaxComLineStrg;
    13711393  PrfQueryProfileData(fmprof, appname, "DirCompare", dircompare,
    1372                       &size);
     1394                      &size);
    13731395  size = MaxComLineStrg;
    13741396  PrfQueryProfileData(fmprof, appname, "Viewer", viewer, &size);
    … …  
    14051427  size = sizeof(lasttoolbar);
    14061428  PrfQueryProfileData(fmprof, appname, "LastToolbar", lasttoolbar,
    1407                       &size);
     1429                      &size);
    14081430  size = sizeof(BOOL);
    14091431  PrfQueryProfileData(fmprof, appname, "LibPathStrictHttpRun", &fLibPathStrictHttpRun,
    1410                       &size);
     1432                      &size);
    14111433  size = sizeof(BOOL);
    14121434  PrfQueryProfileData(fmprof, appname, "LibPathStrictFtpRun", &fLibPathStrictFtpRun,
    1413                       &size);
     1435                      &size);
    14141436  size = sizeof(BOOL);
    14151437  PrfQueryProfileData(fmprof, appname, "LibPathStrictMailRun", &fLibPathStrictMailRun,
    1416                       &size);
     1438                      &size);
    14171439  size = sizeof(BOOL);
    14181440  PrfQueryProfileData(fmprof, appname, "NoMailtoMailRun", &fNoMailtoMailRun,
    1419                       &size);
     1441                      &size);
    14201442  size = sizeof(BOOL);
    14211443  PrfQueryProfileData(fmprof, appname, "FollowTree", &fFollowTree,
    1422                       &size);
     1444                      &size);
    14231445  size = sizeof(BOOL);
    14241446  PrfQueryProfileData(fmprof, appname, "StartMaximized",
    1425                       &fStartMaximized, &size);
     1447                      &fStartMaximized, &size);
    14261448  if (!fStartMaximized) {
    14271449    size = sizeof(BOOL);
    14281450    PrfQueryProfileData(fmprof, appname, "StartMinimized",
    1429                         &fStartMinimized, &size);
     1451                        &fStartMinimized, &size);
    14301452  }
    14311453  size = sizeof(BOOL);
    … …  
    14351457  size = sizeof(BOOL);
    14361458  PrfQueryProfileData(fmprof, appname, "ArcStuffVisible",
    1437                       &fArcStuffVisible, &size);
     1459                      &fArcStuffVisible, &size);
    14381460  size = sizeof(BOOL);
    14391461  PrfQueryProfileData(fmprof, FM3Str, "NoTreeGap", &fNoTreeGap, &size);
    14401462  size = sizeof(BOOL);
    14411463  PrfQueryProfileData(fmprof, FM3Str, "VTreeOpensWPS",
    1442                       &fVTreeOpensWPS, &size);
     1464                      &fVTreeOpensWPS, &size);
    14431465  size = sizeof(BOOL);
    14441466  PrfQueryProfileData(fmprof, appname, "RemoteBug", &fRemoteBug, &size);
    14451467  size = sizeof(BOOL);
    14461468  PrfQueryProfileData(fmprof, appname, "Drag&DropDlg",
    1447                       &fDragndropDlg, &size);
     1469                      &fDragndropDlg, &size);
    14481470  size = sizeof(BOOL);
    14491471  PrfQueryProfileData(fmprof, FM3Str, "UserComboBox", &fUserComboBox, &size);
    … …  
    14521474  size = sizeof(BOOL);
    14531475  PrfQueryProfileData(fmprof, appname, "QuickArcFind",
    1454                       &fQuickArcFind, &size);
     1476                      &fQuickArcFind, &size);
    14551477  size = sizeof(BOOL);
    14561478  PrfQueryProfileData(fmprof, FM3Str, "NoRemovableScan",
    1457                       &fNoRemovableScan, &size);
     1479                      &fNoRemovableScan, &size);
    14581480  size = sizeof(ULONG);
    14591481  PrfQueryProfileData(fmprof, FM3Str, "NoBrokenNotify",
    1460                       &NoBrokenNotify, &size);
     1482                      &NoBrokenNotify, &size);
    14611483  size = sizeof(ULONG);
    14621484  PrfQueryProfileData(fmprof, appname, "ContainerType", &ulCnrType,
    1463                       &size);
     1485                      &size);
    14641486  size = sizeof(ULONG);
    14651487  PrfQueryProfileData(fmprof, appname, "FilesToGet", &FilesToGet, &size);
    … …  
    15441566    if (*argv[x] == '-') {
    15451567      if (!argv[x][1])
    1546         fNoSaveState = TRUE;
     1568        fNoSaveState = TRUE;
    15471569      else
    1548         strcpy(profile, &argv[x][1]);
     1570        strcpy(profile, &argv[x][1]);
    15491571    }
    15501572  }
    15511573
    15521574  hwndFrame = WinCreateStdWindow(HWND_DESKTOP,
    1553                                 WS_VISIBLE,
    1554                                 &FrameFlags,
    1555                                 WC_MAINWND,
    1556                                 NULL,
    1557                                 WS_VISIBLE | WS_ANIMATE,
    1558                                 FM3ModHandle, MAIN_FRAME, &hwndClient);
     1575                                WS_VISIBLE,
     1576                                &FrameFlags,
     1577                                WC_MAINWND,
     1578                                NULL,
     1579                                WS_VISIBLE | WS_ANIMATE,
     1580                                FM3ModHandle, MAIN_FRAME, &hwndClient);
    15591581  if (hwndFrame) {
    15601582    WinSetWindowUShort(hwndFrame, QWS_ID, MAIN_FRAME);
    … …  
    15731595      rcl.xRight -= bsz;
    15741596      WinSetWindowPos(hwndFrame,
    1575                       HWND_TOP,
    1576                       rcl.xLeft,
    1577                       rcl.yBottom,
    1578                       rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom, fl);
     1597                      HWND_TOP,
     1598                      rcl.xLeft,
     1599                      rcl.yBottom,
     1600                      rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom, fl);
    15791601    }
    15801602    if (fLogFile)
    … …  
    15941616  ULONG l;
    15951617  // CHAR buffer[80];
    1596   CHAR buffer[4096];                    // 06 Oct 07 SHL Protect against NTFS defect
     1618  CHAR buffer[4096];                    // 06 Oct 07 SHL Protect against NTFS defect
    15971619  BOOL ret = FALSE;
    15981620
    15991621  DosError(FERR_DISABLEHARDERR);
    16001622  if (DosOpen(filespec,
    1601               &handle,
    1602               &action,
    1603               0,
    1604               0,
    1605               OPEN_ACTION_FAIL_IF_NEW |
    1606               OPEN_ACTION_OPEN_IF_EXISTS,
    1607               OPEN_FLAGS_FAIL_ON_ERROR |
    1608               OPEN_FLAGS_NOINHERIT |
    1609               OPEN_FLAGS_RANDOMSEQUENTIAL |
    1610               OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY, 0))
     1623              &handle,
     1624              &action,
     1625              0,
     1626              0,
     1627              OPEN_ACTION_FAIL_IF_NEW |
     1628              OPEN_ACTION_OPEN_IF_EXISTS,
     1629              OPEN_FLAGS_FAIL_ON_ERROR |
     1630              OPEN_FLAGS_NOINHERIT |
     1631              OPEN_FLAGS_RANDOMSEQUENTIAL |
     1632              OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY, 0))
    16111633    ret = FALSE;
    16121634  else {
    … …  
    16151637    l = min(l, 79);
    16161638    if (!DosChgFilePtr(handle,
    1617                        abs(offset),
    1618                        (offset >= 0) ?
    1619                        FILE_BEGIN : FILE_END, &len)) {
     1639                       abs(offset),
     1640                       (offset >= 0) ?
     1641                       FILE_BEGIN : FILE_END, &len)) {
    16201642      if (!DosRead(handle, buffer, l, &len) && len == l) {
    1621         if (!memcmp(signature, buffer, l))
    1622           ret = TRUE;                   // Matched
     1643        if (!memcmp(signature, buffer, l))
     1644          ret = TRUE;                   // Matched
    16231645      }
    16241646    }
    16251647  }
    1626   DosClose(handle);                     /* Either way, we're done for now */
    1627   return ret;                           /* Return TRUE if matched */
     1648  DosClose(handle);                     /* Either way, we're done for now */
     1649  return ret;                           /* Return TRUE if matched */
    16281650}
    16291651
Note: See TracChangeset for help on using the changeset viewer.