source: trunk/dll/init.c@ 1438

Last change on this file since 1438 was 1438, checked in by Gregg Young, 16 years ago

Improved drivebar changes; Added AddBackslashToPath() to remove repeatative code. replaced "
" with PCSZ variable; ANY_OBJ added the DosAlloc... (experimental)

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 59.4 KB
Line 
1
2/***********************************************************************
3
4 $Id: init.c 1438 2009-06-28 20:47:00Z gyoung $
5
6 Initialization
7
8 Copyright (c) 1993-98 M. Kimes
9 Copyright (c) 2001, 2009 Steven H. Levine
10
11 11 Jun 02 SHL Add CheckVersion
12 11 Jun 03 SHL Add JFS and FAT32 support
13 25 Nov 03 SHL InitFM3DLL: correct strings error mesage
14 23 May 05 SHL Use datamin.h
15 26 May 05 SHL Comments
16 06 Jun 05 SHL indent -i2
17 06 Jun 05 SHL Rework FindSwapperDat for VAC3.65 compat
18 13 Jul 06 SHL Use Runtime_Error
19 13 Jul 06 SHL Sync with current style
20 29 Jul 06 SHL Use xfgets
21 22 Oct 06 GKY Add NDFS32 support
22 18 Feb 07 GKY Add ISOFS, RAMFS support
23 30 Mar 07 GKY Defined golbals for removing GetPString for window class names
24 21 Apr 07 GKY Find FM2Utils by path or utils directory eleminate fAddUtils global
25 15 Jun 07 SHL Make OpenWatcom compatible
26 23 Jun 07 GKY Fix WORPLACE_PROCESS enviroment check logic
27 28 Jun 07 SHL Rework WORKPLACE_PROCESS check to match reality
28 03 Aug 07 GKY Enlarged and made setable everywhere Findbuf (speed file loading)
29 06 Aug 07 GKY Reduce DosSleep times (ticket 148)
30 13 Aug 07 SHL Move #pragma alloc_text to end for OpenWatcom compat
31 18 Aug 07 JBS Added code to read Details* keys from the INI file (Ticket 118)
32 19 Aug 07 SHL Ensure FilesToGet in valid range
33 21 Aug 07 GKY Make Subject column in dircnr sizable and movable from the rigth to the left pane
34 23 Aug 07 SHL InitFM3DLL: report INI file DosSetPathInfo error correctly
35 23 Aug 07 SHL Use BldFullPathName
36 25 Aug 07 SHL Work around DosSetPathInfo kernel defect
37 01 Sep 07 GKY Use xDosSetPathInfo to fix case where FS3 buffer crosses 64k boundry
38 10 Nov 07 GKY Get thousands separator from country info for file sizes.
39 26 Nov 07 GKY Eliminate check of ext path on start up
40 17 Dec 07 GKY Make WPURLDEFAULTSETTINGS the fall back for ftp/httprun
41 13 Jan 08 GKY Get Subjectwidth/Subjectleft working in the collector.
42 12 Feb 08 SHL Compile OpenWatcom version into binary
43 29 Feb 08 GKY Changes to enable user settable command line length
44 29 Feb 08 GKY Refactor global command line variables to notebook.h
45 08 Mar 08 JBS Ticket 230: Replace prefixless INI keys for default directory containers with
46 keys using a "DirCnr." prefix
47 20 Apr 08 GKY Change default cmd line length to 1024 Ask once if user wants to reset it.
48 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.
51 16 JUL 08 GKY Use TMP directory for temp files
52 17 Jul 08 SHL Reduce code bulk in fUseTmp setup
53 19 Jul 08 GKY Use pFM2SaveDirectory, MakeTempName and move temp files to TMP subdirectory if (TMP).
54 20 Jul 08 JBS Ticket 114: Support user-selectable env. strings in Tree container.
55 20 Jul 08 GKY Add support to delete orphaned tmp directories without deleting tmp of other
56 running sessions
57 23 Aug 08 GKY Check that space on TMP & FM2 save drives exceed 5 GiB; Done to allow user setting of
58 minimum size in future
59 29 Nov 08 GKY Remove or replace with a mutex semaphore DosEnterCriSec where appropriate.
60 30 Nov 08 GKY Add the option of creating a subdirectory from the arcname
61 for the extract path to arc container.
62 10 Dec 08 SHL Integrate exception handler support
63 25 Dec 08 GKY Add code to allow write verify to be turned off on a per drive basis
64 28 Dec 08 GKY Check for LVM.EXE and remove Refresh removable media menu item as appropriate
65 28 Dec 08 GKY Rework partition submenu to gray out unavailable items (check for existence of files)
66 and have no default choice.
67 01 Jan 09 GKY Add option to rescan tree container on eject of removable media
68 03 Jan 09 GKY Avoid dbl scan of drive on startup by checking for first rescan drive.
69 03 Jan 09 GKY Check for system that is protectonly to gray out Dos/Win command lines and prevent
70 Dos/Win programs from being inserted into the execute dialog with message why.
71 11 Jan 09 GKY Move strings that shouldn't be translated (font names etc) compile time variables
72 03 Feb 09 SHL Switch to STRINGTABLE
73 07 Feb 09 GKY Move repeated strings to PCSZs.
74 07 Feb 09 GKY Add *DateFormat functions to format dates based on locale
75 07 Feb 09 GKY Eliminate Win_Error2 by moving function names to PCSZs used in Win_Error
76 08 Mar 09 GKY Additional strings move to PCSZs in init.c
77 08 Mar 09 GKY Removed variable aurguments from docopyf and unlinkf (not used)
78 14 Mar 09 GKY PCSZ strings moved to compile time initialization
79 14 Mar 09 GKY Prevent execution of UM_SHOWME while drive scan is occuring replaces check for
80 saved drive containers.
81 06 Jun 09 GKY Add option to show file system type or drive label in tree
82 28 Jun 09 GKY Added AddBackslashToPath() to remove repeatative code.
83
84***********************************************************************/
85
86#include <stdlib.h>
87#include <string.h>
88#include <share.h>
89#include <process.h> // getpid
90#include <time.h>
91#include <ctype.h>
92
93#define INCL_DOS
94#define INCL_WIN
95#define INCL_MMIOOS2
96#define INCL_GPI
97#define INCL_DOSERRORS
98#define INCL_LONGLONG
99#define INCL_DOSNLS
100#include <os2.h>
101#include <os2me.h>
102
103#define DEFINE_GLOBALS 1
104
105#include "fm3dll.h"
106#include "fm3dll2.h" // #define's for UM_*, control id's, etc.
107#include "init.h"
108#include "mkdir.h" // Data declaration(s)
109#include "dircnrs.h" // Data declaration(s)
110#include "comp.h" // Data declaration(s)
111#include "cmdline.h" // Data declaration(s)
112#include "fm2cmd.h" // Data declaration(s)
113#include "printer.h" // Data declaration(s)
114#include "flesh.h" // Data declaration(s)
115#include "worker.h" // Data declaration(s)
116#include "filldir.h" // Data declaration(s)
117#include "defview.h" // Data declaration(s)
118#include "draglist.h" // Data declaration(s)
119#include "fm3dlg.h"
120#include "datamin.h"
121#include "tools.h"
122#include "fm3str.h"
123#include "version.h"
124#include "pathutil.h" // BldFullPathName
125#include "arccnrs.h" // ArcClientWndProc
126#include "errutil.h" // Dos_Error...
127#include "strutil.h" // GetPString
128#include "valid.h" // ArgDriveFlags
129#include "autoview.h" // AutoViewProc
130#include "mainwnd.h" // BubbleProc, ChildButtonProc, DriveBackProc,
131 // DriveProc, LEDProc, MainWndProc, StatusProc
132 // ToolBackProc
133#include "collect.h" // CollectorClientWndProc, CollectorTextProc
134#include "getnames.h" // CustomFileDlg
135#include "notify.h" // EndNote
136#include "valid.h" // FillInDriveFlags, IsValidDir
137#include "inis.h" // IniProc
138#include "viewer.h" // MLEEditorProc
139#include "mainwnd2.h" // MainWndProc2
140#include "notify.h" // NotifyWndProc
141#include "treecnr.h" // OpenButtonProc
142#include "seeall.h" // SeeAllWndProc, SeeStatusProc
143#include "timer.h" // StartTimer, StopTimer
144#include "treecnr.h" // TreeClientWndProc, TreeStatProc
145#include "newview.h" // ViewStatusProc, ViewWndProc
146#include "subj.h" // Subject
147#include "select.h" // UnHilite
148#include "dirs.h" // save_dir
149#include "copyf.h" // unlinkf
150#include "wrappers.h" // xDosSetPathInfo
151#include "misc.h" // HeapThread, LoadDetailsSwitches
152#include "notebook.h" // command line variables (editor etc)
153#include "strips.h" // bstrip
154#include "killproc.h" // GetDosPgmName
155#include "srchpath.h" // searchpath
156#include "fortify.h"
157#include "excputil.h" // xbeginthread
158#include "systemf.h" // runemf2
159
160extern int _CRT_init(void);
161extern void _CRT_term(void);
162
163#ifdef __WATCOMC__
164#define a(x) #x
165#define b(x) a(x)
166// Must be global to prevent warnings
167PSZ pszBuiltWith = "Built with OpenWatcom version " b(__WATCOMC__);
168#undef b
169#undef a
170#endif
171
172static VOID FindSwapperDat(VOID);
173
174// Data definitions
175static PSZ pszSrcFile = __FILE__;
176unsigned __MaxThreads = {48};
177
178#pragma data_seg(GLOBAL1)
179HMTX hmtxFM2Delete;
180HMTX hmtxFM2Globals;
181ULONG OS2ver[2];
182PFNWP PFNWPCnr;
183PFNWP PFNWPMLE;
184CHAR ThousandsSeparator[2];
185CHAR DateSeparator[2];
186CHAR TimeSeparator[2];
187ULONG ulTimeFmt;
188ULONG ulDateFmt;
189BOOL fInitialDriveScan;
190BOOL fAmAV2;
191BOOL fChangeTarget;
192BOOL fIniExisted;
193BOOL fLogFile;
194BOOL fProtectOnly;
195BOOL fReminimize;
196BOOL fWantFirstTimeInit;
197//BOOL fDrivetoSkip[26];
198HPOINTER hptrApp;
199HPOINTER hptrArc;
200HPOINTER hptrArrow;
201HPOINTER hptrArt;
202HPOINTER hptrBusy;
203HPOINTER hptrCDROM;
204HPOINTER hptrDrive;
205HPOINTER hptrEW;
206HPOINTER hptrFloppy;
207HPOINTER hptrNS;
208HPOINTER hptrRamdisk;
209HPOINTER hptrRemote;
210HPOINTER hptrRemovable;
211HPOINTER hptrVirtual;
212HPOINTER hptrZipstrm;
213CHAR *pFM2SaveDirectory;
214CHAR *pTmpDir;
215
216#pragma data_seg(GLOBAL2)
217PCSZ PCSZ_ARCHIVERBB2 = "ARCHIVER.BB2";
218PCSZ PCSZ_ASSOCDAT = "ASSOC.DAT";
219PCSZ PCSZ_CMDLINESDAT = "CMDLINES.DAT";
220PCSZ PCSZ_CMDMINIDAT = "CMDMINI.DAT";
221PCSZ PCSZ_COMMANDSDAT = "COMMANDS.DAT";
222PCSZ PCSZ_FILTERSDAT = "FILTERS.DAT";
223PCSZ PCSZ_GREPMASKDAT = "GREPMASK.DAT";
224PCSZ PCSZ_PATTERNSDAT = "PATTERNS.DAT";
225PCSZ PCSZ_RESOURCEDAT = "RESOURCE.DAT";
226PCSZ PCSZ_QUICKTLSDAT = "QUICKTLS.DAT";
227PCSZ PCSZ_FM3TOOLSDAT = "FM3TOOLS.DAT";
228PCSZ PCSZ_USERDIRSDAT = "USERDIRS.DAT";
229PCSZ PCSZ_FM2PLAYEXE = "FM2PLAY.EXE";
230PCSZ PCSZ_FM2PLAYTEMP = "$FM2PLAY.$$$";
231PCSZ PCSZ_LVMGUICMD = "LVMGUI.CMD";
232PCSZ PCSZ_DFSOS2EXE = "DFSOS2.EXE";
233PCSZ PCSZ_MINILVMEXE = "MINILVM.EXE";
234PCSZ PCSZ_FDISKPMEXE = "FDISKPM.EXE";
235PCSZ PCSZ_LVMEXE = "LVM.EXE";
236PCSZ PCSZ_ARCCNR = "ArcCnr";
237PCSZ PCSZ_COLLECTOR = "Collector";
238PCSZ PCSZ_DIRCNR = "DirCnr";
239PCSZ PCSZ_DIRCMP = "DirCmp";
240PCSZ PCSZ_DIRSIZES = "DirSizes";
241PCSZ PCSZ_TOOLBAR = "ToolBar";
242PCSZ PCSZ_TREECNR = "TreeCnr";
243PCSZ PCSZ_SHUTDOWNSTATE = "FM2Shutdown";
244PCSZ PCSZ_FM2TEMPTEXT = "FM/2_Temp";
245PCSZ DRF_FM2ARCHIVE = "DRF_FM2ARCHIVE";
246PCSZ DRMDRFFM2ARC = "<DRM_FM2ARCMEMBER,DRF_FM2ARCHIVE>";
247PCSZ DRMDRFOS2FILE = "<DRM_OS2FILE,DRF_UNKNOWN>";
248PCSZ DRM_FM2ARCMEMBER = "DRM_FM2ARCMEMBER";
249PCSZ DRM_OS2FILE = "DRM_OS2FILE";
250PCSZ FM2Str = "FM/2";
251HMODULE FM3DllHandle;
252PCSZ FM3Folder = "<FM3_Folder>";
253PCSZ FNT_HELVETICA = "Helvetica";
254PCSZ FNT_6HELVETICA = "6.Helvetica";
255PCSZ FNT_8HELVETICA = "8.Helvetica";
256PCSZ FNT_8HELVETICABOLD = "8.Helvetica.Bold";
257PCSZ FNT_10SYSTEMMONOTEXT = "10.System Monospaced";
258PCSZ FNT_10SYSTEMPROPORT = "10.System Proportional";
259PCSZ FNT_2SYSTEMVIO = "2.System VIO";
260PCSZ FNT_4SYSTEMVIO = "4.System VIO";
261PCSZ FNT_10SYSTEMVIO = "10.System VIO";
262PCSZ FNT_8TIMESNEWROMAN = "8.Times New Roman";
263CHAR HomePath[CCHMAXPATH];
264PCSZ LONGNAME = ".LONGNAME";
265CHAR *NullStr = "";
266PCSZ PCSZ_CM_ALLOCRECORD = "CM_ALLOCRECORD";
267PCSZ PCSZ_DOSCREATEMUTEXSEM = "DosCreateMutexSem";
268PCSZ PCSZ_DOSDUPHANDLE = "DosDupHandle";
269PCSZ PCSZ_DOSGETINFOBLOCKS = "DosGetInfoBlocks";
270PCSZ PCSZ_DOSQUERYPATHINFO = "DosQueryPathInfo";
271PCSZ PCSZ_DOSSEARCHPATH = "DosSearchPath";
272PCSZ PCSZ_DRGACCESSDRAGINFO = "DrgAccessDraginfo";
273PCSZ PCSZ_POSTMSG = "PostMsg";
274PCSZ PCSZ_WINCREATEWINDOW = "WinCreateWindow";
275PCSZ PCSZ_WINLOADACCELTABLE = "WinLoadAccelTable";
276PCSZ PCSZ_WINSETACCELTABLE = "WinSetAccelTable";
277PCSZ PCSZ_INIQUERYPRFTEXT = "PrfQueryProfile";
278PCSZ PCSZ_PRFOPENPROFILEFAILED = "PrfOpenProfile failed for %s";
279PCSZ PCSZ_PRFQUERYPROFILEDATA = "PrfQueryProfileData";
280PCSZ PCSZ_PRFQUERYPROFILESIZE = "PrfQueryProfileSize";
281PCSZ PCSZ_PRFQUERYPROFILESTRING = "PrfQueryProfileString";
282PCSZ PCSZ_FILLDIRQCURERRTEXT = "DosQCurDisk";
283PCSZ PCSZ_NODATA = "No Data";
284PCSZ PCSZ_BACKSLASH = "\\";
285PCSZ PCSZ_STARDOTEXE = "*.EXE";
286PCSZ PCSZ_STARDOTINI = "*.INI";
287PCSZ PCSZ_STARDOTLST = "*.LST";
288PCSZ PCSZ_STARDOTPMD = "*.PMD";
289PCSZ PCSZ_STARDOTTXT = "*.TXT";
290PCSZ PCSZ_DOTEXE = ".EXE";
291PCSZ PCSZ_DOTCOM = ".COM";
292PCSZ PCSZ_DOTCMD = ".CMD";
293PCSZ PCSZ_DOTBTM = ".BTM";
294PCSZ PCSZ_DOTBAT = ".BAT";
295PCSZ PCSZ_DOTLST = ".LST";
296PCSZ PCSZ_DOTTLS = ".TLS";
297PCSZ PCSZ_DOTHLP = ".HLP";
298PCSZ PCSZ_DOTINF = ".INF";
299PCSZ PCSZ_DOTMP3 = ".MP3";
300PCSZ PCSZ_DOTOGG = ".OGG";
301PCSZ PCSZ_DOTFLAC = ".FLAC";
302PCSZ PCSZ_DOTJPEG = ".JPEG";
303PCSZ PCSZ_DOTJPG = ".JPG";
304PCSZ PCSZ_DOTICO = ".ICO";
305PCSZ PCSZ_DOTPTR = ".PTR";
306PCSZ PCSZ_DOTBB2 = ".BB2";
307PCSZ PCSZ_DOTBMP = ".BMP";
308PCSZ PCSZ_DOTCOMMENTS = ".COMMENTS";
309PCSZ PCSZ_PATH = "PATH";
310PCSZ PCSZ_LIBPATH = "LIBPATH";
311CHAR *pLibPathStrict = "SET LIBPATHSTRICT=TRUE";
312PCSZ PCSZ_WPURLDEFAULTSETTINGS = "WPURLDEFAULTSETTINGS";
313PCSZ Settings = "SETTINGS";
314PCSZ Details = "DETAILS";
315PCSZ PCSZ_TREE = "TREE";
316PCSZ PCSZ_ICON = "ICON";
317CHAR SwapperDat[CCHMAXPATH];
318PCSZ WC_OBJECTWINDOW = "WC_OBJECTWINDOW";
319PCSZ WC_BUBBLE = "WC_BUBBLE";
320PCSZ WC_TOOLBUTTONS = "WC_TOOLBUTTONS";
321PCSZ WC_DRIVEBUTTONS = "WC_DRIVEBUTTONS";
322PCSZ WC_DIRCONTAINER = "WC_DIRCONTAINER";
323PCSZ WC_DIRSTATUS = "WC_DIRSTATUS";
324PCSZ WC_TREECONTAINER = "WC_TREECONTAINER";
325PCSZ WC_TREEOPENBUTTON = "WC_TREEOPENBUTTON";
326PCSZ WC_TREESTATUS = "WC_TREESTATUS";
327PCSZ WC_MAINWND = "WC_MAINWND";
328PCSZ WC_MAINWND2 = "WC_MAINWND2";
329PCSZ WC_AUTOVIEW = "WC_AUTOVIEW";
330PCSZ WC_LED = "WC_LED";
331PCSZ WC_COLLECTOR = "WC_COLLECTOR";
332PCSZ WC_COLSTATUS = "WC_COLSTATUS";
333PCSZ WC_STATUS = "WC_STATUS";
334PCSZ WC_TOOLBACK = "WC_TOOLBACK";
335PCSZ WC_DRIVEBACK = "WC_DRIVEBACK";
336PCSZ WC_ARCCONTAINER = "WC_ARCCONTAINER";
337PCSZ WC_ARCSTATUS = "WC_ARCSTATUS";
338PCSZ WC_MLEEDITOR = "WC_MLEEDITOR";
339PCSZ WC_INIEDITOR = "WC_INIEDITOR";
340PCSZ WC_SEEALL = "WC_SEEALL";
341PCSZ WC_NEWVIEW = "WC_NEWVIEW";
342PCSZ WC_SEESTATUS = "WC_SEESTATUS";
343PCSZ WC_VIEWSTATUS = "WC_VIEWSTATUS";
344PCSZ WC_ERRORWND = "WC_ERRORWND";
345PCSZ WC_MINITIME = "WC_MINITIME";
346PCSZ WC_DATABAR = "WC_DATABAR";
347CHAR profile[CCHMAXPATH];
348ULONGLONG ullTmpSpaceNeeded;
349
350BOOL CheckFileHeader(CHAR *filespec, CHAR *signature, LONG offset);
351
352VOID FindSwapperDat(VOID)
353{
354 CHAR filename[] = "C:\\CONFIG.SYS";
355 CHAR input[8192];
356 CHAR *p;
357 CHAR *pp;
358 FILE *fp;
359 FILEFINDBUF3L ffb;
360 ULONG nm;
361 ULONG size = sizeof(SwapperDat);
362 HDIR hdir = HDIR_CREATE;
363 APIRET rc = 1;
364
365 *SwapperDat = 0;
366 // Check already known
367 PrfQueryProfileData(fmprof, FM3Str, "SwapperDat", SwapperDat, &size);
368 if (*SwapperDat) {
369 nm = 1;
370 rc = DosFindFirst(SwapperDat,
371 &hdir,
372 FILE_NORMAL | FILE_ARCHIVED |
373 FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
374 &ffb, sizeof(ffb), &nm, FIL_STANDARDL);
375 if (rc && rc != ERROR_FILE_NOT_FOUND && rc != ERROR_PATH_NOT_FOUND) {
376 FILEFINDBUF3 ffb;
377 rc = DosFindFirst(SwapperDat,
378 &hdir,
379 FILE_NORMAL | FILE_ARCHIVED |
380 FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
381 &ffb, sizeof(ffb), &nm, FIL_STANDARD);
382 fNoLargeFileSupport = TRUE;
383 }
384 if (!rc) {
385 DosFindClose(hdir);
386 fp = fopen(SwapperDat, "r");
387 if (fp) {
388 fclose(fp);
389 *SwapperDat = 0;
390 rc = 1; // Force config.sys scan
391 }
392 }
393 else
394 *SwapperDat = 0;
395 }
396 // If not defined in INI or INI wrong, scan config.sys for SWAPPATH statement
397 if (rc) {
398 if (DosQuerySysInfo(QSV_BOOT_DRIVE,
399 QSV_BOOT_DRIVE,
400 &nm,
401 sizeof(ULONG))) {
402 nm = 3; // Assume drive C:
403 }
404 *filename = (CHAR) nm + '@';
405 fp = xfsopen(filename, "r", SH_DENYNO, pszSrcFile, __LINE__);
406 if (fp) {
407 while (!feof(fp)) {
408 if (!xfgets(input, sizeof(input), fp, pszSrcFile, __LINE__))
409 break;
410 lstrip(input);
411 if (!strnicmp(input, "SWAPPATH", 8)) {
412 p = input + 8;
413 while (*p == ' ')
414 p++;
415 if (*p == '=') {
416 p++;
417 stripcr(p);
418 rstrip(p);
419 while (*p == ' ')
420 p++;
421 if (*p == '\"') {
422 p++;
423 pp = p;
424 while (*pp && *pp != '\"')
425 *pp += 1;
426 if (*pp)
427 *pp = 0;
428 }
429 else {
430 pp = strchr(p, ' ');
431 if (pp)
432 *pp = 0;
433 }
434 if (*p) {
435 strncpy(SwapperDat, p, CCHMAXPATH);
436 SwapperDat[CCHMAXPATH - 1] = 0;
437 BldFullPathName(SwapperDat, SwapperDat, "SWAPPER.DAT");
438 hdir = HDIR_CREATE;
439 nm = 1;
440 rc = DosFindFirst(SwapperDat,
441 &hdir,
442 FILE_NORMAL | FILE_ARCHIVED |
443 FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
444 &ffb, sizeof(ffb), &nm, FIL_STANDARD);
445 if (rc){
446 FILEFINDBUF3 ffb;
447 rc = DosFindFirst(SwapperDat,
448 &hdir,
449 FILE_NORMAL | FILE_ARCHIVED |
450 FILE_HIDDEN | FILE_SYSTEM | FILE_READONLY,
451 &ffb, sizeof(ffb), &nm, FIL_STANDARD);
452 fNoLargeFileSupport = TRUE;
453 }
454 if (!rc) {
455 DosFindClose(hdir);
456 PrfWriteProfileString(fmprof,
457 FM3Str, "SwapperDat", SwapperDat);
458 }
459 else
460 *SwapperDat = 0;
461 break;
462 }
463 }
464 } // if SWAPPATH
465 } // while
466 fclose(fp);
467 }
468 }
469}
470
471unsigned APIENTRY LibMain(unsigned hModule,
472 unsigned ulFlag)
473{
474 switch (ulFlag) {
475 case 0:
476 FM3DllHandle = hModule;
477
478 DosError(FERR_DISABLEHARDERR);
479 memset(&RGBBLACK, 0, sizeof(RGB2));
480 RGBGREY.bRed = RGBGREY.bGreen = RGBGREY.bBlue = (BYTE)204;
481 RGBGREY.fcOptions = 0;
482 FM3UL = *(ULONG *)FM3Str;
483 break;
484 case 1:
485 StopPrinting = 1;
486 if (fmprof)
487 PrfCloseProfile(fmprof);
488 DosError(FERR_ENABLEHARDERR);
489 break;
490 default:
491 return 0UL;
492 }
493 return 1UL;
494}
495
496VOID APIENTRY DeInitFM3DLL(ULONG why)
497{
498 /* cleanup */
499 static CHAR s[CCHMAXPATH];
500 CHAR *enddir, szTempFile[CCHMAXPATH];
501 HDIR search_handle;
502 ULONG num_matches;
503 FILEFINDBUF3 ffb;
504
505 StopTimer();
506 StopPrinting = 1;
507
508 if (LogFileHandle)
509 fclose(LogFileHandle);
510
511 if (fmprof) {
512 PrfCloseProfile(fmprof);
513 fmprof = (HINI) 0;
514 if (fIniExisted) {
515 DosError(FERR_DISABLEHARDERR);
516 DosCopy("FM3.INI", "FM3INI.BAK", DCPY_EXISTING);
517 }
518 }
519
520 if (fToolsChanged)
521 save_tools(NULL);
522 fcloseall();
523 save_dir(s);
524 AddBackslashToPath(s);
525 //if (s[strlen(s) - 1] != '\\')
526 // strcat(s, "\\");
527 enddir = &s[strlen(s)];
528 if (*ArcTempRoot) {
529 strcat(s, ArcTempRoot);
530 strcat(s, "*");
531 search_handle = HDIR_CREATE;
532 num_matches = 1L;
533 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)) {
539 do {
540 strcpy(enddir, ffb.achName);
541 if (ffb.attrFile & FILE_DIRECTORY) {
542 wipeallf("%s\\*", s);
543 DosDeleteDir(s);
544 }
545 else
546 unlinkf(s);
547 }
548 while (!DosFindNext(search_handle,
549 &ffb, sizeof(ffb), &num_matches));
550 DosFindClose(search_handle);
551 }
552 }
553 if (pTmpDir)
554 strcpy(s, pTmpDir);
555 else
556 strcpy(s, pFM2SaveDirectory);
557 AddBackslashToPath(s);
558 //if (s[strlen(s) - 1] != '\\')
559 // strcat(s, "\\");
560 enddir = &s[strlen(s)];
561 strcat(s, "$FM2LI$T.");
562 strcat(s, "???");
563 search_handle = HDIR_CREATE;
564 num_matches = 1;
565 if (!DosFindFirst(s,
566 &search_handle,
567 FILE_NORMAL | FILE_DIRECTORY |
568 FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
569 FILE_ARCHIVED,
570 &ffb, sizeof(ffb), &num_matches, FIL_STANDARD)) {
571 do {
572 if (!(ffb.attrFile & FILE_DIRECTORY)) {
573 strcpy(enddir, ffb.achName);
574 unlinkf(s);
575 }
576 }
577 while (!DosFindNext(search_handle,
578 &ffb, sizeof(ffb), &num_matches));
579 DosFindClose(search_handle);
580 }
581 BldFullPathName(szTempFile, pTmpDir, PCSZ_FM2PLAYTEMP);
582 DosForceDelete(szTempFile);
583 if (pTmpDir) {
584 wipeallf("%s\\*", pTmpDir);
585 DosDeleteDir(pTmpDir);
586 }
587 EndNote();
588 if (FM3ModHandle)
589 DosFreeModule(FM3ModHandle);
590
591 DosExitList(EXLST_REMOVE, DeInitFM3DLL);
592}
593
594BOOL InitFM3DLL(HAB hab, int argc, char **argv)
595{
596 /*
597 * this function should be called by any application using this DLL right
598 * after setting up a message queue
599 */
600
601 CLASSINFO clinfo;
602 APIRET rc;
603 APIRET rcl;
604 APIRET rcq;
605 PFN pfnResVersion;
606 ULONG RVMajor;
607 ULONG RVMinor;
608 ULONG ret;
609 FILESTATUS3 fs3;
610 PSZ env;
611 CHAR dllfile[CCHMAXPATH];
612 ULONG size;
613
614 strcpy(dllfile, "FM3RES");
615 env = getenv("FM3INI");
616 if (env) {
617 DosError(FERR_DISABLEHARDERR);
618 rc = DosQueryPathInfo(env, FIL_STANDARD, &fs3, sizeof(fs3));
619 if (!rc) {
620 if (fs3.attrFile & FILE_DIRECTORY) {
621 BldFullPathName(dllfile, env, "FM3RES"); // 23 Aug 07 SHL
622 DosError(FERR_DISABLEHARDERR);
623 if (DosQueryPathInfo(dllfile, FIL_STANDARD, &fs3, sizeof(fs3)))
624 strcpy(dllfile, "FM3RES");
625 }
626 }
627 }
628
629 rcl = DosLoadModule(NULL, 0, dllfile, &FM3ModHandle);
630 if (rcl) {
631 saymsg(MB_CANCEL | MB_ICONEXCLAMATION,
632 HWND_DESKTOP,
633 GetPString(IDS_ERRORTEXT), GetPString(IDS_FM3RESERROR1TEXT));
634 return FALSE;
635 }
636
637 rc = DosExitList(EXLST_ADD, DeInitFM3DLL);
638 if (rc) {
639 Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
640 "DosExitList");
641 }
642
643 rcq = DosQueryProcAddr(FM3ModHandle, 1, "ResVersion", &pfnResVersion);
644 if (!rcq)
645 ret = pfnResVersion(&RVMajor, &RVMinor);
646 else {
647 ret = 0;
648 RVMajor = 0;
649 RVMinor = 0;
650 }
651
652 if (RVMajor < VERMAJOR || (RVMajor == VERMAJOR && RVMinor < VERMINOR)) {
653 saymsg(MB_ENTER,
654 HWND_DESKTOP,
655 GetPString(IDS_ERRORTEXT),
656 GetPString(IDS_FM3RESERROR2TEXT),
657 !rcq ?
658 GetPString(IDS_FM3RESERROR3TEXT) :
659 !rcl ?
660 GetPString(IDS_FM3RESERROR4TEXT) :
661 GetPString(IDS_FM3RESERROR5TEXT), RVMajor, RVMinor, rcl, rcq, ret);
662 return FALSE;
663 }
664
665 if (!*profile)
666 strcpy(profile, "FM3.INI");
667 mypid = getpid();
668 /* give default appname if none set by caller */
669 if (!*appname)
670 strcpy(appname, FM3Str);
671 /* save appname; may be reset below */
672 strcpy(realappname, appname);
673 if (!strcmp(appname, FM3Str))
674 DosSetMaxFH(100);
675 else if (!strcmp(appname, "VDir") ||
676 !strcmp(appname, "VTree") ||
677 !strcmp(appname, "VCollect") ||
678 !strcmp(appname, "SEEALL") || !strcmp(appname, "FM/4"))
679 DosSetMaxFH(60);
680 else
681 DosSetMaxFH(40);
682
683 if (DosQuerySysInfo(QSV_VERSION_MAJOR,
684 QSV_VERSION_MINOR,
685 OS2ver,
686 sizeof(OS2ver))) {
687 OS2ver[0] = 2;
688 OS2ver[1] = 1;
689 }
690
691 // set up default root names for temp file storage and archive goodies
692 env = getenv("TMP");
693 if (env == NULL)
694 env = getenv("TEMP");
695 if (env != NULL) {
696 DosError(FERR_DISABLEHARDERR);
697 rc = DosQueryPathInfo(env, FIL_STANDARD, &fs3, sizeof(fs3));
698 if (!rc) {
699 CHAR *enddir, *p, szTempName[CCHMAXPATH], temp[CCHMAXPATH];
700 FILEFINDBUF3 ffb;
701 HDIR search_handle;
702 ULONG num_matches, ul;
703
704 strcpy(szTempName, env);
705 AddBackslashToPath(szTempName);
706 //if (szTempName[strlen(szTempName) - 1] != '\\')
707 // strcat(szTempName, "\\");
708 enddir = &szTempName[strlen(szTempName)];
709 strcat(szTempName, "$FM2????.");
710 strcat(szTempName, "???");
711 search_handle = HDIR_CREATE;
712 num_matches = 1;
713 if (!DosFindFirst(szTempName,
714 &search_handle,
715 FILE_NORMAL | FILE_DIRECTORY |
716 FILE_SYSTEM | FILE_READONLY | FILE_HIDDEN |
717 FILE_ARCHIVED,
718 &ffb, sizeof(ffb), &num_matches, FIL_STANDARD)) {
719 do {
720 strcpy(enddir, ffb.achName);
721 p = strrchr(szTempName, '.');
722 if (p) {
723 p++;
724 ul = strtol(p, &p + 2, 16);
725 GetDosPgmName(ul, temp);
726 if (!strstr(temp, "FM/2") &&
727 !strstr(temp, "AV/2")) {
728 wipeallf("%s\\*", szTempName);
729 DosDeleteDir(szTempName);
730 }
731 }
732 }
733 while (!DosFindNext(search_handle,
734 &ffb, sizeof(ffb), &num_matches));
735 DosFindClose(search_handle);
736 }
737 if (fs3.attrFile & FILE_DIRECTORY) {
738 strcpy(szTempName, env);
739 MakeTempName(szTempName, NULL, 1);
740 rc = DosCreateDir(szTempName, 0);
741 if (!rc)
742 pTmpDir = xstrdup(szTempName, pszSrcFile, __LINE__); // if writable
743 }
744 }
745 }
746
747 //Save the FM2 save directory name. This is the location of the ini, dat files etc.
748 {
749 CHAR temp[CCHMAXPATH];
750 save_dir2(temp);
751 pFM2SaveDirectory = xstrdup(temp, pszSrcFile, __LINE__);
752 }
753 // Check free space on TMP and FM2 Save drives
754 {
755 ullTmpSpaceNeeded = 5120000;
756 if (pTmpDir && CheckDriveSpaceAvail(pTmpDir, ullTmpSpaceNeeded, 0) == 1) {
757 if (CheckDriveSpaceAvail(pFM2SaveDirectory, ullTmpSpaceNeeded, 0) == 0){
758 ret = saymsg(MB_YESNO,
759 HWND_DESKTOP,
760 NullStr,
761 GetPString(IDS_TMPDRIVESPACELIMITED),
762 pTmpDir);
763 if (ret == MBID_YES)
764 pTmpDir = pFM2SaveDirectory;
765 }
766 else
767 saymsg(MB_OK,
768 HWND_DESKTOP,
769 NullStr,
770 GetPString(IDS_SAVETMPDRIVESPACELIMITED),
771 pTmpDir,
772 pFM2SaveDirectory);
773 }
774 else if (CheckDriveSpaceAvail(pFM2SaveDirectory, ullTmpSpaceNeeded, 0) == 1)
775 saymsg(MB_OK,
776 HWND_DESKTOP,
777 NullStr,
778 GetPString(IDS_SAVEDRIVESPACELIMITED),
779 pFM2SaveDirectory);
780 }
781 BldFullPathName(ArcTempRoot, pTmpDir, fAmAV2 ? "$AV$ARC$" : "$FM$ARC$");
782
783 // initialize random number generator
784 srand(time(NULL) + clock());
785
786 priority_bumped();
787
788 /* _heapmin() is done in a separate thread -- start it */
789 if (xbeginthread(HeapThread,
790 32768,
791 MPVOID,
792 pszSrcFile,
793 __LINE__) == -1) {
794 return FALSE;
795 }
796
797 /* timer messages are sent from a separate thread -- start it */
798 if (!StartTimer()) {
799 Runtime_Error(pszSrcFile, __LINE__,
800 GetPString(IDS_COULDNTSTARTTHREADTEXT));
801 return FALSE;
802 }
803
804 /* Are we the workplace shell? */
805 env = getenv("WORKPLACE_PROCESS");
806 fWorkPlace = env != NULL &&
807 (stricmp(env, "YES") == 0 || atoi(env) == 1);
808
809 if ((!strchr(profile, '\\') && !strchr(profile, ':')) ||
810 !(fmprof = PrfOpenProfile((HAB)0, profile)))
811 {
812 /* figure out where to put INI file... */
813 CHAR inipath[CCHMAXPATH];
814
815 DosError(FERR_DISABLEHARDERR);
816 strcpy(HomePath, pFM2SaveDirectory);
817 DosError(FERR_DISABLEHARDERR);
818 memset(driveserial, -1, sizeof(driveserial));
819 *inipath = 0;
820 env = getenv("FM3INI");
821 if (env) {
822 strcpy(inipath, env);
823 DosError(FERR_DISABLEHARDERR);
824 rc = DosQueryPathInfo(inipath, FIL_STANDARD, &fs3, sizeof(fs3));
825 if (!rc) {
826 if (fs3.attrFile & FILE_DIRECTORY)
827 BldFullPathName(inipath, inipath, profile);
828 }
829 }
830 if (!env) {
831 env = searchpath(profile);
832 if (!env)
833 env = profile;
834 strcpy(inipath, env);
835 }
836
837 /* in some odd cases the INI file can get set to readonly status */
838 /* here we test it and reset the readonly bit if necessary */
839 if (!*inipath)
840 strcpy(inipath, profile);
841 DosError(FERR_DISABLEHARDERR);
842 // fixme to check for backup if ini not found GKY 1-30-09
843 rc = DosQueryPathInfo(inipath, FIL_STANDARD, &fs3, sizeof(fs3));
844 if (rc) {
845 if (rc == ERROR_FILE_NOT_FOUND)
846 fWantFirstTimeInit = TRUE;
847 }
848 else { //Check the ini file header and restore from backup if corupted
849 if (!CheckFileHeader(inipath, "\xff\xff\xff\xff\x14\x00\x00\x00", 0L)) {
850 saymsg(MB_ENTER,HWND_DESKTOP, GetPString(IDS_DEBUG_STRING),
851 GetPString(IDS_INIFAILURETEXT));
852 DosCopy("FM3.INI", "FM3INI.BAD", DCPY_EXISTING);
853 DosCopy("FM3INI.BAK", "FM3.INI", DCPY_EXISTING);
854 if (!CheckFileHeader(inipath, "\xff\xff\xff\xff\x14\x00\x00\x00", 0L)) {
855 DosCopy("FM3.INI", "FM3INI2.BAD", DCPY_EXISTING);
856 fWantFirstTimeInit = TRUE;
857 }
858 }
859 if (!fWantFirstTimeInit) {
860 fIniExisted = TRUE;
861 if (fs3.attrFile & (FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM)) {
862 fs3.attrFile &= ~(FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM);
863 rc = xDosSetPathInfo(inipath, FIL_STANDARD, &fs3, sizeof(fs3), 0);
864 if (rc) {
865 Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
866 GetPString(IDS_INIREADONLYTEXT), inipath);
867 }
868 }
869 }
870 }
871 fmprof = PrfOpenProfile((HAB)0, inipath);
872 if (!fmprof) {
873 strcpy(inipath, "FM3.INI");
874 fmprof = PrfOpenProfile((HAB)0, inipath);
875 }
876
877 // 10 Jan 08 SHL fixme to do first time if new ini
878 // 10 Jan 08 SHL post UM_FIRSTTIME to main window
879 if (!fmprof) {
880 Win_Error(NULLHANDLE, NULLHANDLE, pszSrcFile, __LINE__,
881 PCSZ_PRFOPENPROFILEFAILED, inipath);
882 return FALSE;
883 }
884 }
885
886 ArgDriveFlags(argc, argv);
887 FillInDriveFlags(NULL);
888
889 FindSwapperDat();
890
891 size = sizeof(BOOL);
892 PrfQueryProfileData(fmprof,
893 FM3Str,
894 "SeparateParms",
895 &fSeparateParms,
896 &size);
897 if (!fSeparateParms)
898 strcpy(appname, FM3Str);
899
900 /* start help */
901 memset(&hini, 0, sizeof(HELPINIT));
902 hini.cb = sizeof(HELPINIT);
903 hini.ulReturnCode = 0;
904 hini.pszTutorialName = NULL;
905 hini.phtHelpTable = (PHELPTABLE) MAKELONG(ID_HELPTABLE, 0xffff);
906 hini.hmodAccelActionBarModule = (HMODULE) 0;
907 hini.idAccelTable = 0;
908 hini.idActionBar = 0;
909 hini.pszHelpWindowTitle = (PSZ)GetPString(IDS_FM2HELPTITLETEXT);
910 hini.fShowPanelId = CMIC_HIDE_PANEL_ID;
911 hini.pszHelpLibraryName = "FM3.HLP";
912 hwndHelp = WinCreateHelpInstance(hab, &hini);
913 if (!hwndHelp) {
914 static CHAR helppath[CCHMAXPATH]; // fixme to be local?
915
916 env = getenv("FM3INI");
917 if (env) {
918 strcpy(helppath, env);
919 DosError(FERR_DISABLEHARDERR);
920 rc = DosQueryPathInfo(helppath, FIL_STANDARD, &fs3, sizeof(fs3));
921 if (!rc) {
922 if (fs3.attrFile & FILE_DIRECTORY) {
923 BldFullPathName(helppath, helppath, "FM3.HLP");
924 hini.pszHelpLibraryName = helppath;
925 hwndHelp = WinCreateHelpInstance(hab, &hini);
926 }
927 }
928 }
929 }
930 if (!hwndHelp) {
931 saymsg(MB_ENTER | MB_ICONEXCLAMATION,
932 HWND_DESKTOP,
933 GetPString(IDS_FM2TROUBLETEXT),
934 GetPString(IDS_CANTLOADHELPTEXT),
935 GetPString(IDS_NOHELPACCEPTTEXT));
936 }
937
938 // a couple of default window procs so we don't have to look them up later
939 if (WinQueryClassInfo(hab, WC_CONTAINER, &clinfo))
940 PFNWPCnr = clinfo.pfnWindowProc;
941 if (WinQueryClassInfo(hab, WC_FRAME, &clinfo))
942 PFNWPFrame = clinfo.pfnWindowProc;
943 if (WinQueryClassInfo(hab, WC_BUTTON, &clinfo))
944 PFNWPButton = clinfo.pfnWindowProc;
945 if (WinQueryClassInfo(hab, WC_STATIC, &clinfo))
946 PFNWPStatic = clinfo.pfnWindowProc;
947 if (WinQueryClassInfo(hab, WC_MLE, &clinfo))
948 PFNWPMLE = clinfo.pfnWindowProc;
949 if (!PFNWPCnr || !PFNWPFrame || !PFNWPButton || !PFNWPStatic || !PFNWPMLE) {
950 Runtime_Error(pszSrcFile, __LINE__, "WinQueryClassInfo");
951 return FALSE;
952 }
953
954 /* register window classes we use */
955 WinRegisterClass(hab,
956 WC_MAINWND,
957 MainWndProc,
958 CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 8);
959 WinRegisterClass(hab,
960 WC_MAINWND2,
961 MainWndProc2,
962 CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 4);
963 WinRegisterClass(hab,
964 WC_TREECONTAINER,
965 TreeClientWndProc,
966 CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
967 WinRegisterClass(hab,
968 WC_DIRCONTAINER,
969 DirClientWndProc,
970 CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
971 WinRegisterClass(hab,
972 WC_COLLECTOR,
973 CollectorClientWndProc,
974 CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
975 WinRegisterClass(hab,
976 WC_ARCCONTAINER,
977 ArcClientWndProc,
978 CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
979 WinRegisterClass(hab,
980 WC_MLEEDITOR,
981 MLEEditorProc,
982 CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
983 WinRegisterClass(hab,
984 WC_INIEDITOR,
985 IniProc,
986 CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID) * 2);
987 WinRegisterClass(hab,
988 WC_TOOLBACK,
989 ToolBackProc,
990 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
991 sizeof(PVOID));
992 WinRegisterClass(hab,
993 WC_DRIVEBACK,
994 DriveBackProc,
995 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
996 sizeof(PVOID));
997 WinRegisterClass(hab,
998 WC_SEEALL,
999 SeeAllWndProc,
1000 CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID));
1001 WinRegisterClass(hab,
1002 WC_NEWVIEW,
1003 ViewWndProc,
1004 CS_SIZEREDRAW | CS_CLIPCHILDREN, sizeof(PVOID));
1005 WinRegisterClass(hab,
1006 WC_TOOLBUTTONS,
1007 ChildButtonProc,
1008 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
1009 sizeof(PVOID));
1010 WinRegisterClass(hab,
1011 WC_DRIVEBUTTONS,
1012 DriveProc,
1013 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
1014 sizeof(PVOID));
1015 WinRegisterClass(hab,
1016 WC_BUBBLE,
1017 BubbleProc,
1018 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
1019 sizeof(ULONG) * 2);
1020 WinRegisterClass(hab,
1021 WC_STATUS,
1022 StatusProc,
1023 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
1024 sizeof(ULONG));
1025 WinRegisterClass(hab,
1026 WC_DIRSTATUS,
1027 DirTextProc,
1028 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
1029 sizeof(ULONG));
1030 WinRegisterClass(hab,
1031 WC_TREESTATUS,
1032 TreeStatProc,
1033 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
1034 sizeof(ULONG));
1035 WinRegisterClass(hab,
1036 WC_ARCSTATUS,
1037 ArcTextProc,
1038 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
1039 sizeof(ULONG));
1040 WinRegisterClass(hab,
1041 WC_COLSTATUS,
1042 CollectorTextProc,
1043 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
1044 sizeof(ULONG));
1045 WinRegisterClass(hab,
1046 WC_SEESTATUS,
1047 SeeStatusProc,
1048 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
1049 sizeof(ULONG));
1050 WinRegisterClass(hab,
1051 WC_VIEWSTATUS,
1052 ViewStatusProc,
1053 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
1054 sizeof(ULONG));
1055 WinRegisterClass(hab,
1056 WC_ERRORWND,
1057 NotifyWndProc,
1058 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
1059 sizeof(PVOID));
1060 WinRegisterClass(hab,
1061 WC_MINITIME,
1062 MiniTimeProc,
1063 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
1064 sizeof(PVOID) * 2);
1065 WinRegisterClass(hab,
1066 WC_DATABAR,
1067 DataProc, CS_SIZEREDRAW, sizeof(PVOID));
1068 WinRegisterClass(hab,
1069 WC_TREEOPENBUTTON,
1070 OpenButtonProc,
1071 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
1072 sizeof(PVOID));
1073 WinRegisterClass(hab,
1074 WC_AUTOVIEW,
1075 AutoViewProc,
1076 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
1077 sizeof(PVOID));
1078 WinRegisterClass(hab,
1079 WC_LED,
1080 LEDProc,
1081 CS_SYNCPAINT | CS_SIZEREDRAW | CS_PARENTCLIP,
1082 sizeof(PVOID));
1083
1084 if (DosCreateMutexSem(NULL, &hmtxFM2Globals, 0L, FALSE))
1085 Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
1086 PCSZ_DOSCREATEMUTEXSEM);
1087 if (DosCreateMutexSem(NULL, &hmtxFM2Delete, 0L, FALSE))
1088 Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
1089 PCSZ_DOSCREATEMUTEXSEM);
1090
1091 /*
1092 * set some defaults (note: everything else automatically initialized
1093 * to 0)
1094 */
1095 dsDirCnrDefault.detailssize = dsDirCnrDefault.detailsea = dsDirCnrDefault.detailslwdate =
1096 dsDirCnrDefault.detailslwtime = dsDirCnrDefault.detailsattr = dsDirCnrDefault.detailsicon =
1097 fAutoTile = fConfirmDelete = fLoadSubject = fUnHilite =
1098 fLoadLongnames = fToolbar = fSaveState = fGuessType = fToolbarHelp =
1099 fAutoAddDirs = fUseNewViewer = fDataToFore = fDataShowDrives =
1100 fSplitStatus = fDragndropDlg = fQuickArcFind = fKeepCmdLine =
1101 fMoreButtons = fDrivebar = fCollapseFirst = fSwitchTree =
1102 fSwitchTreeExpand = fNoSearch = fCustomFileDlg = fOtherHelp =
1103 fSaveMiniCmds = fUserComboBox = fFM2Deletes = fConfirmTarget =
1104 fShowTarget = fDrivebarHelp = fCheckMM = fInitialDriveScan =
1105 fEjectRemovableScan = fRScanLocal = TRUE;
1106 ulCnrType = CCS_EXTENDSEL;
1107 FilesToGet = FILESTOGET_MIN;
1108 MaxComLineStrg = MAXCOMLINESTRGDEFAULT;
1109 AutoviewHeight = 48;
1110 //strcpy(printer, "PRN");
1111 prnwidth = 80;
1112 prnlength = 66;
1113 prntmargin = 6;
1114 prnbmargin = 6;
1115 prnlmargin = 6;
1116 prnrmargin = 3;
1117 prnspacing = 1;
1118 prntabspaces = 8;
1119 CollectorsortFlags = sortFlags = SORT_DIRSFIRST;
1120 ullDATFileSpaceNeeded = 10000;
1121
1122 //Get default Country info
1123 {
1124 COUNTRYCODE Country = {0};
1125 ULONG ulInfoLen = 0;
1126 COUNTRYINFO CtryInfo = {0};
1127
1128 if (!DosQueryCtryInfo(sizeof(CtryInfo), &Country, &CtryInfo, &ulInfoLen)) {
1129 *ThousandsSeparator = CtryInfo.szThousandsSeparator[0];
1130 strcpy(DateSeparator, CtryInfo.szDateSeparator);
1131 strcpy(TimeSeparator, CtryInfo.szTimeSeparator);
1132 ulDateFmt = CtryInfo.fsDateFmt;
1133 ulTimeFmt = CtryInfo.fsTimeFmt;
1134 //DbgMsg(pszSrcFile, __LINE__, "Date Fmt %x", ulDateFmt);
1135 }
1136 else {
1137 strcpy(ThousandsSeparator, ",");
1138 strcpy(DateSeparator, "/");
1139 strcpy(TimeSeparator, ":");
1140 ulDateFmt = 0;
1141 ulTimeFmt = 0;
1142 }
1143 }
1144 { // Check for the existance of various partitioning tools to set up menu items
1145 CHAR *FullPath;
1146 ULONG ulAppType;
1147
1148 FullPath = searchapath(PCSZ_PATH, PCSZ_LVMGUICMD);
1149 if (*FullPath)
1150 fLVMGui = TRUE;
1151 if (!DosQueryAppType(PCSZ_DFSOS2EXE, &ulAppType))
1152 fDFSee = TRUE;
1153 if (!DosQueryAppType(PCSZ_MINILVMEXE, &ulAppType))
1154 fMiniLVM = TRUE;
1155 if (!DosQueryAppType(PCSZ_FDISKPMEXE, &ulAppType))
1156 fFDisk = TRUE;
1157 if (!DosQueryAppType(PCSZ_LVMEXE, &ulAppType))
1158 fLVM = TRUE;
1159
1160 // Check to see if we are running protect only
1161 if (!DosQueryAppType(GetCmdSpec(TRUE), &ulAppType)) {
1162 ret = runemf2(SEPARATE | WINDOWED | BACKGROUND | MINIMIZED,
1163 (HWND) 0, pszSrcFile, __LINE__, NULL, NULL,
1164 "%s /C exit", GetCmdSpec(TRUE));
1165 if (ret == ERROR_SMG_INVALID_PROGRAM_TYPE)
1166 fProtectOnly = TRUE;
1167 }
1168 else
1169 fProtectOnly = TRUE;
1170 }
1171
1172 // load preferences from profile (INI) file
1173 size = sizeof(ULONG);
1174 PrfQueryProfileData(fmprof, appname, "MaxComLineStrg", &MaxComLineStrg, &size);
1175 // Give user one chance to reset the default command line length to 1024 (4os2's unexpanded max)
1176 if (MaxComLineStrg == 2048) {
1177 BOOL MaxComLineChecked = FALSE;
1178
1179 size = sizeof(BOOL);
1180 PrfQueryProfileData(fmprof, appname, "MaxComLineChecked", &MaxComLineChecked, &size);
1181 if (!MaxComLineChecked) {
1182 ret = saymsg(MB_YESNO,
1183 HWND_DESKTOP,
1184 NullStr,
1185 GetPString(IDS_CHANGECMDLINELENGTHDEFAULT));
1186 if (ret == MBID_YES)
1187 MaxComLineStrg = 1024;
1188 MaxComLineChecked = TRUE;
1189 PrfWriteProfileData(fmprof, appname, "MaxComLineChecked", &MaxComLineChecked, sizeof(BOOL));
1190 }
1191 }
1192 if (MaxComLineStrg < CMDLNLNGTH_MIN)
1193 MaxComLineStrg = CMDLNLNGTH_MIN;
1194 else if (MaxComLineStrg > CMDLNLNGTH_MAX)
1195 MaxComLineStrg = CMDLNLNGTH_MAX;
1196 editor = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1197 if (!editor)
1198 return 0; //already complained
1199 viewer = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1200 if (!viewer)
1201 return 0; //already complained
1202 virus = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1203 if (!virus)
1204 return 0; //already complained
1205 compare = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1206 if (!compare)
1207 return 0; //already complained
1208 binview = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1209 if (!binview)
1210 return 0; //already complained
1211 bined = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1212 if (!bined)
1213 return 0; //already complained
1214 dircompare = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1215 if (!dircompare)
1216 return 0; //already complained
1217 ftprun = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1218 if (!ftprun)
1219 return 0; //already complained
1220 httprun = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1221 if (!httprun)
1222 return 0; //already complained
1223 mailrun = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1224 if (!mailrun)
1225 return 0; //already complained
1226 pszTreeEnvVarList = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1227 if (!pszTreeEnvVarList)
1228 return 0; //already complained
1229 size = sizeof(BOOL);
1230 PrfQueryProfileData(fmprof, appname, "ShowTarget", &fShowTarget, &size);
1231 size = sizeof(BOOL);
1232 PrfQueryProfileData(fmprof, appname, "CheckMM", &fCheckMM, &size);
1233 size = sizeof(BOOL);
1234 PrfQueryProfileData(fmprof, appname, "ChangeTarget", &fChangeTarget, &size);
1235 size = sizeof(BOOL);
1236 PrfQueryProfileData(fmprof, appname, "ConfirmTarget", &fConfirmTarget, &size);
1237 size = sizeof(BOOL);
1238 PrfQueryProfileData(fmprof, FM3Str, "CustomFileDlg", &fCustomFileDlg, &size);
1239 size = sizeof(BOOL);
1240 PrfQueryProfileData(fmprof, FM3Str, "SaveMiniCmds", &fSaveMiniCmds, &size);
1241 size = sizeof(BOOL);
1242 PrfQueryProfileData(fmprof, appname, "SaveBigCmds", &fSaveBigCmds, &size);
1243 size = sizeof(BOOL);
1244 PrfQueryProfileData(fmprof, appname, "NoFoldMenu", &fNoFoldMenu, &size);
1245 size = sizeof(BOOL);
1246 PrfQueryProfileData(fmprof, FM3Str, "ThreadNotes", &fThreadNotes, &size);
1247 size = sizeof(BOOL);
1248 PrfQueryProfileData(fmprof, FM3Str, "Prnpagenums", &prnpagenums, &size);
1249 size = sizeof(BOOL);
1250 PrfQueryProfileData(fmprof, FM3Str, "Prnalt", &prnalt, &size);
1251 size = sizeof(BOOL);
1252 PrfQueryProfileData(fmprof, FM3Str, "Prnformat", &prnformat, &size);
1253 size = sizeof(BOOL);
1254 PrfQueryProfileData(fmprof, FM3Str, "Prnformfeedbefore", &prnformfeedbefore, &size);
1255 size = sizeof(BOOL);
1256 PrfQueryProfileData(fmprof, FM3Str, "Prnformfeedafter",&prnformfeedafter, &size);
1257 size = sizeof(ULONG);
1258 PrfQueryProfileData(fmprof, FM3Str, "Prntabspaces", &prntabspaces, &size);
1259 size = sizeof(ULONG);
1260 PrfQueryProfileData(fmprof, FM3Str, "Prnwidth", &prnwidth, &size);
1261 size = sizeof(ULONG);
1262 PrfQueryProfileData(fmprof, FM3Str, "Prnlength", &prnlength, &size);
1263 size = sizeof(ULONG);
1264 PrfQueryProfileData(fmprof, FM3Str, "Prntmargin", &prntmargin, &size);
1265 size = sizeof(ULONG);
1266 PrfQueryProfileData(fmprof, FM3Str, "Prnbmargin", &prnbmargin, &size);
1267 size = sizeof(ULONG);
1268 PrfQueryProfileData(fmprof, FM3Str, "Prnlmargin", &prnlmargin, &size);
1269 size = sizeof(ULONG);
1270 PrfQueryProfileData(fmprof, FM3Str, "Prnrmargin", &prnrmargin, &size);
1271 size = sizeof(ULONG);
1272 PrfQueryProfileData(fmprof, FM3Str, "Prnspacing", &prnspacing, &size);
1273 size = sizeof(BOOL);
1274 PrfQueryProfileData(fmprof, FM3Str, "NoDead", &fNoDead, &size);
1275 size = sizeof(BOOL);
1276 PrfQueryProfileData(fmprof, FM3Str, "NoFinger", &fNoFinger, &size);
1277 size = sizeof(BOOL);
1278 PrfQueryProfileData(fmprof, FM3Str, "AlertBeepOff", &fAlertBeepOff, &size);
1279 size = sizeof(BOOL);
1280 PrfQueryProfileData(fmprof, FM3Str, "ErrorBeepOff", &fErrorBeepOff, &size);
1281 size = sizeof(BOOL);
1282 PrfQueryProfileData(fmprof, appname, "SwitchTree", &fSwitchTree, &size);
1283 size = sizeof(BOOL);
1284 PrfQueryProfileData(fmprof, appname, "SwitchTreeExpand", &fSwitchTreeExpand, &size);
1285 size = sizeof(BOOL);
1286 PrfQueryProfileData(fmprof, appname, "SwitchTreeOnFocus", &fSwitchTreeOnFocus, &size);
1287 size = sizeof(BOOL);
1288 PrfQueryProfileData(fmprof, appname, "CollapseFirst", &fCollapseFirst, &size);
1289 size = sizeof(BOOL);
1290 PrfQueryProfileData(fmprof, appname, "FilesInTree", &fFilesInTree, &size);
1291 size = sizeof(BOOL);
1292 PrfQueryProfileData(fmprof, FM3Str, "TopDir", &fTopDir, &size);
1293 size = sizeof(BOOL);
1294 PrfQueryProfileData(fmprof, FM3Str, "LookInDir", &fLookInDir, &size);
1295 PrfQueryProfileString(fmprof, appname, "DefArc", NULL, szDefArc, sizeof(szDefArc));
1296 size = sizeof(ULONG);
1297 PrfQueryProfileData(fmprof, FM3Str, "AutoviewHeight",
1298 &AutoviewHeight, &size);
1299 size = sizeof(BOOL);
1300 PrfQueryProfileData(fmprof, FM3Str, "KeepCmdLine", &fKeepCmdLine, &size);
1301 if (strcmp(realappname, "FM/4")) {
1302 size = sizeof(BOOL);
1303 PrfQueryProfileData(fmprof, FM3Str, "MoreButtons", &fMoreButtons, &size);
1304 size = sizeof(BOOL);
1305 PrfQueryProfileData(fmprof, FM3Str, "Drivebar", &fDrivebar, &size);
1306 }
1307 else
1308 fDrivebar = fMoreButtons = TRUE;
1309 size = sizeof(BOOL);
1310 PrfQueryProfileData(fmprof, appname, "NoSearch", &fNoSearch, &size);
1311 size = sizeof(BOOL);
1312 PrfQueryProfileData(fmprof, appname, "GuessType", &fGuessType, &size);
1313 size = sizeof(BOOL);
1314 PrfQueryProfileData(fmprof, appname, "ViewChild", &fViewChild, &size);
1315 size = sizeof(BOOL);
1316 PrfQueryProfileData(fmprof, appname, "ShowEnv", &fShowEnv, &size);
1317 PrfQueryProfileString(fmprof, appname, "TreeEnvVarList", "PATH;DPATH;LIBPATH;HELP;BOOKSHELF;",
1318 pszTreeEnvVarList, MaxComLineStrg);
1319 size = sizeof(BOOL);
1320 PrfQueryProfileData(fmprof, FM3Str, "ShowDriveOnly", &fShowDriveOnly, &size);
1321 size = sizeof(BOOL);
1322 PrfQueryProfileData(fmprof, FM3Str, "ShowFSTypeInTree", &fShowFSTypeInTree, &size);
1323 size = sizeof(BOOL);
1324 PrfQueryProfileData(fmprof, FM3Str, "ShowDriveLabelInTree", &fShowDriveLabelInTree, &size);
1325 if (!fShowDriveOnly && !fShowFSTypeInTree && !fShowDriveLabelInTree)
1326 fShowDriveOnly = TRUE;
1327 size = sizeof(BOOL);
1328 PrfQueryProfileData(fmprof, appname, "LeaveTree", &fLeaveTree, &size);
1329 size = sizeof(BOOL);
1330 PrfQueryProfileData(fmprof, FM3Str, "Comments", &fComments, &size);
1331 size = sizeof(ULONG);
1332 PrfQueryProfileData(fmprof, appname, "WS_ANIMATE", &fwsAnimate, &size);
1333 if (fwsAnimate)
1334 fwsAnimate = WS_ANIMATE;
1335 size = sizeof(BOOL);
1336 PrfQueryProfileData(fmprof, appname, "SelectedAlways", &fSelectedAlways, &size);
1337 size = sizeof(BOOL);
1338 PrfQueryProfileData(fmprof, FM3Str, "ToolbarHelp", &fToolbarHelp, &size);
1339 size = sizeof(BOOL);
1340 PrfQueryProfileData(fmprof, FM3Str, "OtherHelp", &fOtherHelp, &size);
1341 size = sizeof(BOOL);
1342 PrfQueryProfileData(fmprof, FM3Str, "DrivebarHelp", &fDrivebarHelp, &size);
1343 size = sizeof(BOOL);
1344 PrfQueryProfileData(fmprof, appname, "AutoAddDirs", &fAutoAddDirs, &size);
1345 size = sizeof(BOOL);
1346 PrfQueryProfileData(fmprof, appname, "AutoAddAllDirs", &fAutoAddAllDirs, &size);
1347 size = sizeof(BOOL);
1348 PrfQueryProfileData(fmprof, FM3Str, "UserListSwitches", &fUserListSwitches, &size);
1349 size = sizeof(BOOL);
1350 PrfQueryProfileData(fmprof, appname, "UseNewViewer", &fUseNewViewer, &size);
1351 size = sizeof(BOOL);
1352 PrfQueryProfileData(fmprof, appname, "DefaultDeletePerm", &fDefaultDeletePerm, &size);
1353 size = sizeof(BOOL);
1354 PrfQueryProfileData(fmprof, FM3Str, "ExternalINIs", &fExternalINIs, &size);
1355 size = sizeof(BOOL);
1356 PrfQueryProfileData(fmprof, FM3Str, "ExternalCollector", &fExternalCollector, &size);
1357 size = sizeof(BOOL);
1358 PrfQueryProfileData(fmprof, FM3Str, "ExternalArcboxes", &fExternalArcboxes, &size);
1359 size = sizeof(BOOL);
1360 PrfQueryProfileData(fmprof, FM3Str, "ExternalViewer", &fExternalViewer, &size);
1361 size = sizeof(BOOL);
1362 PrfQueryProfileData(fmprof, FM3Str, "UseQProcStat", &fUseQProcStat, &size);
1363 size = sizeof(BOOL);
1364 PrfQueryProfileData(fmprof, FM3Str, "UseQSysState", &fUseQSysState, &size);
1365 size = sizeof(BOOL);
1366 PrfQueryProfileData(fmprof, FM3Str, "DataMin", &fDataMin, &size);
1367 size = sizeof(BOOL);
1368 PrfQueryProfileData(fmprof, appname, "DataToFore", &fDataToFore, &size);
1369 size = sizeof(BOOL);
1370 PrfQueryProfileData(fmprof, appname, "DataShowDrives", &fDataShowDrives, &size);
1371 size = sizeof(BOOL);
1372 PrfQueryProfileData(fmprof, appname, "DataInclRemote", &fDataInclRemote, &size);
1373 size = sizeof(BOOL);
1374 PrfQueryProfileData(fmprof, FM3Str, "SplitStatus", &fSplitStatus, &size);
1375 size = sizeof(BOOL);
1376 PrfQueryProfileData(fmprof, appname, "FolderAfterExtract", &fFolderAfterExtract, &size);
1377 size = sizeof(BOOL);
1378 PrfQueryProfileData(fmprof, FM3Str, "DullDatabar", &fDullMin, &size);
1379 size = sizeof(BOOL);
1380 PrfQueryProfileData(fmprof, appname, "BlueLED", &fBlueLED, &size);
1381 size = sizeof(BOOL);
1382 PrfQueryProfileData(fmprof, appname, "ConfirmDelete", &fConfirmDelete, &size);
1383 /*size = sizeof(BOOL); Replaced by UM_SHOWME check 3/14/09 GKY
1384 PrfQueryProfileData(fmprof, FM3Str, "SaveState", &fSaveState, &size);
1385 if (fSaveState && (fSwitchTreeOnFocus || fSwitchTree) &&
1386 (!strcmp(realappname, FM3Str) || !strcmp(realappname, "FM/4"))) {
1387 CHAR szKey[STATE_NAME_MAX_BYTES + 80];
1388 CHAR szDir[CCHMAXPATH];
1389 ULONG drvNum;
1390
1391 if (!strcmp(realappname, "FM/4"))
1392 strcpy(szKey, "FM/4 Dir1");
1393 else
1394 sprintf(szKey, "%s.DirCnrDir.0", PCSZ_SHUTDOWNSTATE);
1395 size = sizeof(szDir);
1396 if (PrfQueryProfileData(fmprof, appname, szKey, szDir, &size)) {
1397 drvNum = toupper(*szDir) - 'A';
1398 fDrivetoSkip[drvNum] = TRUE;
1399 }
1400 } */
1401 size = sizeof(BOOL);
1402 PrfQueryProfileData(fmprof, appname, "SyncUpdates", &fSyncUpdates, &size);
1403 size = sizeof(BOOL);
1404 PrfQueryProfileData(fmprof, appname, "LoadSubject", &fLoadSubject, &size);
1405 size = sizeof(BOOL);
1406 PrfQueryProfileData(fmprof, appname, "UnHilite", &fUnHilite, &size);
1407 size = sizeof(BOOL);
1408 PrfQueryProfileData(fmprof, FM3Str, "TileBackwards", &fTileBackwards, &size);
1409 size = sizeof(BOOL);
1410 PrfQueryProfileData(fmprof, appname, "LoadLongname", &fLoadLongnames, &size);
1411 size = sizeof(BOOL);
1412 PrfQueryProfileData(fmprof, appname, "VerifyWrites", &fVerify, &size);
1413 DosSetVerify(fVerify);
1414 size = sizeof(BOOL);
1415 PrfQueryProfileData(fmprof, appname, "DontMoveMouse", &fDontMoveMouse, &size);
1416 size = sizeof(BOOL);
1417 PrfQueryProfileData(fmprof, appname, "NoIconsFiles", &fNoIconsFiles, &size);
1418 size = sizeof(BOOL);
1419 PrfQueryProfileData(fmprof, appname, "NoIconsDirs", &fNoIconsDirs, &size);
1420 size = sizeof(BOOL);
1421 PrfQueryProfileData(fmprof, appname, "ForceUpper", &fForceUpper, &size);
1422 size = sizeof(BOOL);
1423 PrfQueryProfileData(fmprof, appname, "ForceLower", &fForceLower, &size);
1424 size = sizeof(BOOL);
1425 PrfQueryProfileData(fmprof, FM3Str, "TextTools", &fTextTools, &size);
1426 size = sizeof(BOOL);
1427 PrfQueryProfileData(fmprof, FM3Str, "ToolTitles", &fToolTitles, &size);
1428 size = sizeof(BOOL);
1429 PrfQueryProfileData(fmprof, appname, "DoubleClickOpens", &fDCOpens, &size);
1430 size = sizeof(BOOL);
1431 PrfQueryProfileData(fmprof, appname, "LinkSetsIcon", &fLinkSetsIcon, &size);
1432 size = sizeof(INT);
1433 PrfQueryProfileData(fmprof, appname, "Sort", &sortFlags, &size);
1434 size = sizeof(INT);
1435 PrfQueryProfileData(fmprof, appname, "TreeSort", &TreesortFlags, &size);
1436 size = sizeof(INT);
1437 PrfQueryProfileData(fmprof, appname, "CollectorSort", &CollectorsortFlags, &size);
1438 PrfQueryProfileString(fmprof, appname, "Targetdir", NULL, targetdir, sizeof(targetdir));
1439 if (!IsValidDir(targetdir))
1440 *targetdir = 0;
1441 PrfQueryProfileString(fmprof, appname, "ExtractPath", NULL, extractpath, sizeof(extractpath));
1442 size = sizeof(BOOL);
1443 PrfQueryProfileData(fmprof, FM3Str, "FileNamePathCnr", &fFileNameCnrPath, &size);
1444 PrfQueryProfileString(fmprof, appname, "Printer", "PRN", printer, sizeof(printer));
1445 PrfQueryProfileString(fmprof, appname, "DirCompare", NULL, dircompare, MaxComLineStrg);
1446 PrfQueryProfileString(fmprof, appname, "Viewer", NULL, viewer, MaxComLineStrg);
1447 PrfQueryProfileString(fmprof, appname, "Editor", NULL, editor, MaxComLineStrg);
1448 PrfQueryProfileString(fmprof, appname, "BinView", NULL, binview, MaxComLineStrg);
1449 PrfQueryProfileString(fmprof, appname, "BinEd", NULL, bined, MaxComLineStrg);
1450 PrfQueryProfileString(fmprof, appname, "Compare", NULL, compare, MaxComLineStrg);
1451 PrfQueryProfileString(fmprof, appname, "Virus", NULL, virus, MaxComLineStrg);
1452 size = sizeof(BOOL);
1453 PrfQueryProfileData(fmprof, appname, "FtpRunWPSDefault", &fFtpRunWPSDefault, &size);
1454 PrfQueryProfileString(fmprof, appname, "FTPRun", NULL, ftprun, MaxComLineStrg);
1455 if (!*ftprun)
1456 fFtpRunWPSDefault = TRUE;
1457 size = sizeof(BOOL);
1458 PrfQueryProfileData(fmprof, appname, "HttpRunWPSDefault", &fHttpRunWPSDefault, &size);
1459 PrfQueryProfileString(fmprof, appname, "HTTPRun", NULL, httprun, MaxComLineStrg);
1460 if (!*httprun)
1461 fHttpRunWPSDefault = TRUE;
1462 PrfQueryProfileString(fmprof, appname, "MailRun", NULL, mailrun, MaxComLineStrg);
1463 PrfQueryProfileString(fmprof, appname, "FtpRunDir", NULL, ftprundir, sizeof(ftprundir));
1464 PrfQueryProfileString(fmprof, appname, "HttpRunDir", NULL, httprundir, sizeof(httprundir));
1465 PrfQueryProfileString(fmprof, appname, "MailRunDir", NULL, mailrundir, sizeof(mailrundir));
1466 PrfQueryProfileString(fmprof, appname, "LastToolbar", NULL, lasttoolbar, sizeof(lasttoolbar));
1467 size = sizeof(BOOL);
1468 PrfQueryProfileData(fmprof, appname, "LibPathStrictHttpRun", &fLibPathStrictHttpRun, &size);
1469 size = sizeof(BOOL);
1470 PrfQueryProfileData(fmprof, appname, "LibPathStrictFtpRun", &fLibPathStrictFtpRun, &size);
1471 size = sizeof(BOOL);
1472 PrfQueryProfileData(fmprof, appname, "LibPathStrictMailRun", &fLibPathStrictMailRun, &size);
1473 size = sizeof(BOOL);
1474 PrfQueryProfileData(fmprof, appname, "NoMailtoMailRun", &fNoMailtoMailRun, &size);
1475 size = sizeof(BOOL);
1476 PrfQueryProfileData(fmprof, appname, "FollowTree", &fFollowTree, &size);
1477 size = sizeof(BOOL);
1478 PrfQueryProfileData(fmprof, appname, "StartMaximized", &fStartMaximized, &size);
1479 if (!fStartMaximized) {
1480 size = sizeof(BOOL);
1481 PrfQueryProfileData(fmprof, appname, "StartMinimized", &fStartMinimized, &size);
1482 }
1483 size = sizeof(BOOL);
1484 PrfQueryProfileData(fmprof, appname, "DefaultCopy", &fCopyDefault, &size);
1485 size = sizeof(BOOL);
1486 PrfQueryProfileData(fmprof, appname, "IdleCopy", &fRealIdle, &size);
1487 size = sizeof(BOOL);
1488 PrfQueryProfileData(fmprof, appname, "ArcStuffVisible", &fArcStuffVisible, &size);
1489 size = sizeof(BOOL);
1490 PrfQueryProfileData(fmprof, FM3Str, "NoTreeGap", &fNoTreeGap, &size);
1491 size = sizeof(BOOL);
1492 PrfQueryProfileData(fmprof, FM3Str, "VTreeOpensWPS", &fVTreeOpensWPS, &size);
1493 size = sizeof(BOOL);
1494 PrfQueryProfileData(fmprof, appname, "RemoteBug", &fRemoteBug, &size);
1495 size = sizeof(BOOL);
1496 PrfQueryProfileData(fmprof, appname, "RScanLocal", &fRScanLocal, &size);
1497 size = sizeof(BOOL);
1498 PrfQueryProfileData(fmprof, appname, "RScanRemote", &fRScanRemote, &size);
1499 size = sizeof(BOOL);
1500 PrfQueryProfileData(fmprof, appname, "RScanVirtual", &fRScanVirtual, &size);
1501 size = sizeof(BOOL);
1502 PrfQueryProfileData(fmprof, appname, "RScanSlow", &fRScanSlow, &size);
1503 size = sizeof(BOOL);
1504 PrfQueryProfileData(fmprof, appname, "RScanNoWrite", &fRScanNoWrite, &size);
1505 size = sizeof(BOOL);
1506 PrfQueryProfileData(fmprof, appname, "EjectRemovableScan", &fEjectRemovableScan, &size);
1507 size = sizeof(BOOL);
1508 PrfQueryProfileData(fmprof, appname, "EjectCDScan", &fEjectCDScan, &size);
1509 size = sizeof(BOOL);
1510 PrfQueryProfileData(fmprof, appname, "EjectFlpyScan", &fEjectFlpyScan, &size);
1511 size = sizeof(BOOL);
1512 PrfQueryProfileData(fmprof, appname, "Drag&DropDlg", &fDragndropDlg, &size);
1513 size = sizeof(BOOL);
1514 PrfQueryProfileData(fmprof, FM3Str, "UserComboBox", &fUserComboBox, &size);
1515 size = sizeof(BOOL);
1516 PrfQueryProfileData(fmprof, FM3Str, "MinDirOnOpen", &fMinOnOpen, &size);
1517 size = sizeof(BOOL);
1518 PrfQueryProfileData(fmprof, appname, "QuickArcFind", &fQuickArcFind, &size);
1519 size = sizeof(BOOL);
1520 PrfQueryProfileData(fmprof, FM3Str, "NoRemovableScan", &fNoRemovableScan, &size);
1521 size = sizeof(ULONG);
1522 PrfQueryProfileData(fmprof, FM3Str, "NoBrokenNotify", &NoBrokenNotify, &size);
1523 size = sizeof(ULONG);
1524 PrfQueryProfileData(fmprof, appname, "ContainerType", &ulCnrType, &size);
1525 size = sizeof(ULONG);
1526 PrfQueryProfileData(fmprof, appname, "FilesToGet", &FilesToGet, &size);
1527 if (FilesToGet < FILESTOGET_MIN)
1528 FilesToGet = FILESTOGET_MIN;
1529 else if (FilesToGet > FILESTOGET_MAX)
1530 FilesToGet = FILESTOGET_MAX;
1531 size = sizeof(BOOL);
1532 PrfQueryProfileData(fmprof, FM3Str, "AutoView", &fAutoView, &size);
1533 size = sizeof(BOOL);
1534 PrfQueryProfileData(fmprof, FM3Str, "FM2Deletes", &fFM2Deletes, &size);
1535 size = sizeof(BOOL);
1536 PrfQueryProfileData(fmprof, FM3Str, "TrashCan", &fTrashCan, &size);
1537
1538 LoadDetailsSwitches(PCSZ_DIRCNR, &dsDirCnrDefault, FALSE);
1539
1540 /* load pointers and icons we use */
1541 hptrArrow = WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW, FALSE);
1542 hptrBusy = WinQuerySysPointer(HWND_DESKTOP, SPTR_WAIT, FALSE);
1543 hptrNS = WinQuerySysPointer(HWND_DESKTOP, SPTR_SIZENS, FALSE);
1544 hptrEW = WinQuerySysPointer(HWND_DESKTOP, SPTR_SIZEWE, FALSE);
1545 hptrFloppy = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, FLOPPY_ICON);
1546 hptrDrive = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, DRIVE_ICON);
1547 hptrRemovable = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, REMOVABLE_ICON);
1548 hptrCDROM = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, CDROM_ICON);
1549 hptrFile = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, FILE_ICON);
1550 hptrDir = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, DIR_FRAME);
1551 hptrArc = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, ARC_FRAME);
1552 hptrArt = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, ART_ICON);
1553 hptrSystem = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, FILE_SYSTEM_ICON);
1554 hptrHidden = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, FILE_HIDDEN_ICON);
1555 hptrReadonly = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, FILE_READONLY_ICON);
1556 hptrLast = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, LASTITEM_ICON);
1557 hptrRemote = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, REMOTE_ICON);
1558 hptrVirtual = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, VIRTUAL_ICON);
1559 hptrRamdisk = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, RAMDISK_ICON);
1560 if (!fNoDead)
1561 hptrFinger = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, FINGER_ICON);
1562 else
1563 hptrFinger = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, FINGER2_ICON);
1564 hptrApp = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, APP_ICON);
1565 hptrDunno = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, DUNNO_ICON);
1566 hptrEnv = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, ENV_ICON);
1567 hptrZipstrm = WinLoadPointer(HWND_DESKTOP, FM3ModHandle, ZIPSTREAM_ICON);
1568
1569 // set up color array used by seeall.c and newview.c color dialog
1570
1571 standardcolors[0] = CLR_WHITE;
1572 standardcolors[1] = CLR_BLACK;
1573 standardcolors[2] = CLR_BLUE;
1574 standardcolors[3] = CLR_RED;
1575 standardcolors[4] = CLR_PINK;
1576 standardcolors[5] = CLR_GREEN;
1577 standardcolors[6] = CLR_CYAN;
1578 standardcolors[7] = CLR_YELLOW;
1579 standardcolors[8] = CLR_DARKGRAY;
1580 standardcolors[9] = CLR_DARKBLUE;
1581 standardcolors[10] = CLR_DARKRED;
1582 standardcolors[11] = CLR_DARKPINK;
1583 standardcolors[12] = CLR_DARKGREEN;
1584 standardcolors[13] = CLR_DARKCYAN;
1585 standardcolors[14] = CLR_BROWN;
1586 standardcolors[15] = CLR_PALEGRAY;
1587
1588 return TRUE;
1589}
1590
1591HWND StartFM3(HAB hab, INT argc, CHAR ** argv)
1592{
1593 HWND hwndFrame;
1594 HWND hwndClient;
1595 UINT x;
1596 ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
1597 FCF_SIZEBORDER | FCF_MINMAX |
1598 FCF_ACCELTABLE | FCF_MENU | FCF_ICON | FCF_TASKLIST | FCF_NOBYTEALIGN;
1599
1600 for (x = 1; x < argc; x++) {
1601 if (*argv[x] == '~' && !argv[x][1])
1602 fReminimize = TRUE;
1603 if (*argv[x] == '+' && !argv[x][1])
1604 fLogFile = TRUE;
1605 if (*argv[x] == '-') {
1606 if (!argv[x][1])
1607 fNoSaveState = TRUE;
1608 else
1609 strcpy(profile, &argv[x][1]);
1610 }
1611 }
1612
1613 hwndFrame = WinCreateStdWindow(HWND_DESKTOP,
1614 WS_VISIBLE,
1615 &FrameFlags,
1616 WC_MAINWND,
1617 NULL,
1618 WS_VISIBLE | WS_ANIMATE,
1619 FM3ModHandle, MAIN_FRAME, &hwndClient);
1620 if (hwndFrame) {
1621 WinSetWindowUShort(hwndFrame, QWS_ID, MAIN_FRAME);
1622 hwndMainMenu = WinWindowFromID(hwndFrame, FID_MENU);
1623 if (!WinRestoreWindowPos(FM2Str, "MainWindowPos", hwndFrame)) {
1624
1625 ULONG fl = SWP_MOVE | SWP_SIZE;
1626 RECTL rcl;
1627 ULONG icz = WinQuerySysValue(HWND_DESKTOP, SV_CYICON) * 3L;
1628 ULONG bsz = WinQuerySysValue(HWND_DESKTOP, SV_CYSIZEBORDER);
1629
1630 WinQueryWindowRect(HWND_DESKTOP, &rcl);
1631 rcl.yBottom += icz;
1632 rcl.yTop -= bsz;
1633 rcl.xLeft += bsz;
1634 rcl.xRight -= bsz;
1635 WinSetWindowPos(hwndFrame,
1636 HWND_TOP,
1637 rcl.xLeft,
1638 rcl.yBottom,
1639 rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom, fl);
1640 }
1641 if (fLogFile)
1642 LogFileHandle = _fsopen("FM2.LOG", "a+", SH_DENYWR);
1643 if (hwndHelp)
1644 WinAssociateHelpInstance(hwndHelp, hwndFrame);
1645 PostMsg(hwndClient, UM_SETUP, MPFROMLONG(argc), MPFROMP(argv));
1646 }
1647 return hwndFrame;
1648}
1649
1650BOOL CheckFileHeader(CHAR *filespec, CHAR *signature, LONG offset)
1651{
1652 HFILE handle;
1653 ULONG action;
1654 ULONG len = strlen(signature);
1655 ULONG l;
1656 CHAR buffer[4096]; // 06 Oct 07 SHL Protect against NTFS defect
1657 BOOL ret = FALSE;
1658
1659 DosError(FERR_DISABLEHARDERR);
1660 if (DosOpen(filespec,
1661 &handle,
1662 &action,
1663 0,
1664 0,
1665 OPEN_ACTION_FAIL_IF_NEW |
1666 OPEN_ACTION_OPEN_IF_EXISTS,
1667 OPEN_FLAGS_FAIL_ON_ERROR |
1668 OPEN_FLAGS_NOINHERIT |
1669 OPEN_FLAGS_RANDOMSEQUENTIAL |
1670 OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY, 0))
1671 ret = FALSE;
1672 else {
1673 // Try signature match
1674 l = len;
1675 l = min(l, 79);
1676 if (!DosChgFilePtr(handle,
1677 abs(offset),
1678 (offset >= 0) ?
1679 FILE_BEGIN : FILE_END, &len)) {
1680 if (!DosRead(handle, buffer, l, &len) && len == l) {
1681 if (!memcmp(signature, buffer, l))
1682 ret = TRUE; // Matched
1683 }
1684 }
1685 }
1686 DosClose(handle); /* Either way, we're done for now */
1687 return ret; /* Return TRUE if matched */
1688}
1689
1690int CheckVersion(int vermajor, int verminor)
1691{
1692 int ok = 0;
1693
1694 // fixme to do useful check - was missing in base source
1695
1696#if 0
1697 if (vermajor && verminor) {
1698 *vermajor = VERMAJOR;
1699 *verminor = VERMINOR;
1700 ok = 1;
1701 }
1702#endif
1703
1704 ok = 1;
1705
1706 return ok;
1707}
1708
1709#ifdef __WATCOMC__
1710#pragma alloc_text(INIT,LibMain,InitFM3DLL,DeInitFM3DLL)
1711#pragma alloc_text(INIT1,StartFM3,FindSwapperDat)
1712#endif
Note: See TracBrowser for help on using the repository browser.