diff options
Diffstat (limited to 'Src/auth/Loginbox/loginTab.cpp')
| -rw-r--r-- | Src/auth/Loginbox/loginTab.cpp | 3192 |
1 files changed, 3192 insertions, 0 deletions
diff --git a/Src/auth/Loginbox/loginTab.cpp b/Src/auth/Loginbox/loginTab.cpp new file mode 100644 index 00000000..76567cde --- /dev/null +++ b/Src/auth/Loginbox/loginTab.cpp @@ -0,0 +1,3192 @@ +#include "./loginTab.h" +#include "./common.h" +#include "./imageLoader.h" +#include "./loginGui.h" +#include "./graphics.h" + +#include "../api.h" +#include "../resource.h" +#include "../../nu/windowsTheme.h" + +#include <vssym32.h> +#include <vsstyle.h> + +#include <malloc.h> +#include <math.h> +#include <shlwapi.h> +#include <commctrl.h> +#include <strsafe.h> + +#define MAX_TEXT_AVECHAR_WIDTH 12 +#define MAX_HELP_AVECHAR_WIDTH 28 +#define IMAGE_MARGIN_CY 4 +#define IMAGE_MARGIN_CX 4 + +#define NLTDS_FOCUSED 0x00000001 +#define NLTDS_DISABLED 0x00000002 +#define NLTDS_LOCKED 0x00000004 + + +typedef struct __LOGINTABITEM +{ + LPWSTR text; + UINT iImage; + UINT iImageActive; + UINT iImageDisabled; + LPARAM param; + LONG textWidth; +} LOGINTABITEM; + +typedef struct __ITEMSTATECOLORTABLE +{ + COLORREF backTop; + COLORREF backBottom; + COLORREF backAlpha; + COLORREF text; + INT frameType; +} ITEMSTATECOLORTABLE; + +typedef struct __ITEMCOLORTABLE +{ + ITEMSTATECOLORTABLE normal; + ITEMSTATECOLORTABLE normalPressed; + ITEMSTATECOLORTABLE normalHigh; + ITEMSTATECOLORTABLE normalDisabled; + ITEMSTATECOLORTABLE selected; + ITEMSTATECOLORTABLE selectedPressed; + ITEMSTATECOLORTABLE selectedHigh; + ITEMSTATECOLORTABLE selectedDisabled; +} ITEMCOLORTABLE; + +typedef struct __COLORTABLE +{ + COLORREF backTop; + COLORREF backBottom; + COLORREF backLine; + COLORREF focus; + COLORREF focusDash; + ITEMCOLORTABLE item; +} COLORTABLE; + + +typedef struct __LOGINTAB +{ + LOGINTABITEM **items; + INT itemsCount; + INT *order; + INT iSelected; + INT iHighlighted; + INT iPressed; + INT iFocused; + HIMAGELIST imageList; + UINT drawStyle; + + COLORTABLE colors; + + HFONT fontText; + + LONG textHeight; + LONG spacing; + RECT margins; + LONG textWidthMax; + + HBITMAP chevronImage; + INT chevronWidth; + HMENU chevronMenu; + + LONG chevronLeft; + LONG visibleRight; + INT lastVisible; + + HBITMAP frameBitmap; + INT frameHeight; + INT frameWidth; + + HBITMAP itemBitmap; + + HWND hTooltip; + BSTR helpText; + +} LOGINTAB; + +typedef struct __CALCITEMWIDTH +{ + HDC hdc; + HFONT font; + HWND hwnd; + INT textWidthMax; + INT imageWidth; + INT imageHeight; + INT itemHeight; + INT frameWidth; + INT dialogPt; + HDC ownedDC; + HFONT ownedFont; +} CALCITEMWIDTH; + +#define FRAMETYPE_NONE 0 +#define FRAMETYPE_SELECTED 1 +#define FRAMETYPE_ACTIVE 2 +#define FRAMETYPE_DISABLED 0 + +typedef struct __PAINTITEMPARAM +{ + HWND hwndTab; + HDC hdc; + const RECT *prcPaint; + const RECT *prcClient; + HRGN clipRgn; + HRGN eraseRgn; + HDC hdcSrc; + HDC hdcItem; +} PAINTITEMPARAM; + +typedef struct __GETITEMRECTPARAM +{ + INT index; + RECT *rect; +} GETITEMRECTPARAM; + +typedef struct __HITTESTITEMPARAM +{ + POINT pt; + RECT *rect; +} HITTESTITEMPARAM; + +typedef struct __UPDATELAYOUTPARAM +{ + INT itemCount; + RECT visibleBox; + BOOL chevronVisible; + LONG chevronLeft; +} UPDATELAYOUTPARAM; + +typedef struct __CHEVRONMENUPAINTPARAM +{ + INT itemWidth; + INT itemHeight; + HDC hdcSrc; + HDC hdcItem; + RECT ownerRect; + HWND hwndMenu; +} CHEVRONMENUPAINTPARAM; + +#define GetTab(__hwnd) ((LOGINTAB*)(LONG_PTR)(LONGX86)GetWindowLongPtr((__hwnd), 0)) + +static LRESULT WINAPI LoginTab_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); + +typedef INT (CALLBACK *ITEMRECTCALLBAC)(LOGINTAB* /*tab*/, LOGINTABITEM* /*item*/, INT /*iItem*/, const RECT* /*prcItem*/, ULONG_PTR /*param*/); + +BOOL LoginTab_RegisterClass(HINSTANCE hInstance) +{ + WNDCLASSW wc; + if (FALSE != GetClassInfo(hInstance, NWC_LOGINTAB, &wc)) + return TRUE; + + ZeroMemory(&wc, sizeof(wc)); + + wc.lpszClassName = NWC_LOGINTAB; + wc.lpfnWndProc = LoginTab_WindowProc; + wc.style = CS_PARENTDC; + wc.cbWndExtra = sizeof(LOGINTAB*); + wc.hInstance = hInstance; + wc.hCursor = LoadCursor(NULL, IDC_ARROW); + + return ( 0 != RegisterClassW(&wc)); +} + +HWND LoginTab_CreateWindow(UINT styleEx, LPCWSTR pszTitle, UINT style, INT x, INT y, INT cx, INT cy, HWND hParent, INT_PTR controlId) +{ + if (FALSE == LoginTab_RegisterClass(WASABI_API_ORIG_HINST)) + return FALSE; + + HWND hwnd = CreateWindowEx(styleEx, NWC_LOGINTAB, pszTitle, WS_CHILD | style, + x, y, cx, cy, hParent, (HMENU)controlId, WASABI_API_ORIG_HINST, NULL); + + return hwnd; +} + +static BOOL LoginTab_IsLocked(HWND hwnd) +{ + UINT windowStyle = GetWindowStyle(hwnd); + return (0 != (NLTS_LOCKED & windowStyle)); +} +static BOOL LoginTab_InitCalcItemWidth(HWND hwnd, HDC hdc, CALCITEMWIDTH *pciw) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab || NULL == pciw) return FALSE; + + pciw->hdc = hdc; + pciw->font = tab->fontText; + pciw->hwnd = hwnd; + pciw->textWidthMax = tab->textWidthMax; + + if (NULL == tab->imageList || FALSE == ImageList_GetIconSize(tab->imageList, &pciw->imageWidth, &pciw->imageHeight)) + { + pciw->imageWidth = 0; + pciw->imageHeight = 0; + } + else + { + pciw->imageWidth += 2 * IMAGE_MARGIN_CX; + pciw->imageHeight += 2 * IMAGE_MARGIN_CY; + } + + + RECT rect; + GetClientRect(hwnd, &rect); + pciw->itemHeight = tab->frameHeight * 2 + tab->textHeight + pciw->imageHeight; + pciw->frameWidth = tab->frameWidth; + + pciw->dialogPt = tab->spacing; + pciw->ownedDC = NULL; + pciw->ownedFont = NULL; + + return TRUE; +} + +static BOOL LoginTab_DestroyCalcItemWidth(CALCITEMWIDTH *pciw) +{ + if (NULL == pciw) return FALSE; + if (NULL != pciw->ownedDC) + { + SelectObject(pciw->ownedDC, pciw->ownedFont); + ReleaseDC(pciw->hwnd, pciw->ownedDC); + } + return TRUE; +} +static INT LoginTab_CalculateItemWidth(CALCITEMWIDTH *pciw, LOGINTABITEM *item) +{ + if (NULL == pciw || NULL == item) return 0; + + if (-1 == item->textWidth) + { + if (NULL != item->text && L'\0' != *(item->text)) + { + if (NULL == pciw->hdc) + { + pciw->ownedDC = GetDCEx(pciw->hwnd, NULL, DCX_CACHE | DCX_NORESETATTRS); + if (NULL == pciw->ownedDC) return 0; + pciw->ownedFont = (HFONT)SelectObject(pciw->ownedDC, pciw->font); + pciw->hdc = pciw->ownedDC; + } + + SIZE textSize; + if (FALSE == GetTextExtentPoint(pciw->hdc, item->text, lstrlen(item->text), &textSize)) + return 0; + + item->textWidth = textSize.cx; + + } + else + item->textWidth = 0; + } + + INT width = (item->textWidth > pciw->imageWidth) ? item->textWidth : pciw->imageWidth; + if (width > pciw->textWidthMax) width = pciw->textWidthMax; + + width += 2*pciw->frameWidth; // borders + + if (width < pciw->itemHeight) + { + INT k = (pciw->itemHeight - width)/(2*pciw->dialogPt); + if (k > 2) k = 2; + width += 2*k*pciw->dialogPt; + } + + return width; + +} +static INT LoginTab_EnumerateItemRects(HWND hwnd, HDC hdc, ITEMRECTCALLBAC callback, ULONG_PTR param) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab || NULL == callback) return -1; + + RECT clientRect, tabRect; + LONG chevronLeft, limitRight; + GetClientRect(hwnd, &clientRect); + + chevronLeft = clientRect.right - tab->chevronWidth; + + clientRect.left += tab->margins.left; + clientRect.top += tab->margins.top; + clientRect.right -= tab->margins.right; + clientRect.bottom -= tab->margins.bottom; + + limitRight = (chevronLeft < clientRect.right) ? chevronLeft : clientRect.right; + + CALCITEMWIDTH calcWidth; + + if (FALSE == LoginTab_InitCalcItemWidth(hwnd, hdc, &calcWidth)) + return -1; + + SetRect(&tabRect, clientRect.left, clientRect.top, clientRect.left, clientRect.bottom); + + INT result, index, lastItem; + lastItem = tab->itemsCount - 1; + result = -1; + BOOL ignoreVisibleUpdate = FALSE; + + for (index = 0; index < tab->itemsCount; index++) + { + tabRect.left = tabRect.right; + if (tabRect.left != clientRect.left) + tabRect.left += tab->spacing; + + if (tabRect.left > limitRight) + { + tabRect.right = clientRect.right + 1; + break; + } + INT iItem = tab->order[index]; + LOGINTABITEM *item = tab->items[iItem]; + INT width = LoginTab_CalculateItemWidth(&calcWidth, item); + if (0 == width) break; + + tabRect.right = tabRect.left + width; + if ((index == lastItem && tabRect.right > clientRect.right) || + (index < lastItem && tabRect.right > limitRight)) + { + break; + } + + result = callback(tab, item, iItem, &tabRect, param); + if (-1 != result) + { + ignoreVisibleUpdate = TRUE; + break; + } + } + + if (FALSE == ignoreVisibleUpdate) + { + if ((index == lastItem && tabRect.right > clientRect.right) || + (index < lastItem && tabRect.right > limitRight)) + { + tab->lastVisible = (index - 1); + + SetRect(&tabRect, chevronLeft, clientRect.top, + clientRect.right + tab->margins.right, clientRect.bottom); + + result = callback(tab, NULL, tab->itemsCount, &tabRect, param); + } + else + tab->lastVisible = lastItem; + } + + LoginTab_DestroyCalcItemWidth(&calcWidth); + return result; +} + +static void LoginTab_NotifySelectionChanged(HWND hwnd) +{ + HWND hParent = GetAncestor(hwnd, GA_PARENT); + if (NULL == hParent) return; + + NMHDR nmhdr; + nmhdr.code = NLTN_SELCHANGE; + nmhdr.hwndFrom = hwnd; + nmhdr.idFrom = GetWindowLongPtr(hwnd, GWLP_ID); + SNDMSG(hParent, WM_NOTIFY, (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr); +} + +static HBITMAP LoginTab_GetItemBitmap(LOGINTAB *tab, HDC hdc, INT cx, INT cy) +{ + if (cx < 1) cx = 1; + if (cy < 1) cy = 1; + + BITMAP bm; + if (NULL == tab->itemBitmap || + sizeof(BITMAP) != GetObject(tab->itemBitmap, sizeof(BITMAP), &bm) || + bm.bmWidth <= cx || abs(bm.bmHeight) < cy) + { + if (NULL != tab->itemBitmap) + DeleteObject(tab->itemBitmap); + + cx++; // need +1px to compose selection fill + tab->itemBitmap = CreateCompatibleBitmap(hdc, cx, cy); + } + + return tab->itemBitmap; +} +static HBITMAP LoginTab_LoadChevronImage(HWND hwnd, INT *imageWidth, INT *imageHeight) +{ + INT width, height; + HBITMAP hbmpDst, hbmpSrc; + hbmpSrc = ImageLoader_LoadBitmap(WASABI_API_ORIG_HINST, + MAKEINTRESOURCE(IDR_ARROW_IMAGE), FALSE, &width, &height); + + if (NULL == hbmpSrc) + return NULL; + + if (height < 0) height = -height; + + INT frameHeight = height/2; + INT frameWidth = width; + + BITMAPINFOHEADER bhi; + ZeroMemory(&bhi, sizeof(bhi)); + bhi.biSize = sizeof(bhi); + bhi.biCompression = BI_RGB; + bhi.biBitCount = 32; + bhi.biPlanes = 1; + bhi.biWidth = frameWidth; + bhi.biHeight = 4 * frameHeight; + + UINT *pixelData; + hbmpDst = CreateDIBSection(NULL, (LPBITMAPINFO)&bhi, DIB_RGB_COLORS, (void**)&pixelData, NULL, 0); + if (NULL == hbmpDst) + { + DeleteObject(hbmpSrc); + return NULL; + } + + BOOL resultOk = FALSE; + + HDC hdc = GetDCEx(hwnd, NULL, DCX_CACHE | DCX_NORESETATTRS); + if (NULL != hdc) + { + HDC hdcSrc = CreateCompatibleDC(hdc); + HDC hdcDst = CreateCompatibleDC(hdc); + + if (NULL != hdcSrc && NULL != hdcDst) + { + HBITMAP hbmpSrcOrig = (HBITMAP)SelectObject(hdcSrc, hbmpSrc); + HBITMAP hbmpDstOrig = (HBITMAP)SelectObject(hdcDst, hbmpDst); + + RECT imageRect; + SetRect(&imageRect, 0, 0, frameWidth, frameHeight); + + BOOL blitFailed = FALSE; + // normal + if (FALSE == blitFailed && + FALSE != BitBlt(hdcDst, 0, 0*frameHeight, frameWidth, frameHeight, hdcSrc, 0, 0, SRCCOPY)) + { + Image_AdjustSaturationAlpha(hbmpDst, &imageRect, -150, -100); + } + else blitFailed = TRUE; + + + // active + if (FALSE == blitFailed && + FALSE == BitBlt(hdcDst, 0, 1*frameHeight, frameWidth, frameHeight, hdcSrc, 0, 0, SRCCOPY)) + { + blitFailed = TRUE; + } + + // disabled + if (FALSE == blitFailed && + FALSE != BitBlt(hdcDst, 0, 2*frameHeight, frameWidth, frameHeight, hdcSrc, 0, 0, SRCCOPY)) + { + OffsetRect(&imageRect, 0, 2*frameHeight); + Image_AdjustSaturationAlpha(hbmpDst, &imageRect, -(150 + 600), -(100 + 600)); + } + else blitFailed = TRUE; + + + // pressed + if (FALSE == blitFailed && + FALSE == BitBlt(hdcDst, 0, 3*frameHeight, frameWidth, frameHeight, hdcSrc, 0, frameHeight, SRCCOPY)) + { + blitFailed = TRUE; + } + + if (FALSE == blitFailed) + { + SetRect(&imageRect, 0, 0, bhi.biWidth, -bhi.biHeight); + Image_Premultiply(hbmpDst, &imageRect); + resultOk = TRUE; + } + + SelectObject(hdcSrc, hbmpSrcOrig); + SelectObject(hdcDst, hbmpDstOrig); + } + if (NULL != hdcSrc) DeleteDC(hdcSrc); + if (NULL != hdcDst) DeleteDC(hdcDst); + ReleaseDC(hwnd, hdc); + } + + + DeleteObject(hbmpSrc); + + if (FALSE == resultOk) + { + DeleteObject(hbmpDst); + hbmpDst = NULL; + } + else + { + if (NULL != imageWidth) *imageWidth = width; + if (NULL != imageHeight) *imageHeight = height; + } + + return hbmpDst; +} +static BOOL LoginTab_GradientFillVertRect(HDC hdc, const RECT *prcFill, COLORREF rgbTop, COLORREF rgbBottom) +{ + TRIVERTEX szVertex[2]; + szVertex[0].x = prcFill->left; + szVertex[0].y = prcFill->top; + szVertex[0].Red = GetRValue(rgbTop) << 8; + szVertex[0].Green = GetGValue(rgbTop) << 8; + szVertex[0].Blue = GetBValue(rgbTop) << 8; + szVertex[0].Alpha = 0x0000; + + szVertex[1].x = prcFill->right; + szVertex[1].y = prcFill->bottom; + szVertex[1].Red = GetRValue(rgbBottom) << 8; + szVertex[1].Green = GetGValue(rgbBottom) << 8; + szVertex[1].Blue = GetBValue(rgbBottom) << 8; + szVertex[1].Alpha = 0x0000; + + GRADIENT_RECT szMesh[1]; + szMesh[0].UpperLeft = 0; + szMesh[0].LowerRight = 1; + + return GdiGradientFill(hdc, szVertex, ARRAYSIZE(szVertex), szMesh, 1, GRADIENT_FILL_RECT_V); +} + +static void LoginTab_EraseBkGround(HDC hdc, LOGINTAB *tab, LONG clientHeight, const RECT *prcPaint) +{ + RECT rect; + LONG middleY = clientHeight/2; + + COLORREF rgbOrig = SetBkColor(hdc, tab->colors.backTop); + + CopyRect(&rect, prcPaint); + rect.bottom = middleY; + if (rect.top < rect.bottom) + ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL); + + SetRect(&rect, prcPaint->left, middleY, prcPaint->right, clientHeight - 1); + + if (FALSE == LoginTab_GradientFillVertRect(hdc, &rect, tab->colors.backTop, tab->colors.backBottom)) + { + SetBkColor(hdc, tab->colors.backBottom); + if (prcPaint->bottom < rect.bottom) + rect.bottom = prcPaint->bottom; + if (rect.top < rect.bottom) + ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL); + } + + if (prcPaint->bottom == clientHeight) + { + SetBkColor(hdc, tab->colors.backLine); + SetRect(&rect, prcPaint->left, clientHeight - 1, prcPaint->right, clientHeight); + ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL); + } + + SetBkColor(hdc, rgbOrig); +} + +static BOOL LoginTab_PaintItemFrame(HDC hdc, LOGINTAB *tab, INT frameType, const RECT *prcItem, const RECT *prcPaint, HDC hdcSrc) +{ + if (NULL == tab->frameBitmap) + return FALSE; + + INT offsetY; + switch(frameType) + { + case FRAMETYPE_SELECTED: offsetY = 0; break; + case FRAMETYPE_ACTIVE: offsetY = 1 * (tab->frameHeight * 2 + 1); break; + case FRAMETYPE_DISABLED: offsetY = 2 * (tab->frameHeight * 2 + 1); break; + default: return FALSE; + } + + SelectObject(hdcSrc, tab->frameBitmap); + + BLENDFUNCTION bf; + bf.BlendOp = AC_SRC_OVER; + bf.BlendFlags = 0; + bf.SourceConstantAlpha = 255; + bf.AlphaFormat = AC_SRC_ALPHA; + + INT lineLength; + + // left-top + GdiAlphaBlend(hdc, prcItem->left, prcItem->top, tab->frameWidth, tab->frameHeight, + hdcSrc, 0, offsetY + 0, tab->frameWidth, tab->frameHeight, bf); + + // right-top + GdiAlphaBlend(hdc, prcItem->right - tab->frameWidth, prcItem->top, tab->frameWidth, tab->frameHeight, + hdcSrc, tab->frameWidth + 1, offsetY + 0, tab->frameWidth, tab->frameHeight, bf); + + // right-bottom + GdiAlphaBlend(hdc, prcItem->right - tab->frameWidth, prcItem->bottom - tab->frameHeight, tab->frameWidth, tab->frameHeight, + hdcSrc, tab->frameWidth + 1, offsetY + tab->frameHeight + 1, tab->frameWidth, tab->frameHeight, bf); + + // left-bottom + GdiAlphaBlend(hdc, prcItem->left, prcItem->bottom - tab->frameHeight, tab->frameWidth, tab->frameHeight, + hdcSrc, 0, offsetY + tab->frameHeight + 1, tab->frameWidth, tab->frameHeight, bf); + + lineLength = (prcItem->right - prcItem->left) - tab->frameWidth * 2; + // top + GdiAlphaBlend(hdc, prcItem->left + tab->frameWidth, prcItem->top, lineLength, tab->frameHeight, + hdcSrc, tab->frameWidth, offsetY + 0, 1, tab->frameHeight, bf); + // bottom + GdiAlphaBlend(hdc, prcItem->left + tab->frameWidth, prcItem->bottom - tab->frameHeight, lineLength, tab->frameHeight, + hdcSrc, tab->frameWidth, offsetY + tab->frameHeight + 1, 1, tab->frameHeight, bf); + + lineLength = (prcItem->bottom - prcItem->top) - tab->frameHeight * 2; + // left + GdiAlphaBlend(hdc, prcItem->left, prcItem->top + tab->frameHeight, tab->frameWidth, lineLength, + hdcSrc, 0, offsetY + tab->frameHeight, tab->frameWidth, 1, bf); + // right + GdiAlphaBlend(hdc, prcItem->right - tab->frameWidth, prcItem->top + tab->frameHeight, tab->frameWidth, lineLength, + hdcSrc, tab->frameWidth + 1, offsetY + tab->frameHeight, tab->frameWidth, 1, bf); + return TRUE; +} + +static BOOL LoginTab_FillItem(HDC hdc, const RECT *prcItem, const RECT *prcPaint, INT alpha, COLORREF rgbTop, COLORREF rgbBottom, INT tempX) +{ + + RECT rect; + SetRect(&rect, tempX, prcItem->top, tempX + 1, prcItem->bottom); + if (rgbTop == rgbBottom || FALSE == LoginTab_GradientFillVertRect(hdc, &rect, rgbTop, rgbBottom)) + { + COLORREF rgbOrig = SetBkColor(hdc, rgbBottom); + ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL); + if (rgbOrig != rgbBottom) SetBkColor(hdc, rgbOrig); + } + + INT height = prcPaint->bottom - prcPaint->top; + + BLENDFUNCTION bf; + bf.BlendOp = AC_SRC_OVER; + bf.BlendFlags = 0; + bf.SourceConstantAlpha = alpha; + bf.AlphaFormat = 0x00; + + BOOL result = GdiAlphaBlend(hdc, prcPaint->left, prcPaint->top, 1, height, + hdc, tempX, prcPaint->top, 1, height, bf); + + if (FALSE != result) + { + INT stretchModeOrig = SetStretchBltMode(hdc, COLORONCOLOR); + + result = StretchBlt(hdc, prcPaint->left + 1, prcPaint->top, prcPaint->right - prcPaint->left - 1, height, + hdc, prcPaint->left, prcPaint->top, 1, height, SRCCOPY); + + if (COLORONCOLOR != stretchModeOrig) + SetStretchBltMode(hdc, stretchModeOrig); + } + + return result; +} +static void LoginTab_DrawRect(HDC hdc, const RECT *prc) +{ + RECT rect; + SetRect(&rect, prc->left +1, prc->top, prc->right -1, prc->top + 1); + ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL); + + SetRect(&rect, prc->left + 1, prc->bottom-1, prc->right -1, prc->bottom); + ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL); + + SetRect(&rect, prc->left, prc->top + 1, prc->left + 1, prc->bottom - 1); + ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL); + + SetRect(&rect, prc->right - 1, prc->top + 1, prc->right, prc->bottom - 1); + ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL); + +} +static BOOL LoginTab_PaintChevron(HDC hdc, LOGINTAB *tab, const RECT *prcItem, const RECT *prcPaint, HDC hdcSrc) +{ + ITEMSTATECOLORTABLE *color; + INT iItem = tab->itemsCount; + + if (0 != ((NLTDS_LOCKED | NLTDS_DISABLED) & tab->drawStyle)) + color = &tab->colors.item.normalDisabled; + else + { + if (iItem == tab->iPressed) + color = &tab->colors.item.normalPressed; + else if (iItem == tab->iHighlighted) + color = &tab->colors.item.normalHigh; + else + color = &tab->colors.item.normal; + } + + RECT rect, itemRect; + CopyRect(&itemRect, prcItem); + + if (iItem == tab->iFocused && 0 != (NLTDS_FOCUSED & tab->drawStyle)) + { + CopyRect(&rect, prcItem); + InflateRect(&rect, -(tab->frameWidth - 2), -(tab->frameWidth - 2)); + COLORREF rgbBkOrig = SetBkColor(hdc, tab->colors.focus); + COLORREF rgbTextOrig = SetTextColor(hdc, tab->colors.focusDash); + DrawFocusRect(hdc, &rect); + //LoginTab_DrawRect(hdc, &rect); + if (rgbBkOrig != tab->colors.focus) SetBkColor(hdc, rgbBkOrig); + if (rgbTextOrig != tab->colors.focusDash) SetTextColor(hdc, rgbTextOrig); + } + + INT frameType = color->frameType; + if (iItem == tab->iFocused && 0 != (NLTDS_FOCUSED & tab->drawStyle)) + frameType = FRAMETYPE_ACTIVE; + + + if (FRAMETYPE_NONE != frameType && + FALSE != LoginTab_PaintItemFrame(hdc, tab, frameType, prcItem, prcPaint, hdcSrc)) + { + InflateRect(&itemRect, -(tab->frameWidth -1), -(tab->frameHeight -1)); + } + + if (0 != color->backAlpha && FALSE != IntersectRect(&rect, &itemRect, prcPaint)) + { + LoginTab_FillItem(hdc, &itemRect, &rect, color->backAlpha, color->backTop, color->backBottom, prcPaint->right); + } + + + + if (NULL != tab->chevronImage) + { + BITMAP bm; + if (sizeof(bm) == GetObject(tab->chevronImage, sizeof(bm), &bm)) + { + if (bm.bmHeight < 0) bm.bmHeight = -bm.bmHeight; + bm.bmHeight = bm.bmHeight/4; + + + INT cx = bm.bmWidth; + INT cy = bm.bmHeight; + + INT offsetY; + if (0 != ((NLTDS_LOCKED | NLTDS_DISABLED) & tab->drawStyle)) + offsetY = 2*bm.bmHeight; + else if (iItem == tab->iPressed) + offsetY = 3*bm.bmHeight; + else if (iItem == tab->iHighlighted || iItem == tab->iSelected) + offsetY = 1*bm.bmHeight; + else + offsetY = 0; + + INT x = prcItem->left + ((prcItem->right - prcItem->left) - cx)/2; + if (x < prcItem->left) x = prcItem->left; + + INT y = prcItem->top + ((prcItem->bottom - prcItem->top) - cy)/2; + if (y < prcItem->top) y = prcItem->top; + + if ((x + cx) > prcItem->right) cx = prcItem->right - x; + if ((y + cy) > prcItem->bottom) cy = prcItem->bottom - y; + + if (iItem == tab->iPressed) y++; + + SelectObject(hdcSrc, tab->chevronImage); + + BLENDFUNCTION bf; + bf.BlendOp = AC_SRC_OVER; + bf.BlendFlags = 0; + bf.SourceConstantAlpha = 255; + bf.AlphaFormat = AC_SRC_ALPHA; + + GdiAlphaBlend(hdc, x, y, cx, cy, hdcSrc, 0, offsetY, bm.bmWidth, bm.bmHeight, bf); + } + } + + return TRUE; +} +static void LoginTab_ResolveImageIndex(HWND hwnd, HIMAGELIST imageList, LOGINTABITEM *item, INT iItem, UINT requestMask) +{ + HWND hParent = GetAncestor(hwnd, GA_PARENT); + if (NULL == hParent) return; + + NMLOGINTABIMAGE request; + request.hdr.code = NLTN_GETITEMIMAGE; + request.hdr.hwndFrom = hwnd; + request.hdr.idFrom = GetWindowLongPtr(hwnd, GWLP_ID); + request.iItem = iItem; + request.param = item->param; + request.imageList = imageList; + request.maskRequest = requestMask; + request.maskUpdate = 0; + request.iImage = item->iImage; + request.iImageActive = item->iImageActive; + request.iImageDisabled = item->iImageDisabled; + + SNDMSG(hParent, WM_NOTIFY, (WPARAM)request.hdr.idFrom, (LPARAM)&request); + + if (0 != request.maskUpdate) + { + if (0 != (NLTIF_IMAGE & request.maskUpdate)) + item->iImage = request.iImage; + + if (0 != (NLTIF_IMAGE_ACTIVE & request.maskUpdate)) + item->iImageActive = request.iImageActive; + + if (0 != (NLTIF_IMAGE_DISABLED & request.maskUpdate)) + item->iImageDisabled = request.iImageDisabled; + } + +} +static UINT LoginTab_GetImageIndex(HWND hwnd, HIMAGELIST imageList, LOGINTABITEM *item, INT iItem, UINT imageType) +{ + if (NULL == item) return NLTM_IMAGE_NONE; + switch(imageType & NLTIF_IMAGE_MASK) + { + case NLTIF_IMAGE_ACTIVE: + if (NLTM_IMAGE_CALLBACK == item->iImageActive) + { + LoginTab_ResolveImageIndex(hwnd, imageList, item, iItem, NLTIF_IMAGE_ACTIVE); + if (NLTM_IMAGE_CALLBACK == item->iImageActive) + break; + } + + if (NLTM_IMAGE_NONE != item->iImageActive) + return item->iImageActive; + + break; + case NLTIF_IMAGE_DISABLED: + if (NLTM_IMAGE_CALLBACK == item->iImageDisabled) + { + LoginTab_ResolveImageIndex(hwnd, imageList, item, iItem, NLTIF_IMAGE_DISABLED); + if (NLTM_IMAGE_CALLBACK == item->iImageDisabled) + break; + } + + if (NLTM_IMAGE_NONE != item->iImageDisabled) + return item->iImageDisabled; + + break; + } + + if (NLTM_IMAGE_CALLBACK == item->iImage) + LoginTab_ResolveImageIndex(hwnd, imageList, item, iItem, NLTIF_IMAGE); + + return item->iImage; +} + +static BOOL LoginTab_PaintItem(HWND hwndTab, HDC hdc, LOGINTAB *tab, LOGINTABITEM *item, INT iItem, const RECT *prcItem, const RECT *prcPaint, HDC hdcSrc) +{ + + ITEMSTATECOLORTABLE *color; + UINT imageType; + + if (iItem == tab->iSelected) + { + if (0 != (NLTDS_DISABLED & tab->drawStyle)) + { + color = &tab->colors.item.selectedDisabled; + imageType = NLTIF_IMAGE_DISABLED; + } + else + { + if (0 != (NLTDS_LOCKED & tab->drawStyle)) + { + color = &tab->colors.item.selected; + } + else + { + if (iItem == tab->iPressed) + color = &tab->colors.item.selectedPressed; + else if (iItem == tab->iHighlighted) + color = &tab->colors.item.selectedHigh; + else + color = &tab->colors.item.selected; + } + + imageType = NLTIF_IMAGE_ACTIVE; + } + } + else + { + if (0 != ((NLTDS_DISABLED | NLTDS_LOCKED) & tab->drawStyle)) + { + color = &tab->colors.item.normalDisabled; + imageType = NLTIF_IMAGE_DISABLED; + } + else if (iItem == tab->iPressed) + { + color = &tab->colors.item.normalPressed; + imageType = NLTIF_IMAGE_ACTIVE; + } + else if (iItem == tab->iHighlighted) + { + color = &tab->colors.item.normalHigh; + imageType = NLTIF_IMAGE_ACTIVE; + } + else + { + color = &tab->colors.item.normal; + imageType = NLTIF_IMAGE; + } + } + + RECT rect, itemRect; + CopyRect(&itemRect, prcItem); + + + + if (FRAMETYPE_NONE != color->frameType && + FALSE != LoginTab_PaintItemFrame(hdc, tab, color->frameType, prcItem, prcPaint, hdcSrc)) + { + InflateRect(&itemRect, -(tab->frameWidth -1), -(tab->frameHeight -1)); + } + + if (0 != color->backAlpha && FALSE != IntersectRect(&rect, &itemRect, prcPaint)) + { + LoginTab_FillItem(hdc, &itemRect, &rect, color->backAlpha, color->backTop, color->backBottom, prcPaint->right); + } + + if (iItem == tab->iFocused && 0 != (NLTDS_FOCUSED & tab->drawStyle)) + { + CopyRect(&rect, prcItem); + InflateRect(&rect, -(tab->frameWidth - 2), -(tab->frameWidth - 2)); + COLORREF rgbBkOrig = SetBkColor(hdc, tab->colors.focus); + COLORREF rgbTextOrig = SetTextColor(hdc, tab->colors.focusDash); + DrawFocusRect(hdc, &rect); + //LoginTab_DrawRect(hdc, &rect); + if (rgbBkOrig != tab->colors.focus) SetBkColor(hdc, rgbBkOrig); + if (rgbTextOrig != tab->colors.focusDash) SetTextColor(hdc, rgbTextOrig); + } + + if (NULL != tab->imageList) + { + UINT iImage = LoginTab_GetImageIndex(hwndTab, tab->imageList, item, iItem, imageType); + if (NLTM_IMAGE_NONE != iImage) + { + IMAGELISTDRAWPARAMS dp; + dp.cbSize = 56/*sizeof(IMAGELISTDRAWPARAMS) - sizeof(DWORD) * 3*/; + dp.himl = tab->imageList; + dp.i = iImage; + dp.hdcDst = hdc; + + ImageList_GetIconSize(tab->imageList, &dp.cx, &dp.cy); + dp.x = prcItem->left + ((prcItem->right - prcItem->left) - dp.cx)/2; + if (dp.x < (prcItem->left + tab->frameWidth)) dp.x = prcItem->left + tab->frameWidth; + if ((dp.x + dp.cx) > (prcItem->right - tab->frameWidth)) + { + dp.cx = prcItem->right - tab->frameWidth - dp.x; + if (dp.cx < 0) dp.cx = 0; + } + + dp.y = prcItem->top + tab->frameHeight + IMAGE_MARGIN_CY; + if ((dp.y + dp.cy) > (prcItem->bottom - tab->frameHeight)) + { + dp.cy = prcItem->bottom - tab->frameHeight- dp.y; + if (dp.cy < 0) dp.cy = 0; + } + + dp.xBitmap = 0; + dp.yBitmap = 0; + dp.rgbBk = CLR_NONE; + dp.rgbFg = CLR_NONE; + dp.fStyle = ILD_NORMAL; + dp.dwRop = SRCCOPY; + dp.fState = ILS_NORMAL /*| ILS_SATURATE*/ /*| ILS_ALPHA*/; + dp.Frame = 255; + dp.crEffect = 0; + + if (dp.cx > 0 && dp.cy > 0) + ImageList_DrawIndirect(&dp); + } + + } + if (NULL != item->text && L'\0' != *item->text) + { + LONG left = prcItem->left + ((prcItem->right - prcItem->left) - item->textWidth) / 2; + if (left < (prcItem->left + tab->frameWidth)) left = prcItem->left + tab->frameWidth; + + LONG top = prcItem->bottom - tab->textHeight - tab->frameHeight + 1; + + SetRect(&rect, left, top, left + item->textWidth, top + tab->textHeight); + if (rect.right > (prcItem->right - tab->frameWidth)) rect.right = prcItem->right - tab->frameWidth; + + if (rect.bottom > prcPaint->bottom) rect.bottom = prcPaint->bottom; + if (rect.top < prcPaint->top) rect.top = prcPaint->top; + if (rect.right > prcPaint->right) rect.right = prcPaint->right; + if (rect.left < prcPaint->left) rect.left = prcPaint->left; + + if (rect.left < rect.right && rect.top < rect.bottom) + { + SetTextColor(hdc, color->text); + INT cchText = lstrlen(item->text); + ExtTextOut(hdc, left, top, ETO_CLIPPED, &rect, item->text, cchText, NULL); + } + } + + return TRUE; +} + +static INT CALLBACK LoginTab_PaintItemCallback(LOGINTAB *tab, LOGINTABITEM *item, INT iItem, const RECT *prcItem, ULONG_PTR param) +{ + PAINTITEMPARAM *pip = (PAINTITEMPARAM*)param; + if (NULL == pip) return -2; + + RECT paintRect; + if (FALSE != IntersectRect(&paintRect, pip->prcPaint, prcItem)) + { + + SetRectRgn(pip->clipRgn, paintRect.left, paintRect.top, paintRect.right, paintRect.bottom); + CombineRgn(pip->eraseRgn, pip->eraseRgn, pip->clipRgn, RGN_DIFF); + + HBITMAP hbmp = LoginTab_GetItemBitmap(tab, pip->hdc, + prcItem->right - prcItem->left, + prcItem->bottom - prcItem->top); + + if (NULL != hbmp) + { + SelectObject(pip->hdcItem, hbmp); + SetViewportOrgEx(pip->hdcItem, -paintRect.left, -paintRect.top, NULL); + } + + LoginTab_EraseBkGround(pip->hdcItem, tab, pip->prcClient->bottom - pip->prcClient->top, &paintRect); + + if (iItem == tab->itemsCount) + LoginTab_PaintChevron(pip->hdcItem, tab, prcItem, &paintRect, pip->hdcSrc); + else + LoginTab_PaintItem(pip->hwndTab, pip->hdcItem, tab, item, iItem, prcItem, &paintRect, pip->hdcSrc); + + BitBlt(pip->hdc, paintRect.left, paintRect.top, paintRect.right - paintRect.left, paintRect.bottom - paintRect.top, + pip->hdcItem, paintRect.left, paintRect.top, SRCCOPY); + } + return -1; +} + +static UINT LoginTab_GetDrawStyles(HWND hwnd) +{ + UINT windowStyle = GetWindowStyle(hwnd); + UINT drawStyle = 0; + + if (0 != (WS_DISABLED & windowStyle)) + drawStyle |= NLTDS_DISABLED; + else if (hwnd == GetFocus()) + { + UINT uiState = (UINT)SendMessage(hwnd, WM_QUERYUISTATE, 0, 0L); + if (0 == (UISF_HIDEFOCUS & uiState)) + drawStyle |= NLTDS_FOCUSED; + } + + if (0 != (NLTS_LOCKED & windowStyle)) + drawStyle |= NLTDS_LOCKED; + + return drawStyle; +} + +static void LoginTab_Paint(HWND hwnd, HDC hdc, const RECT *prcPaint, BOOL fErase) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return; + + RECT clientRect; + GetClientRect(hwnd, &clientRect); + + tab->drawStyle = LoginTab_GetDrawStyles(hwnd); + + HBITMAP bitmapSrcOrig, bitmapItemOrig; + HFONT fontItemOrig; + + PAINTITEMPARAM param; + param.hwndTab = hwnd; + param.hdc = hdc; + param.prcPaint = prcPaint; + param.prcClient = &clientRect; + param.clipRgn = CreateRectRgn(0,0,0,0); + param.eraseRgn = CreateRectRgnIndirect(&clientRect); + param.hdcSrc = CreateCompatibleDC(hdc); + param.hdcItem = CreateCompatibleDC(hdc); + + + if (NULL != param.hdcSrc) + bitmapSrcOrig = (HBITMAP)GetCurrentObject(param.hdcSrc, OBJ_BITMAP); + + if (NULL != param.hdcItem) + { + bitmapItemOrig = (HBITMAP)GetCurrentObject(param.hdcItem, OBJ_BITMAP); + SetBkMode(param.hdcItem, TRANSPARENT); + fontItemOrig = (HFONT)SelectObject(param.hdcItem, tab->fontText); + } + + LoginTab_EnumerateItemRects(hwnd, param.hdcItem, LoginTab_PaintItemCallback, (ULONG_PTR)¶m); + + if (FALSE != fErase) + { + SelectClipRgn(hdc, param.eraseRgn); + LoginTab_EraseBkGround(hdc, tab, clientRect.bottom - clientRect.top, prcPaint); + //if (SUCCEEDED(UxTheme_LoadLibrary()) && FALSE != UxIsAppThemed()) + //{ + // // CONTROLPANEL, CPANEL_NAVIGATIONPANE, 0 + // // + // UXTHEME hTheme = UxOpenThemeData(hwnd, L"MENU"); + // if (NULL != hTheme) + // { + // clientRect.right++; + // UxDrawThemeBackground(hTheme, hdc, MENU_BARBACKGROUND, MB_ACTIVE, &clientRect, prcPaint); + // UxCloseThemeData(hTheme); + // } + //} + } + + if (NULL != param.hdcSrc) + { + SelectObject(param.hdcSrc, bitmapSrcOrig); + DeleteDC(param.hdcSrc); + } + + if (NULL != param.hdcItem) + { + SelectObject(param.hdcItem, bitmapItemOrig); + SelectObject(param.hdcItem, fontItemOrig); + DeleteDC(param.hdcItem); + } + + DeleteObject(param.clipRgn); + DeleteObject(param.eraseRgn); +} + +static INT CALLBACK LoginTab_GetItemRectCallback(LOGINTAB *tab, LOGINTABITEM *item, INT iItem, const RECT *prcItem, ULONG_PTR param) +{ + GETITEMRECTPARAM *gip = (GETITEMRECTPARAM*)param; + if (NULL == gip) return -2; + + if (iItem == gip->index) + { + CopyRect(gip->rect, prcItem); + return iItem; + } + + return -1; +} + +static BOOL LoginTab_GetItemRect(HWND hwnd, INT iItem, RECT *itemRect) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab || NULL == itemRect || iItem < 0 || iItem > tab->itemsCount) + return FALSE; + + GETITEMRECTPARAM param; + param.index = iItem; + param.rect = itemRect; + + INT result = LoginTab_EnumerateItemRects(hwnd, NULL, LoginTab_GetItemRectCallback, (ULONG_PTR)¶m); + + return (result == iItem); +} + +static INT CALLBACK LoginTab_HitTestCallback(LOGINTAB *tab, LOGINTABITEM *item, INT iItem, const RECT *prcItem, ULONG_PTR param) +{ + HITTESTITEMPARAM *htp = (HITTESTITEMPARAM*)param; + if (NULL == htp) return -2; + + if (FALSE != PtInRect(prcItem, htp->pt)) + { + if (NULL != htp->rect) + CopyRect(htp->rect, prcItem); + return iItem; + } + + return -1; +} + +static INT LoginTab_HitTest(HWND hwnd, INT x, INT y, RECT *itemRect) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return -1; + + HITTESTITEMPARAM param; + param.pt.x = x; + param.pt.y = y; + param.rect = itemRect; + + return LoginTab_EnumerateItemRects(hwnd, NULL, LoginTab_HitTestCallback, (ULONG_PTR)¶m); +} + +static INT CALLBACK LoginTab_UpdateLayoutCallback(LOGINTAB *tab, LOGINTABITEM *item, INT iItem, const RECT *prcItem, ULONG_PTR param) +{ + UPDATELAYOUTPARAM *ulp = (UPDATELAYOUTPARAM*)param; + if (NULL == ulp) return -2; + + if (iItem != tab->itemsCount) + { + if (0 == ulp->itemCount) + CopyRect(&ulp->visibleBox, prcItem); + else + ulp->visibleBox.right = prcItem->right; + + ulp->itemCount++; + } + else + { + ulp->chevronLeft = prcItem->left; + + if (ulp->visibleBox.right > ulp->chevronLeft) + ulp->visibleBox.right = ulp->chevronLeft; + + ulp->chevronVisible = TRUE; + } + + return -1; +} + +static void LoginTab_UpdateLayout(HWND hwnd, BOOL fRedraw) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return; + + RECT clientRect, rect; + GetClientRect(hwnd, &clientRect); + + UPDATELAYOUTPARAM param; + ZeroMemory(¶m, sizeof(param)); + param.chevronLeft = clientRect.right; + + INT *orderCopy = NULL; + if (tab->itemsCount > 0) + { + orderCopy = (INT*)calloc(tab->itemsCount, sizeof(INT)); + if (NULL == orderCopy) return; + CopyMemory(orderCopy, tab->order, tab->itemsCount * sizeof(INT)); + } + + +// for (INT i = 0; i < tab->itemsCount; i++) +// tab->order[i] = i; // reset order + + LoginTab_EnumerateItemRects(hwnd, NULL, LoginTab_UpdateLayoutCallback, (ULONG_PTR)¶m); + + INT selectPos = -1; + if (-1 != tab->iSelected) + { + for (INT i = 0; i < tab->itemsCount; i++) + { + if (tab->order[i] == tab->iSelected) + { + selectPos = i; + break; + } + } + } + + if (tab->lastVisible < selectPos && tab->lastVisible >= 0 && selectPos >= 0) + { + CALCITEMWIDTH calcWidth; + if (FALSE != LoginTab_InitCalcItemWidth(hwnd, NULL, &calcWidth)) + { + INT selectWidth = LoginTab_CalculateItemWidth(&calcWidth, tab->items[tab->iSelected]); + INT limit = param.chevronLeft - selectWidth; + INT right = param.visibleBox.right + tab->spacing; + INT pos = tab->lastVisible + 1; + + while(right > limit && pos-- > 0) + { + right -= LoginTab_CalculateItemWidth(&calcWidth, tab->items[tab->order[pos]]); + if (pos > 0) + right -= tab->spacing; + } + + if (pos < selectPos) + MoveMemory(tab->order + (pos + 1), tab->order + pos, (selectPos - pos) * sizeof(INT)); + + tab->order[pos] = tab->iSelected; + tab->lastVisible = pos; + + right += selectWidth; + //if (param.visibleBox.right > right) + param.visibleBox.right = right; + + LoginTab_DestroyCalcItemWidth(&calcWidth); + } + + } + + INT invalidLeft = clientRect.right; + if(NULL != orderCopy) + { + for (INT i = 0; i < tab->itemsCount; i++) + { + if (tab->order[i] != orderCopy[i]) + { + if (FALSE != LoginTab_GetItemRect(hwnd, tab->order[i], &rect)) + invalidLeft = rect.left; + break; + } + } + free(orderCopy); + } + + if (tab->chevronLeft != param.chevronLeft) + { + SetRect(&rect, param.chevronLeft, clientRect.top, clientRect.right, clientRect.bottom); + if (rect.left > tab->chevronLeft) + rect.left = tab->chevronLeft; + + InvalidateRect(hwnd, &rect, FALSE); + tab->chevronLeft = param.chevronLeft; + } + + if (tab->visibleRight != param.visibleBox.right || invalidLeft != clientRect.right) + { + CopyRect(&rect, ¶m.visibleBox); + rect.left = min(param.visibleBox.right, tab->visibleRight); + if (invalidLeft < rect.left) rect.left = invalidLeft; + rect.right = max(param.visibleBox.right, tab->visibleRight); + + InvalidateRect(hwnd, &rect, FALSE); + tab->visibleRight = param.visibleBox.right; + } + +} +static void LoginTab_SetItemFocus(HWND hwnd, INT iFocus) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return; + + INT focusPos = -1; + if (iFocus >= tab->itemsCount) + focusPos = iFocus; + else if (-1 != iFocus) + { + for (INT i = 0; i < tab->itemsCount; i++) + { + if (tab->order[i] == iFocus) + { + focusPos = i; + break; + } + } + } + + if (focusPos > tab->lastVisible) + { + if (tab->lastVisible != (tab->itemsCount -1)) + { + iFocus = tab->itemsCount; + } + else + { + iFocus = tab->order[tab->lastVisible]; + } + } + + if (iFocus < 0) + iFocus = (tab->itemsCount > 0) ? 0 : -1; + + if (iFocus != tab->iFocused) + { + INT iFocused = tab->iFocused; + INT iSelected = tab->iSelected; + + tab->iFocused = iFocus; + if (iFocus < tab->itemsCount) + tab->iSelected = iFocus; + + RECT rect; + if (-1 != tab->iFocused && FALSE != LoginTab_GetItemRect(hwnd, tab->iFocused, &rect)) + InvalidateRect(hwnd, &rect, FALSE); + + if (-1 != iFocused && iFocused != tab->iFocused && + FALSE != LoginTab_GetItemRect(hwnd, iFocused, &rect)) + { + InvalidateRect(hwnd, &rect, FALSE); + } + + if (-1 != iSelected && iSelected != tab->iSelected && iSelected != iFocused && + FALSE != LoginTab_GetItemRect(hwnd, iSelected, &rect)) + { + InvalidateRect(hwnd, &rect, FALSE); + } + + if (iSelected != tab->iSelected) + { + LoginTab_NotifySelectionChanged(hwnd); + } + } +} +static BOOL LoginTab_ShowHiddenTabs(HWND hwnd, const RECT *ownerRect) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return FALSE; + + HMENU hMenu = CreatePopupMenu(); + if (NULL == hMenu) return FALSE; + + MENUINFO mi; + mi.cbSize = sizeof(mi); + mi.fMask = MIM_STYLE | MIIM_FTYPE; + mi.dwStyle = /*MNS_MODELESS | */ MNS_NOCHECK; + SetMenuInfo(hMenu, &mi); + + UINT insertedCount = 0; + MENUITEMINFO mii; + mii.cbSize = sizeof(mii); + mii.fMask = MIIM_STRING | MIIM_ID | MIIM_STATE | MIIM_FTYPE | MIIM_DATA; + mii.fState = MFS_UNHILITE | MFS_ENABLED; + + CHEVRONMENUPAINTPARAM menuPaint; + ZeroMemory(&menuPaint, sizeof(menuPaint)); + + CALCITEMWIDTH calcItem; + LoginTab_InitCalcItemWidth(hwnd, NULL, &calcItem); + + menuPaint.itemHeight = calcItem.itemHeight; + if (NULL != ownerRect) + CopyRect(&menuPaint.ownerRect, ownerRect); + + INT width = tab->itemsCount - tab->lastVisible - 1; + if (width < 2) width = 1; + else if (width < 9) width = 2; + else width = (INT)sqrt((float)(width)); + + for(INT offset = 0; offset < width; offset++) + { + mii.fType = MFT_OWNERDRAW | MFT_MENUBREAK; + for(INT i = tab->lastVisible + 1 + offset; i < tab->itemsCount; i += width) + { + LOGINTABITEM *item = tab->items[tab->order[i]]; + + INT itemWidth = LoginTab_CalculateItemWidth(&calcItem, item); + if (menuPaint.itemWidth < itemWidth) menuPaint.itemWidth = itemWidth; + + mii.wID = tab->order[i] + 1; + mii.dwTypeData = item->text; + mii.dwItemData = (ULONG_PTR)item; + + if (FALSE != InsertMenuItem(hMenu, insertedCount, TRUE, &mii)) + insertedCount++; + + mii.fType = MFT_OWNERDRAW; + } + } + + LoginTab_DestroyCalcItemWidth(&calcItem); + + if (NULL != hMenu && insertedCount > 0) + { + RECT windowRect; + GetWindowRect(hwnd, &windowRect); + + POINT menuOrig; + menuOrig.x = windowRect.right; + menuOrig.y = windowRect.bottom - 1; + + UINT menuStyle = TPM_RIGHTALIGN | TPM_TOPALIGN | TPM_VERPOSANIMATION | TPM_NONOTIFY | TPM_RETURNCMD; + + + TRACKMOUSEEVENT tm; + tm.cbSize = sizeof(tm); + tm.dwFlags = TME_CANCEL | TME_LEAVE; + tm.hwndTrack = hwnd; + TrackMouseEvent(&tm); + + tab->chevronMenu = hMenu; + + HBITMAP bitmapSrcOrig, bitmapItemOrig; + HFONT fontItemOrig; + + HBRUSH hbrBack = NULL; + + HDC hdc = GetDCEx(hwnd, NULL, DCX_CACHE | DCX_NORESETATTRS); + if (NULL != hdc) + { + menuPaint.hdcSrc = CreateCompatibleDC(hdc); + menuPaint.hdcItem = CreateCompatibleDC(hdc); + + + if (NULL != menuPaint.hdcSrc) + { + bitmapSrcOrig = (HBITMAP)GetCurrentObject(menuPaint.hdcSrc, OBJ_BITMAP); + + INT menuHeight = (insertedCount /width + insertedCount%width) * menuPaint.itemHeight + 2 * 4; + HBITMAP hbmpPattern = CreateCompatibleBitmap(hdc, 1, menuHeight); + if (NULL != hbmpPattern) + { + HBITMAP bmpOrig = (HBITMAP)SelectObject(menuPaint.hdcSrc, hbmpPattern); + RECT rect; + SetRect(&rect, 0, 0, 1, menuHeight); + LoginTab_EraseBkGround(menuPaint.hdcSrc, tab, menuHeight, &rect); + SelectObject(menuPaint.hdcSrc, bmpOrig); + hbrBack = CreatePatternBrush(hbmpPattern); + DeleteObject(hbmpPattern); + } + } + + if (NULL != menuPaint.hdcItem) + { + bitmapItemOrig = (HBITMAP)GetCurrentObject(menuPaint.hdcItem, OBJ_BITMAP); + SetBkMode(menuPaint.hdcItem, TRANSPARENT); + fontItemOrig = (HFONT)SelectObject(menuPaint.hdcItem, tab->fontText); + } + + + + ReleaseDC(hwnd, hdc); + } + + + MENUINFO mi; + mi.cbSize = sizeof(mi); + mi.fMask = MIM_MENUDATA | MIM_BACKGROUND; + mi.dwMenuData = (ULONG_PTR)&menuPaint; + mi.hbrBack = hbrBack; + SetMenuInfo(hMenu, &mi); + + TPMPARAMS tpm; + tpm.cbSize =sizeof(tpm); + GetWindowRect(hwnd, &tpm.rcExclude); + tpm.rcExclude.bottom -= 2; + tpm.rcExclude.left = -20000; + tpm.rcExclude.right = 20000; + INT commandId = TrackPopupMenuEx(hMenu, menuStyle, menuOrig.x, menuOrig.y, hwnd, &tpm); + commandId--; + + if ( hbrBack != NULL ) + DeleteObject( hbrBack ); + + if (NULL != menuPaint.hdcSrc) + { + SelectObject(menuPaint.hdcSrc, bitmapSrcOrig); + DeleteDC(menuPaint.hdcSrc); + } + + if (NULL != menuPaint.hdcItem) + { + SelectObject(menuPaint.hdcItem, bitmapItemOrig); + SelectObject(menuPaint.hdcItem, fontItemOrig); + DeleteDC(menuPaint.hdcItem); + } + + tab->chevronMenu = NULL; + + if (commandId >= 0 && commandId < tab->itemsCount && tab->iSelected != commandId) + { + LoginTab_SetCurSel(hwnd, commandId); + LoginTab_NotifySelectionChanged(hwnd); + } + } + + if (NULL != hMenu) + DestroyMenu(hMenu); + + return TRUE; +} + +static void LoginTab_TrackMouseLeave(HWND hwnd) +{ + TRACKMOUSEEVENT tm; + tm.cbSize = sizeof(TRACKMOUSEEVENT); + tm.dwFlags = TME_QUERY; + tm.hwndTrack = hwnd; + if (TrackMouseEvent(&tm) && 0 == (TME_LEAVE & tm.dwFlags)) + { + tm.cbSize = sizeof(TRACKMOUSEEVENT); + tm.dwFlags = TME_LEAVE; + tm.hwndTrack = hwnd; + TrackMouseEvent(&tm); + } +} + + +static void LoginTab_UpdateColors(HWND hwnd) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return; + + tab->colors.backTop = GetSysColor(COLOR_WINDOW); + + WORD h, l, s, lBottom, lLine; + INT k; + ColorRGBToHLS(tab->colors.backTop, &h, &l, &s); + k = MulDiv(240, 50, 1000); + lBottom = l + ((l > 0) ? -k : k); + if (lBottom > 240) lBottom = 240; + + k = MulDiv(240, 75, 1000); + lLine = l + ((l > 0) ? -k : k); + if (lLine > 240) lLine = 240; + + tab->colors.backBottom = ColorHLSToRGB(h, lBottom, s); + tab->colors.backLine = ColorHLSToRGB(h, lLine, s); + + tab->colors.focus = RGB(255, 255, 255); + tab->colors.focusDash = RGB(0, 0, 0); + + COLORREF rgbTextActive = GetSysColor(COLOR_WINDOWTEXT); + COLORREF rgbText = Color_Blend(rgbTextActive, tab->colors.backBottom, 210); + + + tab->colors.item.normal.backAlpha = 0; + tab->colors.item.normal.backTop = 0; + tab->colors.item.normal.backBottom = 0; + tab->colors.item.normal.frameType = FRAMETYPE_NONE; + tab->colors.item.normal.text = rgbText; + + tab->colors.item.normalHigh.backAlpha = tab->colors.item.normal.backAlpha; + tab->colors.item.normalHigh.backTop = tab->colors.item.normal.backTop; + tab->colors.item.normalHigh.backBottom = tab->colors.item.normal.backBottom; + tab->colors.item.normalHigh.frameType = tab->colors.item.normal.frameType; + tab->colors.item.normalHigh.text = rgbTextActive; + + tab->colors.item.normalPressed.backAlpha = tab->colors.item.normal.backAlpha; + tab->colors.item.normalPressed.backTop = tab->colors.item.normal.backTop; + tab->colors.item.normalPressed.backBottom = tab->colors.item.normal.backBottom; + tab->colors.item.normalPressed.frameType = tab->colors.item.normal.frameType; + tab->colors.item.normalPressed.text = rgbTextActive; + + tab->colors.item.normalDisabled.backAlpha = tab->colors.item.normal.backAlpha; + tab->colors.item.normalDisabled.backTop = tab->colors.item.normal.backTop; + tab->colors.item.normalDisabled.backBottom = tab->colors.item.normal.backBottom; + tab->colors.item.normalDisabled.frameType = tab->colors.item.normal.frameType; + tab->colors.item.normalDisabled.text = Color_Blend(GetSysColor(COLOR_GRAYTEXT), tab->colors.backBottom, 160); + + tab->colors.item.selected.backAlpha = 100; + tab->colors.item.selected.backTop = Color_Blend(GetSysColor(COLOR_HIGHLIGHT), GetSysColor(COLOR_WINDOW), 100); + tab->colors.item.selected.backBottom = Color_Blend(GetSysColor(COLOR_HIGHLIGHT), GetSysColor(COLOR_WINDOW), 140); + + tab->colors.item.selected.frameType = FRAMETYPE_SELECTED; + tab->colors.item.selected.text = rgbTextActive; + + tab->colors.item.selectedHigh.backAlpha = tab->colors.item.selected.backAlpha; + tab->colors.item.selectedHigh.backTop = tab->colors.item.selected.backTop; + tab->colors.item.selectedHigh.backBottom = tab->colors.item.selected.backBottom; + tab->colors.item.selectedHigh.frameType = tab->colors.item.selected.frameType; + tab->colors.item.selectedHigh.text = tab->colors.item.selected.text; + + tab->colors.item.selectedPressed.backAlpha = tab->colors.item.selected.backAlpha; + tab->colors.item.selectedPressed.backTop = tab->colors.item.selected.backTop; + tab->colors.item.selectedPressed.backBottom = tab->colors.item.selected.backBottom; + tab->colors.item.selectedPressed.frameType = tab->colors.item.selected.frameType; + tab->colors.item.selectedPressed.text = tab->colors.item.selected.text; + + tab->colors.item.selectedDisabled.backAlpha = tab->colors.item.selected.backAlpha; + tab->colors.item.selectedDisabled.backTop = Color_Blend(GetSysColor(COLOR_3DLIGHT), GetSysColor(COLOR_WINDOW), 100); + tab->colors.item.selectedDisabled.backBottom = Color_Blend(GetSysColor(COLOR_3DLIGHT), GetSysColor(COLOR_WINDOW), 140); + tab->colors.item.selectedDisabled.frameType = FRAMETYPE_DISABLED; + tab->colors.item.selectedDisabled.text = tab->colors.item.normalDisabled.text; + + if (NULL != tab->frameBitmap) + DeleteObject(tab->frameBitmap); + + BITMAPINFOHEADER frameHeader; + BYTE *framePixels; + tab->frameBitmap = ImageLoader_LoadBitmapEx(WASABI_API_ORIG_HINST, + MAKEINTRESOURCE(IDR_SELECTIONFRAME_IMAGE), FALSE, &frameHeader, (void**)&framePixels); + if (NULL == tab->frameBitmap) + { + tab->frameWidth = 0; + tab->frameHeight = 0; + } + else + { + if (frameHeader.biHeight < 0) + frameHeader.biHeight = -frameHeader.biHeight; + + tab->frameWidth = (frameHeader.biWidth - 1)/2; + tab->frameHeight = (frameHeader.biHeight/2 - 1)/2; + + COLORREF rgbTop = Color_Blend(GetSysColor(COLOR_HIGHLIGHT), GetSysColor(COLOR_WINDOW), 200); + COLORREF rgbBottom = GetSysColor(COLOR_WINDOW); + + Image_ColorizeEx(framePixels, frameHeader.biWidth, frameHeader.biHeight, 0, 0, + frameHeader.biWidth, frameHeader.biHeight, frameHeader.biBitCount, TRUE, rgbBottom, rgbTop); + } + + if (NULL != tab->chevronImage) + { + DeleteObject(tab->chevronImage); + tab->chevronImage = NULL; + } + + tab->chevronImage = LoginTab_LoadChevronImage(hwnd, &tab->chevronWidth, NULL); + if (NULL == tab->chevronImage) + { + tab->chevronWidth = 0; + } + else + { + INT k = tab->frameWidth - 2; + if (k < 0) k = 0; + tab->chevronWidth += 2 * k; + } + +} + +static void LoginTab_UpdateFonts(HWND hwnd) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return; + + + tab->fontText = NULL; + LoginGuiObject *loginGui; + if (SUCCEEDED(LoginGuiObject::QueryInstance(&loginGui))) + { + tab->fontText = loginGui->GetTextFont(); + loginGui->Release(); + } + + HDC hdc = GetDCEx(hwnd, NULL, DCX_CACHE | DCX_NORESETATTRS); + if (NULL != hdc) + { + HFONT fontOrig = (HFONT)SelectObject(hdc, tab->fontText); + + TEXTMETRIC tm; + if (FALSE != GetTextMetrics(hdc, &tm)) + { + tab->textHeight = tm.tmHeight; + + LONG baseunitY = tm.tmHeight; + LONG baseunitX = LoginBox_GetAveCharWidth(hdc); + + tab->textWidthMax = baseunitX * MAX_TEXT_AVECHAR_WIDTH + tm.tmOverhang; + tab->margins.left = MulDiv(1, baseunitX, 4); + tab->margins.right = MulDiv(1, baseunitX, 4); + tab->margins.top = MulDiv(1, baseunitY, 8); + tab->margins.bottom = MulDiv(1, baseunitY, 8); + tab->spacing = MulDiv(1, baseunitX, 4); + + for (INT i = 0; i < tab->itemsCount; i++) + tab->items[i]->textWidth = -1; + } + + + SelectObject(hdc, fontOrig); + ReleaseDC(hwnd, hdc); + } +} +static void LoginTab_UpdateMouseInfo(HWND hwnd) +{ + POINT pt; + RECT rect; + GetCursorPos(&pt); + MapWindowPoints(HWND_DESKTOP, hwnd, &pt, 1); + + GetClientRect(hwnd, &rect); + if (FALSE == PtInRect(&rect, pt)) + { + SendMessage(hwnd, WM_MOUSELEAVE, 0, 0L); + } + else + { + UINT vKey = 0; + if (0 != (0x8000 & GetAsyncKeyState(VK_CONTROL))) + vKey |= MK_CONTROL; + if (0 != (0x8000 & GetAsyncKeyState(VK_LBUTTON))) + vKey |= MK_LBUTTON; + if (0 != (0x8000 & GetAsyncKeyState(VK_RBUTTON))) + vKey |= MK_RBUTTON; + if (0 != (0x8000 & GetAsyncKeyState(VK_SHIFT))) + vKey |= MK_SHIFT; + if (0 != (0x8000 & GetAsyncKeyState(VK_XBUTTON1))) + vKey |= MK_XBUTTON1; + if (0 != (0x8000 & GetAsyncKeyState(VK_XBUTTON2))) + vKey |= MK_XBUTTON2; + + SendMessage(hwnd, WM_MOUSEMOVE, vKey, MAKELPARAM(pt.x, pt.y)); + } +} +static HWND LoginTab_CreateTooltip(HWND hwnd) +{ + HWND hTooltip = CreateWindowExW(WS_EX_TOOLWINDOW | WS_EX_NOPARENTNOTIFY | WS_EX_TRANSPARENT | WS_EX_LAYERED, + TOOLTIPS_CLASS, NULL, WS_CLIPSIBLINGS | WS_POPUP | TTS_NOPREFIX /*| TTS_ALWAYSTIP*/, + 0, 0, 0, 0, hwnd, NULL, NULL, NULL); + + if (NULL == hTooltip) + return NULL; + + SendMessage(hTooltip, CCM_SETVERSION, 6, 0L); + SetWindowPos(hTooltip, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER); + SendMessage(hTooltip, TTM_SETDELAYTIME, TTDT_INITIAL, MAKELPARAM(1000, 0)); + + TOOLINFO ti; + ZeroMemory(&ti, sizeof(ti)); + ti.cbSize = sizeof(TOOLINFO); + ti.hwnd = hwnd; + ti.lpszText = LPSTR_TEXTCALLBACK; + SendMessage(hTooltip, TTM_ADDTOOL, 0, (LPARAM)&ti); + + + INT helpWidthMax = 260; + + NONCLIENTMETRICS ncm; + ncm.cbSize = sizeof(ncm); + + OSVERSIONINFO vi; + vi.dwOSVersionInfoSize = sizeof(vi); + if (FALSE == GetVersionEx(&vi)) + ZeroMemory(&vi, sizeof(vi)); + + if (vi.dwMajorVersion < 6) + ncm.cbSize -= sizeof(ncm.iPaddedBorderWidth); + + RECT marginRect; + SetRect(&marginRect, 3, 1, 3, 1); + if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, ncm.cbSize, &ncm, 0)) + { + HFONT font = CreateFontIndirect(&ncm.lfStatusFont); + if (NULL != font) + { + HDC hdc = GetDCEx(hTooltip, NULL, DCX_CACHE); + if (NULL != hdc) + { + HFONT fontOrig = (HFONT)SelectObject(hdc, font); + TEXTMETRIC tm; + if (FALSE != GetTextMetrics(hdc, &tm)) + { + INT baseunitX = LoginBox_GetAveCharWidth(hdc); + if (NULL != baseunitX) + { + helpWidthMax = baseunitX * MAX_HELP_AVECHAR_WIDTH + tm.tmOverhang; + marginRect.left = MulDiv(2, baseunitX, 4); + marginRect.right = marginRect.left; + marginRect.top = MulDiv(1, tm.tmHeight, 8); + marginRect.bottom = MulDiv(1, tm.tmHeight, 8); + } + } + SelectObject(hdc, fontOrig); + ReleaseDC(hTooltip, hdc); + } + DeleteObject(font); + } + } + + SendMessage(hTooltip, TTM_SETMAXTIPWIDTH, 0, helpWidthMax); + SendMessage(hTooltip, TTM_SETMARGIN, 0, (LPARAM)&marginRect); + + return hTooltip; +} + +static void LoginTab_RelayTooltipMouseMsg(HWND hwnd, UINT uMsg, UINT vKey, POINTS pts) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab || NULL == tab->hTooltip || -1 == tab->iHighlighted) + return; + + MSG msg; + msg.hwnd = hwnd; + msg.message = uMsg; + msg.wParam = (WPARAM)vKey; + msg.lParam = MAKELPARAM(pts.x, pts.y); + + SendMessage(tab->hTooltip, TTM_RELAYEVENT, 0, (LPARAM)&msg); +} + +static void LoginTab_UpdateTooltip(HWND hwnd) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return; + + TOOLINFO ti; + ZeroMemory(&ti, sizeof(ti)); + ti.cbSize = sizeof(ti); + ti.hwnd = hwnd; + ti.uId = 0; + + if (FALSE == SendMessage(tab->hTooltip, TTM_GETTOOLINFO, 0, (LPARAM)&ti)) + return; + + INT iItem = tab->iHighlighted; + RECT rect; + if (-1 == iItem || FALSE == LoginTab_GetItemRect(hwnd, iItem, &rect)) + { + SendMessage(tab->hTooltip, TTM_ACTIVATE, FALSE, 0L); + SysFreeString(tab->helpText); + tab->helpText = NULL; + + return; + } + + if (ti.lParam != (LPARAM)iItem || FALSE == EqualRect(&ti.rect, &rect)) + { + SendMessage(tab->hTooltip, TTM_ACTIVATE, FALSE, 0L); + + CopyRect(&ti.rect, &rect); + if (ti.lParam != iItem) + { + LPCWSTR pszTitle = NULL; + if (iItem >= 0 && iItem < tab->itemsCount) + pszTitle = tab->items[iItem]->text; + SendMessage(tab->hTooltip, TTM_SETTITLE, (WPARAM)TTI_NONE, (LPARAM)pszTitle); + + ti.lParam = (LPARAM)iItem; + ti.lpszText = LPSTR_TEXTCALLBACK; + + SysFreeString(tab->helpText); + tab->helpText = NULL; + } + SendMessage(tab->hTooltip, TTM_SETTOOLINFO, 0, (LPARAM)&ti); + + } + + SendMessage(tab->hTooltip, TTM_ACTIVATE, TRUE, 0L); +} + +static void LoginTab_FreeItem(LOGINTABITEM *item) +{ + if (NULL == item) return; + + LoginBox_FreeString(item->text); + free(item); +} + +static BOOL LoginTab_SetItemInternal(LOGINTABITEM *dst, const NLTITEM *src) +{ + if (NULL == dst || NULL == src) + return FALSE; + + BOOL succeeded = TRUE; + + if (0 != (NLTIF_TEXT & src->mask)) + { + dst->textWidth = -1; + LoginBox_FreeString(dst->text); + if (NULL != src->pszText) + { + dst->text = LoginBox_CopyString(src->pszText); + if (NULL == dst->text) succeeded = FALSE; + } + else + { + dst->text = NULL; + } + } + + if (0 != (NLTIF_PARAM & src->mask)) + dst->param = src->param; + + if (0 != (NLTIF_IMAGE & src->mask)) + dst->iImage = src->iImage; + + if (0 != (NLTIF_IMAGE_ACTIVE & src->mask)) + dst->iImageActive = src->iImageActive; + + if (0 != (NLTIF_IMAGE_DISABLED & src->mask)) + dst->iImageDisabled = src->iImageDisabled; + + return succeeded; +} + +static LOGINTABITEM *LoginTab_CreateItem(const NLTITEM *pItem) +{ + LOGINTABITEM *item = (LOGINTABITEM*)calloc(1, sizeof(LOGINTABITEM)); + if (NULL == item) return NULL; + + item->textWidth = -1; + item->iImage = NLTM_IMAGE_NONE; + item->iImageActive = NLTM_IMAGE_NONE; + item->iImageDisabled = NLTM_IMAGE_NONE; + + if (NULL != pItem && FALSE == LoginTab_SetItemInternal(item, pItem)) + { + LoginTab_FreeItem(item); + item = NULL; + } + return item; +} + +static INT LoginTab_DeleteAllItemsReal(HWND hwnd, LOGINTABITEM **itemsList, INT itemsCount) +{ + if (NULL == itemsList || itemsCount < 1) + return 0; + + NMLOGINTAB nmp; + nmp.hdr.hwndFrom = hwnd; + nmp.hdr.idFrom = GetWindowLongPtr(hwnd, GWLP_ID); + HWND hParent = GetAncestor(hwnd, GA_PARENT); + + BOOL fNotifyItem = FALSE; + + if (NULL != hParent) + { + nmp.hdr.code = NLTN_DELETEALLITEMS; + nmp.iItem = -1; + fNotifyItem = (FALSE == (BOOL)SNDMSG(hParent, WM_NOTIFY, (WPARAM)nmp.hdr.idFrom, (LPARAM)&nmp)); + if (FALSE != fNotifyItem) + nmp.hdr.code = NLTN_DELETEITEM; + } + + INT deleted = 0; + for(; itemsCount > 0; itemsCount--) + { + nmp.iItem = itemsCount - 1; + if (FALSE != fNotifyItem) + SNDMSG(hParent, WM_NOTIFY, (WPARAM)nmp.hdr.idFrom, (LPARAM)&nmp); + + LoginTab_FreeItem(itemsList[nmp.iItem]); + deleted++; + } + + return deleted; +} + +static LRESULT LoginTab_OnCreate(HWND hwnd, CREATESTRUCT* pcs) +{ + LOGINTAB *tab = (LOGINTAB*)calloc(1, sizeof(LOGINTAB)); + if (NULL != tab) + { + SetLastError(ERROR_SUCCESS); + if (!SetWindowLongPtr(hwnd, 0, (LONGX86)(LONG_PTR)tab) && ERROR_SUCCESS != GetLastError()) + { + free(tab); + tab = NULL; + } + } + + if (NULL == tab) + return -1; + + tab->iPressed = -1; + tab->iSelected = -1; + tab->iHighlighted = -1; + + tab->hTooltip = LoginTab_CreateTooltip(hwnd); + + LoginTab_UpdateColors(hwnd); + LoginTab_UpdateFonts(hwnd); + + return 0; +} + +static void LoginTab_OnDestroy(HWND hwnd) +{ + LOGINTAB *tab = GetTab(hwnd); + SetWindowLongPtr(hwnd, 0, 0L); + if (NULL == tab) return; + + if (NULL != tab->items) + { + tab->itemsCount -= LoginTab_DeleteAllItemsReal(hwnd, tab->items, tab->itemsCount); + free(tab->items); + } + + if (NULL != tab->order) + free(tab->order); + + if (NULL != tab->frameBitmap) + DeleteObject(tab->frameBitmap); + + if (NULL != tab->itemBitmap) + DeleteObject(tab->itemBitmap); + + if (NULL != tab->chevronImage) + DeleteObject(tab->chevronImage); + + if (NULL != tab->hTooltip) + DestroyWindow(tab->hTooltip); + + SysFreeString(tab->helpText); + + free(tab); +} + +static void LoginTab_OnWindowPosChanged(HWND hwnd, WINDOWPOS *pwp) +{ + if (SWP_NOSIZE == ((SWP_NOSIZE | SWP_FRAMECHANGED) & pwp->flags)) + return; + + LoginTab_UpdateLayout(hwnd, 0 == (SWP_NOREDRAW & pwp->flags)); +} + + +static void LoginTab_OnPaint(HWND hwnd) +{ + PAINTSTRUCT ps; + if (BeginPaint(hwnd, &ps)) + { + if (ps.rcPaint.left != ps.rcPaint.right) + LoginTab_Paint(hwnd, ps.hdc, &ps.rcPaint, ps.fErase); + EndPaint(hwnd, &ps); + } +} + +static void LoginTab_OnPrintClient(HWND hwnd, HDC hdc, UINT options) +{ + RECT clientRect; + if (GetClientRect(hwnd, &clientRect)) + LoginTab_Paint(hwnd, hdc, &clientRect, 0 != (PRF_ERASEBKGND & options)); +} + + +static void LoginTab_OnMouseMove(HWND hwnd, UINT vKey, POINTS pts) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return; + + if (FALSE != LoginTab_IsLocked(hwnd)) + return; + + RECT rect; + + INT iHighlighted = tab->iHighlighted; + + tab->iHighlighted = (-1 == tab->iPressed) ? + LoginTab_HitTest(hwnd, pts.x, pts.y, &rect) : -1; + + + + if (iHighlighted != tab->iHighlighted) + LoginTab_UpdateTooltip(hwnd); + + LoginTab_RelayTooltipMouseMsg(hwnd, WM_MOUSEMOVE, vKey, pts); + + + if (iHighlighted != tab->iHighlighted) + { + InvalidateRect(hwnd, &rect, FALSE); + + if (-1 != iHighlighted && FALSE != LoginTab_GetItemRect(hwnd, iHighlighted, &rect)) + InvalidateRect(hwnd, &rect, FALSE); + } + + if (-1 != tab->iHighlighted) + LoginTab_TrackMouseLeave(hwnd); + + +} + +static void LoginTab_OnMouseLeave(HWND hwnd) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return; + + INT iPressed = tab->iPressed; + INT iHighlighted = tab->iHighlighted; + + tab->iPressed = -1; + tab->iHighlighted = -1; + + RECT rect; + if (-1 != iHighlighted && FALSE != LoginTab_GetItemRect(hwnd, iHighlighted, &rect)) + InvalidateRect(hwnd, &rect, FALSE); + + if (-1 != iPressed && iPressed != iHighlighted && FALSE != LoginTab_GetItemRect(hwnd, iPressed, &rect)) + InvalidateRect(hwnd, &rect, FALSE); + +} + +static void LoginTab_OnLButtonDown(HWND hwnd, UINT vKey, POINTS pts) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return; + + if (FALSE != LoginTab_IsLocked(hwnd)) + return; + + LoginTab_RelayTooltipMouseMsg(hwnd, WM_LBUTTONDOWN, vKey, pts); + + RECT rect, rect2; + INT iPressed, iHighlighted; + INT iItem = LoginTab_HitTest(hwnd, pts.x, pts.y, &rect); + + iPressed = tab->iPressed; + iHighlighted = tab->iHighlighted; + + tab->iPressed = iItem; + tab->iHighlighted = -1; + + if (iPressed != iItem && -1 != iPressed && + FALSE != LoginTab_GetItemRect(hwnd, iPressed, &rect2)) + { + InvalidateRect(hwnd, &rect2, FALSE); + } + + if (iHighlighted != iItem && -1 != iHighlighted && iHighlighted != iPressed && + FALSE != LoginTab_GetItemRect(hwnd, iHighlighted, &rect2)) + { + InvalidateRect(hwnd, &rect2, FALSE); + } + + if (-1 != iItem && iPressed != iItem) + { + if (iItem == tab->itemsCount && tab->iFocused != iItem) + { + INT iFocused = tab->iFocused; + tab->iFocused = iItem; + + if (-1 != iFocused && FALSE != LoginTab_GetItemRect(hwnd, iFocused, &rect2)) + InvalidateRect(hwnd, &rect2, FALSE); + } + InvalidateRect(hwnd, &rect, FALSE); + + if (iItem == tab->itemsCount) + { + + LoginTab_ShowHiddenTabs(hwnd, &rect); + + if (0 == (0x8000 & GetAsyncKeyState((FALSE == GetSystemMetrics(SM_SWAPBUTTON)) ? VK_LBUTTON : VK_RBUTTON))) + tab->iPressed = -1; + tab->iFocused = tab->itemsCount; + InvalidateRect(hwnd, &rect, FALSE); + LoginTab_UpdateMouseInfo(hwnd); + + } + else if (hwnd != GetCapture()) + SetCapture(hwnd); + } +} + +static void LoginTab_OnLButtonUp(HWND hwnd, UINT vKey, POINTS pts) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return; + + if (FALSE != LoginTab_IsLocked(hwnd)) + return; + + LoginTab_RelayTooltipMouseMsg(hwnd, WM_LBUTTONUP, vKey, pts); + + RECT rect, rect2; + + INT iPressed = tab->iPressed; + INT iHighlighted = tab->iHighlighted; + INT iSelected = tab->iSelected; + INT iFocused = tab->iFocused; + + INT iItem = LoginTab_HitTest(hwnd, pts.x, pts.y, &rect); + + + tab->iPressed = -1; + tab->iHighlighted = iItem; + + if (iItem == iPressed && -1 != iItem) + { + if (iItem < tab->itemsCount) + tab->iSelected = iItem; + tab->iFocused = iItem; + } + + if (-1 != iHighlighted && iHighlighted != tab->iHighlighted && + iHighlighted != iPressed && iHighlighted != iFocused && iHighlighted != iSelected && + FALSE != LoginTab_GetItemRect(hwnd, iHighlighted, &rect2)) + { + InvalidateRect(hwnd, &rect2, FALSE); + } + + + if (-1 != iPressed && iPressed != tab->iPressed && + (iPressed != iFocused || tab->iFocused == iFocused) && + (iPressed != iSelected || tab->iSelected == iSelected) && + FALSE != LoginTab_GetItemRect(hwnd, iPressed, &rect2)) + { + InvalidateRect(hwnd, &rect2, FALSE); + } + + + if (-1 != iSelected && iSelected != tab->iSelected && + iSelected != iFocused && + FALSE != LoginTab_GetItemRect(hwnd, iSelected, &rect2)) + { + InvalidateRect(hwnd, &rect2, FALSE); + } + + if (-1 != iFocused && iFocused != tab->iFocused && + FALSE != LoginTab_GetItemRect(hwnd, iFocused, &rect2)) + { + InvalidateRect(hwnd, &rect2, FALSE); + } + + + + if (-1 != iItem) + InvalidateRect(hwnd, &rect, FALSE); + + if (hwnd == GetCapture()) + ReleaseCapture(); + + if (-1 != tab->iSelected && tab->iSelected != iSelected) + LoginTab_NotifySelectionChanged(hwnd); +} + +static void LoginTab_OnRButtonDown(HWND hwnd, UINT vKey, POINTS pts) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return; + + if (FALSE != LoginTab_IsLocked(hwnd)) + return; + + LoginTab_RelayTooltipMouseMsg(hwnd, WM_RBUTTONDOWN, vKey, pts); + + HWND hParent = GetAncestor(hwnd, GA_PARENT); + if (NULL != hParent) + { + NMLOGINTABCLICK ntc; + ntc.hdr.code = NM_RCLICK; + ntc.hdr.hwndFrom = hwnd; + ntc.hdr.idFrom = GetWindowLongPtr(hwnd, GWLP_ID); + ntc.pt.x = pts.x; + ntc.pt.y = pts.y; + SNDMSG(hParent, WM_NOTIFY, (WPARAM)ntc.hdr.idFrom, (LPARAM)&ntc); + } +} + +static void LoginTab_OnRButtonUp(HWND hwnd, UINT vKey, POINTS pts) +{ + if (FALSE != LoginTab_IsLocked(hwnd)) + return; + + LoginTab_RelayTooltipMouseMsg(hwnd, WM_RBUTTONUP, vKey, pts); +} + +static void LoginTab_OnMButtonDown(HWND hwnd, UINT vKey, POINTS pts) +{ + if (FALSE != LoginTab_IsLocked(hwnd)) + return; + + LoginTab_RelayTooltipMouseMsg(hwnd, WM_MBUTTONDOWN, vKey, pts); +} + +static void LoginTab_OnMButtonUp(HWND hwnd, UINT vKey, POINTS pts) +{ + if (FALSE != LoginTab_IsLocked(hwnd)) + return; + + LoginTab_RelayTooltipMouseMsg(hwnd, WM_MBUTTONUP, vKey, pts); +} + +static void LoginTab_OnCaptureChanged(HWND hwnd, HWND hCapture) +{ + if (hwnd != hCapture) + LoginTab_TrackMouseLeave(hwnd); +} + +static void LoginTab_OnSetFocus(HWND hwnd, HWND hFocus) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return; + + INT iFocus = tab->iSelected; + tab->iFocused = -1; + LoginTab_SetItemFocus(hwnd, iFocus); +} + +static void LoginTab_OnKillFocus(HWND hwnd, HWND hFocus) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return; + + RECT rect; + if (-1 != tab->iFocused && FALSE != LoginTab_GetItemRect(hwnd, tab->iFocused, &rect)) + { + InvalidateRect(hwnd, &rect, FALSE); + } +} + +static void LoginTab_OnEnable(HWND hwnd, BOOL fEnabled) +{ + InvalidateRect(hwnd, NULL, FALSE); +} + +static void LoginTab_OnKeyDown(HWND hwnd, INT vKey, UINT flags) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return; + + if (FALSE != LoginTab_IsLocked(hwnd)) + return; + + INT focusPos = -1; + if (tab->iFocused >= tab->itemsCount) + { + focusPos = tab->iFocused; + } + else if (-1 != tab->iFocused) + { + for (INT i = 0; i < tab->itemsCount; i++) + { + if (tab->order[i] == tab->iFocused) + { + focusPos = i; + break; + } + } + } + + switch(vKey) + { + case VK_LEFT: focusPos = (focusPos > tab->lastVisible) ? tab->lastVisible : (focusPos - 1); break; + case VK_RIGHT: focusPos++; break; + case VK_PRIOR: + case VK_HOME: focusPos = 0; break; + case VK_END: focusPos = tab->itemsCount -1; break; + case VK_NEXT: focusPos = tab->lastVisible; break; + + case VK_SPACE: + case VK_RETURN: + if (tab->iFocused == tab->itemsCount) + { + tab->iPressed = tab->iFocused; + RECT rect; + if (FALSE == LoginTab_GetItemRect(hwnd, tab->iPressed, &rect)) + SetRectEmpty(&rect); + + LoginTab_ShowHiddenTabs(hwnd, &rect); + tab->iFocused = tab->itemsCount; + tab->iPressed = -1; + InvalidateRect(hwnd, &rect, FALSE); + LoginTab_UpdateMouseInfo(hwnd); + return; + } + break; + } + + INT iFocus; + if (focusPos >= tab->itemsCount) + iFocus = tab->itemsCount; + else if (focusPos < 0) + iFocus = 0; + else + iFocus = tab->order[focusPos]; + + LoginTab_SetItemFocus(hwnd, iFocus); +} + + +static LRESULT LoginTab_OnGetDlgCode(HWND hwnd, INT vKey, MSG *pMsg) +{ + switch(vKey) + { + case VK_TAB: return 0; + } + return DLGC_WANTALLKEYS; +} + +static LRESULT LoginTab_OnMenuChar(HWND hwnd, INT vkCode, INT menuType, HMENU hMenu) +{ + switch(vkCode) + { + case VK_SPACE: + case VK_RETURN: + for (INT i = GetMenuItemCount(hMenu) - 1; i >= 0; i--) + { + UINT r = GetMenuState(hMenu, i, MF_BYPOSITION); + if (-1 != r && 0 != (MF_HILITE & LOWORD(r))) + return MAKELRESULT(i, MNC_EXECUTE); + } + return MAKELRESULT(0, MNC_SELECT); + } + return MAKELRESULT(0, MNC_IGNORE); +} + +static void LoginTab_OnMenuSelect(HWND hwnd, INT iItem, UINT flags, HMENU hMenu) +{ + MENUINFO mi; + mi.cbSize = sizeof(mi); + mi.fMask = MIM_MENUDATA | MIM_BACKGROUND; + + if (FALSE != GetMenuInfo(hMenu, &mi) && NULL != mi.dwMenuData) + { + CHEVRONMENUPAINTPARAM *pmp= (CHEVRONMENUPAINTPARAM*)mi.dwMenuData; + if (NULL != pmp->hwndMenu) + { + UINT stateOrig = (UINT)SendMessage(pmp->hwndMenu, WM_QUERYUISTATE, 0, 0L); + + SendMessage(pmp->hwndMenu, WM_CHANGEUISTATE, + MAKEWPARAM(UISF_HIDEACCEL | UISF_HIDEFOCUS, UIS_INITIALIZE), 0L); + + UINT stateCurrent = (UINT)SendMessage(pmp->hwndMenu, WM_QUERYUISTATE, 0, 0L); + if ((UISF_HIDEFOCUS & stateOrig) != (UISF_HIDEFOCUS & stateCurrent)) + { + INT menuCount = GetMenuItemCount(hMenu); + while(menuCount--) + { + if (iItem == GetMenuItemID(hMenu, menuCount)) + { + RECT rect; + if (FALSE != GetMenuItemRect(NULL, hMenu, menuCount, &rect)) + { + MapWindowPoints(HWND_DESKTOP, pmp->hwndMenu, (POINT*)&rect, 2); + InvalidateRect(pmp->hwndMenu, &rect, FALSE); + } + break; + } + } + } + } + } +} + + +static void LoginTab_GetTootipDispInfo(HWND hwnd, NMTTDISPINFO *pdisp) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return; + + if(NULL == tab->helpText) + { + INT iItem = (INT)pdisp->lParam; + if (iItem >= 0 && iItem < tab->itemsCount) + { + HWND hParent = GetAncestor(hwnd, GA_PARENT); + if (NULL != hParent) + { + NMLOGINTABHELP help; + help.hdr.code = NLTN_GETITEMHELP; + help.hdr.hwndFrom = hwnd; + help.hdr.idFrom = GetWindowLongPtr(hwnd, GWLP_ID); + help.iItem = iItem; + help.param = tab->items[iItem]->param; + help.bstrHelp = NULL; + SNDMSG(hParent, WM_NOTIFY, (WPARAM)help.hdr.idFrom, (LPARAM)&help); + tab->helpText = help.bstrHelp; + } + } + else if (iItem == tab->itemsCount) + { + WCHAR szBuffer[256] = {0}; + WASABI_API_LNGSTRINGW_BUF(IDS_LOGINTAB_MOREPROVIDERS, szBuffer, ARRAYSIZE(szBuffer)); + tab->helpText = SysAllocString(szBuffer); + } + + if (NULL == tab->helpText) + tab->helpText = SysAllocString(L" "); + } + + if (NULL != tab->helpText && L'\0' != tab->helpText) + { + pdisp->lpszText = (LPWSTR)tab->helpText; + pdisp->uFlags = TTF_DI_SETITEM; + } +} + +static BOOL LoginTab_OnShow(HWND hwnd, HWND hTooltip) +{ + TOOLINFO ti; + ZeroMemory(&ti, sizeof(ti)); + ti.cbSize = sizeof(ti); + ti.hwnd = hwnd; + ti.uId = 0; + + if (FALSE == SendMessage(hTooltip, TTM_GETTOOLINFO, 0, (LPARAM)&ti)) + return FALSE; + + MapWindowPoints(hwnd, HWND_DESKTOP, (POINT*)&ti.rect, 2); + + RECT windowRect, tooltipRect; + GetWindowRect(hwnd, &windowRect); + GetWindowRect(hTooltip, &tooltipRect); + + ti.rect.right = ti.rect.left + (tooltipRect.right - tooltipRect.left); + ti.rect.top = windowRect.bottom; + ti.rect.bottom = ti.rect.top + (tooltipRect.bottom - tooltipRect.top); + + HMONITOR hMonitor = MonitorFromRect(&ti.rect, MONITOR_DEFAULTTONEAREST); + if (NULL != hMonitor) + { + MONITORINFO mi; + mi.cbSize = sizeof(mi); + if (FALSE != GetMonitorInfo(hMonitor, &mi)) + { + INT offsetX = 0; + INT offsetY = 0; + + if (ti.rect.right > mi.rcWork.right) + offsetX += (mi.rcWork.right - ti.rect.right); + + if (ti.rect.bottom > mi.rcWork.bottom) + { + offsetY += (mi.rcWork.bottom - ti.rect.bottom); + if ((ti.rect.top + offsetY) < windowRect.bottom && (ti.rect.bottom + offsetY) > windowRect.top) + offsetY = (windowRect.top - (ti.rect.bottom - ti.rect.top)) - ti.rect.top; + } + + if ((ti.rect.left + offsetX) < mi.rcWork.left) + offsetX += (mi.rcWork.left - (ti.rect.left + offsetX)); + if ((ti.rect.top + offsetY) < mi.rcWork.top) + offsetY += (mi.rcWork.top - (ti.rect.top + offsetY)); + + + + + OffsetRect(&ti.rect, offsetX, offsetY); + } + } + + return SetWindowPos(hTooltip, NULL, ti.rect.left, ti.rect.top, 0, 0, + SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOREDRAW); +} + +static LRESULT LoginTab_OnTooltipNotify(HWND hwnd, NMHDR *pnmh) +{ + switch(pnmh->code) + { + case TTN_GETDISPINFO: + LoginTab_GetTootipDispInfo(hwnd, (NMTTDISPINFO*)pnmh); + break; + case TTN_SHOW: + return LoginTab_OnShow(hwnd, pnmh->hwndFrom); + + } + return 0; +} + +static LRESULT LoginTab_OnNotify(HWND hwnd, INT controlId, NMHDR *pnmh) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return 0; + + if (tab->hTooltip == pnmh->hwndFrom && NULL != tab->hTooltip) + return LoginTab_OnTooltipNotify(hwnd, pnmh); + + return 0; +} +static INT LoginTab_OnGetIdealHeight(HWND hwnd) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return 0; + + INT height = 0; + + INT iconCX, iconCY; + if (NULL != tab->imageList && FALSE != ImageList_GetIconSize(tab->imageList, &iconCX, &iconCY)) + { + height += (iconCY + 2 * IMAGE_MARGIN_CY); + } + + height += tab->textHeight; + + height += tab->margins.top + tab->margins.bottom; + height += 2 * tab->frameHeight; + + return height; +} + +static INT LoginTab_OnGetIdealWidth(HWND hwnd, INT itemsCount) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return 0; + + INT width = 0; + + if (itemsCount < 0) itemsCount = 0; + if (itemsCount > tab->itemsCount) itemsCount = tab->itemsCount; + + if (itemsCount == 0) + { + width = tab->margins.left + tab->margins.right; + return width; + } + itemsCount--; + if (itemsCount <= tab->lastVisible) + { + RECT rect; + if (FALSE != LoginTab_GetItemRect(hwnd, itemsCount, &rect)) + width = rect.right; + } + else + { + RECT rect; + GetWindowRect(hwnd, &rect); + LONG origWidth = rect.right - rect.left; + LONG origHeight = rect.bottom - rect.top; + SetWindowPos(hwnd, NULL, 0, 0, 40000, origHeight, + SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE | SWP_NOREDRAW | SWP_NOSENDCHANGING); + + if (FALSE != LoginTab_GetItemRect(hwnd, itemsCount, &rect)) + width = rect.right; + + SetWindowPos(hwnd, NULL, 0, 0, origWidth, origHeight, + SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE | SWP_NOREDRAW | SWP_NOSENDCHANGING); + } + + if (0 != width) + { + width += (itemsCount < (tab->itemsCount - 1) && tab->chevronWidth > tab->margins.right) ? + tab->chevronWidth : tab->margins.right; + } + return width; +} +static INT LoginTab_OnInsertItem(HWND hwnd, INT iItem, NLTITEM *pItem) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab || NULL == pItem) return -1; + if (iItem < 0) iItem = 0; + + + INT itemsMax = (0 != tab->items) ? (INT)(_msize(tab->items)/sizeof(LOGINTABITEM*)) : 0; + if (tab->itemsCount >= itemsMax) + { + INT k = tab->itemsCount + 1 - itemsMax; + if (k < 8) k = 8; + itemsMax += k; + void *data = realloc(tab->items, itemsMax * sizeof(LOGINTABITEM*)); + if (NULL == data) return -1; + tab->items = (LOGINTABITEM**)data; + data = realloc(tab->order, itemsMax * sizeof(INT)); + if (NULL == data) return -1; + tab->order = (INT*)data; + } + + LOGINTABITEM *item = LoginTab_CreateItem(pItem); + if (NULL == item) return -1; + + if (iItem >= tab->itemsCount) + { + iItem = tab->itemsCount; + tab->items[iItem] = item; + tab->order[iItem] = iItem; + } + else + { + MoveMemory((tab->items + iItem + 1), (tab->items + iItem), sizeof(LOGINTABITEM*) * (tab->itemsCount - iItem)); + tab->items[iItem] = item; + + MoveMemory((tab->order + iItem + 1), (tab->order + iItem), sizeof(INT) * (tab->itemsCount - iItem)); + tab->order[iItem] = iItem; + + for (INT i = 0; i <= tab->itemsCount; i++) + { + if (iItem != i && tab->order[i] >= iItem) + ++(tab->order[i]); + } + } + + tab->itemsCount++; + + + return iItem; +} + +static BOOL LoginTab_OnSetItem(HWND hwnd, INT iItem, NLTITEM *pItem) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab || NULL == pItem) return FALSE; + if (iItem < 0 || iItem >= tab->itemsCount) return FALSE; + + BOOL result = LoginTab_SetItemInternal(tab->items[iItem], pItem); + + RECT rect; + GetClientRect(hwnd, &rect); + LONG clientRight = rect.right; + + if (FALSE != LoginTab_GetItemRect(hwnd, iItem, &rect)) + { + rect.right = clientRight; + InvalidateRect(hwnd, &rect, FALSE); + } + else if (NULL != tab->chevronMenu) + { + INT menuCount = GetMenuItemCount(tab->chevronMenu); + while(menuCount--) + { + if (iItem == (GetMenuItemID(tab->chevronMenu, menuCount) - 1)) + { + if (FALSE != GetMenuItemRect(NULL, tab->chevronMenu, menuCount, &rect)) + { + POINT ptTest; + ptTest.x = rect.left + (rect.right - rect.left)/2; + ptTest.y = rect.top + (rect.bottom - rect.top)/2; + HWND hwndMenu = WindowFromPoint(ptTest); + if (NULL != hwndMenu) + { + MapWindowPoints(HWND_DESKTOP, hwndMenu, (POINT*)&rect, 2); + InvalidateRect(hwndMenu, &rect, FALSE); + } + } + break; + } + } + + } + + return result; +} + +static BOOL LoginTab_OnGetItem(HWND hwnd, INT iItem, NLTITEM *pItem) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab || NULL == pItem) return FALSE; + if (iItem < 0 || iItem >= tab->itemsCount) return FALSE; + + LOGINTABITEM *item = tab->items[iItem]; + + BOOL succeeded = TRUE; + + if (0 != (NLTIF_TEXT & pItem->mask)) + { + if (NULL == pItem->pszText || + FAILED(StringCchCopyEx(pItem->pszText, pItem->cchTextMax, item->text, NULL, NULL, STRSAFE_IGNORE_NULLS))) + { + succeeded = FALSE; + } + } + + if (0 != (NLTIF_PARAM & pItem->mask)) + pItem->param = item->param; + + if (0 != (NLTIF_IMAGE & pItem->mask)) + pItem->iImage = item->iImage; + + if (0 != (NLTIF_IMAGE_ACTIVE & pItem->mask)) + pItem->iImageActive = item->iImageActive; + + if (0 != (NLTIF_IMAGE_DISABLED & pItem->mask)) + pItem->iImageDisabled = item->iImageDisabled; + + return succeeded; +} + +static BOOL LoginTab_OnDeleteItem(HWND hwnd, INT iItem) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return FALSE; + + if (iItem < 0 || iItem >= tab->itemsCount) + return FALSE; + + HWND hParent = GetAncestor(hwnd, GA_PARENT); + if (NULL != hParent) + { + NMLOGINTAB nmp; + nmp.hdr.code = NLTN_DELETEITEM; + nmp.hdr.hwndFrom = hwnd; + nmp.hdr.idFrom = GetWindowLongPtr(hwnd, GWLP_ID); + nmp.iItem = iItem; + SNDMSG(hParent, WM_NOTIFY, (WPARAM)nmp.hdr.idFrom, (LPARAM)&nmp); + } + + LOGINTABITEM *item = tab->items[iItem]; + + INT shiftLen = tab->itemsCount - iItem - 1; + if (shiftLen > 0) + { + + MoveMemory((tab->items + iItem), (tab->items + (iItem + 1)), sizeof(LOGINTABITEM*)*shiftLen); + + INT iOrder = tab->itemsCount - 1; + while(iOrder--) + { + if (iItem == tab->order[iOrder]) + { + MoveMemory((tab->order + iOrder), (tab->order + (iOrder + 1)), + sizeof(INT)*(tab->itemsCount - iOrder - 1)); + break; + } + } + + } + + LoginTab_FreeItem(item); + tab->itemsCount--; + + return TRUE; +} + + +static BOOL LoginTab_OnDeleteAllItems(HWND hwnd) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return FALSE; + + tab->itemsCount -= LoginTab_DeleteAllItemsReal(hwnd, tab->items, tab->itemsCount); + return TRUE; +} + +static INT LoginTab_OnGetItemCount(HWND hwnd) +{ + LOGINTAB *tab = GetTab(hwnd); + return (NULL != tab) ? tab->itemsCount : -1; +} + +static INT LoginTab_OnGetCurSel(HWND hwnd) +{ + LOGINTAB *tab = GetTab(hwnd); + return (NULL != tab) ? tab->iSelected : -1; +} + +static INT LoginTab_OnSetCurSel(HWND hwnd, INT iItem) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return -1; + + if (iItem < 0 || iItem >= tab->itemsCount) + return -1; + + if (iItem == tab->iSelected) + return tab->iSelected; + + INT iSelected = tab->iSelected; + INT iFocused = tab->iFocused; + + tab->iSelected = iItem; + + if (tab->iFocused != tab->itemsCount) + tab->iFocused = iItem; + + RECT rect; + if (-1 != iSelected && + FALSE != LoginTab_GetItemRect(hwnd, iSelected, &rect)) + { + InvalidateRect(hwnd, &rect, FALSE); + } + + if (iFocused != tab->iFocused && -1 != iFocused && iFocused != iSelected && + FALSE != LoginTab_GetItemRect(hwnd, iFocused, &rect)) + { + InvalidateRect(hwnd, &rect, FALSE); + } + + if (-1 != tab->iSelected && + FALSE != LoginTab_GetItemRect(hwnd, tab->iSelected, &rect)) + { + InvalidateRect(hwnd, &rect, FALSE); + } + + for(INT i = (tab->lastVisible + 1); i < tab->itemsCount; i++) + { + if (tab->order[i] == tab->iSelected) + { + LoginTab_UpdateLayout(hwnd, TRUE); + break; + } + } + + return iSelected; +} + + +static HIMAGELIST LoginTab_OnSetImageList(HWND hwnd, HIMAGELIST himl) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return NULL; + + HIMAGELIST old = tab->imageList; + tab->imageList = himl; + + LoginTab_UpdateLayout(hwnd, TRUE); + return old; +} + +static HIMAGELIST LoginTab_OnGetImageList(HWND hwnd) +{ + LOGINTAB *tab = GetTab(hwnd); + return (NULL != tab) ? tab->imageList : NULL; +} + +static BOOL LoginTab_OnResetOrder(HWND hwnd) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return FALSE; + + for (INT i = 0; i < tab->itemsCount; i++) + tab->order[i] = i; + + LoginTab_UpdateLayout(hwnd, FALSE); + InvalidateRect(hwnd, NULL, FALSE); + return TRUE; +} + +static void LoginTab_OnLockSelection(HWND hwnd, BOOL fLock) +{ + UINT windowStyle = GetWindowStyle(hwnd); + if ((FALSE != fLock) != (0 != (NLTS_LOCKED & windowStyle))) + { + if (FALSE != fLock) + windowStyle |= NLTS_LOCKED; + else + windowStyle &= ~NLTS_LOCKED; + SetWindowLongPtr(hwnd, GWL_STYLE, windowStyle); + InvalidateRect(hwnd, NULL, FALSE); + } +} +static BOOL LoginTab_OnMeasureChevronItem(HWND hwnd, MEASUREITEMSTRUCT* pmis) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return FALSE; + + MENUINFO mi; + mi.cbSize = sizeof(mi); + mi.fMask = MIM_MENUDATA; + + if (FALSE != GetMenuInfo(tab->chevronMenu, &mi) && NULL != mi.dwMenuData) + { + CHEVRONMENUPAINTPARAM *pmp= (CHEVRONMENUPAINTPARAM*)mi.dwMenuData; + pmis->itemWidth = pmp->itemWidth; + pmis->itemHeight = pmp->itemHeight; + + return TRUE; + } + return FALSE; +} + + +static BOOL LoginTab_OnDrawChevronItem(HWND hwnd, DRAWITEMSTRUCT* pdis) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return FALSE; + + + MENUINFO mi; + mi.cbSize = sizeof(mi); + mi.fMask = MIM_MENUDATA | MIM_BACKGROUND; + + if (FALSE == GetMenuInfo(tab->chevronMenu, &mi) || NULL == mi.dwMenuData) + return FALSE; + + CHEVRONMENUPAINTPARAM *pmp= (CHEVRONMENUPAINTPARAM*)mi.dwMenuData; + + if (NULL == pmp->hwndMenu) + { + pmp->hwndMenu = WindowFromDC(pdis->hDC); + if (NULL != pmp->hwndMenu) + { + SendMessage(pmp->hwndMenu, WM_CHANGEUISTATE, + MAKEWPARAM(UISF_HIDEACCEL | UISF_HIDEFOCUS, UIS_INITIALIZE), 0L); + } + } + + tab->drawStyle = LoginTab_GetDrawStyles(hwnd); + + if (NULL != pmp->hwndMenu) + { + UINT uiState = (UINT)SendMessage(pmp->hwndMenu, WM_QUERYUISTATE, 0, 0L); + if (0 == (UISF_HIDEFOCUS & uiState)) + tab->drawStyle |= NLTDS_FOCUSED; + else + tab->drawStyle &= ~NLTDS_FOCUSED; + } + + + HBITMAP hbmp = LoginTab_GetItemBitmap(tab, pdis->hDC, + pdis->rcItem.right - pdis->rcItem.left, + pdis->rcItem.bottom - pdis->rcItem.top); + + HBITMAP hbmpOrig = NULL; + POINT viewportOrig; + if (NULL != hbmp) + { + hbmpOrig = (HBITMAP)SelectObject(pmp->hdcItem, hbmp); + SetViewportOrgEx(pmp->hdcItem, -pdis->rcItem.left, -pdis->rcItem.top, &viewportOrig); + } + + if (NULL == mi.hbrBack) + mi.hbrBack = GetSysColorBrush(COLOR_MENU); + + INT itemWidth = pdis->rcItem.right - pdis->rcItem.left; + INT itemHeight = pdis->rcItem.bottom - pdis->rcItem.top; + + POINT brushOrgEx; + SetBrushOrgEx(pmp->hdcItem, 0, -pdis->rcItem.top, &brushOrgEx); + FillRect(pmp->hdcItem, &pdis->rcItem, mi.hbrBack); + SetBrushOrgEx(pmp->hdcItem, brushOrgEx.x, brushOrgEx.y, NULL); + + LOGINTABITEM *item = (LOGINTABITEM*)pdis->itemData; + INT iItem = pdis->itemID - 1; + + + INT iHighlighted = tab->iHighlighted; + + if (0 != (ODS_SELECTED & pdis->itemState)) + { + tab->iHighlighted = iItem; + if (tab->iFocused != iItem && -1 != tab->iFocused) + { + RECT rect; + if (FALSE != LoginTab_GetItemRect(hwnd, tab->iFocused, &rect)) + InvalidateRect(hwnd, &rect, FALSE); + } + tab->iFocused = iItem; + } + else + tab->iFocused = -1; + + LoginTab_PaintItem(hwnd, pmp->hdcItem, tab, item, iItem, &pdis->rcItem, &pdis->rcItem, pmp->hdcSrc); + + tab->iHighlighted = iHighlighted; + + BitBlt(pdis->hDC, pdis->rcItem.left, pdis->rcItem.top, itemWidth, itemHeight, + pmp->hdcItem, pdis->rcItem.left, pdis->rcItem.top, SRCCOPY); + + if (NULL != hbmp) + { + SelectObject(pmp->hdcItem, hbmpOrig); + SetViewportOrgEx(pmp->hdcItem, viewportOrig.x, viewportOrig.y, NULL); + } + + return TRUE; +} +static BOOL LoginTab_OnMeasureItem(HWND hwnd, MEASUREITEMSTRUCT* pmis) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return FALSE; + + switch(pmis->CtlType) + { + case ODT_MENU: + if (NULL != tab->chevronMenu) + return LoginTab_OnMeasureChevronItem(hwnd, pmis); + break; + } + + return FALSE; +} + +static BOOL LoginTab_OnDrawItem(HWND hwnd, DRAWITEMSTRUCT* pdis) +{ + LOGINTAB *tab = GetTab(hwnd); + if (NULL == tab) return FALSE; + + switch(pdis->CtlType) + { + case ODT_MENU: + if (NULL != tab->chevronMenu) + return LoginTab_OnDrawChevronItem(hwnd, pdis); + break; + } + + return FALSE; +} + +void LoginTab_OnThemeChanged(HWND hwnd) +{ + LoginTab_UpdateColors(hwnd); + OutputDebugStringA("Theme changed received\r\n"); +} + +void LoginTab_OnSysColorChanged(HWND hwnd) +{ + LoginTab_UpdateColors(hwnd); + OutputDebugStringA("Color changed received\r\n"); +} + + +static LRESULT WINAPI LoginTab_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch(uMsg) + { + case WM_CREATE: return LoginTab_OnCreate(hwnd, (CREATESTRUCT*)lParam); + case WM_DESTROY: LoginTab_OnDestroy(hwnd); return 0; + case WM_ERASEBKGND: return 0; + case WM_PAINT: LoginTab_OnPaint(hwnd); return 0; + case WM_PRINTCLIENT: LoginTab_OnPrintClient(hwnd, (HDC)wParam, (UINT)lParam); return 0; + case WM_WINDOWPOSCHANGED: LoginTab_OnWindowPosChanged(hwnd, (WINDOWPOS*)lParam); return 0; + case WM_SIZE: return 0; + case WM_MOUSEMOVE: LoginTab_OnMouseMove(hwnd, (UINT)wParam, MAKEPOINTS(lParam)); return 0; + case WM_LBUTTONDOWN: LoginTab_OnLButtonDown(hwnd, (UINT)wParam, MAKEPOINTS(lParam)); return 0; + case WM_LBUTTONUP: LoginTab_OnLButtonUp(hwnd, (UINT)wParam, MAKEPOINTS(lParam)); return 0; + case WM_RBUTTONDOWN: LoginTab_OnRButtonDown(hwnd, (UINT)wParam, MAKEPOINTS(lParam)); return 0; + case WM_RBUTTONUP: LoginTab_OnRButtonUp(hwnd, (UINT)wParam, MAKEPOINTS(lParam)); return 0; + case WM_MBUTTONDOWN: LoginTab_OnMButtonDown(hwnd, (UINT)wParam, MAKEPOINTS(lParam)); return 0; + case WM_MBUTTONUP: LoginTab_OnMButtonUp(hwnd, (UINT)wParam, MAKEPOINTS(lParam)); return 0; + case WM_MOUSELEAVE: LoginTab_OnMouseLeave(hwnd); return 0; + case WM_CAPTURECHANGED: LoginTab_OnCaptureChanged(hwnd, (HWND)lParam); return 0; + case WM_SETFOCUS: LoginTab_OnSetFocus(hwnd, (HWND)wParam); return 0; + case WM_KILLFOCUS: LoginTab_OnKillFocus(hwnd, (HWND)wParam); return 0; + case WM_ENABLE: LoginTab_OnEnable(hwnd, (BOOL)wParam); return 0; + case WM_KEYDOWN: LoginTab_OnKeyDown(hwnd, (INT)wParam, (UINT)lParam); return 0; + case WM_GETDLGCODE: return LoginTab_OnGetDlgCode(hwnd, (INT)wParam, (MSG*)lParam); + case WM_MENUCHAR: return LoginTab_OnMenuChar(hwnd, LOWORD(wParam), HIWORD(wParam), (HMENU)lParam); + case WM_MENUSELECT: LoginTab_OnMenuSelect(hwnd, LOWORD(wParam), HIWORD(wParam), (HMENU)lParam); return 0; + case WM_MEASUREITEM: return LoginTab_OnMeasureItem(hwnd, (MEASUREITEMSTRUCT*)lParam); + case WM_DRAWITEM: return LoginTab_OnDrawItem(hwnd, (DRAWITEMSTRUCT*)lParam); + case WM_NOTIFY: return LoginTab_OnNotify(hwnd, (INT)wParam, (NMHDR*)lParam); + case WM_THEMECHANGED: LoginTab_OnThemeChanged(hwnd); return TRUE; + case WM_SYSCOLORCHANGE: LoginTab_OnSysColorChanged(hwnd); return TRUE; + + + case NLTM_GETIDEALHEIGHT: return LoginTab_OnGetIdealHeight(hwnd); + case NLTM_INSERTITEM: return LoginTab_OnInsertItem(hwnd, (INT)wParam, (NLTITEM*)lParam); + case NLTM_SETITEM: return LoginTab_OnSetItem(hwnd, (INT)wParam, (NLTITEM*)lParam); + case NLTM_GETITEM: return LoginTab_OnGetItem(hwnd, (INT)wParam, (NLTITEM*)lParam); + case NLTM_DELETEITEM: return LoginTab_OnDeleteItem(hwnd, (INT)wParam); + case NLTM_DELETEALLITEMS: return LoginTab_OnDeleteAllItems(hwnd); + case NLTM_GETITEMCOUNT: return LoginTab_OnGetItemCount(hwnd); + case NLTM_GETCURSEL: return LoginTab_OnGetCurSel(hwnd); + case NLTM_SETCURSEL: return LoginTab_OnSetCurSel(hwnd, (INT)wParam); + case NLTM_SETIMAGELIST: return (LRESULT)LoginTab_OnSetImageList(hwnd, (HIMAGELIST)lParam); + case NLTM_GETIMAGELIST: return (LRESULT)LoginTab_OnGetImageList(hwnd); + case NLTM_RESETORDER: LoginTab_OnResetOrder(hwnd); return 0; + case NLTM_LOCKSELECTION: LoginTab_OnLockSelection(hwnd, (BOOL)wParam); return 0; + case NLTM_GETIDEALWIDTH: return LoginTab_OnGetIdealWidth(hwnd, (INT)wParam); + } + return DefWindowProc(hwnd, uMsg, wParam, lParam); +}
\ No newline at end of file |