able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/osshell/progman/pmgseg.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

3409 lines
101 KiB
C
Raw Blame History

/****************************************************************************/
/* */
/* PMGSEG.C - */
/* */
/* Program Manager Group Handling Routines */
/* */
/****************************************************************************/
#include "progman.h"
#include "dde.h"
#include "convgrp.h"
#define WORD_MIN -32767
#define WORD_MAX 32767
#ifndef ORGCODE
#include "fcntl.h"
#include "io.h"
#include "stdio.h"
#include <tchar.h>
#define S_IREAD 0000400 /* read permission, owner */
#define S_IWRITE 0000200 /* write permission, owner */
#endif
BOOL fFirstLoad = FALSE;
extern BOOL bHandleProgramGroupsEvent;
#if 0
// DOS apps are no longer set to fullscreen by default in progman
// 5-3-93 johannec (bug 8343)
#ifdef i386
BOOL IsDOSApplication(LPTSTR lpPath);
BOOL SetDOSApplicationToFullScreen(LPTSTR lpTitle);
#endif
#endif
void NEAR PASCAL RemoveItemFromList(PGROUP pGroup, PITEM pItem)
// Removes a PITEM from the list.
{
PITEM *ppItem;
/* Cause it to be repainted later. */
InvalidateIcon(pGroup, pItem);
if (pItem == pGroup->pItems) {
/*
* first one in list, must invalidate next one so it paints an active
* title bar.
*/
InvalidateIcon(pGroup,pItem->pNext);
}
/* Remove it from the list. */
for (ppItem = &pGroup->pItems;*ppItem != pItem;
ppItem = &((*ppItem)->pNext));
*ppItem = pItem->pNext;
/* Lastly free up the memory. */
LocalFree((HANDLE)pItem);
}
#ifdef DEBUG
void NEAR PASCAL CheckBeforeReAlloc(HANDLE h)
{
TCHAR buf[100];
if ((BYTE)GlobalFlags(h)) {
wsprintf(buf, TEXT("LockCount before realloc %d\r\n"), (BYTE)GlobalFlags(h));
OutputDebugString(buf);
DbgBreakPoint();
}
}
#else
#define CheckBeforeReAlloc(h)
#endif
#ifdef PARANOID
/*--------------------------------------------------------------------------*/
/* */
/* CheckRange() - */
/* */
/*--------------------------------------------------------------------------*/
void PASCAL CheckRange(
LPGROUPDEF lpgd,
LPTSTR lp1,
WORD *lpw1,
WORD cb1,
LPTSTR lp2,
WORD w2,
WORD cb2,
LPTSTR lpThing)
{
WORD w1 = *lpw1;
WORD e1, e2;
if (!w1 || (w1 == w2)) {
return;
}
if (!cb1) {
cb1 = (WORD)lstrlen((LPTSTR) PTR(lpgd, *lpw1));
}
e1 = w1 + cb1;
e2 = w2 + cb2;
if ((w1 < e2) && (w2 < e1)) {
KdPrint(("ERROR: %s overlaps %s in %s!!!!\r\n",lp2,lp1,lpThing));
}
}
/*--------------------------------------------------------------------------*/
/* */
/* CheckPointer() - */
/* */
/*--------------------------------------------------------------------------*/
void PASCAL CheckPointer(
LPGROUPDEF lpgd,
LPTSTR lp,
WORD *lpw,
WORD cb,
WORD limit)
{
LPITEMDEF lpid;
int i;
if (lpw == NULL || !*lpw) {
KdPrint(("Warning: %s is NULL\r\n", lp));
DebugBreak();
}
if (!cb) {
cb = lstrlen((LPTSTR) PTR(lpgd, *lpw));
}
if (*lpw + cb > limit) {
KdPrint(("ERROR: %s runs off end of group\r\n", lp));
return;
}
}
/*--------------------------------------------------------------------------*/
/* */
/* VerifyGroup() - */
/* */
/*--------------------------------------------------------------------------*/
void PASCAL VerifyGroup(
LPGROUPDEF lpgd)
{
int i;
LPITEMDEF lpid;
DWORD limit = lpgd->cbGroup;
KdPrint(("\r\nChecking Group %s\r\n",(LPTSTR) PTR(lpgd, lpgd->pName)));
CheckPointer(lpgd, TEXT("Group Name"), &lpgd->pName, 0, limit);
for (i = 0; i < (int)lpgd->cItems; i++) {
if (!lpgd->rgiItems[i]) {
continue;
}
lpid = ITEM(lpgd, i);
KdPrint(("Checking item %d at %4.4X (%s):\r\n", i, lpgd->rgiItems[i],
(LPTSTR) PTR(lpgd, lpid->pName)));
CheckPointer(lpgd, TEXT("Itemdef"), lpgd->rgiItems + i, sizeof(ITEMDEF), limit);
CheckPointer(lpgd, TEXT("Item name"), &lpid->pName, 0, limit);
CheckPointer(lpgd, TEXT("item command"), &lpid->pCommand, 0, limit);
CheckPointer(lpgd, TEXT("item icon path"), &lpid->pIconPath, 0, limit);
}
}
#endif
/*--------------------------------------------------------------------------*/
/* */
/* IsGroupReadOnly() - */
/* */
/*--------------------------------------------------------------------------*/
BOOL FAR PASCAL IsGroupReadOnly(LPTSTR szGroupKey, BOOL bCommonGroup)
{
HKEY hkey;
HKEY hkeyGroups;
if (bCommonGroup)
hkeyGroups = hkeyCommonGroups;
else if (bUseANSIGroups)
hkeyGroups = hkeyAnsiProgramGroups;
else
hkeyGroups = hkeyProgramGroups;
if (!hkeyGroups)
return(FALSE);
if (!RegOpenKeyEx(hkeyGroups, szGroupKey, 0, DELETE | KEY_READ | KEY_WRITE, &hkey)){
RegCloseKey(hkey);
return(FALSE);
}
return(TRUE);
}
/*--------------------------------------------------------------------------*/
/* */
/* GroupCheck() - */
/* */
/*--------------------------------------------------------------------------*/
BOOL FAR PASCAL GroupCheck(PGROUP pGroup)
{
if (!fExiting && IsGroupReadOnly(pGroup->lpKey, pGroup->fCommon)) {
pGroup->fRO = TRUE;
return FALSE;
}
pGroup->fRO = FALSE;
return TRUE;
}
/*--------------------------------------------------------------------------*/
/* */
/* MyDwordAlign() - */
/* */
/*--------------------------------------------------------------------------*/
INT MyDwordAlign(INT wStrLen)
{
return ((wStrLen + 3) & ~3);
}
/*--------------------------------------------------------------------------*/
/* */
/* SizeofGroup() - */
/* */
/*--------------------------------------------------------------------------*/
DWORD PASCAL SizeofGroup(LPGROUPDEF lpgd)
{
LPPMTAG lptag;
DWORD cbSeg;
DWORD cb;
cbSeg = (DWORD)GlobalSize(lpgd);
lptag = (LPPMTAG)((LPSTR)lpgd+lpgd->cbGroup);
if ((DWORD)((PCHAR)lptag - (PCHAR)lpgd +MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb))+4) <= cbSeg
&& lptag->wID == ID_MAGIC
&& lptag->wItem == (int)0xFFFF
&& lptag->cb == (WORD)(MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)) + 4)
&& *(PLONG)lptag->rgb == PMTAG_MAGIC)
{
while ((cb = (DWORD)((PCHAR)lptag - (PCHAR)lpgd + MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)))) <= cbSeg)
{
if (lptag->wID == ID_LASTTAG)
return cb;
(LPSTR)lptag += lptag->cb;
}
}
return lpgd->cbGroup;
}
/*--------------------------------------------------------------------------*/
/* */
/* LockGroup() - */
/* */
/*--------------------------------------------------------------------------*/
/* Given the handle to the group's window, lock the group segment and return
* a pointer thereto. Reloads the group segment if it is not in memory.
*/
LPGROUPDEF FAR PASCAL LockGroup(HWND hwndGroup)
{
PGROUP pGroup;
LPGROUPDEF lpgd;
WORD status;
LPTSTR lpszKey;
HKEY hKey = NULL;
LONG err;
DWORD cbMaxValueLen = 0;
FILETIME ft;
TCHAR szClass[64];
DWORD dummy = 64;
DWORD cbSecDesc;
HKEY hkeyGroups;
BOOL bCommonGroup;
wLockError = 0; // No errors.
/* Find the handle and try to lock it. */
pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
/* If we got a non-NULL selector, return the pointer. */
if (pGroup->fLoaded)
return(lpgd);
if (lpgd) {
GlobalUnlock(pGroup->hGroup);
}
NukeIconBitmap(pGroup); // invalidate the bitmap
/* The group has been discarded, must reread the file... */
lpszKey = pGroup->lpKey;
pGroup->fRO = FALSE;
bCommonGroup = pGroup->fCommon;
if (bCommonGroup)
hkeyGroups = hkeyCommonGroups;
else if (bUseANSIGroups)
hkeyGroups = hkeyAnsiProgramGroups;
else
hkeyGroups = hkeyProgramGroups;
if (!hkeyGroups)
goto RegError;
/* Try to open the group key. */
if (err = RegOpenKeyEx(hkeyGroups, lpszKey, 0,
DELETE | KEY_READ | KEY_WRITE,
&hKey)) {
/* Try read-only access */
if (err = RegOpenKeyEx(hkeyGroups, lpszKey, 0,
KEY_READ, &hKey) || !hKey) {
status = IDS_NOGRPFILE;
goto LGError1;
}
if (!bUseANSIGroups) {
pGroup->fRO = TRUE;
}
}
if (!(err = RegQueryInfoKey(hKey,
szClass,
&dummy, // cbClass
NULL, // Title index
&dummy, // cbSubKeys
&dummy, // cb Max subkey length
&dummy, // max class len
&dummy, // values count
&dummy, // max value name length
&cbMaxValueLen,
&cbSecDesc, // cb Security Descriptor
&ft))) {
if (!pGroup->ftLastWriteTime.dwLowDateTime &&
!pGroup->ftLastWriteTime.dwHighDateTime)
pGroup->ftLastWriteTime = ft;
else if (pGroup->ftLastWriteTime.dwLowDateTime != ft.dwLowDateTime ||
pGroup->ftLastWriteTime.dwHighDateTime != ft.dwHighDateTime ) {
wLockError = LOCK_FILECHANGED;
status = IDS_GRPHASCHANGED;
if (!fExiting) // Don't reload changed groups on exit.
PostMessage(hwndProgman,WM_RELOADGROUP,(WPARAM)pGroup,0L);
goto LGError2;
}
}
/* Find the size of the file by seeking to the end. */
if (cbMaxValueLen < sizeof(GROUPDEF)) {
status = IDS_BADFILE;
goto LGError2;
}
/* Allocate some memory for the thing. */
CheckBeforeReAlloc(pGroup->hGroup);
if (!GlobalReAlloc(pGroup->hGroup, (DWORD)cbMaxValueLen, GMEM_MOVEABLE)) {
wLockError = LOCK_LOWMEM;
status = IDS_LOWMEM;
lpszKey = NULL;
goto LGError2;
}
pGroup->fLoaded = TRUE;
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
/* Read the whole group data into memory. */
status = IDS_BADFILE;
if (err = RegQueryValueEx(hKey, NULL, 0, 0, (LPBYTE)lpgd, &cbMaxValueLen)) {
goto LGError3;
}
//
// If we start out from the ANSI groups, we need the security description
// to copy the entire information to the UNICODE groups
//
if (bUseANSIGroups) {
pGroup->pSecDesc = (PSECURITY_DESCRIPTOR)LocalAlloc(LPTR, cbSecDesc);
RegGetKeySecurity(hKey, DACL_SECURITY_INFORMATION, pGroup->pSecDesc, &cbSecDesc);
}
else {
pGroup->pSecDesc = NULL;
}
//
// If we loaded an old format ANSI group, then convert it to the
// UNICODE format and save it back in the registry.
//
if (lpgd->dwMagic == GROUP_MAGIC) {
HANDLE hUNIGroup;
if (cbMaxValueLen = ConvertToUnicodeGroup((LPGROUPDEF_A)lpgd, &hUNIGroup)) {
UnlockGroup(hwndGroup);
/* Free the ANSI group. */
GlobalFree(pGroup->hGroup);
pGroup->hGroup = hUNIGroup;
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
}
else {
goto LGError3;
}
}
if (lpgd->dwMagic != GROUP_UNICODE)
goto LGError3;
if (lpgd->cbGroup > cbMaxValueLen)
goto LGError3;
/* Now return the pointer. */
RegCloseKey(hKey);
return(lpgd);
LGError3:
GlobalUnlock(pGroup->hGroup);
GlobalDiscard(pGroup->hGroup);
pGroup->fLoaded = FALSE;
LGError2:
RegCloseKey(hKey);
LGError1:
if (status != IDS_LOWMEM && status != IDS_GRPHASCHANGED && status != IDS_NOGRPFILE) {
MyMessageBox(hwndProgman, IDS_GROUPFILEERR, status, pGroup->lpKey,
MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
if (status == IDS_BADFILE) {
//
// stop handling of Program Groups key changes.
//
bHandleProgramGroupsEvent = FALSE;
RegDeleteKey(hkeyGroups, lpszKey);
//
// reset handling of Program Groups key changes.
//
ResetProgramGroupsEvent(bCommonGroup);
bHandleProgramGroupsEvent = TRUE;
}
return(NULL);
}
/*
* Special case the group not being found so we can delete it's entry...
*/
if (status == IDS_NOGRPFILE) {
/*
* If no restrictions then we can fixup progman.ini...
*/
if (!fNoSave && dwEditLevel < 1) {
TCHAR szGroup[10];
if (MyMessageBox(hwndProgman,IDS_GROUPFILEERR,IDS_NOGRPFILE2,lpszKey, MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON1 | MB_SYSTEMMODAL) == IDNO) {
wsprintf(szGroup,TEXT("Group%d"),pGroup->wIndex);
//
// stop handling of Program Groups key changes.
//
bHandleProgramGroupsEvent = FALSE;
RegDeleteKey(hkeyProgramGroups, lpszKey);
//
// reset handling of Program Groups key changes.
//
ResetProgramGroupsEvent(bCommonGroup);
bHandleProgramGroupsEvent = TRUE;
RegDeleteValue(hkeyPMGroups, szGroup);
if (!fFirstLoad)
PostMessage(hwndProgman,WM_UNLOADGROUP,(WPARAM)hwndGroup,0L);
}
}
else {
RegError:
/*
* Restrictions mean that the user can only OK this error...
*/
MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_NOGRPFILE, lpszKey,
MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
}
}
ShowWindow(hwndGroup, SW_SHOWMINNOACTIVE);
return(NULL);
}
/*--------------------------------------------------------------------------*/
/* */
/* UnlockGroup() - */
/* */
/*--------------------------------------------------------------------------*/
void FAR PASCAL UnlockGroup(register HWND hwndGroup)
{
GlobalUnlock(((PGROUP)GetWindowLongPtr(hwndGroup,GWLP_PGROUP))->hGroup);
}
/*--------------------------------------------------------------------------*/
/* */
/* LockItem() - */
/* */
/*--------------------------------------------------------------------------*/
LPITEMDEF FAR PASCAL LockItem(PGROUP pGroup, PITEM pItem)
{
LPGROUPDEF lpgd;
lpgd = LockGroup(pGroup->hwnd);
if (!lpgd)
return((LPITEMDEF)NULL);
return ITEM(lpgd,pItem->iItem);
}
/*--------------------------------------------------------------------------*/
/* */
/* KeepGroupAround() - */
/* */
/*--------------------------------------------------------------------------*/
/*
* Sets or unsets the discardable flag for the given group file. If setting
* to non-discard, forces the group to be in memory.
*/
HANDLE PASCAL KeepGroupAround(HWND hwndGroup, BOOL fKeep)
{
PGROUP pGroup;
UNREFERENCED_PARAMETER(fKeep);
pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);
return pGroup->hGroup;
#ifdef ORGCODE
PGROUP pGroup;
WORD flag;
pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);
if (fKeep) {
if (LockGroup(hwndGroup)) {
UnlockGroup(hwndGroup); // it is still in memory
} else {
return NULL; // failure
}
flag = GMEM_MODIFY | GMEM_MOVEABLE; // make non discardable
} else {
flag = GMEM_MODIFY | GMEM_MOVEABLE | GMEM_DISCARDABLE; // discardable
}
return GlobalReAlloc(pGroup->hGroup, 0, flag);
#endif
}
/*--------------------------------------------------------------------------*/
/* */
/* SaveGroup() - */
/* */
/*--------------------------------------------------------------------------*/
/*
* Writes out a group file. It must already be in memory or the operation
* is meaningless.
*/
BOOL APIENTRY SaveGroup(
HWND hwndGroup, BOOL bDiscard
)
{
LPGROUPDEF lpgd;
HKEY hKey;
PGROUP pGroup;
WORD status = 0;
DWORD cb;
LONG err;
HKEY hkeyGroups;
BOOL bCommonGroup;
DWORD dwDisposition;
pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);
bCommonGroup = pGroup->fCommon;
if (!bUseANSIGroups && IsGroupReadOnly(pGroup->lpKey, bCommonGroup)) {
// Don't produce an error message for RO groups.
return FALSE;
}
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
if (!lpgd) {
return FALSE;
}
if (bCommonGroup)
hkeyGroups = hkeyCommonGroups;
else
hkeyGroups = hkeyProgramGroups;
if (!hkeyGroups) {
goto Exit1;
}
// it may already exist
if (err = RegCreateKeyEx(hkeyGroups, pGroup->lpKey, 0, 0, 0,
DELETE | KEY_READ | KEY_WRITE | WRITE_DAC,
pSecurityAttributes, &hKey, &dwDisposition)) {
//if (err = RegOpenKeyEx(hkeyGroups, pGroup->lpKey, 0,
// KEY_SET_VALUE, &hKey)) {
/*
* We can't open output group key.
*/
if (err = RegOpenKeyEx(hkeyGroups, pGroup->lpKey, 0,
KEY_READ, &hKey)) {
status = IDS_NOGRPFILE;
} else {
// status = IDS_GRPISRO;
RegCloseKey(hKey);
}
goto Exit1;
}
else {
if (dwDisposition == REG_CREATED_NEW_KEY && bUseANSIGroups) {
RegSetKeySecurity(hKey, DACL_SECURITY_INFORMATION, pGroup->pSecDesc);
LocalFree(pGroup->pSecDesc);
pGroup->pSecDesc = NULL;
}
}
//
// stop handling Program Groups key changes for a SAveGroup.
//
bHandleProgramGroupsEvent = FALSE;
cb = SizeofGroup(lpgd);
if (err = RegSetValueEx(hKey, NULL, 0, REG_BINARY, (LPBYTE)lpgd, cb)) {
status = IDS_CANTWRITEGRP;
}
RegFlushKey(hKey);
RegCloseKey(hKey);
pGroup->ftLastWriteTime.dwLowDateTime = 0; // update file time stamp if we need to reload
pGroup->ftLastWriteTime.dwHighDateTime = 0;
Exit1:
GlobalUnlock(pGroup->hGroup);
if (status && !fExiting) {
MyMessageBox(hwndProgman, IDS_GROUPFILEERR, status, pGroup->lpKey,
MB_OK | MB_ICONEXCLAMATION);
/*
* Force the group to be reset.
*/
if (bDiscard) {
GlobalDiscard(pGroup->hGroup);
pGroup->fLoaded = FALSE;
InvalidateRect(pGroup->hwnd, NULL, TRUE);
}
}
//
// reset handling of Program Groups key changes.
//
ResetProgramGroupsEvent(bCommonGroup);
bHandleProgramGroupsEvent = TRUE;
return (status == 0);
}
/*--------------------------------------------------------------------------*/
/* */
/* AdjustPointers() - */
/* */
/*--------------------------------------------------------------------------*/
/*
* Adjusts pointers in the segment after a section is moved up or down.
*/
void PASCAL AdjustPointers(LPGROUPDEF lpgd, DWORD iFirst, DWORD di)
{
WORD i;
LPITEMDEF lpid;
if (lpgd->pName >= iFirst) {
lpgd->pName += di;
}
for (i = 0; i < lpgd->cItems; i++) {
if (!lpgd->rgiItems[i]) {
continue;
}
if (lpgd->rgiItems[i] >= iFirst) {
lpgd->rgiItems[i] += di;
}
lpid = ITEM(lpgd, i);
if (lpid->pIconRes >= iFirst)
lpid->pIconRes += di;
if (lpid->pName >= iFirst)
lpid->pName += di;
if (lpid->pCommand >= iFirst)
lpid->pCommand += di;
if (lpid->pIconPath >= iFirst)
lpid->pIconPath += di;
}
}
/*--------------------------------------------------------------------------*/
/* */
/* FindFreeItemIndex() - */
/* */
/* Returns the index of a free slot in the item offset array. If necessary,*/
/* moves stuff around. */
/* */
/*--------------------------------------------------------------------------*/
WORD PASCAL FindFreeItemIndex(HWND hwndGroup)
{
LPGROUPDEF lpgd;
PGROUP pGroup;
WORD i;
LPTSTR lp1;
LPTSTR lp2;
DWORD cb;
lpgd = LockGroup(hwndGroup);
if (!lpgd) {
return(0xFFFF);
}
for (i = 0; i < lpgd->cItems; i++) {
if (!lpgd->rgiItems[i]) {
UnlockGroup(hwndGroup);
return(i);
}
}
/*
* Didn't find an empty slot... make some new ones.
*/
pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);
// Current groups+tags size.
cb = SizeofGroup(lpgd);
// Increase space reserved item info.
lpgd->cbGroup += NSLOTS*sizeof(DWORD);
// Increase size of whole group.
cb += NSLOTS*sizeof(DWORD);
UnlockGroup(hwndGroup);
CheckBeforeReAlloc(pGroup->hGroup);
if (!GlobalReAlloc(pGroup->hGroup, cb, GMEM_MOVEABLE)) {
return 0xFFFF;
}
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
/*
* Copy tags junk (which starts at the end of the rgiItems array)
* up a bit to make room for the bigger array..
*/
lp1 = (LPTSTR)&(lpgd->rgiItems[lpgd->cItems]);
lp2 = (LPTSTR)&(lpgd->rgiItems[lpgd->cItems + NSLOTS]);
/*
* Copy everything down in the segment.
*/
RtlMoveMemory(lp2, lp1, (WORD)(cb - (DWORD)((LPSTR)lp2 - (LPSTR)lpgd)));
/*
* Zero out the new offsets.
*/
for (i = (WORD)lpgd->cItems; i < (WORD)(lpgd->cItems + NSLOTS); i++) {
lpgd->rgiItems[i] = 0;
}
i = lpgd->cItems;
/* Record that we now have more slots */
lpgd->cItems += NSLOTS;
/*
* Fix up all the offsets in the segment. Since the rgiItems array is
* part of the group header, all the pointers will change.
*/
AdjustPointers(lpgd, (WORD)1, NSLOTS * sizeof(DWORD));
GlobalUnlock(pGroup->hGroup);
return i;
}
/*--------------------------------------------------------------------------*/
/* */
/* DeleteThing() - */
/* */
/* */
/* Removes a part of the group segment. Updates everything in the segment */
/* but does not realloc. */
/* */
/*--------------------------------------------------------------------------*/
void NEAR PASCAL DeleteThing(LPGROUPDEF lpgd, LPDWORD lpiThing, WORD cbThing)
{
DWORD dwThingOffset;
LPTSTR lp1;
LPTSTR lp2;
INT cb;
WORD cbThingSize;
if (cbThing == 0xFFFF) {
return;
}
dwThingOffset = *lpiThing;
if (!dwThingOffset)
return;
*lpiThing = 0;
lp1 = (LPTSTR) PTR(lpgd, dwThingOffset);
/* If its a string we're removing, the caller can pass 0 as the length
* and have it calculated!!!
*/
if (!cbThing) {
cbThing = (WORD)sizeof(TCHAR)*(1 + lstrlen(lp1));
}
cbThingSize = (WORD)MyDwordAlign((int)cbThing);
lp2 = (LPTSTR)((LPBYTE)lp1 + cbThingSize);
cb = (int)SizeofGroup(lpgd);
RtlMoveMemory(lp1, lp2, (cb - (DWORD)((LPSTR)lp2 - (LPSTR)lpgd)));
lpgd->cbGroup -= cbThingSize;
AdjustPointers(lpgd, dwThingOffset, -cbThingSize);
}
/*--------------------------------------------------------------------------*/
/* */
/* AddThing() - */
/* */
/* in: */
/* hGroup group handle, must not be discardable */
/* lpStuff pointer to data or NULL to init data to zero */
/* cbStuff count of item (may be 0) if lpStuff is a string */
/* */
/* Adds an object to the group segment and returns its offset. Will */
/* reallocate the segment if necessary. */
/* */
/* Handle passed in must not be discardable */
/* */
/* returns: */
/* 0 failure */
/* > 0 offset to thing in the segment */
/* */
/*--------------------------------------------------------------------------*/
DWORD PASCAL AddThing(HANDLE hGroup, LPTSTR lpStuff, DWORD cbStuff)
{
DWORD cb;
LPGROUPDEF lpgd;
DWORD offset;
LPTSTR lpT;
DWORD cbStuffSize;
DWORD cbGroupSize;
DWORD myOffset;
if (cbStuff == 0xFFFFFFFF) {
return 0xFFFFFFFF;
}
if (!cbStuff) {
cbStuff = sizeof(TCHAR)*(DWORD)(1 + lstrlen(lpStuff));
}
cbStuffSize = MyDwordAlign((int)cbStuff);
lpgd = (LPGROUPDEF)GlobalLock(hGroup);
cb = SizeofGroup(lpgd);
cbGroupSize = MyDwordAlign((int)cb);
offset = lpgd->cbGroup;
myOffset = (DWORD)MyDwordAlign((int)offset);
GlobalUnlock(hGroup);
CheckBeforeReAlloc(hGroup);
if (!GlobalReAlloc(hGroup,(DWORD)(cbGroupSize + cbStuffSize), GMEM_MOVEABLE))
return 0;
lpgd = (LPGROUPDEF)GlobalLock(hGroup);
/*
* Slide the tags up
*/
RtlMoveMemory((LPSTR)lpgd + myOffset + cbStuffSize, (LPSTR)lpgd + myOffset,
(cbGroupSize - myOffset));
lpgd->cbGroup += cbStuffSize;
lpT = (LPTSTR)((LPSTR)lpgd + myOffset);
if (lpStuff) {
RtlMoveMemory(lpT, lpStuff, cbStuff);
} else {
/*
* Zero it
*/
while (cbStuffSize--) {
*((LPSTR)lpT)++ = 0;
}
}
GlobalUnlock(hGroup);
return myOffset;
}
/*--------------------------------------------------------------------------*/
/* */
/* FindTag() - */
/* */
/*--------------------------------------------------------------------------*/
LPPMTAG NEAR PASCAL FindTag(LPGROUPDEF lpgd, int item, WORD id)
{
LPPMTAG lptag;
int cbSeg;
int cb;
cbSeg = (DWORD)GlobalSize(lpgd);
lptag = (LPPMTAG)((LPSTR)lpgd+lpgd->cbGroup);
if ((PCHAR)lptag - (PCHAR)lpgd + MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)) + 4 <= cbSeg
&& lptag->wID == ID_MAGIC
&& lptag->wItem == (int)0xFFFF
&& lptag->cb == (WORD)(MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)) +4)
&& *(LONG FAR *)lptag->rgb == PMTAG_MAGIC) {
while ((cb = (int)((PCHAR)lptag - (PCHAR)lpgd + MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)))) <= cbSeg)
{
if ((item == lptag->wItem)
&& (id == 0 || id == lptag->wID)) {
return lptag;
}
if (lptag->wID == ID_LASTTAG)
return NULL;
(LPSTR)lptag += lptag->cb;
}
}
return NULL;
}
/*--------------------------------------------------------------------------*/
/* */
/* CopyTag() - */
/* */
/*--------------------------------------------------------------------------*/
INT FAR PASCAL CopyTag(LPGROUPDEF lpgd, int item, WORD id, LPTSTR lpbuf, int cb)
{
LPTSTR lpt;
LPPMTAG lptag;
WORD cbT;
lptag = FindTag(lpgd,item,id);
if (lptag == NULL)
return 0;
if (cb > (int)lptag->cb)
cb = lptag->cb;
cbT = (WORD)cb;
lpt = (LPTSTR) lptag->rgb;
while (*lpt && cbT) {
*lpbuf++=*lpt++;
cbT--;
}
if (!(*lpt) && cbT) {
*lpbuf = TEXT('\0');
}
return cb;
}
/*--------------------------------------------------------------------------*/
/* */
/* DeleteTag() - */
/* */
/* in: */
/* hGroup group handle, can be discardable (alwayws shrink object) */
/* */
/*--------------------------------------------------------------------------*/
VOID FAR PASCAL DeleteTag(HANDLE hGroup, int item, WORD id)
{
LPPMTAG lptag;
LPTSTR lp1, lp2;
LPTSTR lpend;
LPGROUPDEF lpgd;
lpgd = (LPGROUPDEF) GlobalLock(hGroup);
lptag = FindTag(lpgd,item,id);
if (lptag == NULL) {
GlobalUnlock(hGroup);
return;
}
lp1 = (LPTSTR)lptag;
lp2 = (LPTSTR)((LPSTR)lptag + lptag->cb);
lpend = (LPTSTR)((LPSTR)lpgd + SizeofGroup(lpgd));
while (lp2 < lpend) {
*lp1++ = *lp2++;
}
/* always reallocing smaller
*/
GlobalUnlock(hGroup);
CheckBeforeReAlloc(hGroup);
GlobalReAlloc(hGroup, (DWORD)((LPSTR)lp1 - (LPSTR)lpgd), 0);
return;
}
/*--------------------------------------------------------------------------*/
/* */
/* AddTag() - */
/* */
/* in: */
/* h group handle, must not be discardable! */
/* */
/* returns: */
/* 0 failure */
/* 1 success */
/*--------------------------------------------------------------------------*/
INT PASCAL AddTag(HANDLE h, int item, WORD id, LPTSTR lpbuf, int cb)
{
LPPMTAG lptag;
WORD fAddFirst;
LPGROUPDEF lpgd;
int cbNew;
int cbMyLen;
LPGROUPDEF lpgdOld;
if (!cb && lpbuf) {
cb = sizeof(TCHAR)*(lstrlen(lpbuf) + 1);
}
cbMyLen = MyDwordAlign(cb);
if (!lpbuf) {
cb = 0;
cbMyLen = 0;
}
/*
* Remove the old version of the tag, if any.
*/
DeleteTag(h, item, id);
lpgd = (LPGROUPDEF)GlobalLock(h);
lptag = FindTag(lpgd, (int)0xFFFF, (WORD)ID_LASTTAG);
if (!lptag) {
/*
* In this case, there are no tags at all, and we have to add
* the first tag, the interesting tag, and the last tag
*/
cbNew = 3 * (MyDwordAlign(sizeof(PMTAG)) - MyDwordAlign(sizeof(lptag->rgb))) + 4 + cbMyLen;
fAddFirst = TRUE;
lptag = (LPPMTAG)((LPSTR)lpgd + lpgd->cbGroup);
} else {
/*
* In this case, only the interesting tag needs to be added
* but we count in the last because the delta is from lptag
*/
cbNew = 2 * (MyDwordAlign(sizeof(PMTAG)) - MyDwordAlign(sizeof(lptag->rgb))) + cbMyLen;
fAddFirst = FALSE;
}
/*
* check for 64K limit
*/
if ((DWORD_PTR)lptag + cbNew < (DWORD_PTR)lptag) {
return 0;
}
cbNew += (int)((PCHAR)lptag -(PCHAR)lpgd);
lpgdOld = lpgd;
GlobalUnlock(h);
CheckBeforeReAlloc(h);
if (!GlobalReAlloc(h, (DWORD)cbNew, GMEM_MOVEABLE)) {
return 0;
}
lpgd = (LPGROUPDEF)GlobalLock(h);
lptag = (LPPMTAG)((LPSTR)lpgd + ((LPSTR)lptag - (LPSTR)lpgdOld));
if (fAddFirst) {
/*
* Add the first tag
*/
lptag->wID = ID_MAGIC;
lptag->wItem = (int)0xFFFF;
*(LONG FAR *)lptag->rgb = PMTAG_MAGIC;
lptag->cb = (WORD)(MyDwordAlign(sizeof(PMTAG)) - MyDwordAlign(sizeof(lptag->rgb)) + 4);
(LPSTR)lptag += lptag->cb;
}
/*
* Add the tag
*/
lptag->wID = id;
lptag->wItem = item;
lptag->cb = (WORD)(MyDwordAlign(sizeof(PMTAG)) - MyDwordAlign(sizeof(lptag->rgb)) + cbMyLen);
if (lpbuf) {
RtlMoveMemory(lptag->rgb, lpbuf, (WORD)cb);
}
(LPSTR)lptag += lptag->cb;
/*
* Add the end tag
*/
lptag->wID = ID_LASTTAG;
lptag->wItem = (int)0xFFFF;
lptag->cb = 0;
GlobalUnlock(h);
return 1;
}
/*--------------------------------------------------------------------------*/
/* */
/* NukeIconBitmap -- Deletes the icon bitmap if one exists for the group */
/* */
/*--------------------------------------------------------------------------*/
void PASCAL NukeIconBitmap(PGROUP pGroup)
{
if (pGroup->hbm) {
DeleteObject(pGroup->hbm);
pGroup->hbm = NULL;
}
}
/*--------------------------------------------------------------------------*/
/* */
/* GroupFlag() - */
/* */
/*--------------------------------------------------------------------------*/
WORD PASCAL GroupFlag(PGROUP pGroup, PITEM pItem, WORD wFlag)
{
LPGROUPDEF lpgd;
LPPMTAG lptag;
WORD wT = 0;
int wItem;
if (pItem) {
wItem = pItem->iItem;
} else {
wItem = (int)0xFFFF;
}
lpgd = LockGroup(pGroup->hwnd);
if (!lpgd)
return 0;
lptag = FindTag(lpgd, wItem, wFlag);
if (!lptag)
wT = 0;
else if (lptag->cb == (WORD)(MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb))))
wT = 1;
else if (lptag->cb == (WORD)(MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)) + 1))
wT = lptag->rgb[0];
else if (lptag->cb == (WORD)(MyDwordAlign(sizeof(PMTAG))-MyDwordAlign(sizeof(lptag->rgb)) + 4))
wT = *(LPWORD)lptag->rgb;
UnlockGroup(pGroup->hwnd);
return wT;
}
/*--------------------------------------------------------------------------*/
/* */
/* GetGroupTag() - */
/* */
/*--------------------------------------------------------------------------*/
WORD PASCAL GetGroupTag(
PGROUP pGroup,
PITEM pItem,
WORD id,
LPTSTR lpT,
WORD cb)
{
WORD wT;
LPGROUPDEF lpgd;
int wItem;
if (pItem)
wItem = pItem->iItem;
else
wItem = (int)0xFFFF;
lpgd = LockGroup(pGroup->hwnd);
if (!lpgd)
return 0;
wT = (WORD)CopyTag(lpgd, wItem, id, lpT, cb);
UnlockGroup(pGroup->hwnd);
return wT;
}
/*--------------------------------------------------------------------------*/
/* */
/* ChangeTagID() - */
/* */
/*--------------------------------------------------------------------------*/
void PASCAL ChangeTagID(
LPGROUPDEF lpgd,
int iOld,
int iNew)
{
LPPMTAG lptag;
while (lptag = FindTag(lpgd,iOld,0)) {
lptag->wItem = iNew;
}
}
/*--------------------------------------------------------------------------*/
/* */
/* LoadItem() - */
/* */
/* Creates an item window (iconic) within a group window. Assumes that the */
/* group segment is up to date. */
/* */
/*--------------------------------------------------------------------------*/
PITEM PASCAL LoadItem(HWND hwndGroup, WORD iItem, BOOL bActivate)
{
LPGROUPDEF lpgd;
LPITEMDEF lpid;
PGROUP pGroup;
PITEM pItem;
PITEM *ppItem;
lpgd = LockGroup(hwndGroup);
if (!lpgd)
return NULL;
pItem = (PITEM)LocalAlloc(LPTR, sizeof(ITEM));
if (!pItem) {
UnlockGroup(hwndGroup);
return NULL;
}
pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);
NukeIconBitmap(pGroup);
if (bActivate) {
InvalidateIcon(pGroup, pGroup->pItems);
pItem->pNext = pGroup->pItems;
pGroup->pItems = pItem;
} else {
ppItem = &pGroup->pItems;
while (*ppItem) {
ppItem = &((*ppItem)->pNext);
}
pItem->pNext = NULL;
*ppItem = pItem;
}
lpid = ITEM(lpgd, iItem);
pItem->iItem = iItem;
pItem->dwDDEId = 0;
SetRectEmpty(&pItem->rcTitle);
SetRectEmpty(&pItem->rcIcon);
ComputeIconPosition(pGroup, lpid->pt, &pItem->rcIcon, &pItem->rcTitle,
(LPTSTR) PTR(lpgd, lpid->pName));
UnlockGroup(hwndGroup);
InvalidateIcon(pGroup, pItem);
return pItem;
}
PITEM FindItemName(LPGROUPDEF lpgd, register PITEM pItem, LPTSTR lpTitle)
{
LPITEMDEF lpid;
while (pItem) {
lpid = ITEM(lpgd, pItem->iItem);
if (!lstrcmp(lpTitle, (LPTSTR) PTR(lpgd, lpid->pName)))
return pItem;
pItem = pItem->pNext;
}
return NULL;
}
/*--------------------------------------------------------------------------*/
/* */
/* CreateNewItem() - */
/* */
/*--------------------------------------------------------------------------*/
/*
* Creates a new item in the file, and adds a window for it.
*/
PITEM PASCAL CreateNewItem(
HWND hwndGroup,
LPTSTR lpTitle,
LPTSTR lpCommand,
LPTSTR lpIconPath,
LPTSTR lpDefDir,
WORD wHotKey,
BOOL fMinimize,
WORD wIconId,
WORD wIconIndex,
HICON hIcon,
LPPOINT lppt,
DWORD dwFlags)
{
LPGROUPDEF lpgd;
LPITEMDEF lpid;
WORD id;
DWORD offset;
PGROUP pGroup;
LPTSTR lpIconRes;
WORD cbIconRes;
//DWORD dwVer;
WORD wVer;
WORD idError = IDS_LOWMEM;
PITEM pItem;
DWORD cb;
TCHAR szCommand[3*MAX_PATH];
TCHAR szExeDir[MAXITEMPATHLEN + 1];
TCHAR szIconExe[MAX_PATH];
TCHAR szTemp[MAXITEMPATHLEN+1];
LPTSTR lp1, lp2, lp3;
HANDLE hIconRes;
HANDLE hModule;
BOOL fWin32App = FALSE;
BOOL fUseDefaultIcon = FALSE;
BOOL bNoIconPath = TRUE;
TCHAR cSeparator;
/*
* Before we do anything, whack the command line and exedir
*/
lp1 = lpCommand;
if (*lpCommand == TEXT('"') && wcschr(lpCommand + 1, TEXT('"'))) {
cSeparator = TEXT('"');
//lp1++;
}
else {
cSeparator = TEXT(' ');
}
for (lp2=lp3=szExeDir; *lp1 && *lp1 != cSeparator; lp1 = CharNext(lp1))
{
*lp2++ = *lp1;
/*
* We know we're looking at the first byte
*/
if ((*lp1 == TEXT(':')) || (*lp1 == TEXT('\\'))) {
lp3 = lp2;
}
}
*lp2 = 0;
/*
* If the default dir pointer is NULL then we use the directory
* component of the command line. Otherwise we do the normal
* path whacking stuff to get everything into 3.0 format.
*/
if (lpDefDir) {
LPTSTR lpT;
lpT = lpDefDir;
// We have a valid pointer.
lstrcpy(szCommand,lpDefDir);
#if 0
/* spaces are allowed in LFN.
*/
RemoveLeadingSpaces(szCommand);
#endif
// If a default dir was supplied then go ahead and whack it
// into 3.0 format otherwise leave it blank.
if (*lpDefDir)
{
LPTSTR lpNextChar;
// locate the character before the NULL
while ( *(lpNextChar = CharNext(lpDefDir)) )
lpDefDir = lpNextChar;
// If there is no '\' seperator, add one.
if (lpDefDir[0] != TEXT('\\')) {
lstrcat(szCommand,TEXT("\\"));
}
}
/*
* Now add the filename itself. this puts the command in the
* 3.0 format: defdir\exename
*/
lstrcat(szCommand, lp3);
/*
* Append the arguments
*/
lstrcat(szCommand, lp1);
lpDefDir = lpT;
} else {
/*
* Use the same command line (note def dir is assigned exe dir
*/
lstrcpy(szCommand, lpCommand);
}
/*
* Now truncate exedir so that it does not include the command filename
*/
*lp3 = 0;
pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
if (!GroupCheck(pGroup)) {
MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_GROUPRO,
(LPTSTR) PTR(lpgd, lpgd->pName),
MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
GlobalUnlock(pGroup->hGroup);
return NULL;
}
GlobalUnlock(pGroup->hGroup);
if (*lpIconPath) {
bNoIconPath = FALSE;
}
lstrcpy(szIconExe, lpIconPath);
if (bNoIconPath && !(dwFlags & CI_NO_ASSOCIATION)) {
lstrcpy(szIconExe, lpCommand);
}
DoEnvironmentSubst(szIconExe, (WORD)CharSizeOf(szIconExe));
StripArgs(szIconExe);
if (!bNoIconPath) {
TagExtension(szIconExe, sizeof(szIconExe));
}
if (*szIconExe == TEXT('"') && *(szIconExe + lstrlen(szIconExe)-1) == TEXT('"')) {
SheRemoveQuotes(szIconExe);
}
if (bNoIconPath) {
//
// if it's a relative path, extractassociatedicon and LoadLibrary don't
// handle that so find the executable first
//
SetCurrentDirectory(szOriginalDirectory);
FindExecutable(szIconExe, lpDefDir, szTemp);
if (*szTemp) {
lstrcpy(szIconExe, szTemp);
TagExtension(szIconExe, sizeof(szIconExe));
if (*szIconExe == TEXT('"') && *(szIconExe + lstrlen(szIconExe)-1) == TEXT('"')) {
SheRemoveQuotes(szIconExe);
}
}
else {
*szIconExe = 0; // Use a dummy value so no icons will be found
// and progman's item icon will be used instead
// This is to make moricons.dll item icon be the
// right one. -johannec 6/4/93
}
//
// reset the current directory to progman's working directory i.e. Windows directory
//
SetCurrentDirectory(szWindowsDirectory);
wIconId = 0;
wIconIndex = 0;
}
NoIcon:
if (!wIconId) {
TCHAR szOldIconExe[MAX_PATH];
lstrcpy(szOldIconExe, szIconExe);
hIcon = ExtractAssociatedIconEx(hAppInstance, szIconExe, &wIconIndex, &wIconId);
if (lstrcmp(szOldIconExe, szIconExe)) {
/* using default icon from Progman.exe */
fUseDefaultIcon = TRUE;
}
if (hIcon)
DestroyIcon(hIcon);
}
lpIconRes = NULL;
hIconRes = NULL;
if (hModule = LoadLibrary(szIconExe)) {
fWin32App = TRUE;
hIconRes = FindResource(hModule, (LPTSTR) MAKEINTRESOURCE(wIconId), (LPTSTR) MAKEINTRESOURCE(RT_ICON));
if (hIconRes) {
//dwVer = 0x00030000; // resource version is windows 3.x
wVer = 3; // resource version is windows 3.x
cbIconRes = (WORD)SizeofResource(hModule, hIconRes);
hIconRes = LoadResource(hModule, hIconRes);
lpIconRes = LockResource(hIconRes);
}
if (fUseDefaultIcon) {
wIconId = 0;
}
}
else { // Win 3.1 app
if (wVer = ExtractIconResInfo(hAppInstance, szIconExe, wIconIndex, &cbIconRes, &hIconRes)){
lpIconRes = GlobalLock(hIconRes);
}
}
if (!lpIconRes) {
wIconId = 0;
wIconIndex = 0;
// ToddB: I see no harm in always setting the current directory to the WinDir
// before jumping back to NoIcon. Seems to be required to fix a Japanese bug.
// The WinDir is the default directory of Progman anyhow, I really don't see
// where it's possible for us to not already be in this directory.
SetCurrentDirectory(szWindowsDirectory);
goto NoIcon;
}
if (!KeepGroupAround(hwndGroup, TRUE)) {
goto FreeIcon;
}
id = FindFreeItemIndex(hwndGroup);
if (id == 0xFFFF) {
goto FreeIcon;
}
if (id >= CITEMSMAX) { // check group size limit
idError = IDS_TOOMANYITEMS;
goto FreeIcon;
}
offset = AddThing(pGroup->hGroup, (TCHAR)0, (WORD)sizeof(ITEMDEF));
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
if (!offset) {
goto QuitThis;
}
lpgd->rgiItems[id] = offset;
lpid = ITEM(lpgd, id);
GlobalUnlock(pGroup->hGroup);
offset = AddThing(pGroup->hGroup, lpTitle, (WORD)0);
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
lpid = ITEM(lpgd, id);
if (!offset) {
goto PuntCreation;
}
lpid->pName = offset;
GlobalUnlock(pGroup->hGroup);
offset = AddThing(pGroup->hGroup, szCommand,(WORD) 0);
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
lpid = ITEM(lpgd, id);
if (!offset) {
goto PuntCreation;
}
lpid->pCommand = offset;
GlobalUnlock(pGroup->hGroup);
CheckEscapes(szIconExe, CharSizeOf(szIconExe));
offset = AddThing(pGroup->hGroup, szIconExe,(WORD) 0);
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
lpid = ITEM(lpgd, id);
if (!offset)
goto PuntCreation;
lpid->pIconPath = offset;
GlobalUnlock(pGroup->hGroup);
offset = AddThing(pGroup->hGroup, lpIconRes, cbIconRes);
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
lpid = ITEM(lpgd, id);
if (!offset)
goto PuntCreation;
lpid->pIconRes = offset;
if (lppt) {
lpid->pt = *lppt;
} else {
lpid->pt.x = lpid->pt.y = -1;
}
lpid->iIcon = wIconId;
lpid->wIconIndex = wIconIndex;
//lpid->dwIconVer = dwVer;
lpid->wIconVer = wVer;
lpid->cbIconRes = cbIconRes;
if (cbIconRes != 0xFFFF)
if (fWin32App) {
UnlockResource(hIconRes);
FreeResource(hIconRes);
FreeLibrary(hModule);
}
else {
GlobalUnlock(hIconRes);
GlobalFree(hIconRes);
}
GlobalUnlock(pGroup->hGroup);
if (wHotKey) {
AddTag(pGroup->hGroup, (int)id, (WORD)ID_HOTKEY, (LPTSTR)&wHotKey, sizeof(wHotKey));
}
if (fMinimize) {
AddTag(pGroup->hGroup, (int)id, (WORD)ID_MINIMIZE, NULL, 0);
}
if (dwFlags & CI_SEPARATE_VDM) {
AddTag(pGroup->hGroup, (int)id, (WORD)ID_NEWVDM, NULL, 0);
}
if (*szExeDir) {
AddTag(pGroup->hGroup, (int)id, (WORD)ID_APPLICATIONDIR, szExeDir, 0);
}
pItem = LoadItem(hwndGroup, id, dwFlags & CI_ACTIVATE);
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
lpid = ITEM(lpgd, id);
if (!pItem) {
goto PuntCreation;
}
lpid->pt.x = pItem->rcIcon.left;
lpid->pt.y = pItem->rcIcon.top;
GlobalUnlock(pGroup->hGroup);
#if 0
// DOS apps are no longer set to fullscreen by default in progman
// 5-3-93 johannec (bug 8343)
#ifdef i386
//
// If this is a new DOS application, set the default to full screen.
// This is only done for x86, since mips doesn't have full screen.
//
lstrcpy(szCommand, lpCommand);
DoEnvironmentSubst(szCommand, (WORD)lstrlen(szCommand));
StripArgs(szCommand);
TagExtension(szCommand, sizeof(szCommand));
*szTemp = 0;
FindExecutable(szCommand, lpDefDir, szTemp);
if ((dwFlags & CI_SET_DOS_FULLSCRN) && *szTemp && IsDOSApplication(szTemp)) {
SetDOSApplicationToFullScreen(lpTitle);
}
#endif
#endif
KeepGroupAround(hwndGroup, FALSE);
// We need to save the current group to disk now
// in case a setup program is doing DDE with us,
// and they reboot the system when finished.
if (!SaveGroup (hwndGroup, FALSE)) {
idError = 0;
DeleteItem(pGroup, pItem);
goto FreeIcon;
}
return pItem;
PuntCreation:
/*
* Note, must set lpid after each because it may move
*/
DeleteThing(lpgd, (LPDWORD)&lpid->pName, 0);
DeleteThing(lpgd, (LPDWORD)&lpid->pCommand, 0);
DeleteThing(lpgd, (LPDWORD)&lpid->pIconPath, 0);
DeleteThing(lpgd, (LPDWORD)&lpid->pIconRes, lpid->cbIconRes);
DeleteThing(lpgd, (LPDWORD)&lpgd->rgiItems[id], sizeof(ITEMDEF));
QuitThis:
cb = SizeofGroup(lpgd);
UnlockGroup(pGroup->hwnd);
CheckBeforeReAlloc(pGroup->hGroup);
GlobalReAlloc(pGroup->hGroup, cb, GMEM_MOVEABLE);
KeepGroupAround(hwndGroup, FALSE);
FreeIcon:
if (cbIconRes != 0xFFFF)
if (fWin32App) {
UnlockResource(hIconRes);
FreeResource(hIconRes);
FreeLibrary(hModule);
}
else {
GlobalUnlock(hIconRes);
GlobalFree(hIconRes);
}
if (idError != 0)
MyMessageBox(hwndProgman, IDS_GROUPFILEERR, idError, NULL,
MB_OK | MB_ICONEXCLAMATION);
// Force re-read of group.
//GlobalDiscard(pGroup->hGroup);
//pGroup->fLoaded = FALSE ;
//LockGroup(pGroup->hwnd);
//UnlockGroup(pGroup->hwnd);
return NULL;
}
/*--------------------------------------------------------------------------*/
/* */
/* DeleteItem() - */
/* */
/*--------------------------------------------------------------------------*/
VOID FAR PASCAL DeleteItem(PGROUP pGroup, PITEM pItem)
{
LPGROUPDEF lpgd;
LPITEMDEF lpid;
DWORD cb;
LPPMTAG lptag;
lpgd = LockGroup(pGroup->hwnd);
if (!lpgd)
return;
if (!GroupCheck(pGroup)) {
MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_GROUPRO,
(LPTSTR) PTR(lpgd, lpgd->pName),
MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
InvalidateIcon(pGroup, pItem);
return;
}
NukeIconBitmap(pGroup);
lpid = ITEM(lpgd,pItem->iItem);
if ( (lpgd->cbGroup != (DWORD)MyDwordAlign((int)lpgd->cbGroup)) ||
(lpid->pName != (DWORD)MyDwordAlign((int)lpid->pName)) ||
(lpid->pCommand != (DWORD)MyDwordAlign((int)lpid->pCommand)) ||
(lpid->pIconPath != (DWORD)MyDwordAlign((int)lpid->pIconPath)) ||
(lpgd->rgiItems[pItem->iItem] != (DWORD)MyDwordAlign((int)lpgd->rgiItems[pItem->iItem])) ) {
MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_BADFILE,
(LPTSTR) PTR(lpgd, lpgd->pName),
MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
return;
}
/* note, must set lpid after each because it may move
*/
DeleteThing(lpgd, (LPDWORD)&lpid->pName, 0);
DeleteThing(lpgd, (LPDWORD)&lpid->pCommand, 0);
DeleteThing(lpgd, (LPDWORD)&lpid->pIconPath, 0);
DeleteThing(lpgd, (LPDWORD)&lpid->pIconRes, lpid->cbIconRes);
DeleteThing(lpgd, (LPDWORD)&lpgd->rgiItems[pItem->iItem], sizeof(ITEMDEF));
while (lptag = FindTag(lpgd,pItem->iItem,0)) {
/* delete all tags associated with this item
*/
UnlockGroup(pGroup->hwnd);
DeleteTag(pGroup->hGroup, lptag->wItem, lptag->wID);
lpgd = LockGroup(pGroup->hwnd);
}
/* Don't need Item anymore so delete it. */
RemoveItemFromList(pGroup, pItem);
cb = SizeofGroup(lpgd);
UnlockGroup(pGroup->hwnd);
CheckBeforeReAlloc(pGroup->hGroup);
GlobalReAlloc(pGroup->hGroup, cb, GMEM_MOVEABLE);
if (bAutoArrange && !bAutoArranging)
ArrangeItems(pGroup->hwnd);
else if (!bAutoArranging)
CalcGroupScrolls(pGroup->hwnd);
}
/*--------------------------------------------------------------------------*/
/* */
/* CreateItemIcons() - */
/* */
/* Creates all the item windows... */
/* */
/*--------------------------------------------------------------------------*/
VOID PASCAL CreateItemIcons(HWND hwndGroup)
{
LPGROUPDEF lpgd;
int i;
lpgd = LockGroup(hwndGroup);
if (!lpgd) {
return;
}
/*
* Create the items in reverse Z-Order.
*/
for (i = lpgd->cItems - 1; i >= 0; i--) {
if (lpgd->rgiItems[i]) {
LoadItem(hwndGroup, (WORD)i, TRUE);
}
}
UnlockGroup(hwndGroup);
// REVIEW This may be not be needed because LoadGroupWindow does a
// SetInternalWindowPos which MIGHT already be generating the messages
// to do this.
if (bAutoArrange && !bAutoArranging)
ArrangeItems(hwndGroup);
else if (!bAutoArranging)
CalcGroupScrolls(hwndGroup);
}
/*--------------------------------------------------------------------------*/
/* */
/* CheckIconResolution() - */
/* */
/* Makes sure we have the right icons loaded... reextracts and saves */
/* the file if not. */
/* */
/*--------------------------------------------------------------------------*/
VOID NEAR PASCAL CheckIconResolution(HWND hwndGroup)
{
LPGROUPDEF lpgd;
LPITEMDEF lpid;
register PGROUP pGroup;
HANDLE hGroup;
BOOL fGottaDoIt;
register HDC hdc;
int i;
HICON hIcon;
WORD cbIconRes;
DWORD pIconRes;
LPTSTR lpIconRes;
WORD wFormat;
TCHAR szTemp[MAXITEMPATHLEN];
HANDLE hModule;
BOOL fWin32App;
//DWORD dwVer;
WORD wVer;
lpgd = LockGroup(hwndGroup);
if (!lpgd)
return;
hdc = GetDC(hwndGroup);
wFormat = (WORD)GetDeviceCaps(hdc, BITSPIXEL) |
(WORD)GetDeviceCaps(hdc, PLANES) * (WORD)256;
ReleaseDC(hwndGroup,hdc);
fGottaDoIt = lpgd->wIconFormat != wFormat ||
lpgd->cxIcon != (WORD)GetSystemMetrics(SM_CXICON) ||
lpgd->cyIcon != (WORD)GetSystemMetrics(SM_CYICON);
if (!fGottaDoIt) {
goto CleanUpAndLeave;
}
pGroup = (PGROUP)GetWindowLongPtr(hwndGroup,GWLP_PGROUP);
NukeIconBitmap(pGroup);
/* Save the new resolution parameters in the group file. */
lpgd->wIconFormat = wFormat;
lpgd->cxIcon = (WORD)GetSystemMetrics(SM_CXICON);
lpgd->cyIcon = (WORD)GetSystemMetrics(SM_CYICON);
hGroup = pGroup->hGroup;
for (i = 0; i < (int)lpgd->cItems; ++i) {
if (!lpgd->rgiItems[i])
continue;
lpid = ITEM(lpgd, i);
DeleteThing(lpgd, (LPDWORD)&lpid->pIconRes, lpid->cbIconRes);
lpid = ITEM(lpgd, i);
lstrcpy(szTemp, (LPTSTR) PTR(lpgd, lpid->pIconPath));
if (!*szTemp) {
/* Get default icon path */
lstrcpy(szTemp, (LPTSTR) PTR(lpgd, lpid->pCommand));
DoEnvironmentSubst(szTemp, (WORD)(MAXITEMPATHLEN+1));
StripArgs(szTemp);
}
SheRemoveQuotes(szTemp);
cbIconRes = 0xFFFF;
lpIconRes = NULL;
hIcon = NULL;
if (hModule = LoadLibrary(szTemp)) {
// if WIN32 app
fWin32App = TRUE;
hIcon = (HICON)FindResource(hModule, (LPTSTR) MAKEINTRESOURCE(lpid->iIcon), (LPTSTR) MAKEINTRESOURCE(RT_ICON));
if (hIcon) {
//dwVer = 0x00030000;
wVer = 3;
cbIconRes = (WORD)SizeofResource(hModule, (HRSRC)hIcon);
hIcon = (HICON)LoadResource(hModule, (HRSRC)hIcon);
lpIconRes = LockResource(hIcon);
}
}
else { // Win 3.1 app
fWin32App = FALSE;
if (wVer = ExtractIconResInfo(hAppInstance, szTemp, lpid->iIcon, &cbIconRes, (LPHANDLE)&hIcon)){
lpIconRes = GlobalLock(hIcon);
}
}
UnlockGroup(hwndGroup);
pIconRes = AddThing(pGroup->hGroup, lpIconRes, cbIconRes);
lpgd = LockGroup(hwndGroup);
if (!lpgd)
continue;
/* In case the segment got moved... */
lpid = ITEM(lpgd, i);
if (hIcon)
if (fWin32App) {
UnlockResource(hIcon);
FreeResource(hIcon);
FreeLibrary(hModule);
}
else {
GlobalUnlock(hIcon);
GlobalFree(hIcon);
}
lpid->pIconRes = pIconRes;
//lpid->dwIconVer = dwVer;
lpid->wIconVer = wVer;
lpid->cbIconRes = cbIconRes;
}
#ifdef ORGCODE
// Check everythings OK.
if (!pHdr || !pAND || !pXOR)
{
// FU - delete icon stuff for this item..
// REVIEW UNDONE - warn user about memory problem ?
#ifdef DEBUG
KdPrint(("PM.CIR: Corrupted icon %s \n\r", (LPTSTR) PTR(lpid->pName)));
#endif
lpid = ITEM(lpgd, i);
DeleteThing(lpgd, (LPDWORD)&lpid->pIconRes, lpid->cbIconRes);
// Mark item as being effed - the header is checked by
// GetItemIcon.
lpid = ITEM(lpgd, i);
lpid->pIconRes = NULL;
lpid->wIconVer = 0; // This is the important one.
lpid->cbIconRes = 0;
// Warn user when we're through, not right in the middle.
fErrorOnExtract = TRUE;
}
}
#endif
if (!GroupCheck(pGroup))
MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_EEGROUPRO,
(LPTSTR) PTR(lpgd, lpgd->pName),
MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
CleanUpAndLeave:
UnlockGroup(hwndGroup);
//REVIEW See above.
KeepGroupAround(hwndGroup, FALSE);
return;
}
/*--------------------------------------------------------------------------*/
/* */
/* CreateGroupHandle() - */
/* */
/* Creates a discarded handle for use as a group handle... on the first */
/* LockGroup() the file will be loaded. */
/* */
/*--------------------------------------------------------------------------*/
HANDLE NEAR PASCAL CreateGroupHandle(void)
{
register HANDLE hGroup;
if (hGroup = GlobalAlloc(GMEM_MOVEABLE | GMEM_DISCARDABLE, 1L))
GlobalDiscard(hGroup);
return(hGroup);
}
/*--------------------------------------------------------------------------*/
/* */
/* StartupGroup() - */
/* */
/*--------------------------------------------------------------------------*/
VOID FAR PASCAL StartupGroup(HWND hwnd)
{
PITEM pItemCur, pItemExec;
LPGROUPDEF lpgd;
INT xLast, yLast; // Coord of icon to exec.
INT xBest, yBest; // Coord of next topmost-leftmost icon.
MSG msg; // Peek a message.
PGROUP pGroup; // The group.
pGroup = (PGROUP)GetWindowLongPtr(hwnd, GWLP_PGROUP);
/*
* Handle Startup group in icon position order - not Z-order.
*/
lpgd = LockGroup(hwnd);
if (!lpgd)
return;
/*
* Starts with the top left and works from left to right then
* top to bottom.
* This is really naff in terms of speed, but groups are usually
* small and the time cost is still small compared to that of execing.
*/
yLast = WORD_MIN;
xLast = WORD_MIN;
for (;;) {
/*
* Init
*/
xBest = WORD_MAX;
yBest = WORD_MAX;
pItemExec = NULL;
/*
* Find next icon to the right of this one.
*/
for (pItemCur = pGroup->pItems; pItemCur; pItemCur = pItemCur->pNext) {
/*
* Look for Icon to the right of this one.
* REVIEW This will ignore icons stacked on top of each other.
*/
if (pItemCur->rcIcon.top >= yLast
&& pItemCur->rcIcon.top <= yLast + (cyArrange/2)
&& pItemCur->rcIcon.left < xBest
&& pItemCur->rcIcon.left > xLast) {
pItemExec = pItemCur;
xBest = pItemCur->rcIcon.left;
}
/*
* Check if it'll be suitable for the next row.
*/
else if (pItemCur->rcIcon.top > yLast + (cyArrange/2)
&& pItemCur->rcIcon.top < yBest) {
yBest = pItemCur->rcIcon.top;
}
}
if (pItemExec) {
/*
* Found one on the current row.
*/
xLast = xBest;
/*
* Move this item to the top of the z-order so that any searches
* done during DDE will find the last execed item first.
* REVIEW This messes with the z-odrder of the startup group.
*/
BringItemToTop(pGroup, pItemExec, TRUE);
/* Start it up. */
ExecItem(pGroup,pItemExec,FALSE, TRUE);
/*
* Handle any DDE before doing anything else to stop
* the message queue from over-flowing.
*/
while(PeekMessage(&msg, hwndProgman, 0, 0, PM_REMOVE|PM_NOYIELD)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
else if (yBest != WORD_MAX) {
/*
* Nothing left on the current row but there is another row.
*/
yLast = yBest;
xLast = WORD_MIN;
}
else {
/*
* Nothing left.
*/
goto Quit;
}
}
Quit:
UnlockGroup(pGroup->hwnd);
}
/*---------------------------------------------------------------------------
* Check for null item pointers and item pointers that go out of the group.
* REVIEW UNDONE this doesn't check that the pointers point to things
* after the end of the items array.
*/
BOOL NEAR PASCAL ValidItems(LPGROUPDEF lpgd)
{
INT i;
LPITEMDEF lpid;
DWORD cbGroup;
if (!lpgd)
return FALSE;
cbGroup = lpgd->cbGroup;
for (i = 0; (WORD)i < lpgd->cItems; i++) {
if (!lpgd->rgiItems[i])
continue;
lpid = ITEM(lpgd,i);
if (!lpid)
return FALSE;
if (lpid->pName > cbGroup)
return FALSE;
if (lpid->pCommand > cbGroup)
return FALSE;
if (lpid->pIconPath > cbGroup)
return FALSE;
if ((lpid->cbIconRes != (WORD)-1) && (lpid->pIconRes > cbGroup))
return FALSE;
}
return(TRUE);
}
/*--------------------------------------------------------------------------*/
/* */
/* IsGroupAlreadyLoaded() - */
/* */
/* Determines if the user is trying to load a currently loaded group. */
/* */
/*--------------------------------------------------------------------------*/
HWND NEAR PASCAL IsGroupAlreadyLoaded(LPTSTR lpGroupKey, BOOL bCommonGroup)
{
HWND hwndT;
PGROUP pGroup;
for (hwndT=GetWindow(hwndMDIClient, GW_CHILD); hwndT; hwndT=GetWindow(hwndT, GW_HWNDNEXT)) {
if (GetWindow(hwndT, GW_OWNER))
continue;
pGroup = (PGROUP)GetWindowLongPtr(hwndT, GWLP_PGROUP);
if (!lstrcmpi(lpGroupKey, pGroup->lpKey)) {
if (bCommonGroup) {
if (pGroup->fCommon)
return(hwndT);
} else {
if (!pGroup->fCommon)
return(hwndT);
}
}
}
return(NULL);
}
BOOL NEAR PASCAL IndexUsed(WORD wIndex, BOOL bCommonGroup)
{
PGROUP pGroup;
for (pGroup = pFirstGroup; pGroup; pGroup = pGroup->pNext)
if ((pGroup->wIndex == wIndex) && (pGroup->fCommon == bCommonGroup))
return TRUE;
return FALSE;
}
/*--------------------------------------------------------------------------*/
/* */
/* LoadGroupWindow() - */
/* */
/* Creates a group window by sending an MDI create message to the MDI client. */
/* The MDICREATESTRUCT contains a parameter pointer to the name of the group */
/* key. */
/* */
/*--------------------------------------------------------------------------*/
// GroupFile must be ANSI.
HWND PASCAL LoadGroupWindow(LPTSTR lpKey, WORD wIndex, BOOL bCommonGroup)
{
MDICREATESTRUCT mdics;
PGROUP pGroup;
TCHAR szGroupClass[64];
LPGROUPDEF lpgd;
HWND hwnd;
TCHAR szCommonGroupSuffix[MAXKEYLEN];
TCHAR szCommonGroupTitle[2*MAXKEYLEN];
WINDOWPLACEMENT wp;
//
// Check if the group is already loaded. This will prevent duplicate groups.
//
if (hwnd = IsGroupAlreadyLoaded(lpKey, bCommonGroup)) {
return(hwnd);
}
if (!wIndex) {
while (IndexUsed(++wIndex, bCommonGroup))
;
}
if (!LoadString(hAppInstance, IDS_GROUPCLASS, szGroupClass,
CharSizeOf(szGroupClass))) {
return NULL;
}
pGroup = (PGROUP)LocalAlloc(LPTR,sizeof(GROUP));
if (!pGroup) {
return NULL;
}
pGroup->hGroup = CreateGroupHandle();
pGroup->pItems = NULL;
pGroup->hbm = NULL;
pGroup->wIndex = wIndex;
pGroup->fCommon = bCommonGroup;
pGroup->ftLastWriteTime.dwLowDateTime = 0;
pGroup->ftLastWriteTime.dwHighDateTime = 0;
pGroup->lpKey = (LPTSTR)LocalAlloc(LPTR, sizeof(TCHAR)*(lstrlen(lpKey) + 1));
pGroup->fLoaded = FALSE;
if (!pGroup->lpKey) {
GoAway:
GlobalFree(pGroup->hGroup);
LocalFree((HANDLE)pGroup);
if (!fLowMemErrYet) {
MyMessageBox(hwndProgman, IDS_APPTITLE, IDS_LOWMEMONINIT,
lpKey, MB_OK|MB_ICONEXCLAMATION);
fLowMemErrYet = TRUE;
}
return NULL;
}
lstrcpy(pGroup->lpKey, lpKey);
mdics.szTitle = TEXT("");
mdics.hOwner = hAppInstance;
mdics.szClass = szGroupClass;
mdics.style = WS_VSCROLL|WS_HSCROLL;
mdics.x = mdics.y = mdics.cx = mdics.cy = CW_USEDEFAULT;
mdics.lParam = (LPARAM)pGroup;
/*
* REVIEW HACK - Set the auto arranging flag to stop the group being
* loaded by ArrangingIcons doing a LockGroup and then producing
* an error if something goes wrong. We're going to do a lock
* later on anyway and we don't want two error messages.
*/
bAutoArranging = TRUE;
pGroup->hwnd = (HWND)SendMessage(hwndMDIClient, WM_MDICREATE, 0, (LPARAM)(LPTSTR)&mdics);
bAutoArranging = FALSE;
if (!pGroup->hwnd) {
LocalFree((HANDLE)pGroup->lpKey);
goto GoAway;
}
/*
* Note that we're about to load a group for the first time.
* NB Stting this tells LockGroup that the caller can handle the errors.
*/
fFirstLoad = TRUE;
lpgd = LockGroup(pGroup->hwnd);
/*
* The group has been loaded or at least we tried.
*/
fFirstLoad = FALSE;
if (!lpgd) {
LoadFail:
/* Loading the group failed somehow... */
SendMessage(hwndMDIClient, WM_MDIDESTROY, (WPARAM)pGroup->hwnd, 0L);
//
// stop handling of Program Groups key changes.
//
bHandleProgramGroupsEvent = FALSE;
RegDeleteKey(hkeyProgramGroups, pGroup->lpKey);
//
// reset handling of Program Groups key changes.
//
ResetProgramGroupsEvent(bCommonGroup);
bHandleProgramGroupsEvent = TRUE;
LocalFree((HANDLE)pGroup->lpKey);
GlobalFree(pGroup->hGroup);
LocalFree((HANDLE)pGroup);
return NULL;
}
/*
* test if it is a Windows 3.1 group file format. If so it is not
* valid in WIN32. In Windows 3.1 RECT and POINT are WORD instead of LONG.
*/
if ( (lpgd->rcNormal.left != (INT)(SHORT)lpgd->rcNormal.left) ||
(lpgd->rcNormal.right != (INT)(SHORT)lpgd->rcNormal.right) ||
(lpgd->rcNormal.top != (INT)(SHORT)lpgd->rcNormal.top) ||
(lpgd->rcNormal.bottom != (INT)(SHORT)lpgd->rcNormal.bottom) ){
/* The group is invalid. */
MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_BADFILE,
(LPTSTR) PTR(lpgd, lpgd->pName),
MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
UnlockGroup(pGroup->hwnd);
goto LoadFail;
}
if (!ValidItems(lpgd)) {
MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_BADFILE,
(LPTSTR) PTR(lpgd, lpgd->pName),
MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
UnlockGroup(pGroup->hwnd);
goto LoadFail;
}
if (lpgd->nCmdShow) {
SetInternalWindowPos(pGroup->hwnd, (UINT)lpgd->nCmdShow, &lpgd->rcNormal,
&lpgd->ptMin);
}
if (pGroup->fCommon) {
//
// Add the common group suffix to the name of the group e.g. (Common)
// Only do this if the group window is not minimized.
//
wp.length = sizeof(WINDOWPLACEMENT);
GetWindowPlacement(pGroup->hwnd, &wp);
if ((wp.showCmd == SW_MINIMIZE) ||
(wp.showCmd == SW_SHOWMINIMIZED) ||
(wp.showCmd == SW_SHOWMINNOACTIVE) ) {
SetWindowText(pGroup->hwnd, (LPTSTR) PTR(lpgd, lpgd->pName));
}
else {
lstrcpy(szCommonGroupTitle, (LPTSTR) PTR(lpgd, lpgd->pName));
if (LoadString(hAppInstance, IDS_COMMONGRPSUFFIX, szCommonGroupSuffix,
CharSizeOf(szCommonGroupSuffix))) {
lstrcat(szCommonGroupTitle, szCommonGroupSuffix);
}
SetWindowText(pGroup->hwnd, szCommonGroupTitle);
if (!UserIsAdmin) {
pGroup->fRO = TRUE;
}
}
}
else {
SetWindowText(pGroup->hwnd, (LPTSTR) PTR(lpgd, lpgd->pName));
}
UnlockGroup(pGroup->hwnd);
//CheckIconResolution(pGroup->hwnd);
CreateItemIcons(pGroup->hwnd);
/*
* Link the group.
*/
pGroup->pNext = NULL;
*pLastGroup = pGroup;
pLastGroup = &pGroup->pNext;
pCurrentGroup = pGroup;
#ifdef NOTINUSER
CalcChildScroll(pGroup->hwnd, SB_BOTH);
#endif
GroupCheck(pGroup);
return(pGroup->hwnd);
}
/*--------------------------------------------------------------------------*/
/* */
/* UnloadGroupWindow() - */
/* */
/*--------------------------------------------------------------------------*/
void FAR PASCAL UnloadGroupWindow(HWND hwnd)
{
PGROUP pGroup, *ppGroup;
PITEM pItem, pItemNext;
pGroup = (PGROUP)GetWindowLongPtr(hwnd,GWLP_PGROUP);
/* Destroy the window. */
SendMessage(hwndMDIClient,WM_MDIDESTROY,(WPARAM)hwnd,0L);
/* Free the group segment. */
GlobalFree(pGroup->hGroup);
/* Free the local stuff. */
LocalFree((HANDLE)pGroup->lpKey);
/* The cached bitmap if there is one. */
if (pGroup->hbm) {
DeleteObject(pGroup->hbm);
pGroup->hbm = NULL;
}
/* The item data. */
for (pItem = pGroup->pItems; pItem; pItem = pItemNext) {
pItemNext = pItem->pNext;
LocalFree((HANDLE) pItem);
}
/* Remove the group from the linked list. */
for (ppGroup = &pFirstGroup; *ppGroup; ppGroup = &((*ppGroup)->pNext)) {
if (*ppGroup == pGroup) {
*ppGroup = pGroup->pNext;
break;
}
}
if (pLastGroup == &pGroup->pNext)
pLastGroup = ppGroup;
/* Lastly, free the group structure itself. */
LocalFree((HANDLE)pGroup);
}
/*--------------------------------------------------------------------------*/
/* */
/* RemoveBackslashFromKeyName() - */
/* */
/* replace the invalid characters for a key name by some valid charater. */
/* the same characters that are invalid for a file name are invalid for a */
/* key name. */
/* */
/*--------------------------------------------------------------------------*/
void RemoveBackslashFromKeyName(LPTSTR lpKeyName)
{
LPTSTR lpt;
for (lpt = lpKeyName; *lpt; lpt++) {
if ((*lpt == TEXT('\\')) || (*lpt == TEXT(':')) || (*lpt == TEXT('>')) || (*lpt == TEXT('<')) ||
(*lpt == TEXT('*')) || (*lpt == TEXT('?')) ){
*lpt = TEXT('.');
}
}
}
/*--------------------------------------------------------------------------*/
/* */
/* CreateNewGroup() - */
/* */
/* This function creates a new, empty group. */
/* */
/*--------------------------------------------------------------------------*/
HWND PASCAL CreateNewGroup(LPTSTR pGroupName, BOOL bCommonGroup)
{
HANDLE hT;
LPGROUPDEF lpgd;
PGROUP pGroup;
HDC hdc;
int i;
int cb;
TCHAR szKeyName[MAXKEYLEN+1];
HWND hwnd;
DWORD status = 0;
WORD cGroups;
INT wGroupNameLen; //length of pGroupName DWORD aligned.
HKEY hkeyGroups;
HKEY hKey;
HWND hwndT;
PSECURITY_ATTRIBUTES pSecAttr;
/*
* Check we're not trying to create too many groups.
* Count the current number of groups.
*/
cGroups = 0;
for (hwnd = GetWindow(hwndMDIClient, GW_CHILD); hwnd; hwnd = GetWindow(hwnd, GW_HWNDNEXT)) {
if (GetWindow(hwnd, GW_OWNER))
continue;
//
// count the common groups seperately from the personal group.
// Both have a maximum of CGROUPSMAX groups.
//
pGroup = (PGROUP)GetWindowLongPtr(hwnd, GWLP_PGROUP);
if (bCommonGroup && pGroup->fCommon ||
!bCommonGroup && !pGroup->fCommon) {
cGroups++;
}
}
// Compare with limit.
if (cGroups >= CGROUPSMAX) {
status = bCommonGroup ? IDS_TOOMANYCOMMONGROUPS : IDS_TOOMANYGROUPS;
goto Exit;
}
if (bCommonGroup) {
hkeyGroups = hkeyCommonGroups;
pSecAttr = pAdminSecAttr;
if (!hkeyGroups) {
if (MyMessageBox(hwndProgman,
IDS_COMMONGROUPERR,
IDS_NOCOMMONGRPS,
pGroupName,
MB_OKCANCEL | MB_ICONEXCLAMATION | MB_TASKMODAL)
== IDOK) {
hkeyGroups = hkeyProgramGroups;
pSecAttr = pSecurityAttributes;
bCommonGroup = FALSE;
} else {
return(NULL);
}
}
} else {
hkeyGroups = hkeyProgramGroups;
pSecAttr = pSecurityAttributes;
}
if (!hkeyGroups) {
status = IDS_NOGRPFILE;
goto Exit;
}
//
// Replace backslash in the group name because the registry does not
// allow key names with backslash, bckslash is used to separate keys.
//
lstrcpy(szKeyName, pGroupName);
RemoveBackslashFromKeyName(szKeyName);
//
// Test for existing key.
//
while (!RegOpenKeyEx(hkeyGroups, szKeyName, 0, KEY_READ, &hKey)) {
/* a group with this name already exists */
if (hwndT = IsGroupAlreadyLoaded(szKeyName, bCommonGroup)) {
if (lstrlen(szKeyName) < MAXKEYLEN) {
lstrcat(szKeyName, TEXT("."));
GlobalUnlock(pGroup->hGroup);
RegCloseKey(hKey);
continue;
}
}
RegCloseKey(hKey);
goto LoadGroupFile;
}
wGroupNameLen = MyDwordAlign(sizeof(TCHAR)*(lstrlen(pGroupName) + 1));
cb = sizeof(GROUPDEF) + (NSLOTS * sizeof(DWORD)) + wGroupNameLen;
/*
* In CreateNewGroup before GlobalAlloc.
*/
hT = GlobalAlloc(GHND, (DWORD)cb);
if (!hT) {
status = IDS_LOWMEM;
goto Exit;
}
lpgd = (LPGROUPDEF)GlobalLock(hT);
lpgd->dwMagic = GROUP_UNICODE;
lpgd->cbGroup = (DWORD)cb;
lpgd->nCmdShow = 0; /* use MDI defaults */
lpgd->pName = sizeof(GROUPDEF) + NSLOTS * sizeof(DWORD);
hdc = GetDC(NULL);
lpgd->wIconFormat = (WORD)GetDeviceCaps(hdc, BITSPIXEL) + (WORD)256 *
(WORD)GetDeviceCaps(hdc, PLANES);
ReleaseDC(NULL, hdc);
lpgd->cxIcon = (WORD)GetSystemMetrics(SM_CXICON);
lpgd->cyIcon = (WORD)GetSystemMetrics(SM_CYICON);
lpgd->Reserved1 = (WORD)-1;
lpgd->Reserved2 = (DWORD)-1;
lpgd->cItems = NSLOTS;
for (i = 0; i < NSLOTS; i++) {
lpgd->rgiItems[i] = 0;
}
lstrcpy((LPTSTR)((LPSTR)lpgd + sizeof(GROUPDEF) + NSLOTS * sizeof(DWORD)),
pGroupName);
/*
* In CreateNewGroup before SizeofGroup.
*/
cb = (int)SizeofGroup(lpgd);
//
// stop handling of Program Groups key changes when creating groups.
//
bHandleProgramGroupsEvent = FALSE;
//
// REARCHITECT: pSecurityAttributes might change for Common groups.
//
if (!RegCreateKeyEx(hkeyGroups, szKeyName, 0, 0, 0,
DELETE | KEY_READ | KEY_WRITE,
pSecAttr, &hKey, NULL)) {
if (RegSetValueEx(hKey, NULL, 0, REG_BINARY, (LPBYTE)lpgd, cb))
status = IDS_CANTWRITEGRP;
RegCloseKey(hKey);
}
else
status = IDS_NOGRPFILE;
GlobalUnlock(hT);
GlobalFree(hT);
Exit:
if (status) {
MyMessageBox(hwndProgman, IDS_GROUPFILEERR, (WORD)status, pGroupName,
MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);
ResetProgramGroupsEvent(bCommonGroup);
bHandleProgramGroupsEvent = TRUE;
return NULL;
}
LoadGroupFile:
/*
* The group file now exists on the disk... load it in!
*/
fLowMemErrYet = FALSE;
fErrorOnExtract = FALSE;
hwnd = LoadGroupWindow(szKeyName, 0, bCommonGroup);
if (fErrorOnExtract) {
// On observed problem with icon extraction has been to do
// with a low memory.
MyMessageBox(hwndProgman, IDS_OOMEXITTITLE, IDS_LOWMEMONEXTRACT,
NULL, MB_OK|MB_ICONHAND|MB_SYSTEMMODAL);
}
// Save the group section even if SaveSettings is off to stop
// users from themselves.
if (!bCommonGroup) {
WriteGroupsSection();
}
ResetProgramGroupsEvent(bCommonGroup);
bHandleProgramGroupsEvent = TRUE;
return hwnd;
}
/*--------------------------------------------------------------------------*/
/* */
/* DeleteGroup() - */
/* */
/*--------------------------------------------------------------------------*/
VOID FAR PASCAL DeleteGroup(HWND hwndGroup)
{
PGROUP pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);
PGROUP *ppGroup;
PITEM pItem;
TCHAR szT[10];
BOOL bCommonGroup;
HKEY hkeyGroups;
//
// stop handling of Program Groups key changes when deleting groups.
//
bHandleProgramGroupsEvent = FALSE;
bCommonGroup = pGroup->fCommon;
if (bCommonGroup)
hkeyGroups = hkeyCommonGroups;
else
hkeyGroups = hkeyProgramGroups;
if (pGroup->fRO || RegDeleteKey(hkeyGroups, pGroup->lpKey) != ERROR_SUCCESS) {
MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_ERRORDELETEGROUP,
pGroup->lpKey, MB_OK);
//
// reset handling of Program Groups key changes.
//
ResetProgramGroupsEvent(bCommonGroup);
bHandleProgramGroupsEvent = TRUE;
return; // cannot delete the group
}
//
// reset handling of Program Groups key changes.
//
ResetProgramGroupsEvent(bCommonGroup);
bHandleProgramGroupsEvent = TRUE;
/* Destroy the window, the global memory block, and the file. */
SendMessage(hwndMDIClient, WM_MDIDESTROY, (WPARAM)hwndGroup, 0L);
NukeIconBitmap(pGroup);
GlobalFree(pGroup->hGroup);
if (!bCommonGroup) {
//
// Remove the program manager's settings for that personal group.
//
wsprintf(szT,TEXT("Group%d"),pGroup->wIndex);
RegDeleteValue(hkeyPMGroups, szT);
}
/* Unlink the group structure. */
for (ppGroup=&pFirstGroup; *ppGroup && *ppGroup != pGroup; ppGroup = &(*ppGroup)->pNext)
;
if (*ppGroup)
*ppGroup = pGroup->pNext;
if (pLastGroup == &pGroup->pNext)
pLastGroup = ppGroup;
/* Destroying the window should activate another one, but if it is the
* last one, nothing will get activated, so to make sure punt the
* current group pointer...
*/
if (pCurrentGroup == pGroup)
pCurrentGroup = NULL;
/* Lastly, toss out the group and item structures. */
while (pGroup->pItems) {
pItem = pGroup->pItems;
pGroup->pItems = pItem->pNext;
LocalFree((HANDLE)pItem);
}
LocalFree((HANDLE)pGroup->lpKey);
LocalFree((HANDLE)pGroup);
if (!bCommonGroup) {
//
// Change the program manager's settings for that personal group.
//
WriteGroupsSection();
}
}
/*--------------------------------------------------------------------------*/
/* */
/* ChangeGroupTitle() - */
/* */
/* Modifies the name of a program group, on the screen and in the file. */
/* */
/*--------------------------------------------------------------------------*/
VOID FAR PASCAL ChangeGroupTitle(HWND hwndGroup, LPTSTR lpName, BOOL bCommonGroup)
{
LPGROUPDEF lpgd;
PGROUP pGroup;
DWORD pName;
TCHAR szCommonGroupSuffix[MAXKEYLEN];
TCHAR szCommonGroupTitle[2*MAXKEYLEN];
WINDOWPLACEMENT wp;
if (!hwndGroup)
return;
//
// Change the title of the window.
//
if (bCommonGroup) {
//
// Add the common group suffix to the name of the group e.g. (Common),
// do not append the common suffix if the group window is minimized.
//
wp.length = sizeof(WINDOWPLACEMENT);
GetWindowPlacement(hwndGroup, &wp);
if (wp.showCmd == SW_MINIMIZE || wp.showCmd == SW_SHOWMINIMIZED ||
wp.showCmd == SW_SHOWMINNOACTIVE) {
SetWindowText(hwndGroup, lpName);
}
else {
lstrcpy(szCommonGroupTitle, lpName);
if (LoadString(hAppInstance, IDS_COMMONGRPSUFFIX, szCommonGroupSuffix,
CharSizeOf(szCommonGroupSuffix))) {
lstrcat(szCommonGroupTitle, szCommonGroupSuffix);
}
SetWindowText(hwndGroup, szCommonGroupTitle);
}
}
else {
SetWindowText(hwndGroup, lpName);
}
//
// Remove the old name.
//
lpgd = LockGroup(hwndGroup);
if (!lpgd)
return;
DeleteThing(lpgd, (LPDWORD)&lpgd->pName, 0);
UnlockGroup(hwndGroup);
//
// Insert the new one.
//
pGroup = (PGROUP)GetWindowLongPtr(hwndGroup,GWLP_PGROUP);
pName = AddThing(pGroup->hGroup, lpName ,(WORD)0);
//
// Set the new offset...
//
if (lpgd = LockGroup(hwndGroup)) {
lpgd->pName = pName;
UnlockGroup(hwndGroup);
}
}
/*--------------------------------------------------------------------------*/
/* */
/* SetGroupDimensions() - */
/* */
/* Saves the size and position of the group file in the group segment, as */
/* as well as the positions of all the item icons */
/* */
/*--------------------------------------------------------------------------*/
VOID NEAR PASCAL SetGroupDimensions(HWND hwndGroup)
{
LPGROUPDEF lpgd;
LPITEMDEF lpid;
PGROUP pGroup;
PITEM pItem;
WORD i;
lpgd = LockGroup(hwndGroup);
if (!lpgd)
return;
lpgd->nCmdShow = (WORD)GetInternalWindowPos(hwndGroup, &lpgd->rcNormal,
&lpgd->ptMin);
pGroup = (PGROUP)GetWindowLongPtr(hwndGroup,GWLP_PGROUP);
NukeIconBitmap(pGroup); // invalidate the bitmap
for (pItem=pGroup->pItems; pItem; pItem=pItem->pNext) {
lpid = ITEM(lpgd,pItem->iItem);
lpid->pt.x = pItem->rcIcon.left;
lpid->pt.y = pItem->rcIcon.top;
/* save offset of ITEMDEF for each item
*/
ChangeTagID(lpgd,pItem->iItem,(int)lpgd->rgiItems[pItem->iItem]);
pItem->iItem = (int)lpgd->rgiItems[pItem->iItem];
}
for (i=0, pItem=pGroup->pItems; pItem; pItem=pItem->pNext, i++) {
/* write offsets back out in Z order and update the index
*/
ChangeTagID(lpgd,pItem->iItem,(int)i);
lpgd->rgiItems[i] = (DWORD)pItem->iItem;
pItem->iItem = (int)i;
}
/* Clear out remaining pointers to prevent duped item wierdness. */
while (i < lpgd->cItems)
lpgd->rgiItems[i++] = 0;
UnlockGroup(hwndGroup);
}
/*--------------------------------------------------------------------------*/
/* */
/* WriteGroupsSection() - */
/* */
/*--------------------------------------------------------------------------*/
void PASCAL WriteGroupsSection(VOID)
{
PGROUP pGroup;
HCURSOR hCursor;
HWND hwndGroup;
LPGROUPDEF lpgd;
TCHAR szT[66];
TCHAR szOrd[CGROUPSMAX*8+7];
TCHAR szFmt[] = TEXT("Group%d");
TCHAR szFmtCommonGrp[] = TEXT("GroupC%d");
INT cGroups;
TCHAR szGroupKey[MAXKEYLEN];
INT i;
RECT rc;
POINT ptMin;
TCHAR szCGrpInfo[MAXKEYLEN];
INT cbValueName;
hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
ShowCursor(TRUE);
if (!(hwndGroup = GetWindow(hwndMDIClient, GW_CHILD))) {
goto WPIExit;
}
hwndGroup = GetWindow(hwndGroup, GW_HWNDLAST);
szOrd[0] = 0;
cGroups = 0;
//
// Clear user's previous positioning of common groups.
//
if (hkeyPMCommonGroups) {
cbValueName = CharSizeOf(szGroupKey);
while (!RegEnumValue(hkeyPMCommonGroups, 0, szGroupKey, &cbValueName, 0, 0,
0, 0)) {
RegDeleteValue(hkeyPMCommonGroups, szGroupKey);
cbValueName = CharSizeOf(szGroupKey);
}
}
for (; hwndGroup; hwndGroup = GetWindow(hwndGroup, GW_HWNDPREV)) {
/*
* Check to make sure we're not out of room for the order string.
*/
if (cGroups > CGROUPSMAX) {
MessageBeep(0);
break;
}
if (GetWindow(hwndGroup, GW_OWNER)) {
continue;
}
pGroup = (PGROUP)GetWindowLongPtr(hwndGroup, GWLP_PGROUP);
if (!pGroup->lpKey || !*pGroup->lpKey) {
if (pGroup->lpKey) {
LocalFree((HANDLE)pGroup->lpKey);
}
lpgd = LockGroup(hwndGroup);
if (!lpgd) {
continue;
}
lstrcpy(szGroupKey, (LPTSTR) PTR(lpgd, lpgd->pName));
pGroup->lpKey = (LPTSTR)LocalAlloc(LPTR, sizeof(TCHAR)*(lstrlen(szGroupKey) + 1));
lstrcpy(pGroup->lpKey, szGroupKey);
UnlockGroup(hwndGroup);
}
if (pGroup->fCommon) {
wsprintf(szT, szFmtCommonGrp, pGroup->wIndex);
lstrcat(szOrd, TEXT(" C"));
lstrcat(szOrd, szT + CCHCOMMONGROUP);
if (hkeyPMCommonGroups) {
i = GetInternalWindowPos(hwndGroup, &rc, &ptMin);
if (i==SW_SHOWMINNOACTIVE)
i = SW_SHOWNORMAL;
wsprintf(szCGrpInfo, TEXT("%d %d %d %d %d %d %d "),
rc.left, rc.top, rc.right, rc.bottom,
ptMin.x, ptMin.y, i);
lstrcat(szCGrpInfo, pGroup->lpKey);
RegSetValueEx(hkeyPMCommonGroups, szT, 0, REG_SZ, (LPBYTE)szCGrpInfo, sizeof(TCHAR)*(lstrlen(szCGrpInfo)+1));
}
}
else {
wsprintf(szT, szFmt, pGroup->wIndex);
lstrcat(szOrd, TEXT(" "));
lstrcat(szOrd, szT + CCHGROUP);
if (hkeyPMGroups) {
RegSetValueEx(hkeyPMGroups, szT, 0, REG_SZ, (LPBYTE)pGroup->lpKey, sizeof(TCHAR)*(lstrlen(pGroup->lpKey)+1));
}
}
cGroups++;
}
if (hkeyPMSettings) {
RegSetValueEx(hkeyPMSettings, szOrder, 0, REG_SZ, (LPBYTE)szOrd, sizeof(TCHAR)*(lstrlen(szOrd) + 1));
}
WPIExit:
ShowCursor(FALSE);
SetCursor(hCursor);
}
/*--------------------------------------------------------------------------*/
/* */
/* SaveGroupsContent() -
/*
/* Save the contents of the all the groups, doesn't save changes in
/* size or position if bSaveGroupSettings is FALSE, only the group items.
/* */
/*--------------------------------------------------------------------------*/
BOOL SaveGroupsContent(BOOL bSaveGroupSettings)
{
HWND hwndGroup;
hwndGroup = GetWindow(hwndMDIClient, GW_CHILD);
if (!hwndGroup)
return FALSE;
for (hwndGroup=GetWindow(hwndGroup, GW_HWNDLAST); hwndGroup; hwndGroup=GetWindow(hwndGroup, GW_HWNDPREV)) {
if (GetWindow(hwndGroup, GW_OWNER))
continue;
/* Save the latest sizes and positions. */
if (bSaveGroupSettings) {
SetGroupDimensions(hwndGroup);
if (wLockError == LOCK_LOWMEM && !fLowMemErrYet) {
// No more error messages.
fLowMemErrYet = TRUE;
wLockError = 0;
// Warn user that some settings couldn't be saved.
MyMessageBox(hwndProgman, IDS_OOMEXITTITLE, IDS_LOWMEMONEXIT, NULL,
MB_OK | MB_ICONHAND | MB_SYSTEMMODAL);
}
}
SaveGroup(hwndGroup, TRUE);
}
RegFlushKey(HKEY_CURRENT_USER);
return(TRUE);
}
/*--------------------------------------------------------------------------*/
/* */
/* WriteINIFile() - */
/* */
/*--------------------------------------------------------------------------*/
void FAR PASCAL WriteINIFile()
{
register int i;
RECT rc;
TCHAR szT[40];
HANDLE hCursor;
//
// Don't save if restricted. But force save if we've just converted the
// ansi groups to unicode so we can work from unicode the next time around.
//
if (fNoSave && !bUseANSIGroups)
return;
fLowMemErrYet = FALSE;
hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
ShowCursor(TRUE);
i = GetInternalWindowPos(hwndProgman, &rc, NULL);
if (i==SW_SHOWMINNOACTIVE)
i = SW_SHOWNORMAL;
wsprintf(szT, TEXT("%d %d %d %d %d"), rc.left, rc.top, rc.right, rc.bottom, i);
if (hkeyPMSettings) {
RegSetValueEx(hkeyPMSettings, szWindow, 0, REG_SZ, (LPBYTE)szT, sizeof(TCHAR)*(lstrlen(szT)+ 1));
}
if (!bLoadEvil)
WriteGroupsSection();
//
// Save all groups content, TRUE means we want the size and position saved
// as well.
//
SaveGroupsContent(TRUE);
ShowCursor(FALSE);
SetCursor(hCursor);
}
/*--------------------------------------------------------------------------*/
/* */
/* GetItemCommand() - */
/* */
/*--------------------------------------------------------------------------*/
void FAR PASCAL GetItemCommand(
PGROUP pGroup,
PITEM pItem,
LPTSTR lpCommand,
LPTSTR lpDir)
{
BYTE b=0;
LPTSTR lp1, lp2, lp3;
LPGROUPDEF lpgd;
LPITEMDEF lpid;
BOOL bNoFirstQuote = TRUE;
if (!GetGroupTag(pGroup,pItem,(WORD)ID_APPLICATIONDIR,lpCommand,MAXITEMPATHLEN)) {
// the application directory is not defined
*lpCommand = 0;
}
lpgd = LockGroup(pGroup->hwnd);
if (!lpgd) {
*lpCommand = 0;
*lpDir = 0;
return;
}
lpid = ITEM(lpgd,pItem->iItem);
// init working directory
lp3 = lpDir;
*lp3 = 0;
// item command
lp1 = (LPTSTR) PTR(lpgd, lpid->pCommand);
if (*lp1 == TEXT('"')) {
lp2 = lp1;
while (lp2 && (lp2 = wcschr(lp2+1, TEXT('"'))) && *(lp2+1) != TEXT('\\')) { //go to next quote
;
}
if (!lp2) {
//
// The directory is not in quotes and since the command path starts
// with a quote, there's no working directory.
//
lp2 = lpDir;
*lp2 = 0;
}
else {
if (*(lp2+1) == TEXT('\\')) {
//
// the working directory is in quotes
//
*lp3++ = *lp1++; //write first quote
for (; *lp1 && lp1 != lp2; lp1 = CharNext(lp1)) {
*lp3++ = *lp1;
}
if (*lp1 == TEXT('"')) {
*lp3++ = *lp1++; //write last quote
lp1++;
*lp3 = 0;
}
}
lp2 = lp3 + lstrlen(lp3);
}
}
else {
//
// if there's a working directory, it is not in quotes
//
for (lp2 = lp3 = lpDir; *lp1 && *lp1 != TEXT(' ') && *lp1 != TEXT('"'); // the command line might be in quotes
lp1 = CharNext(lp1)) {
*lp3++ = *lp1;
if (*lp1 == TEXT(':') || *lp1 == TEXT('\\'))
lp2 = lp3;
}
*lp3 = 0;
}
/* we are assuming the exe dir contains the necessary separator
* add the filename to the command line
*/
lstrcat(lpCommand,lp2);
/* add the arguments to the command line
*/
lstrcat(lpCommand,lp1);
/* truncate the command name from the exe path. note this implies
* that if there is no path, lpDir will be empty
*/
*lp2 = 0;
lp2 = CharPrev(lpDir,lp2);
if (*lp2 == TEXT('\\') && *CharPrev(lpDir,lp2) != TEXT(':'))
*lp2 = 0;
UnlockGroup(pGroup->hwnd);
}
/*--------------------------------------------------------------------------*/
/* */
/* DuplicateItem() - */
/* */
/*--------------------------------------------------------------------------*/
PITEM PASCAL DuplicateItem(
PGROUP pGroup,
PITEM pItem,
PGROUP pGNew,
LPPOINT lppt)
{
WORD wIconId;
WORD wIconIndex;
LPITEMDEF lpid;
LPGROUPDEF lpgd;
TCHAR szCommand[MAXITEMPATHLEN + 1];
TCHAR szDefDir[2 * (MAXITEMPATHLEN + 1)];
TCHAR szIconPath[MAXITEMPATHLEN + 1];
TCHAR szName[64];
TCHAR szExpPath[MAXITEMPATHLEN+1];
TCHAR szExpDir[MAXITEMPATHLEN+1];
DWORD dwFlags = CI_ACTIVATE;
lpid = LockItem(pGroup, pItem);
if (lpid == 0L) {
UnlockGroup(pGroup->hwnd);
return NULL;
}
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
lstrcpy(szName, (LPTSTR) PTR(lpgd, lpid->pName));
lstrcpy(szIconPath, (LPTSTR) PTR(lpgd, lpid->pIconPath));
wIconId = lpid->iIcon;
wIconIndex = lpid->wIconIndex;
GlobalUnlock(pGroup->hGroup);
UnlockGroup(pGroup->hwnd);
GetItemCommand(pGroup, pItem, szCommand, szDefDir);
//
// I f there's no icon path, check if we have an executable associated
// with the command path.
//
if (!*szIconPath) {
lstrcpy(szExpPath, szCommand);
DoEnvironmentSubst(szExpPath, CharSizeOf(szExpPath));
StripArgs(szExpPath);
lstrcpy(szExpDir, szDefDir);
DoEnvironmentSubst(szExpDir, CharSizeOf(szExpDir));
FindExecutable(szExpPath, szExpDir, szIconPath);
if (!*szIconPath) {
dwFlags |= CI_NO_ASSOCIATION;
}
else
*szIconPath = 0;
}
if (GroupFlag(pGroup, pItem, (WORD)ID_NEWVDM)) {
dwFlags |= CI_SEPARATE_VDM;
}
return CreateNewItem(pGNew->hwnd,
szName,
szCommand,
szIconPath,
szDefDir,
GroupFlag(pGroup, pItem, (WORD)ID_HOTKEY),
GroupFlag(pGroup, pItem, (WORD)ID_MINIMIZE),
wIconId,
wIconIndex,
NULL,
lppt,
dwFlags);
}
Reference in a new issue View git blame Copy permalink