Microsoft/Windows2000
Microsoft/Windows2000
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
45f4a58588
Windows2000/private/windows/shell/progman/pmgroup.c

2152 lines
56 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
#include "progman.h"
#include "ime.h"
BOOL FAR PASCAL IMEStringWindow(HWND,HANDLE);
int FAR PASCAL IMEWindowGetCnt(LPTSTR,LPTSTR);
#define HK_SHIFT 0x0100
#define HK_CONTROL 0x0200
#define HK_ALT 0x0400
#define HK_EXT 0x0800
#define F_EXT 0x01000000L
#define OBJ_ITEM 1
BOOL bNoScrollCalc = FALSE;
RECT rcArrangeRect;
HWND hwndScrolling = NULL;
BOOL APIENTRY InQuotes(LPTSTR sz);
void NEAR PASCAL ViewActiveItem(PGROUP pGroup);
/* Make the first item in a list the last and return a pointer to it.*/
PITEM PASCAL MakeFirstItemLast(PGROUP pGroup)
{
PITEM pItemCur;
/* Just quit if there's no list.*/
if ((pItemCur = pGroup->pItems) == NULL)
return NULL;
/* Find the end of the list.*/
for( ; pItemCur->pNext ; pItemCur = pItemCur->pNext)
;
/* End of the list.*/
/* This works even if there is only one item in the */
/* list, it's a waste of time though.*/
pItemCur->pNext = pGroup->pItems;
pGroup->pItems = pGroup->pItems->pNext;
pItemCur->pNext->pNext = NULL;
return pItemCur->pNext;
}
VOID PASCAL GetItemText(PGROUP pGroup, PITEM pItem, LPTSTR lpT, int index)
{
LPITEMDEF lpid;
LPGROUPDEF lpgd;
lpid = LockItem(pGroup,pItem);
if (!lpid) {
UnlockGroup(pGroup->hwnd);
*lpT = 0;
return;
}
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
switch (index) {
case 0:
lstrcpy(lpT, (LPTSTR) PTR(lpgd, lpid->pName));
break;
case 1:
lstrcpy(lpT, (LPTSTR) PTR(lpgd, lpid->pCommand));
break;
case 2:
lstrcpy(lpT, (LPTSTR) PTR(lpgd, lpid->pIconPath));
break;
default:
*lpT = 0;
break;
}
GlobalUnlock(pGroup->hGroup);
UnlockGroup(pGroup->hwnd);
}
ULONG Color16Palette[] = {
0x00000000, 0x00800000, 0x00008000, 0x00808000,
0x00000080, 0x00800080, 0x00008080, 0x00808080,
0x00c0c0c0, 0x00ff0000, 0x0000ff00, 0x00ffff00,
0x000000ff, 0x00ff00ff, 0x0000ffff, 0x00ffffff
};
ULONG Color256Palette[] = {
0x00000000, 0x00800000, 0x00008000, 0x00808000, 0x00000080, 0x00800080, 0x00008080, 0x00c0c0c0,
0x00c0dcc0, 0x00a6caf0, 0x00cccccc, 0x00580800, 0x00600800, 0x00680800, 0x00700800, 0x00780800,
0x00801000, 0x00881000, 0x00901000, 0x00981000, 0x00a01000, 0x00a81000, 0x00b01000, 0x00b81000,
0x00c01800, 0x00c81800, 0x00d01800, 0x00d81800, 0x00e01800, 0x00e81800, 0x00f01800, 0x00f81800,
0x00002000, 0x00082000, 0x00102000, 0x00182000, 0x00202000, 0x00282000, 0x00302000, 0x00382000,
0x00402800, 0x00482800, 0x00502800, 0x00582800, 0x00602800, 0x00682800, 0x00702800, 0x00782800,
0x00803000, 0x00883000, 0x00903000, 0x00983000, 0x00a03000, 0x00a83000, 0x00b03000, 0x00b83000,
0x00c03800, 0x00c83800, 0x00d03800, 0x00d83800, 0x00e03800, 0x00e83800, 0x00f03800, 0x00f83800,
0x00004010, 0x00084010, 0x00104010, 0x00184010, 0x00204010, 0x00284010, 0x00304010, 0x00384010,
0x00404810, 0x00484810, 0x00504810, 0x00584810, 0x00604810, 0x00684810, 0x00704810, 0x00784810,
0x00805010, 0x00885010, 0x00905010, 0x00985010, 0x00a05010, 0x00a85010, 0x00b05010, 0x00b85010,
0x00c05810, 0x00c85810, 0x00d05810, 0x00d85810, 0x00e05810, 0x00e85810, 0x00f05810, 0x00f85810,
0x00006010, 0x00086010, 0x00106010, 0x00186010, 0x00206010, 0x00286010, 0x00306010, 0x00386010,
0x00406810, 0x00486810, 0x00506810, 0x00586810, 0x00606810, 0x00686810, 0x00706810, 0x00786810,
0x00807010, 0x00887010, 0x00907010, 0x00987010, 0x00a07010, 0x00a87010, 0x00b07010, 0x00b87010,
0x00c07810, 0x00c87810, 0x00d07810, 0x00d87810, 0x00e07810, 0x00e87810, 0x00f07810, 0x00f87810,
0x00008020, 0x00088020, 0x00108020, 0x00188020, 0x00208020, 0x00288020, 0x00308020, 0x00388020,
0x00408820, 0x00488820, 0x00508820, 0x00588820, 0x00608820, 0x00688820, 0x00708820, 0x00788820,
0x00809020, 0x00889020, 0x00909020, 0x00989020, 0x00a09020, 0x00a89020, 0x00b09020, 0x00b89020,
0x00c09820, 0x00c89820, 0x00d09820, 0x00d89820, 0x00e09820, 0x00e89820, 0x00f09820, 0x00f89820,
0x0000a020, 0x0008a020, 0x0010a020, 0x0018a020, 0x0020a020, 0x0028a020, 0x0030a020, 0x0038a020,
0x0040a820, 0x0048a820, 0x0050a820, 0x0058a820, 0x0060a820, 0x0068a820, 0x0070a820, 0x0078a820,
0x0080b020, 0x0088b020, 0x0090b020, 0x0098b020, 0x00a0b020, 0x00a8b020, 0x00b0b020, 0x00b8b020,
0x00c0b820, 0x00b820c8, 0x00b820d0, 0x00b820d8, 0x00b820e0, 0x00b820e8, 0x00b820f0, 0x00b820f8,
0x0000c030, 0x00c03008, 0x00c03010, 0x00c03018, 0x00c03020, 0x00c03028, 0x00c03030, 0x00c03038,
0x0040c830, 0x00c83048, 0x00c83050, 0x00c83058, 0x00c83060, 0x00c83068, 0x00c83070, 0x00c83078,
0x0080d030, 0x00d03088, 0x00d03090, 0x00d03098, 0x00d030a0, 0x00d030a8, 0x00d030b0, 0x00d030b8,
0x00c0d830, 0x00c8d830, 0x00d0d830, 0x00d8d830, 0x00e0d830, 0x00e8d830, 0x00f0d830, 0x00f8d830,
0x0000e030, 0x0008e030, 0x0010e030, 0x0018e030, 0x0020e030, 0x0028e030, 0x0030e030, 0x0038e030,
0x0040e830, 0x0048e830, 0x0050e830, 0x0058e830, 0x0060e830, 0x0068e830, 0x0070e830, 0x0078e830,
0x0080f030, 0x0088f030, 0x0090f030, 0x0098f030, 0x00a0f030, 0x00a8f030, 0x00fffbf0, 0x00a0a0a4,
0x00808080, 0x00ff0000, 0x0000ff00, 0x00ffff00, 0x000000ff, 0x00ff00ff, 0x0000ffff, 0x00ffffff
};
HICON APIENTRY GetItemIcon(HWND hwnd, PITEM pitem)
{
LPGROUPDEF lpgd;
LPITEMDEF lpid;
HICON hIcon = NULL;
DWORD dwVer;
HANDLE h;
LPBYTE p;
INT id = 0;
INT cb;
DWORD colors, size;
PBITMAPINFOHEADER pbih, pbihNew;
LPVOID palette;
lpgd = LockGroup(hwnd);
if (!lpgd)
return DuplicateIcon(hAppInstance, hItemIcon);
//return hItemIcon;
lpid = ITEM(lpgd,pitem->iItem);
if ((SHORT)lpid->cbIconRes > 0) {
if (lpid->wIconVer == 2)
dwVer = 0x00020000;
else
dwVer = 0x00030000;
pbihNew = NULL;
pbih = (PBITMAPINFOHEADER)PTR(lpgd, lpid->pIconRes);
size = lpid->cbIconRes;
if (pbih->biClrUsed == -1) {
colors = (1 << (pbih->biPlanes * pbih->biBitCount));
size += colors * sizeof(RGBQUAD);
if (colors == 16) {
palette = Color16Palette;
} else if (colors == 256) {
palette = Color256Palette;
} else {
palette = NULL;
}
if (palette != NULL)
pbihNew = (PBITMAPINFOHEADER)LocalAlloc(LPTR, size);
if (pbihNew != NULL) {
RtlCopyMemory(pbihNew, pbih, sizeof( *pbih ));
pbihNew->biClrUsed = 0;
RtlCopyMemory((pbihNew+1), palette, colors * sizeof(RGBQUAD));
RtlCopyMemory((PCHAR)(pbihNew+1) + (colors * sizeof(RGBQUAD)),
(pbih+1),
lpid->cbIconRes - sizeof(*pbih)
);
pbih = pbihNew;
}
else {
// reset size
size = lpid->cbIconRes;
}
}
hIcon = CreateIconFromResource((PBYTE)pbih, size, TRUE, dwVer);
if (pbihNew != NULL)
LocalFree(pbihNew);
}
if (!hIcon) {
if (h = FindResource(hAppInstance, (LPTSTR) MAKEINTRESOURCE(ITEMICON), RT_GROUP_ICON)) {
h = LoadResource(hAppInstance, h);
p = LockResource(h);
id = LookupIconIdFromDirectory(p, TRUE);
UnlockResource(h);
FreeResource(h);
}
if (h = FindResource(hAppInstance, (LPTSTR) MAKEINTRESOURCE(id), (LPTSTR) MAKEINTRESOURCE(RT_ICON))) {
cb = SizeofResource(hAppInstance, h);
h = LoadResource(hAppInstance, h);
p = LockResource(h);
hIcon = CreateIconFromResource(p, cb, TRUE, 0x00030000);
UnlockResource(h);
FreeResource(h);
}
}
UnlockGroup(hwnd);
return hIcon;
}
COLORREF PASCAL GetTitleTextColor(VOID)
{
COLORREF color;
color = GetSysColor(COLOR_WINDOW);
if (((WORD)LOBYTE(LOWORD(color)) +
(WORD)HIBYTE(LOWORD(color)) +
(WORD)LOBYTE(HIWORD(color))) >= 3*127)
{
return RGB(0,0,0);
}
else
{
return RGB(255,255,255);
}
}
#define REVERSEPAINT
void NEAR PASCAL ReverseGroupList(PGROUP pGroup)
{
PITEM pitem, p1, p2;
for (p1 = pGroup->pItems, p2 = p1->pNext, p1->pNext = NULL; p2; ) {
pitem = p2->pNext;
p2->pNext = p1;
p1 = p2;
p2 = pitem;
}
pGroup->pItems = p1;
}
VOID PASCAL PaintGroup(HWND hwnd)
{
register HDC hdc;
PGROUP pGroup;
PITEM pitem;
PAINTSTRUCT ps;
LPGROUPDEF lpgd;
LPITEMDEF lpid;
int fontheight;
HBRUSH hbrTitle;
HFONT hFontT;
RECT rcWin;
TEXTMETRIC tm;
HDC hdcMem;
HBITMAP hbmTemp;
HBRUSH hbr, hbrTemp;
INT nMax;
HICON hIcon;
pGroup = (PGROUP)GetWindowLongPtr(hwnd, GWLP_PGROUP);
hdc = BeginPaint(hwnd, &ps);
if (!pGroup->pItems) {
goto Exit;
}
GetClientRect(hwnd, &rcWin);
#ifdef WEIRDBUG
/* DavidPe - 05/15/91
* For some reason RectVisible() will return FALSE in
* situations it shouldn't. Since this is only a
* performance optimization, we can ignore the problem
* for now.
*/
if (!RectVisible(hdc, &rcWin))
goto Exit;
#endif
if (!(lpgd = LockGroup(hwnd)))
goto Exit;
hFontT = SelectObject(hdc, hFontTitle);
GetTextMetrics(hdc, &tm);
// ToddB: This seems like a good point, I don't see why tmExternalLeading should ever
// need to be considered. The result of decreasing the FontHeight is that DrawText
// will be used instead of TextOut in some cases, which should be harmless but might
// effect the apearence of some single line icon titles.
//#ifdef JAPAN
// Why we should think about ExternalLeading though we calculate the
// title rectange by DrawText() without DT_EXTERNALLEADING. -YN
fontheight = tm.tmHeight;
//#else
// fontheight = tm.tmHeight + tm.tmExternalLeading;
//#endif
SetBkMode(hdc, TRANSPARENT);
SetTextColor(hdc, GetTitleTextColor());
hbrTitle = NULL;
hdcMem = CreateCompatibleDC(hdc);
if (!hdcMem)
goto BitmapSetupComplete;
if (pGroup->hbm) {
hbmTemp = SelectObject(hdcMem, pGroup->hbm);
if (hbmTemp)
goto BitmapSetupComplete;
else
DeleteObject(pGroup->hbm);
}
for (nMax = 1, pitem = pGroup->pItems; pitem; pitem = pitem->pNext) {
if (nMax <= pitem->iItem)
nMax = pitem->iItem + 1;
}
pGroup->hbm = CreateDiscardableBitmap(hdc, cxIcon*lpgd->cItems, cyIcon);
if (!pGroup->hbm)
goto NukeMemDC;
hbmTemp = SelectObject(hdcMem, pGroup->hbm);
if (!hbmTemp)
goto NukeBitmap;
hbr = CreateSolidBrush(GetSysColor(COLOR_WINDOW));
if (!hbr)
goto NukeBitmap;
hbrTemp = SelectObject(hdcMem, hbr);
if (!hbrTemp)
goto NukeBrush;
PatBlt(hdcMem, 0, 0, cxIcon * lpgd->cItems, cyIcon, PATCOPY);
SelectObject(hdcMem, hbrTemp);
DeleteObject(hbr);
for (pitem = pGroup->pItems; pitem != NULL; pitem = pitem->pNext) {
if (hIcon = GetItemIcon(hwnd, pitem)) {
DrawIcon(hdcMem, pitem->iItem * cxIcon, 0, hIcon);
DestroyIcon(hIcon);
} else {
goto DeselectAndNukeBitmap;
}
}
goto BitmapSetupComplete;
NukeBrush:
DeleteObject(hbr);
DeselectAndNukeBitmap:
SelectObject(hdcMem, hbmTemp);
NukeBitmap:
DeleteObject(pGroup->hbm);
pGroup->hbm = NULL;
NukeMemDC:
DeleteDC(hdcMem);
hdcMem = NULL;
BitmapSetupComplete:
ReverseGroupList(pGroup); // reverse the icon list
/* Paint the icons */
for (pitem = pGroup->pItems; pitem; pitem = pitem->pNext) {
if (!pitem->pNext
&& pGroup == pCurrentGroup
&& hwndProgman == GetActiveWindow()) {
hbrTitle = (HANDLE)1; // Use it as a flag
}
else
hbrTitle = (HANDLE)0;
lpid = ITEM(lpgd,pitem->iItem);
if (!bMove || !hbrTitle) {
if (hdcMem) {
BitBlt(hdc, pitem->rcIcon.left + cxOffset,
pitem->rcIcon.top + cyOffset,
lpgd->cxIcon, lpgd->cyIcon, hdcMem,
lpgd->cxIcon*pitem->iItem, 0,
SRCCOPY);
}
else {
if (RectVisible(hdc,&pitem->rcIcon)) {
if (hIcon = GetItemIcon(hwnd,pitem)) {
DrawIcon(hdc, pitem->rcIcon.left + cxOffset,
pitem->rcIcon.top + cyOffset, hIcon);
}
else {
PatBlt(hdc,pitem->rcIcon.left + cxOffset,
pitem->rcIcon.top + cyOffset,
cxIcon, cyIcon, BLACKNESS);
}
}
}
}
}
/* Paint the titles. */
for (pitem = pGroup->pItems; pitem; pitem = pitem->pNext) {
/* test for the active icon */
if (!pitem->pNext
&& pGroup == pCurrentGroup
&& hwndProgman == GetActiveWindow()) {
SetTextColor(hdc, GetSysColor(COLOR_CAPTIONTEXT));
hbrTitle = CreateSolidBrush(GetSysColor(COLOR_ACTIVECAPTION));
}
else {
hbrTitle = (HANDLE)0;
}
lpid = ITEM(lpgd,pitem->iItem);
if (!bMove || !hbrTitle) {
if (hbrTitle)
FillRect(hdc, &(pitem->rcTitle), hbrTitle);
/* draw multi line titles like USER does */
if (pitem->rcTitle.bottom - pitem->rcTitle.top < fontheight*2)
TextOut(hdc, pitem->rcTitle.left+cxOffset, pitem->rcTitle.top,
(LPTSTR) PTR(lpgd, lpid->pName), lstrlen((LPTSTR) PTR(lpgd, lpid->pName)));
else {
if (RectVisible(hdc,&pitem->rcTitle)) {
DrawText(hdc,
(LPTSTR)PTR(lpgd, lpid->pName), -1,
&(pitem->rcTitle),
bIconTitleWrap ?
DT_CENTER | DT_WORDBREAK | DT_NOPREFIX :
DT_CENTER | DT_WORDBREAK | DT_NOPREFIX | DT_SINGLELINE);
}
}
}
if (hbrTitle) {
SetTextColor(hdc, GetTitleTextColor());
DeleteObject(hbrTitle);
hbrTitle = NULL;
}
}
ReverseGroupList(pGroup); // re-reverse the icon list
if (hFontT) {
SelectObject(hdc, hFontT);
}
if (hdcMem) {
SelectObject(hdcMem, hbmTemp);
DeleteDC(hdcMem);
}
UnlockGroup(hwnd);
Exit:
SetBkMode(hdc, OPAQUE);
EndPaint(hwnd, &ps);
#ifdef DEBUG
ProfStop();
{
TCHAR buf[80];
wsprintf(buf, TEXT("msec to paint group = %ld\r\n"), GetTickCount() - dwStartTime);
OutputDebugString(buf);
}
#endif
}
/* Draw the group icon. */
VOID DrawGroupIcon(HWND hwnd)
{
PAINTSTRUCT ps;
HDC hDC;
PGROUP pGroup;
hDC = BeginPaint(hwnd, &ps);
pGroup = (PGROUP)GetWindowLongPtr(hwnd,GWLP_PGROUP);
if (pGroup->fCommon) {
DrawIcon(hDC, cxOffset, cyOffset, hCommonGrpIcon);
}
else {
DrawIcon(hDC, cxOffset, cyOffset, hGroupIcon);
}
EndPaint(hwnd, &ps);
}
PITEM PASCAL ItemHitTest(
PGROUP pGroup,
POINTS pts)
{
PITEM pItem;
POINT pt;
pt.x = (int)pts.x;
pt.y = (int)pts.y;
for (pItem = pGroup->pItems; pItem; pItem = pItem->pNext) {
if (PtInRect(&pItem->rcIcon, pt) || PtInRect(&pItem->rcTitle, pt)) {
break;
}
}
return pItem;
}
HRGN PASCAL IconExcludedRgn(PGROUP pGroup, PITEM pItem)
{
RECT rc;
PITEM pItemT;
HRGN hrgn, hrgnT;
hrgn = CreateRectRgn(0,0,0,0);
if (!hrgn)
return NULL;
hrgnT = CreateRectRgn(0,0,0,0);
if (!hrgnT)
{
return hrgn;
}
for (pItemT = pGroup->pItems;
pItemT && pItemT != pItem;
pItemT = pItemT->pNext)
{
if (IntersectRect(&rc,&pItem->rcIcon,&pItemT->rcIcon))
{
SetRectRgn(hrgnT,rc.left,rc.top,rc.right,rc.bottom);
CombineRgn(hrgn,hrgn,hrgnT,RGN_OR);
}
if (IntersectRect(&rc,&pItem->rcIcon,&pItemT->rcTitle))
{
SetRectRgn(hrgnT,rc.left,rc.top,rc.right,rc.bottom);
CombineRgn(hrgn,hrgn,hrgnT,RGN_OR);
}
}
DeleteObject(hrgnT);
return hrgn;
}
VOID APIENTRY InvalidateIcon(PGROUP pGroup, PITEM pItem)
{
RECT rc;
if (!pGroup || !pItem)
return;
UnionRect(&rc, &pItem->rcIcon, &pItem->rcTitle);
if (bAutoArranging)
UnionRect(&rcArrangeRect, &rcArrangeRect, &rc);
else
InvalidateRect(pGroup->hwnd,&rc,TRUE);
}
VOID PASCAL BringItemToTop(PGROUP pGroup, PITEM pItem, BOOL fUpdate)
{
PITEM pItemT;
HRGN hrgn;
if (pItem == pGroup->pItems) {
return;
}
if (hrgn = IconExcludedRgn(pGroup, pItem)) {
InvalidateRgn(pGroup->hwnd, hrgn, TRUE);
DeleteObject(hrgn);
}
/*
* At this point we know there is at least two items, and we're not the
* first one...
*/
for (pItemT = pGroup->pItems; pItemT->pNext != pItem; pItemT = pItemT->pNext)
;
pItemT->pNext = pItem->pNext;
pItem->pNext = pGroup->pItems;
pGroup->pItems = pItem;
/*
* Invalidate the whole titles in order to change the color.
*/
if (fUpdate) {
InvalidateRect(pGroup->hwnd, &pItem->rcTitle, TRUE);
InvalidateRect(pGroup->hwnd, &pItem->pNext->rcTitle, TRUE);
}
}
VOID PASCAL ClickOn(HWND hwnd, POINTS pts)
{
PGROUP pGroup;
PITEM pItem;
POINT pt;
pGroup = (PGROUP)GetWindowLongPtr(hwnd, GWLP_PGROUP);
pItem = ItemHitTest(pGroup, pts);
if (!pItem) {
return;
}
BringItemToTop(pGroup, pItem, TRUE);
ViewActiveItem(pGroup);
pt.x = (int)pts.x;
pt.y = (int)pts.y;
*(LPPOINT)&rcDrag.left = pt;
*(LPPOINT)&rcDrag.right = pt;
hwndDrag = hwnd;
InflateRect(&rcDrag, GetSystemMetrics(SM_CXDOUBLECLK) / 2,
GetSystemMetrics(SM_CYDOUBLECLK) / 2);
}
VOID PASCAL DragItem(HWND hwnd)
{
PGROUP pGroup;
PITEM pItem;
HICON hIcon;
pGroup = (PGROUP)GetWindowLongPtr(hwnd,GWLP_PGROUP);
pItem = pGroup->pItems;
if (!pItem || hwndDrag != hwnd)
goto ProcExit;
/* If the control key isn't down, do a Move operation. */
bMove = !(GetKeyState(VK_CONTROL) & 0x8000);
/* Don't allow "moves" from RO groups. */
if (pGroup->fRO && bMove == TRUE)
goto ProcExit;
/*
* Redraw the window minus the item we're moving.
* REVIEW - if you just painted the background colour into the
* pItem->rcIcon area then you could remove the bMove code from
* PaintGroup().
*/
if (bMove) {
InvalidateIcon(pGroup,pItem);
UpdateWindow(hwnd);
}
hIcon = GetItemIcon(hwnd,pItem);
// BUG BUG MAKELONG(pGroup,pItem) doesn't make sense since all
// pointers all LOMG in WIN32. Will need to change the parameters!
// johannec 08-19-91
if (DragObject(hwndMDIClient, hwnd, (UINT)OBJ_ITEM,
MAKELONG(pGroup,pItem), hIcon) == DRAG_COPY) {
if (bMove)
DeleteItem(pGroup,pItem);
}
else {
/* Drag was SWP or drag failed... just show the item. */
if (bMove) {
bMove = FALSE;
InvalidateIcon(pGroup,pItem);
}
}
DestroyIcon(hIcon);
ProcExit:
bMove = FALSE;
}
void PASCAL GetRealClientRect(
HWND hwnd,
DWORD dwStyle,
LPRECT lprcClient)
{
DWORD Style;
Style = GetWindowLong(hwnd, GWL_STYLE);
/*BUG BUG will GWL_STYLE work???*/
SetWindowLong(hwnd,GWL_STYLE,dwStyle);
GetWindowRect(hwnd,lprcClient);
ScreenToClient(hwnd,(LPPOINT)&lprcClient->left);
ScreenToClient(hwnd,(LPPOINT)&lprcClient->right);
SendMessage(hwnd,WM_NCCALCSIZE,0,(LPARAM)lprcClient);
}
VOID APIENTRY CalcGroupScrolls(HWND hwnd)
{
register PGROUP pGroup;
register PITEM pItem;
RECT rcClient;
RECT rcRange;
RECT rcT;
DWORD dwStyle, dwStyleNew, dwStyleT;
int iMinPos, iMaxPos;
if (bNoScrollCalc || IsIconic(hwnd))
return;
// Stop re-entrance of this routine.
bNoScrollCalc = TRUE;
pGroup = (PGROUP)GetWindowLongPtr(hwnd,GWLP_PGROUP);
if (!pGroup->pItems) {
// No items...
SetRectEmpty(&rcRange);
goto ChangeStyle;
}
hwndScrolling = hwnd;
// If the user has selected auto arranging then make
// the next item in the z-order visable.
if (bAutoArrange)
ViewActiveItem(pGroup);
SetRectEmpty(&rcRange);
for (pItem = pGroup->pItems; pItem; pItem = pItem->pNext)
{
UnionRect(&rcRange,&rcRange,&pItem->rcIcon);
rcT.top = pItem->rcTitle.top; // don't include the
rcT.bottom = pItem->rcTitle.bottom; // title overhang part
rcT.left = pItem->rcIcon.left;
rcT.right = pItem->rcIcon.right;
UnionRect(&rcRange,&rcRange,&rcT);
}
if (rcRange.left != rcRange.right)
{
// Add on a bit for the left border here.
rcRange.left -= ((cxArrange-cxIconSpace)/2)+cxOffset;
// Don't add on a right border so we can cram as many icons in as poss.
// rcRange.right += ((cxArrange-cxIconSpace)/2);
// ADJUST THE RECT SO THAT WE DON'T GET SCROLL BARS IF ONLY THE BORDERS
// OF TEXT ARE NOT VISIBLE ~~~
}
ChangeStyle:
dwStyleNew = dwStyle = GetWindowLong(hwnd,GWL_STYLE);
dwStyleNew &= ~(WS_HSCROLL | WS_VSCROLL);
for (;;)
{
dwStyleT = dwStyleNew;
GetRealClientRect(hwnd, dwStyleNew, &rcClient);
if (rcRange.left < rcClient.left || rcRange.right > rcClient.right)
dwStyleNew |= WS_HSCROLL;
if (rcRange.top < rcClient.top || rcRange.bottom > rcClient.bottom)
dwStyleNew |= WS_VSCROLL;
if (dwStyleNew == dwStyleT)
break;
}
if (dwStyleNew == dwStyle && !(dwStyle & (WS_VSCROLL|WS_HSCROLL)))
{
/* none there and don't need to add 'em!
*/
goto ProcExit;
}
UnionRect(&rcRange,&rcClient,&rcRange);
/* union garantees that left==right or top==bottom in case of no
* scrollbar.
*/
rcRange.right -= rcClient.right-rcClient.left;
rcRange.bottom -= rcClient.bottom-rcClient.top;
/* if the style changed, don't redraw in sb code, just redraw the
* frame at the end cause the whole ncarea has to be repainted
* if it hasn't changed, just move the thumb
*/
if (dwStyleNew==dwStyle)
{
if (dwStyleNew & WS_HSCROLL)
{
if (GetScrollPos(hwnd,SB_HORZ)!=0)
goto SetScrollInfo;
GetScrollRange(hwnd,SB_HORZ,&iMinPos,&iMaxPos);
if ((iMinPos != rcRange.left) || (iMaxPos != rcRange.right))
goto SetScrollInfo;
}
if (dwStyleNew & WS_VSCROLL)
{
if (GetScrollPos(hwnd,SB_VERT)!=0)
goto SetScrollInfo;
GetScrollRange(hwnd,SB_VERT,&iMinPos,&iMaxPos);
if ((iMinPos != rcRange.top) || (iMaxPos != rcRange.bottom))
goto SetScrollInfo;
}
goto ProcExit;
}
SetScrollInfo:
SetScrollPos(hwnd,SB_HORZ,0,FALSE);
SetScrollPos(hwnd,SB_VERT,0,FALSE);
SetScrollRange(hwnd,SB_HORZ,rcRange.left,rcRange.right,FALSE);
SetScrollRange(hwnd,SB_VERT,rcRange.top,rcRange.bottom,FALSE);
SetWindowPos(hwnd, NULL, 0, 0, 0, 0, SWP_NOZORDER | SWP_NOSIZE
| SWP_NOMOVE | SWP_NOACTIVATE
| SWP_DRAWFRAME);
ProcExit:
// Allow other scroll calculations.
bNoScrollCalc = FALSE;
}
VOID PASCAL ScrollGroup(PGROUP pGroup, int xMove, int yMove, BOOL fCalc)
{
register PITEM pItem;
for (pItem = pGroup->pItems; pItem; pItem = pItem->pNext)
{
OffsetRect(&pItem->rcIcon,xMove,yMove);
OffsetRect(&pItem->rcTitle,xMove,yMove);
}
ScrollWindow(pGroup->hwnd,xMove,yMove,NULL,NULL);
UpdateWindow(pGroup->hwnd);
if (fCalc)
CalcGroupScrolls(pGroup->hwnd);
}
VOID APIENTRY ViewActiveItem(PGROUP pGroup)
{
RECT rcClient, rc;
int xMove = 0, yMove = 0;
GetClientRect(pGroup->hwnd,&rcClient);
UnionRect(&rc, &pGroup->pItems->rcIcon, &pGroup->pItems->rcTitle);
// Clip width to that of icon i.e. ignore width of text.
rc.left = pGroup->pItems->rcIcon.left;
rc.right = pGroup->pItems->rcIcon.right;
if (rc.left < rcClient.left)
xMove = rcClient.left - rc.left;
else if (rc.right > rcClient.right)
xMove = rcClient.right - rc.right;
if (rc.top < rcClient.top)
yMove = rcClient.top - rc.top;
else if (rc.bottom > rcClient.bottom)
yMove = rcClient.bottom - rc.bottom;
if (xMove || yMove)
ScrollGroup(pGroup, xMove, yMove,TRUE);
}
BOOL FAR PASCAL CheckHotKey(WPARAM wParam, LPARAM lParam)
{
HWND hwndT;
PGROUP pGroup;
PITEM pItem;
switch (wParam)
{
case VK_SHIFT:
case VK_CONTROL:
case VK_MENU:
case VK_RETURN:
return FALSE;
}
if (GetKeyState(VK_SHIFT) < 0) {
// DBG((" + SHIFT"));
wParam |= HK_SHIFT;
}
if (GetKeyState(VK_CONTROL) < 0) {
// DBG((" + CONTROL"));
wParam |= HK_CONTROL;
}
if (GetKeyState(VK_MENU) < 0) {
// DBG((" + ALT"));
wParam |= HK_ALT;
}
if (lParam & F_EXT) {
// DBG((" EXTENDED"));
wParam |= HK_EXT;
}
// DBG(("... Full code %4.4X...\r\n",wParam));
for (hwndT = GetWindow(hwndMDIClient,GW_CHILD);
hwndT;
hwndT = GetWindow(hwndT,GW_HWNDNEXT)) {
if (GetWindow(hwndT,GW_OWNER))
continue;
pGroup = (PGROUP)GetWindowLongPtr(hwndT,GWLP_PGROUP);
for (pItem = pGroup->pItems; pItem; pItem = pItem->pNext) {
// DBG(("Checking (%4.4X,%4.4X)...\r\n",pGroup,pItem));
if (GroupFlag(pGroup,pItem,(WORD)ID_HOTKEY) == (WORD)wParam) {
// DBG(("F*O*U*N*D\r\n"));
ExecItem(pGroup,pItem,FALSE,FALSE);
return TRUE;
}
}
}
return FALSE;
}
VOID APIENTRY KeyWindow(HWND hwnd, WORD wDirection)
{
int wT;
int wNext;
RECT rc;
RECT rcT;
POINT ptA;
POINT ptT;
PGROUP pGroup;
PITEM pItem, pItemNext;
pGroup = (PGROUP)GetWindowLongPtr(hwnd,GWLP_PGROUP);
if (!pGroup->pItems)
return;
wNext = 0x7FFF;
pItemNext = NULL;
CopyRect(&rc,&pGroup->pItems->rcIcon);
for (pItem = pGroup->pItems->pNext; pItem; pItem = pItem->pNext) {
CopyRect(&rcT,&pItem->rcIcon);
ptT.x = rcT.left - rc.left;
ptT.y = rcT.top - rc.top;
ptA.x = (ptT.x < 0) ? -ptT.x : ptT.x;
ptA.y = (ptT.y < 0) ? -ptT.y : ptT.y;
switch (wDirection) {
case VK_LEFT:
if ((ptT.x >= 0) || (ptA.x < ptA.y))
continue;
break;
case VK_RIGHT:
if ((ptT.x <= 0) || (ptA.x < ptA.y))
continue;
break;
case VK_DOWN:
if ((ptT.y <= 0) || (ptA.y < ptA.x))
continue;
break;
case VK_UP:
if ((ptT.y >= 0) || (ptA.y < ptA.x))
continue;
break;
default:
/* illegal key
*/
return;
}
wT = ptA.y + ptA.x;
if (wT <= wNext) {
wNext = wT;
pItemNext = pItem;
}
}
if (pItemNext) {
BringItemToTop(pGroup,pItemNext, TRUE);
ViewActiveItem(pGroup);
}
}
VOID APIENTRY CharWindow(register HWND hwnd, register WORD wChar)
{
LPGROUPDEF lpgd;
LPITEMDEF lpid;
PGROUP pGroup;
PITEM pItem, pItemLast;
pGroup = (PGROUP)GetWindowLongPtr(hwnd,GWLP_PGROUP);
if (!pGroup->pItems)
return;
lpgd = LockGroup(hwnd);
if (!lpgd)
return;
/* Search for item, skip the currently selected one.*/
for ( pItem = pGroup->pItems->pNext; pItem; pItem=pItem->pNext)
{
lpid = ITEM(lpgd,pItem->iItem);
if (CharUpper((LPTSTR)(DWORD)wChar)
== CharUpper((LPTSTR)(DWORD)(BYTE)*PTR(lpgd, lpid->pName)))
{
pItemLast = MakeFirstItemLast(pGroup);
BringItemToTop(pGroup,pItem, FALSE);
/* Handle updates.*/
InvalidateRect(pGroup->hwnd,&pItem->rcTitle,TRUE);
InvalidateRect(pGroup->hwnd,&pItemLast->rcTitle,TRUE);
ViewActiveItem(pGroup);
break;
}
}
UnlockGroup(hwnd);
}
VOID APIENTRY ScrollMessage(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
int wMin;
int wMax;
int wPos;
int wInc;
int wPage;
int wNewPos;
RECT rcClient;
int yMove;
int xMove;
BOOL fTemp;
GetClientRect(hwnd, &rcClient);
if (uiMsg == WM_HSCROLL) {
GetScrollRange(hwnd, SB_HORZ, &wMin, &wMax);
wPos = GetScrollPos(hwnd, SB_HORZ);
wInc = cxIconSpace + cxArrange / 2;
wPage = rcClient.right-rcClient.left;
}
else {
GetScrollRange(hwnd, SB_VERT, &wMin, &wMax);
wPos = GetScrollPos(hwnd, SB_VERT);
wInc = cyArrange;
wPage = rcClient.bottom-rcClient.top;
}
switch (GET_WM_VSCROLL_CODE(wParam, lParam)) {
case SB_BOTTOM:
wNewPos = wMax;
break;
case SB_TOP:
wNewPos = wMin;
break;
case SB_LINEDOWN:
wNewPos = wPos + wInc;
break;
case SB_LINEUP:
wNewPos = wPos - wInc;
break;
case SB_PAGEDOWN:
wNewPos = wPos + wPage;
break;
case SB_PAGEUP:
wNewPos = wPos - wPage;
break;
case SB_THUMBTRACK:
case SB_THUMBPOSITION:
wNewPos = (INT)(SHORT)GET_WM_VSCROLL_POS(wParam, lParam);
break;
case SB_ENDSCROLL:
// We might suddenly not need the scroll bars anymore so
// check now.
// Stop CGS from moving the view.
fTemp = bAutoArrange;
bAutoArrange = FALSE;
CalcGroupScrolls(hwnd);
bAutoArrange = fTemp;
/*** FALL THRU ***/
default:
return;
}
if (wNewPos < wMin)
wNewPos = wMin;
else if (wNewPos > wMax)
wNewPos = wMax;
if (uiMsg == WM_VSCROLL) {
SetScrollPos(hwnd, SB_VERT, wNewPos, TRUE);
yMove = wPos - wNewPos;
xMove = 0;
}
else {
SetScrollPos(hwnd, SB_HORZ, wNewPos, TRUE);
yMove = 0;
xMove = wPos - wNewPos;
}
ScrollGroup((PGROUP)GetWindowLongPtr(hwnd,GWLP_PGROUP),xMove,yMove,FALSE);
}
VOID PASCAL OfficialRect(
LPRECT lprc,
int x,
int y,
int xOffset,
int yOffset)
{
// Work out were the icon should go in the icon grid, taking
// note of where the scroll bars are.
lprc->right = (lprc->left = x-xOffset + (cxIconSpace - cxArrange) / 2) +
cxArrange - 1;
lprc->bottom = (lprc->top = y-yOffset) + cyArrange - 1;
}
BOOL PASCAL IconOverlaps(
PGROUP pGroup,
LPRECT lprc,
int xOffset,
int yOffset)
{
PITEM pItem;
RECT rcT;
for (pItem = pGroup->pItems; pItem; pItem = pItem->pNext) {
// Ignore icons at -1. This is where icon's get put when
// we don't know where to put them and they will get moved
// later.
if (pItem->rcIcon.left == -1) {
continue;
}
OfficialRect(&rcT, pItem->rcIcon.left, pItem->rcIcon.top, xOffset, yOffset);
if (IntersectRect(&rcT, &rcT, lprc)) {
return TRUE;
}
}
return FALSE;
}
/*
* NB This is called for every icon at init time so put anything to do with
* finding icon positions inside the `if' because that's skipped on init.
* If you don't it'll get tres slow.
*/
VOID PASCAL ComputeIconPosition(
PGROUP pGroup,
POINT pt,
LPRECT lprcIcon,
LPRECT lprcTitle,
LPTSTR lpText)
{
HDC hdc;
int cch;
RECT rcClient, rcT;
HFONT hFontT;
int xsp, ysp; // Current position of scrollbar.
int vMax, vMin; // Range.
int hMax, hMin; // Range.
int xOffset, yOffset;
DWORD dwStyle;
if (pt.x == -1) {
/*
* Icon is in "find me a default position" mode...
* so search the icon space for it...
*/
// Get the current window style.
dwStyle = GetWindowLong(pGroup->hwnd,GWL_STYLE);
if (dwStyle & WS_MINIMIZE) {
// DBG(("PM.CIP: Window Minimised\n\r"));
// We want to use the restored state of the window.
GetInternalWindowPos(pGroup->hwnd, &rcClient, NULL);
// Convert from screen coords to client coords.
OffsetRect(&rcClient, -rcClient.left, -rcClient.top);
}
else {
// DBG(("PM.CIP: Window normal or maxed.\n\r"));
// Take into account scroll bars.
GetClientRect(pGroup->hwnd, &rcClient);
}
if (dwStyle & WS_HSCROLL) {
xsp = GetScrollPos(pGroup->hwnd, SB_HORZ);
GetScrollRange(pGroup->hwnd, SB_HORZ, &hMin, &hMax);
xOffset = xsp-hMin; // Offset icon grid to match scroll bar pos.
}
else {
xOffset = 0;
}
if (dwStyle & WS_VSCROLL) {
ysp = GetScrollPos(pGroup->hwnd, SB_VERT);
GetScrollRange(pGroup->hwnd, SB_VERT, &vMin, &vMax);
yOffset = ysp-vMin; // Offset icon grid.
}
else {
yOffset = 0;
}
pt.x = (cxArrange - cxIconSpace) / 2 + cxOffset - xOffset;
pt.y = 0 - yOffset;
/* Set this icon's left to -1 so that it'll be excluded
* by the IconOverlaps check.
*/
lprcIcon->left = -1;
for (;;) {
OfficialRect(&rcT, pt.x, pt.y, xOffset, yOffset);
if (!IconOverlaps(pGroup, &rcT, xOffset, yOffset)) {
break;
}
if (rcT.right + cxArrange > rcClient.right) {
pt.x = (cxArrange-cxIconSpace)/2 + cxOffset - xOffset;
pt.y += cyArrange;
}
else {
pt.x += cxArrange;
}
}
}
SetRect(lprcIcon, pt.x, pt.y, pt.x+cxIconSpace, pt.y+cyIconSpace);
if (IsRectEmpty(lprcTitle)) {
cch = lstrlen(lpText);
hdc = GetDC(pGroup->hwnd);
hFontT = SelectObject(hdc, hFontTitle);
/*
* Compute the icon rect using DrawText.
*/
lprcTitle->right = cxArrange - (2 * cxOffset);
DrawText(hdc, lpText, -1, lprcTitle, bIconTitleWrap ?
(WORD)(DT_CALCRECT | DT_WORDBREAK | DT_NOPREFIX) :
(WORD)(DT_CALCRECT | DT_WORDBREAK | DT_NOPREFIX | DT_SINGLELINE));
if (hFontT) {
SelectObject(hdc, hFontT);
}
ReleaseDC(pGroup->hwnd, hdc);
lprcTitle->right += cxOffset * 2;
lprcTitle->bottom += dyBorder * 2;
}
else {
SetRect(lprcTitle, 0, 0, lprcTitle->right - lprcTitle->left,
lprcTitle->bottom - lprcTitle->top);
}
OffsetRect(lprcTitle, pt.x+(cxIconSpace/2)-((lprcTitle->right-lprcTitle->left)/2),
pt.y + cyIconSpace - dyBorder);
// REVIEW Very expensive to do this here.
// if ((bAutoArrange) && (!bAutoArranging))
// ArrangeItems(pGroup->hwnd);
}
VOID APIENTRY MoveItem(PGROUP pGroup, PITEM pItem, POINT pt)
{
LPITEMDEF lpid;
LPGROUPDEF lpgd;
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
/*
* If the position is the same, ignore
*/
if ((pt.x == pItem->rcIcon.left) && (pt.y == pItem->rcIcon.top)) {
GlobalUnlock(pGroup->hGroup);
return;
}
/*
* Repaint the original position
*/
InvalidateIcon(pGroup, pItem);
lpid = LockItem(pGroup,pItem);
if (!lpid) {
GlobalUnlock(pGroup->hGroup);
return;
}
ComputeIconPosition(pGroup, pt, &pItem->rcIcon, &pItem->rcTitle,
(LPTSTR) PTR(lpgd, lpid->pName));
UnlockGroup(pGroup->hwnd);
GlobalUnlock(pGroup->hGroup);
/*
* Repaint the new position
*/
InvalidateIcon(pGroup,pItem);
// CalcGroupScrolls(pGroup->hwnd);
}
/* DropObject() - */
LONG NEAR PASCAL DropObject(HWND hWnd, LPDROPSTRUCT lpds)
{
BOOL fNC;
BOOL fOk;
POINT pt;
LPPOINT lppt;
PGROUP pGroup;
PITEM pItem;
RECT rcClient;
pGroup = pCurrentGroup;
pItem = pGroup->pItems;
pt = lpds->ptDrop;
// A drop anywhere in the window is valid.
GetWindowRect(hWnd, &rcClient);
// Convert to client coords.
ScreenToClient(hWnd,(LPPOINT)&(rcClient.left));
ScreenToClient(hWnd,(LPPOINT)&(rcClient.right));
if (pt.x >= rcClient.left && pt.y >= rcClient.top && pt.x <= rcClient.right
&& pt.y <= rcClient.bottom) {
/* Dropped in given point of client area. */
fNC = FALSE;
pt.x -= (GetSystemMetrics(SM_CXICON) / 2) + 2;
pt.y -= (GetSystemMetrics(SM_CYICON) / 2) + 2;
lppt = &pt;
}
else {
/* Dropped in nonclient area. */
fNC = TRUE;
lppt = NULL;
}
/* Are we iconic ? */
if (IsIconic(hWnd)) {
// Yep, we'll need to use default positioning.
fNC = TRUE;
lppt = NULL;
}
#if 0
// this if statement code if obsolete, it is never called. - johannec 8/11/93
if (lpds->wFmt == DOF_EXECUTABLE || lpds->wFmt == DOF_DOCUMENT) {
BuildDescription(szNameField, szPathName);
return((LONG)(CreateNewItem(hWnd,
szNameField, szPathName, szPathName, TEXT(""),
0, FALSE, 0, 0, NULL, lppt, CI_SET_DOS_FULLSCRN) != NULL));
}
#endif
if ((hWnd == pGroup->hwnd) && (bMove)) {
/* Don't drop on our own non-client area. */
if (fNC)
return 0L;
/* We are just moving the item within its own group.
* Hide it first so the icon title is treated correctly.
*/
MoveItem(pGroup,pItem, pt);
if ((bAutoArrange) && (!bAutoArranging))
ArrangeItems(pGroup->hwnd);
else if (!bAutoArranging)
CalcGroupScrolls(pGroup->hwnd);
return(DRAG_SWP);
}
else {
/* Copy the item to the new group... Set the hourglass
* cursor (it will get unset after the message returns),
* select the new group, and add the item at the specified
* point.
*/
fOk = DuplicateItem(pGroup,pItem,
(PGROUP)GetWindowLongPtr(hWnd,GWLP_PGROUP),lppt) != NULL;
/*
* Re-Arrange items within the destination group.
* NB The source will been taken care of by the DeleteItem routine
* called from DragItem.
*/
if ((bAutoArrange) && (!bAutoArranging)) {
/* Destination */
ArrangeItems(hWnd);
}
else if (!bAutoArranging) {
/* Destination */
CalcGroupScrolls(hWnd);
}
/* View the current item. */
BringItemToTop(pGroup,pItem, TRUE);
ViewActiveItem(pGroup);
/* If the dest isn't minimised then move the focus to it. */
if (!IsIconic(hWnd))
SetFocus(hWnd);
return (fOk ? DRAG_COPY : 0L);
}
}
LONG APIENTRY DropFiles(HWND hwnd, HANDLE hDrop)
{
POINT pt;
LPPOINT lppt;
UINT i;
HCURSOR hCursor;
DWORD dwRet;
DWORD dwFlags = CI_ACTIVATE | CI_SET_DOS_FULLSCRN;
hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
ShowCursor(TRUE);
if (!DragQueryPoint(hDrop, &pt) ||
DragQueryFile(hDrop, (UINT)-1, NULL, 0) != 1) {
lppt = NULL;
}
else {
pt.x -= (GetSystemMetrics(SM_CXICON) / 2) + 2;
pt.y -= (GetSystemMetrics(SM_CYICON) / 2) + 2;
lppt = &pt;
}
for (i=0; DragQueryFile(hDrop, i, szPathField, MAXITEMPATHLEN); i++) {
// if filename or directory have spaces, put the path
// between quotes.
CheckEscapes(szPathField, MAXITEMPATHLEN+1);
/* Verify the file's existance... */
dwRet = ValidatePath(hwndProgman, szPathField, NULL, szIconPath);
if (dwRet == PATH_INVALID) {
continue;
}
else if (dwRet == PATH_INVALID_OK) {
dwFlags |= CI_NO_ASSOCIATION;
}
BuildDescription(szNameField,szPathField);
GetDirectoryFromPath(szPathField, szDirField);
if (!InQuotes(szDirField)) {
CheckEscapes(szDirField, MAXITEMPATHLEN+1);
}
HandleDosApps(szIconPath);
if (!CreateNewItem(hwnd,
szNameField, /* name*/
szPathField, /* command*/
szIconPath , /* icon path*/
szDirField, /* no default dir*/
0,0, /* no hotkey, no min on run*/
0,0,0, /* default icon*/
lppt, /* at this point*/
dwFlags))
break;
}
DragFinish(hDrop);
ShowCursor(FALSE);
SetCursor(hCursor);
if ((bAutoArrange) && (!bAutoArranging))
ArrangeItems(hwnd);
else if (!bAutoArranging)
CalcGroupScrolls(hwnd);
return 1L;
}
LRESULT APIENTRY GroupWndProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
POINT pt;
switch (uiMsg) {
case WM_CREATE:
{
LPMDICREATESTRUCT lpmdics;
lpmdics = (LPMDICREATESTRUCT)(((LPCREATESTRUCT)lParam)->lpCreateParams);
SetWindowLongPtr(hwnd, GWLP_PGROUP, lpmdics->lParam);
DragAcceptFiles(hwnd,TRUE);
SetFocus(hwnd);
break;
}
case WM_ERASEBKGND:
if (IsIconic(hwnd)) {
// Erase background with the APPWORKSPACE color
RECT rc;
if (!hbrWorkspace)
hbrWorkspace = CreateSolidBrush(GetSysColor(COLOR_APPWORKSPACE));
GetUpdateRect(hwnd, &rc, FALSE);
if (IsRectEmpty(&rc)) {
GetClientRect(hwnd, &rc);
}
FillRect((HDC)wParam, &rc, hbrWorkspace);
}
else {
goto DefProc;
}
break;
case WM_PAINT:
if (IsIconic(hwnd)) {
DrawGroupIcon(hwnd);
}
else {
PaintGroup(hwnd);
}
break;
case WM_QUERYDRAGICON:
{
PGROUP pGroup;
HICON hIcon = NULL;
pGroup = (PGROUP)GetWindowLongPtr(hwnd, GWLP_PGROUP);
if (pGroup->fCommon) {
hIcon = LoadIcon(hAppInstance, (LPTSTR) MAKEINTRESOURCE(COMMGROUPICON));
}
else {
hIcon = LoadIcon(hAppInstance, (LPTSTR) MAKEINTRESOURCE(PERSGROUPICON));
}
if (hIcon) {
return((LRESULT)hIcon);
}
else {
goto DefProc;
}
break;
}
case WM_LBUTTONDOWN:
ClickOn(hwnd, MAKEPOINTS(lParam));
break;
case WM_MOUSEMOVE:
if (wParam & MK_LBUTTON) {
pt.x = (int)(MAKEPOINTS(lParam).x);
pt.y = (int)(MAKEPOINTS(lParam).y);
if (!IsRectEmpty(&rcDrag) && !PtInRect(&rcDrag, pt)
&& !fNoFileMenu && (dwEditLevel < 2)) {
SetRect(&rcDrag,0,0,0,0);
DragItem(hwnd);
}
}
else {
SetRect(&rcDrag,0,0,0,0);
}
break;
case WM_LBUTTONUP:
SetRect(&rcDrag,0,0,0,0);
break;
case WM_NCLBUTTONDBLCLK:
if (IsIconic(hwnd) && (GetKeyState(VK_MENU) < 0)) {
PostMessage(hwndProgman, WM_COMMAND, IDM_PROPS, 0L);
} else {
goto DefProc;
}
break;
case WM_LBUTTONDBLCLK:
if (ItemHitTest((PGROUP)GetWindowLongPtr(hwnd,GWLP_PGROUP),
MAKEPOINTS(lParam))) {
if (GetKeyState(VK_MENU) < 0) {
if (!fNoFileMenu)
PostMessage(hwndProgman,WM_COMMAND,IDM_PROPS,0L);
} else {
PostMessage(hwndProgman,WM_COMMAND,IDM_OPEN,0L);
}
} else {
/*
* Check for Alt-dblclk on nothing to get new item.
*/
if (GetKeyState(VK_MENU) < 0 && !fNoFileMenu &&
(dwEditLevel <= 1) && !(pCurrentGroup->fRO) ) {
MyDialogBox(ITEMDLG, hwndProgman, NewItemDlgProc);
}
}
break;
case WM_VSCROLL:
case WM_HSCROLL:
ScrollMessage(hwnd,uiMsg,wParam,lParam);
break;
case WM_CLOSE:
SendMessage(hwnd, WM_SYSCOMMAND, SC_MINIMIZE, 0L);
break;
case WM_SYSCOMMAND:
{
PGROUP pGroup;
LPGROUPDEF lpgd;
TCHAR szCommonGroupSuffix[MAXKEYLEN];
TCHAR szCommonGroupTitle[2*MAXKEYLEN];
if (wParam == SC_MINIMIZE) {
// if the group is common remove the common suffix from the group
// window title
pGroup = (PGROUP)GetWindowLongPtr(hwnd, GWLP_PGROUP);
if (pGroup->fCommon) {
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
SetWindowText(hwnd, (LPTSTR) PTR(lpgd, lpgd->pName));
GlobalUnlock(pGroup->hGroup);
}
}
if (wParam == SC_RESTORE) {
if (!LockGroup(hwnd)) {
if (wLockError == LOCK_LOWMEM) {
MyMessageBox(hwndProgman, IDS_GROUPFILEERR, IDS_LOWMEM, NULL, MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL);
break;
}
else {
/*
* Lock failed for some other reason - hopefully just
* a group change. Stop the icon group from being
* restored.
*/
break;
}
}
else {
UnlockGroup(hwnd);
}
}
if ((wParam == SC_MAXIMIZE) || (wParam == SC_RESTORE)) {
// if the group is common add the common suffix to the group
// window title
pGroup = (PGROUP)GetWindowLongPtr(hwnd, GWLP_PGROUP);
if (pGroup->fCommon) {
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
if (!lpgd)
goto DefProc;
lstrcpy(szCommonGroupTitle, (LPTSTR) PTR(lpgd, lpgd->pName));
GlobalUnlock(pGroup->hGroup);
if (LoadString(hAppInstance, IDS_COMMONGRPSUFFIX, szCommonGroupSuffix,
CharSizeOf(szCommonGroupSuffix))) {
lstrcat(szCommonGroupTitle, szCommonGroupSuffix);
}
SetWindowText(pGroup->hwnd, szCommonGroupTitle);
}
InvalidateRect(hwnd, NULL, 0);
}
if (wParam == SC_MAXIMIZE)
SetWindowLong(hwnd, GWL_STYLE,
(GetWindowLong(hwnd,GWL_STYLE) & ~(WS_HSCROLL | WS_VSCROLL)));
goto DefProc;
}
case WM_SYSKEYDOWN:
if (!CheckHotKey(wParam,lParam))
goto DefProc;
break;
case WM_KEYDOWN:
if (!CheckHotKey(wParam,lParam))
KeyWindow(hwnd,(WORD)wParam);
break;
//IME Support
//by yutakas 1992.10.22
// When user input DBCS, go and activate icon which has that
// DBCS charcter in the first of description.
case WM_IME_REPORT:
switch (wParam)
{
case IR_STRING:
IMEStringWindow(hwnd,(HANDLE)lParam);
return TRUE;
default:
goto DefProc;
}
break;
case WM_CHAR:
CharWindow(hwnd, (WORD) wParam);
break;
case WM_QUERYDROPOBJECT:
{
#define lpds ((LPDROPSTRUCT)lParam)
PGROUP pGroup;
pGroup = (PGROUP)GetWindowLongPtr(hwnd,GWLP_PGROUP);
if (pGroup->fRO) {
return FALSE;
}
if (lpds->wFmt == OBJ_ITEM) {
return TRUE;
}
#undef lpds
goto DefProc;
}
case WM_DROPOBJECT:
#define lpds ((LPDROPSTRUCT)lParam)
if (lpds->wFmt == OBJ_ITEM)
return DropObject(hwnd, lpds);
#undef lpds
goto DefProc;
case WM_DROPFILES:
return DropFiles(hwnd,(HANDLE)wParam);
case WM_NCACTIVATE:
{
PGROUP pGroup = (PGROUP)GetWindowLongPtr(hwnd,GWLP_PGROUP);
if (pGroup->pItems != NULL) {
InvalidateRect(hwnd,&pGroup->pItems->rcTitle,TRUE);
}
goto DefProc;
}
case WM_QUERYOPEN:
{
PGROUP pGroup;
LPGROUPDEF lpgd;
TCHAR szCommonGroupSuffix[MAXKEYLEN];
TCHAR szCommonGroupTitle[2*MAXKEYLEN];
// if the group is common add the common suffix to the group
// window title
pGroup = (PGROUP)GetWindowLongPtr(hwnd, GWLP_PGROUP);
if (pGroup->fCommon) {
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
if (!lpgd)
goto DefProc;
lstrcpy(szCommonGroupTitle,(LPTSTR) PTR(lpgd, lpgd->pName));
GlobalUnlock(pGroup->hGroup);
if (LoadString(hAppInstance, IDS_COMMONGRPSUFFIX, szCommonGroupSuffix,
CharSizeOf(szCommonGroupSuffix))) {
lstrcat(szCommonGroupTitle, szCommonGroupSuffix);
}
SetWindowText(pGroup->hwnd, szCommonGroupTitle);
}
goto DefProc;
}
case WM_SIZE:
lParam = DefMDIChildProc(hwnd, uiMsg, wParam, lParam);
if (wParam != SIZEICONIC) {
if ((bAutoArrange) && (!bAutoArranging)) {
ArrangeItems(hwnd);
} else if (!bArranging) {
CalcGroupScrolls(hwnd);
}
}
else {
PGROUP pGroup;
LPGROUPDEF lpgd;
// reset window text of common groups
pGroup = (PGROUP)GetWindowLongPtr(hwnd, GWLP_PGROUP);
if (pGroup->fCommon) {
lpgd = (LPGROUPDEF)GlobalLock(pGroup->hGroup);
SetWindowText(pGroup->hwnd, (LPTSTR) PTR(lpgd, lpgd->pName));
GlobalUnlock(pGroup->hGroup);
}
}
return lParam;
case WM_MDIACTIVATE:
if (!pCurrentGroup) {
goto DefProc;
}
/*
* If we are de-activating this window...
*/
if (lParam == 0) {
/*
* We're the last window... punt.
*/
pCurrentGroup = NULL;
} else if (hwnd == (HWND)wParam) {
/*
* We're being deactivated. Update pCurrentGroup
* to the node being activated.
*/
pCurrentGroup = (PGROUP)GetWindowLongPtr((HWND)lParam, GWLP_PGROUP);
} else {
SetFocus(hwnd);
}
goto DefProc;
case WM_MENUSELECT:
// to handle F1 on group window system menu
if (lParam) { /*make sure menu handle isn't null*/
wMenuID = GET_WM_COMMAND_ID(wParam, lParam); /*get cmd from loword of wParam*/
hSaveMenuHandle = (HANDLE)lParam; /*Save hMenu into one variable*/
wSaveFlags = HIWORD(wParam);/*Save flags into another*/
bFrameSysMenu = FALSE;
}
break;
default:
DefProc:
return DefMDIChildProc(hwnd, uiMsg, wParam, lParam);
}
return 0L;
}
/* ArrangeItems() - */
/* Arranges iconic windows within a group. */
VOID FAR PASCAL ArrangeItems(HWND hwnd)
{
PGROUP pGroup;
register PITEM pItem;
PITEM pItemT;
int xSlots;
register int i;
int j,k;
RECT rc;
LPGROUPDEF lpgd;
PITEM rgpitem[CITEMSMAX];
POINT pt;
int t1, t2;
LONG style;
if (bAutoArranging || IsIconic(hwnd))
return;
pGroup = (PGROUP)GetWindowLongPtr(hwnd,GWLP_PGROUP);
if (!pGroup)
return;
/*
* If the group is RO then don't rearrange the items, just update the
* scroll bars
*/
if (!GroupCheck(pGroup)) {
CalcGroupScrolls(hwnd);
return;
}
bAutoArranging = TRUE;
SetRectEmpty(&rcArrangeRect);
style = GetWindowLong(hwnd,GWL_STYLE);
GetRealClientRect(hwnd,style&~(WS_VSCROLL|WS_HSCROLL),&rc);
SetWindowLong(hwnd,GWL_STYLE,style);
xSlots = (rc.right - rc.left)/cxArrange;
if (xSlots < 1)
xSlots = 1;
/* sort the items by x location within a row, or by row if the
* rows are different
*/
k = 0;
for (pItem = pGroup->pItems; pItem; pItem = pItem->pNext) {
/* find nearest row
*/
t1 = pItem->rcIcon.top + cyArrange/2;
if (t1 >= 0)
t1 -= t1 % cyArrange;
else
t1 += t1 % cyArrange;
for (i = 0; i < k; i++) {
pItemT = rgpitem[i];
t2 = pItemT->rcIcon.top + cyArrange/2;
if (t2 >= 0)
t2 -= t2 % cyArrange;
else
t2 += t2 % cyArrange;
if (t2 > t1)
break;
else if (t2 == t1 && pItemT->rcIcon.left > pItem->rcIcon.left)
break;
}
for (j = k; j > i; j--) {
rgpitem[j] = rgpitem[j-1];
}
rgpitem[i] = pItem;
k++;
}
lpgd = LockGroup(hwnd);
if (!lpgd) {
bAutoArranging = FALSE;
return;
}
bNoScrollCalc = TRUE;
for (i = 0; i < k; i++) {
pItem = rgpitem[i];
/* cxOffset necessary to match (buggy???) win 3 USER
*/
pt.x = (i%xSlots)*cxArrange + (cxArrange-cxIconSpace)/2 + cxOffset;
pt.y = (i/xSlots)*cyArrange;
MoveItem(pGroup,pItem,pt);
}
if (!IsRectEmpty(&rcArrangeRect))
InvalidateRect(pGroup->hwnd,&rcArrangeRect,TRUE);
UnlockGroup(hwnd);
bNoScrollCalc = FALSE;
CalcGroupScrolls(hwnd);
bAutoArranging = FALSE;
}
/*
* IMEStringWindow(hwnd,hstr)
* Change activate item by the strings come from IME.
* When Get WM_IME_REPORT with IR_STRING,this function is called.
* by yutakas 1992.10.22
*/
BOOL FAR PASCAL IMEStringWindow(HWND hwnd, HANDLE hStr)
{
LPTSTR lpStr;
LPGROUPDEF lpgd;
LPITEMDEF lpid;
PGROUP pGroup;
PITEM pItem = NULL;
PITEM pItemLast,pTItem;
int nCnt = 0;
int nTCnt = 0;
BOOL ret = FALSE;
if (!hStr)
return ret;
if (!(lpStr = GlobalLock(hStr)))
return ret;
pGroup = (PGROUP)GetWindowLongPtr(hwnd,GWLP_PGROUP);
if (!pGroup->pItems)
return ret;
lpgd = LockGroup(hwnd);
if (!lpgd)
return ret;
#ifdef _DEBUG
{
TCHAR szDev[80];
OutputDebugString((LPTSTR)TEXT("In IME Winsdow\r\n"));
wsprintf ((LPTSTR)szDev,TEXT("IMEStringWindow: lpStr is %s \r\n"),lpStr);
OutputDebugString((LPSTR)szDev);
}
#endif
// Search for item, skip the currently selected one.
for ( pTItem = pGroup->pItems->pNext; pTItem; pTItem=pTItem->pNext)
{
lpid = ITEM(lpgd,pTItem->iItem);
nTCnt = IMEWindowGetCnt(lpStr,(LPTSTR)PTR(lpgd,lpid->pName));
if (nCnt < nTCnt)
{
nCnt = nTCnt;
pItem = pTItem;
}
}
lpid = ITEM(lpgd,pGroup->pItems->iItem);
nTCnt = IMEWindowGetCnt(lpStr,(LPTSTR)PTR(lpgd,lpid->pName));
if ((nCnt >= nTCnt) && pItem)
{
pItemLast = MakeFirstItemLast(pGroup);
BringItemToTop(pGroup,pItem, FALSE);
// Handle updates.
InvalidateRect(pGroup->hwnd,&pItem->rcTitle,TRUE);
InvalidateRect(pGroup->hwnd,&pItemLast->rcTitle,TRUE);
ViewActiveItem(pGroup);
ret = TRUE;
}
GlobalUnlock(hStr);
UnlockGroup(hwnd);
#ifdef _DEBUG
{
TCHAR szDev[80];
wsprintf ((LPTSTR)szDev,TEXT("IMEStringWindow: ret is %s \r\n"),ret);
OutputDebugString((LPTSTR)szDev);
}
#endif
return ret;
}
/*
* IMEWindowGetCnt(LPSTR,LPSTR)
* Compare strings from ahead and return the number of same character
* by yutakas 1992.10.22
*/
int FAR PASCAL IMEWindowGetCnt(LPTSTR lp1, LPTSTR lp2)
{
int cnt = 0;
while (*lp1 && *lp2)
{
// ToddB: This typecasting is to prevent lp1 and lp2 from being modified
// by CharUpper'ing one char at a time instead of the whole string
if (CharUpper((LPTSTR)(DWORD)(BYTE)*lp1) ==
CharUpper((LPTSTR)(DWORD)(BYTE)*lp2))
{
cnt++;
}
else
break;
lp1++;
lp2++;
}
return (*lp1 ? 0 : cnt);
}
Reference in New Issue Copy Permalink