/*********************************************************************** $Id: misc.c 552 2007-03-01 06:24:47Z gyoung $ Misc GUI support functions Copyright (c) 1993-98 M. Kimes Copyright (c) 2003, 2007 Steven H. Levine 11 Jun 03 SHL Add JFS and FAT32 support 01 Aug 04 SHL Rework lstrip/rstrip usage 01 Aug 04 SHL LoadLibPath: avoid buffer overflow 07 Jun 05 SHL Drop obsoletes 24 Jul 05 SHL Beautify 24 Jul 05 SHL Correct longname display option 17 Jul 06 SHL Use Runtime_Error 26 Jul 06 SHL Use chop_at_crnl 27 Jul 06 SHL Comments, apply indent 29 Jul 06 SHL Use xfgets_bstripcr 16 Aug 06 SHL Comments 31 Aug 06 SHL disable_menuitem: rework args to match name - sheesh 10 Oct 06 GKY Add NDFS32 support 18 Feb 07 GKY More drive type and drive icon support ***********************************************************************/ #define INCL_DOS #define INCL_WIN #define INCL_GPI #include #include #include #include #include #include #include #include "fm3dll.h" #include "fm3dlg.h" #include "fm3str.h" #pragma data_seg(DATA1) static PSZ pszSrcFile = __FILE__; #pragma alloc_text(MAINWND5,SetSysMenu) #pragma alloc_text(MISC1,BoxWindow,PaintRecessedWindow,PostMsg,PaintSTextWindow) #pragma alloc_text(MISC1,FixSwitchList,FindDirCnr,CurrentRecord,SetShiftState,AddToListboxBottom) #pragma alloc_text(CNR_MISC1,AdjustCnrColVis,AdjustCnrColsForFSType) #pragma alloc_text(CNR_MISC1,AdjustCnrColsForPref,SetCnrCols) #pragma alloc_text(CNR_MISC2,CnrDirectEdit,EmptyCnr,OpenEdit) #pragma alloc_text(MISC2,SetMenuCheck,disable_menuitem,SetSortChecks) #pragma alloc_text(MISC2,SetDetailsSwitches,SetViewMenu) #pragma alloc_text(MISC3,SetupCommandMenu,AdjustDetailsSwitches) #pragma alloc_text(MISC3,ViewHelp,GetCmdSpec) #pragma alloc_text(MISC3,ExecFile,SetConditionalCascade,LoadDetailsSwitches) #pragma alloc_text(MISC3,FreeMallocedMem,FcloseFile) #pragma alloc_text(MISC4,PortholeInit,CheckMenu,Broadcast,SetupWinList,SwitchCommand) #pragma alloc_text(MISC6,DrawTargetEmphasis,EmphasizeButton) #pragma alloc_text(MISC_LIBPATH,LoadLibPath) #pragma alloc_text(MISC_SAY,SayView,SaySort,SayFilter) #ifndef BEGIN_LIBPATH #define BEGIN_LIBPATH 1 #endif #ifndef END_LIBPATH #define END_LIBPATH 2 #endif #ifndef ORD_DOS32QUERYEXTLIBPATH #define ORD_DOS32QUERYEXTLIBPATH 874 #endif VOID SetShiftState(VOID) { shiftstate = 0; if (WinGetKeyState(HWND_DESKTOP, VK_CTRL) & 0x8000) shiftstate |= KC_CTRL; if (WinGetKeyState(HWND_DESKTOP, VK_SHIFT) & 0x8000) shiftstate |= KC_SHIFT; if (WinGetKeyState(HWND_DESKTOP, VK_ALT) & 0x8000) shiftstate |= KC_ALT; } void EmphasizeButton(HWND hwnd, BOOL on) { HPS hps = DrgGetPS(hwnd); // fixme to complain? if (hps) { POINTL ptl; SWP swp; WinQueryWindowPos(hwnd, &swp); ptl.x = 1; ptl.y = 1; GpiMove(hps, &ptl); GpiSetColor(hps, ((on) ? CLR_BLACK : CLR_PALEGRAY)); ptl.x = swp.cx - 2; ptl.y = swp.cy - 2; GpiBox(hps, DRO_OUTLINE, &ptl, 0, 0); DrgReleasePS(hps); if (remove) //fixme always true WinInvalidateRect(hwnd, NULL, FALSE); } } void DrawTargetEmphasis(HWND hwnd, BOOL on) { HPS hps = DrgGetPS(WinQueryWindow(hwnd, QW_PARENT)); if (hps) { BoxWindow(hwnd, hps, ((on) ? CLR_BLACK : CLR_PALEGRAY)); DrgReleasePS(hps); } } void BoxWindow(HWND hwnd, HPS hps, LONG color) { POINTL ptl; SWP swp; BOOL releaseme = FALSE; if (!hps) { hps = WinGetPS(WinQueryWindow(hwnd, QW_PARENT)); releaseme = TRUE; } if (hps && WinQueryWindowPos(hwnd, &swp)) { ptl.x = swp.x - 2; ptl.y = swp.y - 2; GpiMove(hps, &ptl); GpiSetColor(hps, color); ptl.x = swp.x + swp.cx + 1; ptl.y = swp.y + swp.cy + 1; GpiBox(hps, DRO_OUTLINE, &ptl, 0, 0); } if (releaseme && hps) WinReleasePS(hps); } void PaintSTextWindow(HWND hwnd, HPS hps) { /* * paint a text window such that the rightmost part of the text is * always visible even if the text length exceeds the length of the * window -- otherwise, paint the window so that it is left-justified * and vertically centered. */ char *s = NULL; long len; POINTL aptl[TXTBOX_COUNT], ptl; RECTL rcl; char *p; BOOL releaseme = FALSE; if (!hps) { releaseme = TRUE; hps = WinGetPS(hwnd); } if (hps) { WinQueryWindowRect(hwnd, &rcl); WinFillRect(hps, &rcl, CLR_PALEGRAY); len = WinQueryWindowTextLength(hwnd); if (len) s = xmalloc(len + 1, pszSrcFile, __LINE__); if (s) { *s = 0; WinQueryWindowText(hwnd, CCHMAXPATH, s); if (*s) { rcl.xRight -= 3; p = s; GpiQueryTextBox(hps, 3, "...", TXTBOX_COUNT, aptl); len = aptl[TXTBOX_TOPRIGHT].x; do { GpiQueryTextBox(hps, strlen(p), p, TXTBOX_COUNT, aptl); if (aptl[TXTBOX_TOPRIGHT].x > (rcl.xRight - ((p != s) ? len : 0))) p++; else break; } while (*p); if (*p) { GpiSetMix(hps, FM_OVERPAINT); GpiSetColor(hps, CLR_BLACK); ptl.x = 3; ptl.y = ((rcl.yTop / 2) - ((aptl[TXTBOX_TOPRIGHT].y + aptl[TXTBOX_BOTTOMLEFT].y) / 2)); GpiMove(hps, &ptl); if (p != s) GpiCharString(hps, 3, "..."); GpiCharString(hps, strlen(p), p); } } free(s); } if (releaseme) WinReleasePS(hps); } } VOID PaintRecessedWindow(HWND hwnd, HPS hps, BOOL outtie, BOOL dbl) { /* * paint a recessed box around the window * two pixels width required around window for painting... */ BOOL releaseme = FALSE; if (!hps) { hps = WinGetPS(WinQueryWindow(hwnd, QW_PARENT)); releaseme = TRUE; } if (hps) { POINTL ptl; SWP swp; WinQueryWindowPos(hwnd, &swp); ptl.x = swp.x - 1; ptl.y = swp.y - 1; GpiMove(hps, &ptl); if (!outtie) GpiSetColor(hps, CLR_WHITE); else GpiSetColor(hps, CLR_DARKGRAY); ptl.x = swp.x + swp.cx; GpiLine(hps, &ptl); ptl.y = swp.y + swp.cy; GpiLine(hps, &ptl); if (dbl) { ptl.x = swp.x - 2; ptl.y = swp.y - 2; GpiMove(hps, &ptl); ptl.x = swp.x + swp.cx + 1; GpiLine(hps, &ptl); ptl.y = swp.y + swp.cy + 1; GpiLine(hps, &ptl); } if (!outtie) GpiSetColor(hps, CLR_DARKGRAY); else GpiSetColor(hps, CLR_WHITE); if (dbl) { ptl.x = swp.x - 2; GpiLine(hps, &ptl); ptl.y = swp.y - 2; GpiLine(hps, &ptl); ptl.x = swp.x + swp.cx; ptl.y = swp.y + swp.cy; GpiMove(hps, &ptl); } ptl.x = swp.x - 1; GpiLine(hps, &ptl); ptl.y = swp.y - 1; GpiLine(hps, &ptl); GpiSetColor(hps, CLR_PALEGRAY); ptl.x = swp.x - (2 + (dbl != FALSE)); ptl.y = swp.y - (2 + (dbl != FALSE)); GpiMove(hps, &ptl); ptl.x = swp.x + swp.cx + (1 + (dbl != FALSE)); GpiLine(hps, &ptl); ptl.y = swp.y + swp.cy + (1 + (dbl != FALSE)); GpiLine(hps, &ptl); ptl.x = swp.x - (2 + (dbl != FALSE)); GpiLine(hps, &ptl); ptl.y = swp.y - (2 + (dbl != FALSE)); GpiLine(hps, &ptl); if (releaseme) WinReleasePS(hps); } } BOOL AdjustCnrColVis(HWND hwndCnr, CHAR * title, BOOL visible, BOOL toggle) { PFIELDINFO pfi = (PFIELDINFO) WinSendMsg(hwndCnr, CM_QUERYDETAILFIELDINFO, MPVOID, MPFROMSHORT(CMA_FIRST)); while (pfi) { if (!strcmp(pfi->pTitleData, title)) { if (toggle) { if (pfi->flData & CFA_INVISIBLE) pfi->flData &= (~CFA_INVISIBLE); else pfi->flData |= CFA_INVISIBLE; return !(pfi->flData & CFA_INVISIBLE); } else { if (visible) pfi->flData &= (~CFA_INVISIBLE); else pfi->flData |= CFA_INVISIBLE; } return TRUE; } pfi = pfi->pNextFieldInfo; } return FALSE; } BOOL AdjustCnrColRO(HWND hwndCnr, CHAR * title, BOOL readonly, BOOL toggle) { PFIELDINFO pfi = (PFIELDINFO) WinSendMsg(hwndCnr, CM_QUERYDETAILFIELDINFO, MPVOID, MPFROMSHORT(CMA_FIRST)); while (pfi) { if (!strcmp(pfi->pTitleData, title)) { if (toggle) { if (pfi->flData & CFA_FIREADONLY) pfi->flData &= (~CFA_FIREADONLY); else pfi->flData |= CFA_FIREADONLY; return (pfi->flData & CFA_FIREADONLY); } else { if (!readonly) pfi->flData &= (~CFA_FIREADONLY); else pfi->flData |= CFA_FIREADONLY; } return TRUE; } pfi = pfi->pNextFieldInfo; } return FALSE; } VOID AdjustCnrColsForFSType(HWND hwndCnr, CHAR * directory, DIRCNRDATA * dcd) { CHAR FileSystem[CCHMAXPATH]; INT x; BOOL hasCreateDT; BOOL hasAccessDT; BOOL hasLongNames; BOOL *pBool; if (!directory || !*directory) return; x = CheckDrive(toupper(*directory), FileSystem, NULL); if (x != -1) { if (!stricmp(FileSystem, HPFS) || !stricmp(FileSystem, JFS) || !stricmp(FileSystem, FAT32) || !stricmp(FileSystem, RAMFS) || !stricmp(FileSystem, NDFS32) || !stricmp(FileSystem, HPFS386)) { hasCreateDT = TRUE; hasAccessDT = TRUE; hasLongNames = TRUE; } else if (!strcmp(FileSystem, CDFS) || !strcmp(FileSystem, ISOFS)) { hasCreateDT = TRUE; hasAccessDT = FALSE; hasLongNames = FALSE; } else { // Assume FAT hasCreateDT = FALSE; hasAccessDT = FALSE; hasLongNames = FALSE; } } else { // Assume FAT hasCreateDT = FALSE; hasAccessDT = FALSE; hasLongNames = FALSE; } pBool = (dcd) ? &dcd->detailsladate : &detailsladate; AdjustCnrColVis(hwndCnr, GetPString(IDS_LADATE), (*pBool) ? hasAccessDT : FALSE, FALSE); pBool = (dcd) ? &dcd->detailslatime : &detailslatime; AdjustCnrColVis(hwndCnr, GetPString(IDS_LATIME), (*pBool) ? hasAccessDT : FALSE, FALSE); pBool = (dcd) ? &dcd->detailscrdate : &detailscrdate; AdjustCnrColVis(hwndCnr, GetPString(IDS_CRDATE), (*pBool) ? hasCreateDT : FALSE, FALSE); pBool = (dcd) ? &dcd->detailscrtime : &detailscrtime; AdjustCnrColVis(hwndCnr, GetPString(IDS_CRTIME), (*pBool) ? hasCreateDT : FALSE, FALSE); pBool = (dcd) ? &dcd->detailslongname : &detailslongname; AdjustCnrColVis(hwndCnr, GetPString(IDS_LNAME), (*pBool) ? hasLongNames : FALSE, FALSE); WinSendMsg(hwndCnr, CM_INVALIDATEDETAILFIELDINFO, MPVOID, MPVOID); } VOID AdjustCnrColsForPref(HWND hwndCnr, CHAR * directory, DIRCNRDATA * dcd, BOOL compare) { BOOL *bool; bool = (dcd) ? &dcd->detailssubject : &detailssubject; AdjustCnrColVis(hwndCnr, ((compare) ? GetPString(IDS_STATUS) : GetPString(IDS_SUBJ)), *bool, FALSE); bool = (dcd) ? &dcd->detailsattr : &detailsattr; AdjustCnrColVis(hwndCnr, GetPString(IDS_ATTR), *bool, FALSE); bool = (dcd) ? &dcd->detailsicon : &detailsicon; AdjustCnrColVis(hwndCnr, GetPString(IDS_ICON), *bool, FALSE); bool = (dcd) ? &dcd->detailslwdate : &detailslwdate; AdjustCnrColVis(hwndCnr, GetPString(IDS_LWDATE), *bool, FALSE); bool = (dcd) ? &dcd->detailslwtime : &detailslwtime; AdjustCnrColVis(hwndCnr, GetPString(IDS_LWTIME), *bool, FALSE); bool = (dcd) ? &dcd->detailsea : &detailsea; AdjustCnrColVis(hwndCnr, GetPString(IDS_EA), *bool, FALSE); bool = (dcd) ? &dcd->detailssize : &detailssize; AdjustCnrColVis(hwndCnr, GetPString(IDS_SIZE), *bool, FALSE); if (!directory) { bool = (dcd) ? &dcd->detailsladate : &detailsladate; AdjustCnrColVis(hwndCnr, GetPString(IDS_LADATE), *bool, FALSE); bool = (dcd) ? &dcd->detailslatime : &detailslatime; AdjustCnrColVis(hwndCnr, GetPString(IDS_LATIME), *bool, FALSE); bool = (dcd) ? &dcd->detailscrdate : &detailscrdate; AdjustCnrColVis(hwndCnr, GetPString(IDS_CRDATE), *bool, FALSE); bool = (dcd) ? &dcd->detailscrtime : &detailscrtime; AdjustCnrColVis(hwndCnr, GetPString(IDS_CRTIME), *bool, FALSE); bool = (dcd) ? &dcd->detailslongname : &detailslongname; AdjustCnrColVis(hwndCnr, GetPString(IDS_LNAME), *bool, FALSE); WinSendMsg(hwndCnr, CM_INVALIDATEDETAILFIELDINFO, MPVOID, MPVOID); } else AdjustCnrColsForFSType(hwndCnr, directory, dcd); } BOOL SetCnrCols(HWND hwndCnr, BOOL compare) { BOOL fSuccess = TRUE; PFIELDINFO pfi, pfiLastLeftCol, pfiIconCol; // Allocate storage for container column data pfi = WinSendMsg(hwndCnr, CM_ALLOCDETAILFIELDINFO, MPFROMLONG(CONTAINER_COLUMNS), NULL); if (pfi) { PFIELDINFO pfiFirst; FIELDINFOINSERT fii; // Store original value of pfi so we won't lose it when it changes. // This will be needed on the CM_INSERTDETAILFIELDINFO message. pfiFirst = pfi; // Fill in column information for the icon column pfi->flData = CFA_BITMAPORICON | CFA_CENTER | CFA_FIREADONLY; pfi->flTitle = CFA_CENTER | CFA_FITITLEREADONLY; pfi->pTitleData = GetPString(IDS_ICON); pfi->offStruct = FIELDOFFSET(MINIRECORDCORE, hptrIcon); pfiIconCol = pfi; // Fill in column information for the file name. Note that we are // using the pszFileName variable rather than szFileName. We do this // because the container needs a pointer to the file name. If we used // szFileName (a character array, not a pointer), the container would // take the first 4 bytes of szFileName and think it was a pointer, // which of course it is not. Later in the FillInRecord* functions we set // pszFileName to point to szFileName. pfi = pfi->pNextFieldInfo; pfi->flData = CFA_STRING | CFA_LEFT | CFA_SEPARATOR; pfi->flTitle = CFA_CENTER; pfi->pTitleData = GetPString(IDS_FILENAME); pfi->offStruct = FIELDOFFSET(CNRITEM, pszFileName); // Fill in column information for the longname. pfi = pfi->pNextFieldInfo; pfi->flData = CFA_STRING | CFA_LEFT; pfi->flTitle = CFA_CENTER | CFA_FITITLEREADONLY; pfi->pTitleData = GetPString(IDS_LNAME); pfi->offStruct = FIELDOFFSET(CNRITEM, pszLongname); // Store the current pfi value as that will be used to indicate the // last column in the lefthand container window (we have a splitbar) pfiLastLeftCol = pfi; // Fill in column info for subjects pfi = pfi->pNextFieldInfo; pfi->flData = CFA_STRING | CFA_LEFT | CFA_SEPARATOR; if (compare) pfi->flData |= CFA_FIREADONLY; pfi->flTitle = CFA_CENTER | CFA_FITITLEREADONLY; pfi->pTitleData = (compare) ? GetPString(IDS_STATUS) : GetPString(IDS_SUBJ); pfi->offStruct = FIELDOFFSET(CNRITEM, pszSubject); // Fill in column information for the file size pfi = pfi->pNextFieldInfo; pfi->flData = CFA_ULONG | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY; pfi->flTitle = CFA_CENTER; pfi->pTitleData = GetPString(IDS_SIZE); pfi->offStruct = FIELDOFFSET(CNRITEM, cbFile); // Fill in the column information for the file's ea size pfi = pfi->pNextFieldInfo; pfi->flData = CFA_ULONG | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY; pfi->flTitle = CFA_CENTER; pfi->pTitleData = GetPString(IDS_EA); pfi->offStruct = FIELDOFFSET(CNRITEM, easize); // Fill in the column information for the file attribute pfi = pfi->pNextFieldInfo; pfi->flData = CFA_STRING | CFA_CENTER | CFA_SEPARATOR | CFA_FIREADONLY; pfi->flTitle = CFA_CENTER | CFA_FITITLEREADONLY; pfi->pTitleData = GetPString(IDS_ATTR); pfi->offStruct = FIELDOFFSET(CNRITEM, pszDispAttr); // Fill in column information for last write file date pfi = pfi->pNextFieldInfo; pfi->flData = CFA_DATE | CFA_RIGHT | CFA_FIREADONLY; pfi->flTitle = CFA_CENTER; pfi->pTitleData = GetPString(IDS_LWDATE); pfi->offStruct = FIELDOFFSET(CNRITEM, date); // Fill in column information for the last write file time pfi = pfi->pNextFieldInfo; pfi->flData = CFA_TIME | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY; pfi->flTitle = CFA_CENTER; pfi->pTitleData = GetPString(IDS_LWTIME); pfi->offStruct = FIELDOFFSET(CNRITEM, time); // Fill in column information for last access file date pfi = pfi->pNextFieldInfo; pfi->flData = CFA_DATE | CFA_RIGHT | CFA_FIREADONLY; pfi->flTitle = CFA_CENTER; pfi->pTitleData = GetPString(IDS_LADATE); pfi->offStruct = FIELDOFFSET(CNRITEM, ladate); // Fill in column information for the last access file time pfi = pfi->pNextFieldInfo; pfi->flData = CFA_TIME | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY; pfi->flTitle = CFA_CENTER; pfi->pTitleData = GetPString(IDS_LATIME); pfi->offStruct = FIELDOFFSET(CNRITEM, latime); // Fill in column information for create file date pfi = pfi->pNextFieldInfo; pfi->flData = CFA_DATE | CFA_RIGHT | CFA_FIREADONLY; pfi->flTitle = CFA_CENTER; pfi->pTitleData = GetPString(IDS_CRDATE); pfi->offStruct = FIELDOFFSET(CNRITEM, crdate); // Fill in column information for the create file time pfi = pfi->pNextFieldInfo; pfi->flData = CFA_TIME | CFA_RIGHT | CFA_FIREADONLY; pfi->flTitle = CFA_CENTER; pfi->pTitleData = GetPString(IDS_CRTIME); pfi->offStruct = FIELDOFFSET(CNRITEM, crtime); // Use the CM_INSERTDETAILFIELDINFO message to tell the container // all the column information it needs to function properly. Place // this column info first in the column list and update the display // after they are inserted (fInvalidateFieldInfo = TRUE) (void)memset(&fii, 0, sizeof(FIELDINFOINSERT)); fii.cb = sizeof(FIELDINFOINSERT); fii.pFieldInfoOrder = (PFIELDINFO) CMA_FIRST; fii.cFieldInfoInsert = (SHORT) CONTAINER_COLUMNS; fii.fInvalidateFieldInfo = TRUE; if (!WinSendMsg(hwndCnr, CM_INSERTDETAILFIELDINFO, MPFROMP(pfiFirst), MPFROMP(&fii))) fSuccess = FALSE; } else fSuccess = FALSE; if (fSuccess) { CNRINFO cnri; ULONG size; // Tell the container about the splitbar and where it goes cnri.cb = sizeof(CNRINFO); cnri.pFieldInfoLast = pfiLastLeftCol; cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 32; cnri.pFieldInfoObject = pfiIconCol; size = sizeof(LONG); PrfQueryProfileData(fmprof, appname, "CnrSplitBar", &cnri.xVertSplitbar, &size); if (cnri.xVertSplitbar <= 0) cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 32; if (!WinSendMsg(hwndCnr, CM_SETCNRINFO, MPFROMP(&cnri), MPFROMLONG(CMA_PFIELDINFOLAST | CMA_PFIELDINFOOBJECT | CMA_XVERTSPLITBAR))) fSuccess = FALSE; } return fSuccess; } MRESULT CnrDirectEdit(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { switch (SHORT2FROMMP(mp1)) { case CN_BEGINEDIT: if (mp2) { PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo; PCNRITEM pci = (PCNRITEM) ((PCNREDITDATA) mp2)->pRecord; if (pci && (INT) pci != -1 && !IsRoot(pci->szFileName) && !(pci->flags & RECFLAGS_ENV) && !(pci->flags & RECFLAGS_UNDERENV)) { if (!pfi || pfi->offStruct == FIELDOFFSET(CNRITEM, pszFileName)) { PostMsg(hwnd, UM_FIXEDITNAME, MPFROMP(pci->szFileName), MPVOID); } else if (pfi->offStruct == FIELDOFFSET(CNRITEM, pszSubject)) PostMsg(hwnd, UM_FIXCNRMLE, MPFROMLONG(40), MPVOID); else PostMsg(hwnd, UM_FIXCNRMLE, MPFROMLONG(CCHMAXPATH), MPVOID); } else PostMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID); } break; case CN_REALLOCPSZ: if (mp2) { PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo; PCNRITEM pci = (PCNRITEM) ((PCNREDITDATA) mp2)->pRecord; CHAR szData[CCHMAXPATH], testname[CCHMAXPATH], *p; HWND hwndMLE = WinWindowFromID(hwnd, CID_MLE); if (pci && (INT) pci != -1 && !IsRoot(pci->szFileName)) { if (pfi && pfi->offStruct == FIELDOFFSET(CNRITEM, pszSubject)) { APIRET rc; EAOP2 eaop; PFEA2LIST pfealist = NULL; CHAR szSubject[256]; ULONG ealen; USHORT len; CHAR *eaval; WinQueryWindowText(hwndMLE, 40, szSubject); szSubject[39] = 0; chop_at_crnl(szSubject); bstrip(szSubject); WinSetWindowText(hwndMLE, szSubject); len = strlen(szSubject); if (len) ealen = sizeof(FEA2LIST) + 9 + len + 4; else ealen = sizeof(FEALIST) + 9; rc = DosAllocMem((PPVOID) & pfealist, ealen + 64L, OBJ_TILE | PAG_COMMIT | PAG_READ | PAG_WRITE); if (rc) Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__, GetPString(IDS_OUTOFMEMORY)); else { memset(pfealist, 0, ealen + 1); pfealist->cbList = ealen; pfealist->list[0].oNextEntryOffset = 0L; pfealist->list[0].fEA = 0; pfealist->list[0].cbName = 8; strcpy(pfealist->list[0].szName, SUBJECT); if (len) { eaval = pfealist->list[0].szName + 9; *(USHORT *) eaval = (USHORT) EAT_ASCII; eaval += sizeof(USHORT); *(USHORT *) eaval = (USHORT) len; eaval += sizeof(USHORT); memcpy(eaval, szSubject, len); pfealist->list[0].cbValue = len + (sizeof(USHORT) * 2); } else pfealist->list[0].cbValue = 0; eaop.fpGEA2List = (PGEA2LIST) 0; eaop.fpFEA2List = pfealist; eaop.oError = 0L; rc = DosSetPathInfo(pci->szFileName, FIL_QUERYEASIZE, (PVOID) & eaop, sizeof(EAOP2), DSPI_WRTTHRU); DosFreeMem(pfealist); if (rc) return FALSE; } return (MRESULT) TRUE; } else if (pfi && pfi->offStruct == FIELDOFFSET(CNRITEM, pszLongname)) { CHAR longname[CCHMAXPATHCOMP]; *longname = 0; WinQueryWindowText(hwndMLE, sizeof(longname), longname); longname[CCHMAXPATHCOMP - 1] = 0; chop_at_crnl(longname); WinSetWindowText(hwndMLE, longname); return (MRESULT) WriteLongName(pci->szFileName, longname); } else { WinQueryWindowText(hwndMLE, sizeof(szData), szData); if (strchr(szData, '?') || strchr(szData, '*') || IsRoot(pci->szFileName)) return (MRESULT) FALSE; /* If the text changed, rename the file system object. */ chop_at_crnl(szData); bstrip(szData); if (!IsFullName(szData)) Runtime_Error(pszSrcFile, __LINE__, "bad name"); else { if (DosQueryPathInfo(szData, FIL_QUERYFULLNAME, testname, sizeof(testname))) return FALSE; if (DosQueryPathInfo(pci->szFileName, FIL_QUERYFULLNAME, szData, sizeof(szData))) strcpy(szData, pci->szFileName); WinSetWindowText(hwndMLE, szData); if (strcmp(szData, testname)) { if (stricmp(szData, testname) && IsFile(testname) != -1) { DosBeep(50, 100); /* exists; disallow */ return (MRESULT) FALSE; } if (docopyf(MOVE, szData, "%s", testname)) Runtime_Error(pszSrcFile, __LINE__, "docopyf"); else { CHAR *filename; filename = xstrdup(testname, pszSrcFile, __LINE__); if (filename) { if (!PostMsg(hwnd, UM_FIXEDITNAME, MPVOID, MPFROMP(filename))) free(filename); } if (stricmp(testname, pci->szFileName)) { PostMsg(hwnd, UM_FIXEDITNAME, MPFROMLONG(-1), MPFROMP(pci)); filename = xstrdup(pci->szFileName, pszSrcFile, __LINE__); if (filename) { if (!PostMsg(hwnd, UM_FIXEDITNAME, MPVOID, MPFROMP(filename))) free(filename); } } } } } } } } return FALSE; case CN_ENDEDIT: if (mp2) { PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo; PCNRITEM pci = (PCNRITEM) ((PCNREDITDATA) mp2)->pRecord; if (pci && (INT) pci != -1 && !IsRoot(pci->szFileName)) { WinSendMsg(hwnd, CM_INVALIDATERECORD, MPFROMP(&pci), MPFROM2SHORT(1, CMA_ERASE | CMA_TEXTCHANGED)); if (pfi && pfi->offStruct == FIELDOFFSET(CNRITEM, pszFileName)) PostMsg(hwnd, UM_SORTRECORD, MPVOID, MPVOID); } else { USHORT cmd = 0; if (!pfi || pfi->offStruct == FIELDOFFSET(CNRITEM, pszFileName)) cmd = IDM_SORTSMARTNAME; else if (pfi->offStruct == FIELDOFFSET(CNRITEM, cbFile)) cmd = IDM_SORTSIZE; else if (pfi->offStruct == FIELDOFFSET(CNRITEM, easize)) cmd = IDM_SORTEASIZE; else if (pfi->offStruct == FIELDOFFSET(CNRITEM, date)) cmd = IDM_SORTLWDATE; else if (pfi->offStruct == FIELDOFFSET(CNRITEM, time)) cmd = IDM_SORTLWDATE; else if (pfi->offStruct == FIELDOFFSET(CNRITEM, ladate)) cmd = IDM_SORTLADATE; else if (pfi->offStruct == FIELDOFFSET(CNRITEM, latime)) cmd = IDM_SORTLADATE; else if (pfi->offStruct == FIELDOFFSET(CNRITEM, crdate)) cmd = IDM_SORTCRDATE; else if (pfi->offStruct == FIELDOFFSET(CNRITEM, crtime)) cmd = IDM_SORTCRDATE; if (cmd) PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID); } } break; } return (MRESULT) - 1; } BOOL SetMenuCheck(HWND hwndMenu, USHORT id, BOOL * bool, BOOL toggle, CHAR * savename) { if (toggle) { *bool = (*bool) ? FALSE : TRUE; if (savename && *savename) PrfWriteProfileData(fmprof, appname, savename, bool, sizeof(BOOL)); } WinSendMsg(hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(id, 1), MPFROM2SHORT(MIA_CHECKED, (*bool ? MIA_CHECKED : 0))); return *bool; } //== disable_menuitem() disable or enable_menuitem == VOID disable_menuitem(HWND hwndMenu, USHORT id, BOOL disable) { WinSendMsg(hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(id, TRUE), MPFROM2SHORT(MIA_DISABLED, (disable ? MIA_DISABLED : 0))); } //== ViewHelp() invoke view.exe, return TRUE if OK == BOOL ViewHelp(CHAR * filename) { CHAR s[CCHMAXPATH + 81]; FILE *fp; INT ret = -1; fp = _fsopen(filename, "rb", SH_DENYNO); if (fp) { *s = 0; fread(s, 1, 3, fp); if (*s != 'H' || s[1] != 'S' || s[2] != 'P') { fclose(fp); return FALSE; } fclose(fp); ret = runemf2(SEPARATE | WINDOWED, HWND_DESKTOP, NULL, NULL, "VIEW.EXE \"%s\"", filename); } return (ret != -1); } //== ExecFile() run file, return 1 if OK 0 if skipped -1 if can't run == INT ExecFile(HWND hwnd, CHAR * filename) { EXECARGS ex; CHAR cl[1001], path[CCHMAXPATH], *p; APIRET ret; static INT lastflags = 0; strcpy(path, filename); p = strrchr(path, '\\'); if (!p) p = strrchr(path, ':'); if (p) { if (*p == ':') { p++; *p = '\\'; p++; } *p = 0; } else *path = 0; *cl = 0; if (needs_quoting(filename)) strcat(cl, "\""); strcat(cl, filename); if (needs_quoting(filename)) strcat(cl, "\""); memset(&ex, 0, sizeof(ex)); ex.flags = lastflags; ex.commandline = cl; *ex.path = 0; *ex.environment = 0; ret = WinDlgBox(HWND_DESKTOP, hwnd, CmdLineDlgProc, FM3ModHandle, EXEC_FRAME, &ex); if (ret == 1) { lastflags = ex.flags; return runemf2(ex.flags, hwnd, path, (*ex.environment) ? ex.environment : NULL, "%s", cl) != -1; } else if (ret != 0) return -1; return 0; } VOID EmptyCnr(HWND hwnd) { /* Empty out a container in preparation to it dying */ PCNRITEM pci; PFIELDINFO pfi; pci = (PCNRITEM) WinSendMsg(hwnd, CM_QUERYRECORD, MPVOID, MPFROMSHORT(CMA_FIRST)); if (pci && (INT) pci != -1) WinSendMsg(hwnd, CM_REMOVERECORD, MPVOID, MPFROM2SHORT(0, CMA_FREE)); pfi = (PFIELDINFO) WinSendMsg(hwnd, CM_QUERYDETAILFIELDINFO, MPVOID, MPFROMSHORT(CMA_FIRST)); if (pfi) WinSendMsg(hwnd, CM_REMOVEDETAILFIELDINFO, MPVOID, MPFROM2SHORT(0, CMA_FREE)); } VOID SetDetailsSwitches(HWND hwnd, DIRCNRDATA * dcd) { WinCheckMenuItem(hwnd, IDM_SHOWLNAMES, (dcd) ? dcd->detailslongname : detailslongname); WinCheckMenuItem(hwnd, IDM_SHOWSUBJECT, (dcd) ? dcd->detailssubject : detailssubject); WinCheckMenuItem(hwnd, IDM_SHOWEAS, (dcd) ? dcd->detailsea : detailsea); WinCheckMenuItem(hwnd, IDM_SHOWSIZE, (dcd) ? dcd->detailssize : detailssize); WinCheckMenuItem(hwnd, IDM_SHOWICON, (dcd) ? dcd->detailsicon : detailsicon); WinCheckMenuItem(hwnd, IDM_SHOWLWDATE, (dcd) ? dcd->detailslwdate : detailslwdate); WinCheckMenuItem(hwnd, IDM_SHOWLWTIME, (dcd) ? dcd->detailslwtime : detailslwtime); WinCheckMenuItem(hwnd, IDM_SHOWLADATE, (dcd) ? dcd->detailsladate : detailsladate); WinCheckMenuItem(hwnd, IDM_SHOWLATIME, (dcd) ? dcd->detailslatime : detailslatime); WinCheckMenuItem(hwnd, IDM_SHOWCRDATE, (dcd) ? dcd->detailscrdate : detailscrdate); WinCheckMenuItem(hwnd, IDM_SHOWCRTIME, (dcd) ? dcd->detailscrtime : detailscrtime); WinCheckMenuItem(hwnd, IDM_SHOWATTR, (dcd) ? dcd->detailsattr : detailsattr); } VOID AdjustDetailsSwitches(HWND hwnd, HWND hwndMenu, USHORT cmd, CHAR * directory, CHAR * keyroot, DIRCNRDATA * dcd, BOOL compare) { CHAR s[CCHMAXPATH], *eos = s; BOOL *bool = NULL; *s = 0; if (keyroot) { strcpy(s, keyroot); strcat(s, "."); eos = &s[strlen(s)]; } switch (cmd) { case IDM_SHOWLNAMES: bool = (dcd) ? &dcd->detailslongname : &detailslongname; strcpy(eos, "DetailsLongname"); break; case IDM_SHOWSUBJECT: bool = (dcd) ? &dcd->detailssubject : &detailssubject; strcpy(eos, "DetailsSubject"); break; case IDM_SHOWEAS: bool = (dcd) ? &dcd->detailsea : &detailsea; strcpy(eos, "DetailsEA"); break; case IDM_SHOWSIZE: bool = (dcd) ? &dcd->detailssize : &detailssize; strcpy(eos, "DetailsSize"); break; case IDM_SHOWICON: bool = (dcd) ? &dcd->detailsicon : &detailsicon; strcpy(eos, "DetailsIcon"); break; case IDM_SHOWLWDATE: bool = (dcd) ? &dcd->detailslwdate : &detailslwdate; strcpy(eos, "DetailsLWDate"); break; case IDM_SHOWLWTIME: bool = (dcd) ? &dcd->detailslwtime : &detailslwtime; strcpy(eos, "DetailsLWTime"); break; case IDM_SHOWLADATE: bool = (dcd) ? &dcd->detailsladate : &detailsladate; strcpy(eos, "DetailsLADate"); break; case IDM_SHOWLATIME: bool = (dcd) ? &dcd->detailslatime : &detailslatime; strcpy(eos, "DetailsLATime"); break; case IDM_SHOWCRDATE: bool = (dcd) ? &dcd->detailscrdate : &detailscrdate; strcpy(eos, "DetailsCRDate"); break; case IDM_SHOWCRTIME: bool = (dcd) ? &dcd->detailscrtime : &detailscrtime; strcpy(eos, "DetailsCRTime"); break; case IDM_SHOWATTR: bool = (dcd) ? &dcd->detailsattr : &detailsattr; strcpy(eos, "DetailsAttr"); break; default: if (hwndMenu) SetDetailsSwitches(hwndMenu, dcd); return; } if (bool) *bool = (*bool) ? FALSE : TRUE; if (*s && bool) PrfWriteProfileData(fmprof, appname, s, bool, sizeof(BOOL)); if (hwnd) AdjustCnrColsForPref(hwnd, directory, dcd, compare); if (hwndMenu) SetDetailsSwitches(hwndMenu, dcd); } VOID SetConditionalCascade(HWND hwndMenu, USHORT id, USHORT def) { MENUITEM mi; mi.iPosition = MIT_END; mi.hItem = 0L; mi.hwndSubMenu = (HWND) 0; mi.afAttribute = 0; mi.afStyle = MIS_TEXT; if (WinSendMsg (hwndMenu, MM_QUERYITEM, MPFROM2SHORT(id, TRUE), MPFROMP(&mi))) { WinSetWindowBits(mi.hwndSubMenu, QWL_STYLE, MS_CONDITIONALCASCADE, MS_CONDITIONALCASCADE); WinSendMsg(mi.hwndSubMenu, MM_SETDEFAULTITEMID, MPFROMSHORT(def), MPVOID); WinCheckMenuItem(mi.hwndSubMenu, def, TRUE); } } VOID SetSortChecks(HWND hwndMenu, INT sortflags) { WinCheckMenuItem(hwndMenu, IDM_SORTNONE, FALSE); WinCheckMenuItem(hwndMenu, IDM_SORTFIRST, FALSE); WinCheckMenuItem(hwndMenu, IDM_SORTLAST, FALSE); WinCheckMenuItem(hwndMenu, IDM_SORTSIZE, FALSE); WinCheckMenuItem(hwndMenu, IDM_SORTEASIZE, FALSE); WinCheckMenuItem(hwndMenu, IDM_SORTLWDATE, FALSE); WinCheckMenuItem(hwndMenu, IDM_SORTLADATE, FALSE); WinCheckMenuItem(hwndMenu, IDM_SORTCRDATE, FALSE); WinCheckMenuItem(hwndMenu, IDM_SORTFILENAME, FALSE); WinCheckMenuItem(hwndMenu, IDM_SORTNAME, FALSE); WinCheckMenuItem(hwndMenu, IDM_SORTSUBJECT, FALSE); WinCheckMenuItem(hwndMenu, IDM_SORTDIRSFIRST, FALSE); WinCheckMenuItem(hwndMenu, IDM_SORTDIRSLAST, FALSE); WinCheckMenuItem(hwndMenu, IDM_SORTREVERSE, FALSE); if (sortflags & SORT_FIRSTEXTENSION) WinCheckMenuItem(hwndMenu, IDM_SORTFIRST, TRUE); else if (sortflags & SORT_LASTEXTENSION) WinCheckMenuItem(hwndMenu, IDM_SORTLAST, TRUE); else if (sortflags & SORT_SIZE) WinCheckMenuItem(hwndMenu, IDM_SORTSIZE, TRUE); else if (sortflags & SORT_EASIZE) WinCheckMenuItem(hwndMenu, IDM_SORTEASIZE, TRUE); else if (sortflags & SORT_LWDATE) WinCheckMenuItem(hwndMenu, IDM_SORTLWDATE, TRUE); else if (sortflags & SORT_LADATE) WinCheckMenuItem(hwndMenu, IDM_SORTLADATE, TRUE); else if (sortflags & SORT_CRDATE) WinCheckMenuItem(hwndMenu, IDM_SORTCRDATE, TRUE); else if (sortflags & SORT_FILENAME) WinCheckMenuItem(hwndMenu, IDM_SORTFILENAME, TRUE); else if (sortflags & SORT_NOSORT) WinCheckMenuItem(hwndMenu, IDM_SORTNONE, TRUE); else if (sortflags & SORT_SUBJECT) WinCheckMenuItem(hwndMenu, IDM_SORTSUBJECT, TRUE); else WinCheckMenuItem(hwndMenu, IDM_SORTNAME, TRUE); if (sortflags & SORT_DIRSFIRST) WinCheckMenuItem(hwndMenu, IDM_SORTDIRSFIRST, TRUE); else if (sortflags & SORT_DIRSLAST) WinCheckMenuItem(hwndMenu, IDM_SORTDIRSLAST, TRUE); if (sortflags & SORT_REVERSE) WinCheckMenuItem(hwndMenu, IDM_SORTREVERSE, TRUE); } VOID FreeMallocedMem(VOID * mem) { /* for use by apps that don't use the DLLs runtime library */ free(mem); } VOID FcloseFile(FILE * fp) { /* for use by apps that don't use the DLLs runtime library */ fclose(fp); } VOID SetupCommandMenu(HWND hwndMenu, HWND hwndCnr) { MENUITEM mi, mit; INT x; SHORT numitems; LINKCMDS *info; if (!cmdloaded) load_commands(); mi.iPosition = MIT_END; mi.hwndSubMenu = (HWND) 0; mi.hItem = 0L; mi.afAttribute = 0; mi.afStyle = MIS_TEXT; memset(&mit, 0, sizeof(MENUITEM)); if (WinQueryWindowUShort(hwndMenu, QWS_ID) == IDM_COMMANDSMENU) mit.hwndSubMenu = hwndMenu; else WinSendMsg(hwndMenu, MM_QUERYITEM, MPFROM2SHORT(IDM_COMMANDSMENU, TRUE), MPFROMP(&mit)); if (mit.hwndSubMenu) { numitems = (SHORT) WinSendMsg(mit.hwndSubMenu, MM_QUERYITEMCOUNT, MPVOID, MPVOID); WinSendMsg(mit.hwndSubMenu, MM_DELETEITEM, MPFROMSHORT(-1), MPVOID); for (x = 0; x < numitems; x++) WinSendMsg(mit.hwndSubMenu, MM_DELETEITEM, MPFROMSHORT((SHORT) (x + IDM_COMMANDSTART)), MPVOID); if (hwndCnr && cmdhead) { x = 0; info = cmdhead; while (info) { CHAR s[CCHMAXPATH + 24]; sprintf(s, "%s%s%s", info->title, (x < 20) ? "\tCtrl + " : NullStr, (x < 20 && x > 9) ? "Shift + " : NullStr); if (x < 20) sprintf(&s[strlen(s)], "%d", (((x % 10) + 1) == 10) ? 0 : (x % 10) + 1); mi.id = IDM_COMMANDSTART + x; mi.afAttribute = (((info->flags & ONCE) != 0) ? MIA_CHECKED : 0) | (((info->flags & PROMPT) != 0) ? MIA_FRAMED : 0); mi.afStyle = MIS_TEXT; if (!(x % 24) && x && info->next) mi.afStyle |= MIS_BREAK; WinSendMsg(mit.hwndSubMenu, MM_INSERTITEM, MPFROMP(&mi), MPFROMP(s)); x++; info = info->next; } } } } VOID LoadDetailsSwitches(CHAR * keyroot, DIRCNRDATA * dcd) { ULONG size; CHAR s[CCHMAXPATH], *eos = s; BOOL *bool; *s = 0; if (keyroot) { strcpy(s, keyroot); strcat(s, "."); eos = &s[strlen(s)]; } strcpy(eos, "DetailsLongname"); if (dcd) bool = &dcd->detailslongname; else bool = &detailslongname; *bool = detailslongname; size = sizeof(BOOL); PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size); strcpy(eos, "DetailsSubject"); if (dcd) bool = &dcd->detailssubject; else bool = &detailssubject; *bool = detailssubject; size = sizeof(BOOL); PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size); strcpy(eos, "DetailsEA"); if (dcd) bool = &dcd->detailsea; else bool = &detailsea; *bool = detailsea; size = sizeof(BOOL); PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size); strcpy(eos, "DetailsSize"); if (dcd) bool = &dcd->detailssize; else bool = &detailssize; *bool = detailssize; size = sizeof(BOOL); PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size); strcpy(eos, "DetailsIcon"); if (dcd) bool = &dcd->detailsicon; else bool = &detailsicon; *bool = detailsicon; size = sizeof(BOOL); PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size); strcpy(eos, "DetailsAttr"); if (dcd) bool = &dcd->detailsattr; else bool = &detailsattr; *bool = detailsattr; size = sizeof(BOOL); PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size); strcpy(eos, "DetailsCRDate"); if (dcd) bool = &dcd->detailscrdate; else bool = &detailscrdate; *bool = detailscrdate; size = sizeof(BOOL); PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size); strcpy(eos, "DetailsCRTime"); if (dcd) bool = &dcd->detailscrtime; else bool = &detailscrtime; *bool = detailscrtime; size = sizeof(BOOL); PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size); strcpy(eos, "DetailsLWDate"); if (dcd) bool = &dcd->detailslwdate; else bool = &detailslwdate; *bool = detailslwdate; size = sizeof(BOOL); PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size); strcpy(eos, "DetailsLWTime"); if (dcd) bool = &dcd->detailslwtime; else bool = &detailslwtime; *bool = detailslwtime; size = sizeof(BOOL); PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size); strcpy(eos, "DetailsLADate"); if (dcd) bool = &dcd->detailsladate; else bool = &detailsladate; *bool = detailsladate; size = sizeof(BOOL); PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size); strcpy(eos, "DetailsLATime"); if (dcd) bool = &dcd->detailslatime; else bool = &detailslatime; *bool = detailslatime; size = sizeof(BOOL); PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size); } HWND FindDirCnr(HWND hwndParent) { HWND found, hwndDir = (HWND) 0; HENUM henum; henum = WinBeginEnumWindows(hwndParent); while ((found = WinGetNextWindow(henum)) != NULLHANDLE) { hwndDir = WinWindowFromID(found, FID_CLIENT); if (hwndDir) { hwndDir = WinWindowFromID(hwndDir, DIR_CNR); if (hwndDir) break; hwndDir = (HWND) 0; } } WinEndEnumWindows(henum); return hwndDir; } VOID HeapThread(VOID * dummy) { ULONG postcount; APIRET rc; rc = DosCreateEventSem(NULL, &CompactSem, 0L, FALSE); if (rc) Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__, "DosCreateEventSem"); else { priority_normal(); for (;;) { if (DosWaitEventSem(CompactSem, SEM_INDEFINITE_WAIT)) break; _heapmin(); DosResetEventSem(CompactSem, &postcount); } } } VOID FixSwitchList(HWND hwnd, CHAR * text) { HSWITCH hswitch; SWCNTRL swctl; hswitch = WinQuerySwitchHandle(hwnd, 0); if (hswitch) { if (!WinQuerySwitchEntry(hswitch, &swctl)) { strcpy(swctl.szSwtitle, "FM/2"); WinChangeSwitchEntry(hswitch, &swctl); } } } VOID QuickPopup(HWND hwnd, DIRCNRDATA * dcd, HWND hwndMenu, USHORT id) { dcd->hwndLastMenu = hwndMenu; if (dcd->hwndLastMenu && !dcd->cnremphasized) { WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID, MPFROM2SHORT(TRUE, CRA_SOURCE)); dcd->cnremphasized = TRUE; } if (dcd->flWindowAttr & CV_MINI) WinCheckMenuItem(dcd->hwndLastMenu, IDM_MINIICONS, TRUE); if (!WinPopupMenu(hwnd, hwnd, dcd->hwndLastMenu, 8, 8, 0, PU_HCONSTRAIN | PU_VCONSTRAIN | PU_KEYBOARD | PU_MOUSEBUTTON1)) { if (dcd->cnremphasized) { WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID, MPFROM2SHORT(FALSE, CRA_SOURCE)); dcd->cnremphasized = FALSE; } } else WinSendMsg(dcd->hwndLastMenu, MM_SELECTITEM, MPFROM2SHORT(id, TRUE), MPFROM2SHORT(0, FALSE)); } PMINIRECORDCORE CurrentRecord(HWND hwndCnr) { SHORT attrib = (fSelectedAlways) ? CRA_SELECTED : CRA_CURSORED; PMINIRECORDCORE pmi; for (;;) { pmi = (PMINIRECORDCORE) WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST), MPFROMSHORT(attrib)); if ((!pmi || (INT) pmi == -1) && attrib == CRA_SELECTED) /* punt */ attrib = CRA_CURSORED; else break; } return ((INT) pmi == -1) ? NULL : pmi; } BOOL PostMsg(HWND h, ULONG msg, MPARAM mp1, MPARAM mp2) { BOOL rc = WinPostMsg(h, msg, mp1, mp2); if (!rc) { PIB *ppib; TIB *ptib; if (!DosGetInfoBlocks(&ptib, &ppib)) { PID pid; TID tid; QMSG qmsg; if (WinQueryWindowProcess(h, &pid, &tid)) { // If window owned by some other process or some other thread? if (pid != ppib->pib_ulpid || tid != ptib->tib_ptib2->tib2_ultid) { for (;;) { DosSleep(1L); rc = WinPostMsg(h, msg, mp1, mp2); if (rc) break; // OK if (!WinIsWindow((HAB) 0, h)) break; // Window gone if (WinPeekMsg((HAB) 0, &qmsg, (HWND) 0, 0, 0, PM_NOREMOVE)) break; // Queue has message(s) } // for } } } } return rc; } VOID OpenEdit(HWND hwnd) { CNREDITDATA ced; PCNRITEM pci; PFIELDINFO pfi; pci = (PCNRITEM) WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED)); if (pci && (INT) pci != -1) { memset(&ced, 0, sizeof(ced)); ced.cb = sizeof(ced); ced.hwndCnr = hwnd; ced.id = WinQueryWindowUShort(hwnd, QWS_ID); ced.pRecord = (PRECORDCORE) pci; pfi = (PFIELDINFO) WinSendMsg(hwnd, CM_QUERYDETAILFIELDINFO, MPVOID, MPFROMSHORT(CMA_FIRST)); if (!pfi) WinSendMsg(hwnd, CM_OPENEDIT, MPFROMP(&ced), MPVOID); else { while (pfi && (INT) pfi != -1 && pfi->offStruct != FIELDOFFSET(CNRITEM, pszFileName)) pfi = (PFIELDINFO) WinSendMsg(hwnd, CM_QUERYDETAILFIELDINFO, MPFROMP(pfi), MPFROMSHORT(CMA_NEXT)); if (pfi && (INT) pfi != -1) { ced.pFieldInfo = pfi; { CNRINFO cnri; memset(&cnri, 0, sizeof(CNRINFO)); cnri.cb = sizeof(CNRINFO); WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO))); if (cnri.flWindowAttr & CV_DETAIL) ced.id = CID_LEFTDVWND; } WinSendMsg(hwnd, CM_OPENEDIT, MPFROMP(&ced), MPVOID); } } } } #ifdef NEVER VOID QuickView(HWND hwnd, CHAR * filename) { if (filename && IsFile(filename) == 1) { if (TestBinary(filename) && *binview) { CHAR *list[2]; list[0] = filename; list[1] = NULL; ExecOnList(hwnd, binview, WINDOWED | SEPARATE, NULL, list, NULL); return; } else if (*viewer) { CHAR *list[2]; list[0] = filename; list[1] = NULL; ExecOnList(hwnd, viewer, WINDOWED | SEPARATE | ((fViewChild) ? CHILD : 0), NULL, list, NULL); return; } StartMLEEditor(HWND_DESKTOP, 5, filename, (HWND) 0); } } VOID QuickEdit(HWND hwnd, CHAR * filename) { if (filename && IsFile(filename) == 1) { if (TestBinary(filename) && *bined) { CHAR *list[2]; list[0] = filename; list[1] = NULL; ExecOnList(hwnd, bined, WINDOWED | SEPARATE, NULL, list, NULL); return; } else if (*editor) { CHAR *list[2]; list[0] = filename; list[1] = NULL; ExecOnList(hwnd, editor, WINDOWED | SEPARATE, NULL, list, NULL); return; } StartMLEEditor(HWND_DESKTOP, 4, filename, (HWND) 0); } } #endif VOID PortholeInit(HWND hwndNew, MPARAM mp1, MPARAM mp2) { static HWND DefMenu = (HWND) 0; HWND hwndMenu = (HWND) mp2; { ULONG style; style = WinQueryWindowULong(hwndMenu, QWL_STYLE); if (!(style & MS_ACTIONBAR)) return; } switch (SHORT1FROMMP(mp1)) { case 0: { HWND hwndNow; MENUITEM mi; ULONG ulStyle; memset(&mi, 0, sizeof(mi)); mi.iPosition = MIT_END; mi.afStyle = MIS_TEXT; WinSendMsg(hwndMenu, MM_QUERYITEM, MPFROM2SHORT(IDM_FILESMENU, TRUE), MPFROMP(&mi)); if (!DefMenu) DefMenu = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, DEFMENU); hwndNow = mi.hwndSubMenu; mi.hwndSubMenu = hwndNew; if (!mi.hwndSubMenu) mi.hwndSubMenu = DefMenu; WinSetParent(hwndNow, WinQueryObjectWindow(HWND_DESKTOP), FALSE); WinSetOwner(hwndNow, WinQueryObjectWindow(HWND_DESKTOP)); WinSetOwner(mi.hwndSubMenu, hwndMenu); WinSetParent(mi.hwndSubMenu, hwndMenu, FALSE); WinSetWindowUShort(mi.hwndSubMenu, QWS_ID, IDM_FILESMENU); mi.afStyle = MIS_SUBMENU; ulStyle = WinQueryWindowULong(mi.hwndSubMenu, QWL_STYLE); ulStyle &= -WS_SAVEBITS; ulStyle |= MS_POPUP | WS_CLIPSIBLINGS | WS_SAVEBITS; WinSetWindowULong(mi.hwndSubMenu, QWL_STYLE, ulStyle); WinSendMsg(hwndMenu, MM_SETITEM, MPFROM2SHORT(0, TRUE), MPFROMP(&mi)); } break; case 1: { HWND hwndNow; MENUITEM mi; ULONG ulStyle; memset(&mi, 0, sizeof(mi)); mi.iPosition = MIT_END; mi.afStyle = MIS_TEXT; WinSendMsg(hwndMenu, MM_QUERYITEM, MPFROM2SHORT(IDM_VIEWSMENU, TRUE), MPFROMP(&mi)); if (!DefMenu) DefMenu = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, DEFMENU); hwndNow = mi.hwndSubMenu; mi.hwndSubMenu = hwndNew; if (!mi.hwndSubMenu) mi.hwndSubMenu = DefMenu; WinSetParent(hwndNow, WinQueryObjectWindow(HWND_DESKTOP), FALSE); WinSetOwner(hwndNow, WinQueryObjectWindow(HWND_DESKTOP)); WinSetOwner(mi.hwndSubMenu, hwndMenu); WinSetParent(mi.hwndSubMenu, hwndMenu, FALSE); WinSetWindowUShort(mi.hwndSubMenu, QWS_ID, IDM_VIEWSMENU); mi.afStyle = MIS_SUBMENU; ulStyle = WinQueryWindowULong(mi.hwndSubMenu, QWL_STYLE); ulStyle &= -WS_SAVEBITS; ulStyle |= MS_POPUP | WS_CLIPSIBLINGS | WS_SAVEBITS; WinSetWindowULong(mi.hwndSubMenu, QWL_STYLE, ulStyle); WinSendMsg(hwndMenu, MM_SETITEM, MPFROM2SHORT(0, TRUE), MPFROMP(&mi)); } break; } } HWND CheckMenu(HWND * hwndMenu, USHORT id) { /* load and adjust menus as required */ if (!*hwndMenu || !WinIsWindow((HAB) 0, *hwndMenu)) { *hwndMenu = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, id); if (hwndMenu == &DirMenu) { WinSetWindowUShort(DirMenu, QWS_ID, IDM_FILESMENU); SetConditionalCascade(DirMenu, IDM_COMMANDSMENU, IDM_DOITYOURSELF); SetConditionalCascade(DirMenu, IDM_COPYMENU, IDM_COPY); SetConditionalCascade(DirMenu, IDM_MOVEMENU, IDM_MOVE); SetConditionalCascade(DirMenu, IDM_SAVESUBMENU, IDM_SAVETOCLIP); SetConditionalCascade(DirMenu, IDM_VIEWSUBMENU, IDM_INFO); SetConditionalCascade(DirMenu, IDM_EDITSUBMENU, IDM_ATTRS); SetConditionalCascade(DirMenu, IDM_DELETESUBMENU, (fDefaultDeletePerm) ? IDM_PERMDELETE : IDM_DELETE); SetConditionalCascade(DirMenu, IDM_MISCSUBMENU, IDM_SIZES); SetConditionalCascade(DirMenu, IDM_OPENSUBMENU, IDM_OPENWINDOW); if (fWorkPlace) { WinSendMsg(DirMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID); WinSendMsg(DirMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID); } } else if (hwndMenu == &TreeMenu) { WinSetWindowUShort(TreeMenu, QWS_ID, IDM_FILESMENU); SetConditionalCascade(TreeMenu, IDM_COMMANDSMENU, IDM_DOITYOURSELF); SetConditionalCascade(TreeMenu, IDM_SAVESUBMENU, IDM_SAVETOCLIP); SetConditionalCascade(TreeMenu, IDM_EDITSUBMENU, IDM_ATTRS); SetConditionalCascade(TreeMenu, IDM_EXPANDSUBMENU, IDM_EXPAND); SetConditionalCascade(TreeMenu, IDM_MISCSUBMENU, IDM_SIZES); SetConditionalCascade(TreeMenu, IDM_OPENSUBMENU, IDM_OPENWINDOW); if (fWorkPlace) { WinSendMsg(TreeMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID); WinSendMsg(TreeMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID); } } else if (hwndMenu == &ArcMenu) { WinSetWindowUShort(ArcMenu, QWS_ID, IDM_FILESMENU); SetConditionalCascade(ArcMenu, IDM_EXTRACTSUBMENU, IDM_EXTRACT); SetConditionalCascade(ArcMenu, IDM_EDITSUBMENU, IDM_EDIT); SetConditionalCascade(ArcMenu, IDM_VIEWSUBMENU, IDM_VIEW); if (fWorkPlace) WinSendMsg(ArcMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_FOLDERAFTEREXTRACT, TRUE), MPVOID); } else if (hwndMenu == &FileMenu) { WinSetWindowUShort(FileMenu, QWS_ID, IDM_FILESMENU); SetConditionalCascade(FileMenu, IDM_COMMANDSMENU, IDM_DOITYOURSELF); SetConditionalCascade(FileMenu, IDM_COPYMENU, IDM_COPY); SetConditionalCascade(FileMenu, IDM_MOVEMENU, IDM_MOVE); SetConditionalCascade(FileMenu, IDM_SAVESUBMENU, IDM_SAVETOCLIP); SetConditionalCascade(FileMenu, IDM_VIEWSUBMENU, IDM_VIEW); SetConditionalCascade(FileMenu, IDM_EDITSUBMENU, IDM_EDIT); SetConditionalCascade(FileMenu, IDM_COLLECTMENU, IDM_COLLECT); SetConditionalCascade(FileMenu, IDM_DELETESUBMENU, (fDefaultDeletePerm) ? IDM_PERMDELETE : IDM_DELETE); SetConditionalCascade(FileMenu, IDM_OPENSUBMENU, IDM_OPENDEFAULT); SetConditionalCascade(FileMenu, IDM_OBJECTSUBMENU, IDM_SHADOW); if (fWorkPlace) { WinSendMsg(FileMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID); WinSendMsg(FileMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID); } } else if (hwndMenu == &DirCnrMenu) { WinSetWindowUShort(DirCnrMenu, QWS_ID, IDM_VIEWSMENU); SetConditionalCascade(DirCnrMenu, IDM_MISCSUBMENU, IDM_SIZES); SetConditionalCascade(DirCnrMenu, IDM_OPENSUBMENU, IDM_OPENSETTINGSME); if (fWorkPlace) WinSendMsg(DirCnrMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID); } else if (hwndMenu == &TreeCnrMenu) { WinSetWindowUShort(TreeCnrMenu, QWS_ID, IDM_VIEWSMENU); SetConditionalCascade(TreeCnrMenu, IDM_PARTITIONSMENU, IDM_PARTITION); if (fWorkPlace) WinSendMsg(TreeCnrMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_PARTITIONSMENU, TRUE), MPVOID); } else if (hwndMenu == &ArcCnrMenu) { WinSetWindowUShort(ArcCnrMenu, QWS_ID, IDM_VIEWSMENU); SetConditionalCascade(ArcCnrMenu, IDM_EXTRACTSUBMENU, IDM_ARCEXTRACT); if (fWorkPlace) WinSendMsg(ArcCnrMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_FOLDERAFTEREXTRACT, TRUE), MPVOID); } else if (hwndMenu == &CollectorCnrMenu) { WinSetWindowUShort(CollectorCnrMenu, QWS_ID, IDM_VIEWSMENU); SetConditionalCascade(CollectorCnrMenu, IDM_COLLECTMENU, IDM_COLLECTFROMCLIP); } else if (hwndMenu == &CollectorFileMenu) { WinSetWindowUShort(CollectorFileMenu, QWS_ID, IDM_FILESMENU); SetConditionalCascade(CollectorFileMenu, IDM_COMMANDSMENU, IDM_DOITYOURSELF); SetConditionalCascade(CollectorFileMenu, IDM_COPYMENU, IDM_COPY); SetConditionalCascade(CollectorFileMenu, IDM_MOVEMENU, IDM_MOVE); SetConditionalCascade(CollectorFileMenu, IDM_SAVESUBMENU, IDM_SAVETOCLIP); SetConditionalCascade(CollectorFileMenu, IDM_VIEWSUBMENU, IDM_VIEW); SetConditionalCascade(CollectorFileMenu, IDM_EDITSUBMENU, IDM_EDIT); SetConditionalCascade(CollectorFileMenu, IDM_DELETESUBMENU, (fDefaultDeletePerm) ? IDM_PERMDELETE : IDM_DELETE); SetConditionalCascade(CollectorFileMenu, IDM_OPENSUBMENU, IDM_OPENDEFAULT); SetConditionalCascade(CollectorFileMenu, IDM_OBJECTSUBMENU, IDM_SHADOW); if (fWorkPlace) { WinSendMsg(CollectorFileMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID); WinSendMsg(CollectorFileMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID); } } else if (hwndMenu == &CollectorDirMenu) { WinSetWindowUShort(CollectorDirMenu, QWS_ID, IDM_FILESMENU); SetConditionalCascade(CollectorDirMenu, IDM_COMMANDSMENU, IDM_DOITYOURSELF); SetConditionalCascade(CollectorDirMenu, IDM_COPYMENU, IDM_COPY); SetConditionalCascade(CollectorDirMenu, IDM_MOVEMENU, IDM_MOVE); SetConditionalCascade(CollectorDirMenu, IDM_SAVESUBMENU, IDM_SAVETOCLIP); SetConditionalCascade(CollectorDirMenu, IDM_VIEWSUBMENU, IDM_INFO); SetConditionalCascade(CollectorDirMenu, IDM_EDITSUBMENU, IDM_ATTRS); SetConditionalCascade(CollectorDirMenu, IDM_DELETESUBMENU, (fDefaultDeletePerm) ? IDM_PERMDELETE : IDM_DELETE); SetConditionalCascade(CollectorDirMenu, IDM_MISCSUBMENU, IDM_SIZES); SetConditionalCascade(CollectorDirMenu, IDM_OPENSUBMENU, IDM_OPENWINDOW); if (fWorkPlace) { WinSendMsg(CollectorDirMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID); WinSendMsg(CollectorDirMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID); } } else if (hwndMenu == &MainPopupMenu) { WinSetWindowUShort(MainPopupMenu, QWS_ID, IDM_MAINPOPUP); SetConditionalCascade(MainPopupMenu, IDM_TOOLSUBMENU, IDM_TOOLBAR); SetConditionalCascade(MainPopupMenu, IDM_AUTOVIEWSUBMENU, IDM_AUTOVIEW); } } return *hwndMenu; } SHORT AddToListboxBottom(HWND hwnd, CHAR * str) { SHORT ln; ln = (SHORT) WinSendMsg(hwnd, LM_INSERTITEM, MPFROM2SHORT(LIT_END, 0), MPFROMP(str)); if (ln) WinSendMsg(hwnd, LM_SELECTITEM, MPFROM2SHORT(ln, 0), MPVOID); return ln; } VOID SetSysMenu(HWND hwndSysMenu) { CHAR s[128], *p; if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT, MPFROM2SHORT(SC_RESTORE, 128), MPFROMP(s))) { p = strchr(s, '\t'); if (p) { p++; strcpy(p, "Ctrl+Alt+F5"); WinSetMenuItemText(hwndSysMenu, SC_RESTORE, s); } } if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT, MPFROM2SHORT(SC_CLOSE, 128), MPFROMP(s))) { p = strchr(s, '\t'); if (p) { p++; strcpy(p, "Ctrl+Alt+F4"); WinSetMenuItemText(hwndSysMenu, SC_CLOSE, s); } } if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT, MPFROM2SHORT(SC_MOVE, 128), MPFROMP(s))) { p = strchr(s, '\t'); if (p) { p++; strcpy(p, "Ctrl+Alt+F7"); WinSetMenuItemText(hwndSysMenu, SC_MOVE, s); } } if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT, MPFROM2SHORT(SC_SIZE, 128), MPFROMP(s))) { p = strchr(s, '\t'); if (p) { p++; strcpy(p, "Ctrl+Alt+F8"); WinSetMenuItemText(hwndSysMenu, SC_SIZE, s); } } if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT, MPFROM2SHORT(SC_MINIMIZE, 128), MPFROMP(s))) { p = strchr(s, '\t'); if (p) { p++; strcpy(p, "Ctrl+Alt+F9"); WinSetMenuItemText(hwndSysMenu, SC_MINIMIZE, s); } } if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT, MPFROM2SHORT(SC_MAXIMIZE, 128), MPFROMP(s))) { p = strchr(s, '\t'); if (p) { p++; strcpy(p, "Ctrl+Alt+F10"); WinSetMenuItemText(hwndSysMenu, SC_MAXIMIZE, s); } } if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT, MPFROM2SHORT(SC_HIDE, 128), MPFROMP(s))) { p = strchr(s, '\t'); if (p) { p++; strcpy(p, "Ctrl+Alt+F11"); WinSetMenuItemText(hwndSysMenu, SC_HIDE, s); } } } VOID LoadLibPath(CHAR * str, LONG len) { ULONG ver[2]; CHAR configsys[] = "C:\\CONFIG.SYS"; static CHAR var[8192], beg[16384], end[16384]; BOOL warp; FILE *fp; PFN DQELIBPATH = NULL; HMODULE hmod; if (str && len) { *str = 0; if (DosQuerySysInfo(QSV_BOOT_DRIVE, QSV_BOOT_DRIVE, (PVOID) ver, (ULONG) sizeof(ULONG))) ver[0] = 3L; *configsys = (CHAR) ver[0] + '@'; if (!DosQuerySysInfo(QSV_VERSION_MAJOR, QSV_VERSION_MINOR, (PVOID) ver, (ULONG) sizeof(ver)) && ver[1] >= 30) warp = TRUE; *var = *beg = *end = 0; if (warp) { if (!DosLoadModule(var, sizeof(var), "DOSCALL1.DLL", &hmod)) { if (!DosQueryProcAddr(hmod, ORD_DOS32QUERYEXTLIBPATH, NULL, (PFN *) & DQELIBPATH)) { DQELIBPATH(beg, BEGIN_LIBPATH); DQELIBPATH(end, END_LIBPATH); } DosFreeModule(hmod); } *var = 0; } fp = xfopen(configsys, "r", pszSrcFile, __LINE__); if (fp) { while (!feof(fp)) { if (!xfgets_bstripcr(var, sizeof(var), fp, pszSrcFile, __LINE__)) break; if (!strnicmp(var, "LIBPATH=", 8)) { memmove(var, var + 8, strlen(var + 8) + 1); lstrip(var); break; } } fclose(fp); } strncpy(str, beg, len); strncat(str, var, len - strlen(str)); strncat(str, end, len - strlen(str)); str[len - 1] = 0; } } void SetViewMenu(HWND hwndMenu, ULONG flWindowAttr) { WinCheckMenuItem(hwndMenu, IDM_MINIICONS, ((flWindowAttr & CV_MINI))); WinCheckMenuItem(hwndMenu, IDM_TEXT, ((flWindowAttr & CV_TEXT))); WinCheckMenuItem(hwndMenu, IDM_ICON, ((flWindowAttr & CV_ICON) && !(flWindowAttr & CV_TREE))); WinCheckMenuItem(hwndMenu, IDM_TREEVIEW, ((flWindowAttr & CV_TREE))); WinCheckMenuItem(hwndMenu, IDM_DETAILS, ((flWindowAttr & CV_DETAIL))); WinCheckMenuItem(hwndMenu, IDM_NAME, ((flWindowAttr & CV_NAME))); } void SaySort(HWND hwnd, INT sortflags, BOOL archive) { char *s = NULL; s = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__); if (s) { sprintf(s, "S:%s%s", (sortflags & SORT_REVERSE) ? "^" : NullStr, (sortflags & SORT_FIRSTEXTENSION) ? GetPString(IDS_FIRSTX) : (sortflags & SORT_LASTEXTENSION) ? GetPString(IDS_LASTX) : (sortflags & SORT_SIZE) ? "Size" : (sortflags & SORT_EASIZE) ? (archive == 0) ? GetPString(IDS_EASIZE) : GetPString(IDS_CSIZE) : (sortflags & SORT_LWDATE) ? (archive == 0) ? GetPString(IDS_LWDATE) : GetPString(IDS_DATE) : (sortflags & SORT_LADATE) ? GetPString(IDS_LADATE) : (sortflags & SORT_CRDATE) ? GetPString(IDS_CRDATE) : (sortflags & SORT_PATHNAME) ? GetPString(IDS_PATH) : (sortflags & SORT_NOSORT) ? GetPString(IDS_NONE) : (sortflags & SORT_SUBJECT) ? GetPString(IDS_SUBJ) : GetPString(IDS_NAME)); WinSetWindowText(hwnd, s); free(s); } } void SayView(HWND hwnd, ULONG flWindowAttr) { char *s = NULL; s = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__); if (s) { sprintf(s, "V:%s%s", (flWindowAttr & CV_TREE) ? GetPString(IDS_TREE) : (flWindowAttr & CV_NAME) ? GetPString(IDS_NAME) : (flWindowAttr & CV_DETAIL) ? GetPString(IDS_DETAIL) : (flWindowAttr & CV_TEXT) ? GetPString(IDS_TEXT) : GetPString(IDS_ICON), ((flWindowAttr & CV_MINI) && !(flWindowAttr & CV_TEXT)) ? GetPString(IDS_MINI) : NullStr); WinSetWindowText(hwnd, s); free(s); } } void SayFilter(HWND hwnd, MASK * mask, BOOL archive) { char *s = NULL; s = xmalloc(CCHMAXPATH * 2, pszSrcFile, __LINE__); if (s) { sprintf(s, "F:%s%s", mask->szMask, (!archive && (mask->attrFile != ALLATTRS || mask->antiattr != 0)) ? " " : NullStr, (!archive && (mask->attrFile != ALLATTRS || mask->antiattr != 0)) ? GetPString(IDS_ATTRTEXT) : NullStr); if (!s[2]) sprintf(s, "F:%s", GetPString(IDS_ALLTEXT)); WinSetWindowText(hwnd, s); free(s); } } char *GetCmdSpec(BOOL dos) { char *cmspec; if (!dos) { cmspec = getenv("OS2_SHELL"); if (!cmspec) cmspec = getenv("COMSPEC"); if (!cmspec) cmspec = "CMD.EXE"; } else { cmspec = getenv("DOS_SHELL"); if (!cmspec) cmspec = "COMMAND.COM"; } return cmspec; } void Broadcast(HAB hab, HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { if (hwndMain) WinBroadcastMsg(hwndMain, msg, mp1, mp2, BMSG_SEND | BMSG_FRAMEONLY); if (hwnd && hwnd != HWND_DESKTOP && hwnd != hwndMain && hwnd != WinQueryDesktopWindow(hab, NULLHANDLE) && WinIsWindow(hab, hwnd) && (!hwndMain || !WinIsChild(hwnd, hwndMain))) WinSendMsg(hwnd, msg, mp1, mp2); } void SetupWinList(HWND hwndMenu, HWND hwndTop, HWND hwndFrame) { /* * add switchlist entries to end of pulldown menu */ SHORT sItemCount, x = 0, y = 0; MENUITEM mi; sItemCount = (SHORT) WinSendMsg(hwndMenu, MM_QUERYITEMCOUNT, MPVOID, MPVOID); /* clean out old additions */ while ((SHORT) WinSendMsg(hwndMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_SWITCHSTART + x++, TRUE), MPVOID) < sItemCount) sItemCount--; x = 0; while ((SHORT) WinSendMsg(hwndMenu, MM_DELETEITEM, MPFROM2SHORT(IDM_WINDOWSTART + x++, TRUE), MPVOID) < sItemCount) sItemCount--; x = 0; if (hwndTop) { char wtext[CCHMAXPATH + 8]; HENUM henum; HWND hwndChild; /* add children of the main FM/2 client */ henum = WinBeginEnumWindows(hwndTop); memset(&mi, 0, sizeof(mi)); while ((hwndChild = WinGetNextWindow(henum)) != NULLHANDLE) { if (WinQueryWindowUShort(hwndChild, QWS_ID) && hwndChild != hwndFrame) { *wtext = 0; WinQueryWindowText(hwndChild, CCHMAXPATH + 8, wtext); if (*wtext) { wtext[CCHMAXPATH + 7] = 0; mi.afStyle = MIS_TEXT; if (!((x + sItemCount) % 28)) mi.afStyle |= MIS_BREAK; mi.id = IDM_WINDOWSTART + x; mi.iPosition = MIT_END; if ((SHORT) WinSendMsg(hwndMenu, MM_INSERTITEM, MPFROMP(&mi), MPFROMP(wtext)) >= 0) x++; } } } WinEndEnumWindows(henum); } /* add external FM/2 windows */ { PSWBLOCK pswb; ULONG ulSize, ulcEntries; HWND hwndTopFrame; register INT i; hwndTopFrame = (hwndTop) ? WinQueryWindow(hwndTop, QW_PARENT) : (HWND) 0; /* Get the switch list information */ x = 0; ulcEntries = WinQuerySwitchList(0, NULL, 0); ulSize = sizeof(SWBLOCK) + sizeof(HSWITCH) + (ulcEntries + 4L) * (LONG) sizeof(SWENTRY); /* Allocate memory for list */ pswb = xmalloc(ulSize, pszSrcFile, __LINE__); if (pswb) { /* Put the info in the list */ ulcEntries = WinQuerySwitchList(0, pswb, ulSize - sizeof(SWENTRY)); /* do the dirty deed */ memset(&mi, 0, sizeof(mi)); for (i = 0; i < pswb->cswentry; i++) { if (pswb->aswentry[i].swctl.uchVisibility == SWL_VISIBLE && pswb->aswentry[i].swctl.fbJump == SWL_JUMPABLE && (pswb->aswentry[i].swctl.idProcess != mypid || !hwndFrame || pswb->aswentry[i].swctl.hwnd != hwndFrame) && (pswb->aswentry[i].swctl.idProcess != mypid || !hwndTopFrame || pswb->aswentry[i].swctl.hwnd != hwndTopFrame || !WinIsChild(hwndFrame, hwndTop))) { if (!strnicmp(pswb->aswentry[i].swctl.szSwtitle, "AV/2", 4) || !stricmp(pswb->aswentry[i].swctl.szSwtitle, "File Manager/2") || !stricmp(pswb->aswentry[i].swctl.szSwtitle, "Collector") || !strnicmp(pswb->aswentry[i].swctl.szSwtitle, "VTree", 5) || !strnicmp(pswb->aswentry[i].swctl.szSwtitle, "VDir", 4) || !strnicmp(pswb->aswentry[i].swctl.szSwtitle, FM2Str, 4)) { mi.afStyle = MIS_TEXT; if (x && !(x % 28)) mi.afStyle |= MIS_BREAK; mi.id = IDM_SWITCHSTART + y; mi.iPosition = MIT_END; switches[y] = pswb->aswentry[i].hswitch; if ((SHORT) WinSendMsg(hwndMenu, MM_INSERTITEM, MPFROMP(&mi), MPFROMP(pswb->aswentry[i]. swctl.szSwtitle)) >= 0) { y++; x++; } } } } numswitches = y; free(pswb); DosPostEventSem(CompactSem); } } } BOOL SwitchCommand(HWND hwndMenu, USHORT cmd) { BOOL ret = FALSE; if (hwndMain && hwndMenu && cmd >= IDM_WINDOWSTART && cmd < IDM_SWITCHSTART) { /* * select a child window (of client) */ MENUITEM mi; HWND hwndSubMenu = (HWND) 0, hwndChild; CHAR s[CCHMAXPATH + 8]; if (WinQueryWindowUShort(hwndMenu, QWS_ID) != IDM_WINDOWSMENU) { memset(&mi, 0, sizeof(mi)); mi.iPosition = MIT_END; mi.afStyle = MIS_TEXT; if (WinSendMsg(hwndMenu, MM_QUERYITEM, MPFROM2SHORT(IDM_WINDOWSMENU, TRUE), MPFROMP(&mi))) hwndSubMenu = mi.hwndSubMenu; } else hwndSubMenu = hwndMenu; if (hwndSubMenu) { *s = 0; if (WinSendMsg(hwndSubMenu, MM_QUERYITEMTEXT, MPFROM2SHORT(cmd, CCHMAXPATH + 8), MPFROMP(s)) && *s) { HENUM henum; CHAR checkText[CCHMAXPATH + 8]; SWP swp; s[CCHMAXPATH + 7] = 0; henum = WinBeginEnumWindows(hwndMain); while ((hwndChild = WinGetNextWindow(henum)) != NULLHANDLE) { if (WinQueryWindowUShort(hwndChild, QWS_ID)) { *checkText = 0; WinQueryWindowText(hwndChild, CCHMAXPATH + 8, checkText); checkText[CCHMAXPATH + 7] = 0; if (!stricmp(checkText, s)) { if (WinQueryWindowPos(hwndChild, &swp)) { if (swp.fl & (SWP_MINIMIZE | SWP_HIDE)) WinSetWindowPos(hwndChild, HWND_TOP, 0, 0, 0, 0, SWP_RESTORE | SWP_ZORDER); } WinSetActiveWindow(HWND_DESKTOP, hwndChild); ret = TRUE; break; } } } WinEndEnumWindows(henum); } } } else if (cmd >= IDM_SWITCHSTART && cmd < IDM_SWITCHSTART + 499) { if (cmd - IDM_SWITCHSTART < numswitches) { WinSwitchToProgram(switches[cmd - IDM_SWITCHSTART]); ret = TRUE; } } return ret; }