2152 lines
56 KiB
C
2152 lines
56 KiB
C
#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);
|
|
}
|