| /* | |
| * Rebar control | |
| * | |
| * Copyright 1998 Eric Kohl | |
| * | |
| * NOTES | |
| * An author is needed! Any volunteers? | |
| * I will only improve this control once in a while. | |
| * Eric <ekohl@abo.rhein-zeitung.de> | |
| * | |
| * TODO: | |
| * - vertical placement | |
| * - ComboBox and ComboBoxEx placement | |
| * - center image | |
| * - Layout code. | |
| * - Display code. | |
| * - Some messages. | |
| * - All notifications. | |
| */ | |
| #include "windows.h" | |
| #include "commctrl.h" | |
| #include "rebar.h" | |
| #include "win.h" | |
| #include "sysmetrics.h" | |
| #include "debug.h" | |
| /* fDraw flags */ | |
| #define DRAW_GRIPPER 1 | |
| #define DRAW_IMAGE 2 | |
| #define DRAW_TEXT 4 | |
| #define DRAW_CHILD 8 | |
| #define GRIPPER_WIDTH 13 | |
| #define REBAR_GetInfoPtr(wndPtr) ((REBAR_INFO *)wndPtr->wExtra[0]) | |
| static VOID | |
| REBAR_DrawBand (HDC32 hdc, REBAR_INFO *infoPtr, REBAR_BAND *lpBand) | |
| { | |
| DrawEdge32 (hdc, &lpBand->rcBand, BDR_RAISEDINNER, BF_MIDDLE); | |
| /* draw background */ | |
| /* draw gripper */ | |
| if (lpBand->fDraw & DRAW_GRIPPER) | |
| DrawEdge32 (hdc, &lpBand->rcGripper, BDR_RAISEDINNER, BF_RECT | BF_MIDDLE); | |
| /* draw caption image */ | |
| if (lpBand->fDraw & DRAW_IMAGE) { | |
| /* FIXME: center image */ | |
| POINT32 pt; | |
| pt.y = (lpBand->rcCapImage.bottom + lpBand->rcCapImage.top - infoPtr->imageSize.cy)/2; | |
| pt.x = (lpBand->rcCapImage.right + lpBand->rcCapImage.left - infoPtr->imageSize.cx)/2; | |
| ImageList_Draw (infoPtr->himl, lpBand->iImage, hdc, | |
| /* lpBand->rcCapImage.left, lpBand->rcCapImage.top, */ | |
| pt.x, pt.y, | |
| ILD_TRANSPARENT); | |
| } | |
| /* draw caption text */ | |
| if (lpBand->fDraw & DRAW_TEXT) { | |
| HFONT32 hOldFont = SelectObject32 (hdc, infoPtr->hFont); | |
| INT32 oldBkMode = SetBkMode32 (hdc, TRANSPARENT); | |
| DrawText32W (hdc, lpBand->lpText, -1, &lpBand->rcCapText, | |
| DT_CENTER | DT_VCENTER | DT_SINGLELINE); | |
| if (oldBkMode != TRANSPARENT) | |
| SetBkMode32 (hdc, oldBkMode); | |
| SelectObject32 (hdc, hOldFont); | |
| } | |
| } | |
| static VOID | |
| REBAR_Refresh (WND *wndPtr, HDC32 hdc) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| REBAR_BAND *lpBand; | |
| UINT32 i; | |
| for (i = 0; i < infoPtr->uNumBands; i++) { | |
| lpBand = &infoPtr->bands[i]; | |
| if ((lpBand->fStyle & RBBS_HIDDEN) || | |
| ((wndPtr->dwStyle & CCS_VERT) && (lpBand->fStyle & RBBS_NOVERT))) | |
| continue; | |
| REBAR_DrawBand (hdc, infoPtr, lpBand); | |
| } | |
| } | |
| static VOID | |
| REBAR_CalcHorzBand (REBAR_INFO *infoPtr, REBAR_BAND *lpBand) | |
| { | |
| lpBand->fDraw = 0; | |
| /* set initial caption image rectangle */ | |
| SetRect32 (&lpBand->rcCapImage, 0, 0, 0, 0); | |
| /* image is visible */ | |
| if ((lpBand->iImage > -1) && (infoPtr->himl)) { | |
| lpBand->fDraw |= DRAW_IMAGE; | |
| lpBand->rcCapImage.right = lpBand->rcCapImage.left + infoPtr->imageSize.cx; | |
| lpBand->rcCapImage.bottom = lpBand->rcCapImage.top + infoPtr->imageSize.cy; | |
| /* update band height */ | |
| if (lpBand->uMinHeight < infoPtr->imageSize.cy + 2) { | |
| lpBand->uMinHeight = infoPtr->imageSize.cy + 2; | |
| lpBand->rcBand.bottom = lpBand->rcBand.top + lpBand->uMinHeight; | |
| } | |
| } | |
| /* set initial caption text rectangle */ | |
| lpBand->rcCapText.left = lpBand->rcCapImage.right; | |
| lpBand->rcCapText.top = lpBand->rcBand.top + 1; | |
| lpBand->rcCapText.right = lpBand->rcCapText.left; | |
| lpBand->rcCapText.bottom = lpBand->rcBand.bottom - 1; | |
| /* text is visible */ | |
| if (lpBand->lpText) { | |
| HDC32 hdc = GetDC32 (0); | |
| HFONT32 hOldFont = SelectObject32 (hdc, infoPtr->hFont); | |
| SIZE32 size; | |
| lpBand->fDraw |= DRAW_TEXT; | |
| GetTextExtentPoint32W (hdc, lpBand->lpText, | |
| lstrlen32W (lpBand->lpText), &size); | |
| lpBand->rcCapText.right += size.cx; | |
| SelectObject32 (hdc, hOldFont); | |
| ReleaseDC32 (0, hdc); | |
| } | |
| /* set initial child window rectangle */ | |
| if (lpBand->fStyle & RBBS_FIXEDSIZE) { | |
| lpBand->rcChild.left = lpBand->rcCapText.right; | |
| lpBand->rcChild.top = lpBand->rcBand.top; | |
| lpBand->rcChild.right = lpBand->rcBand.right; | |
| lpBand->rcChild.bottom = lpBand->rcBand.bottom; | |
| } | |
| else { | |
| lpBand->rcChild.left = lpBand->rcCapText.right + 4; | |
| lpBand->rcChild.top = lpBand->rcBand.top + 2; | |
| lpBand->rcChild.right = lpBand->rcBand.right - 4; | |
| lpBand->rcChild.bottom = lpBand->rcBand.bottom - 2; | |
| } | |
| /* calculate gripper rectangle */ | |
| if ((!(lpBand->fStyle & RBBS_NOGRIPPER)) && | |
| (!(lpBand->fStyle & RBBS_FIXEDSIZE)) && | |
| ((lpBand->fStyle & RBBS_GRIPPERALWAYS) || | |
| (infoPtr->uNumBands > 1))) { | |
| lpBand->fDraw |= DRAW_GRIPPER; | |
| lpBand->rcGripper.left = lpBand->rcBand.left + 3; | |
| lpBand->rcGripper.right = lpBand->rcGripper.left + 3; | |
| lpBand->rcGripper.top = lpBand->rcBand.top + 3; | |
| lpBand->rcGripper.bottom = lpBand->rcBand.bottom - 3; | |
| /* move caption rectangles */ | |
| OffsetRect32 (&lpBand->rcCapImage, GRIPPER_WIDTH, 0); | |
| OffsetRect32 (&lpBand->rcCapText, GRIPPER_WIDTH, 0); | |
| /* adjust child rectangle */ | |
| lpBand->rcChild.left += GRIPPER_WIDTH; | |
| } | |
| } | |
| static VOID | |
| REBAR_CalcVertBand (WND *wndPtr, REBAR_INFO *infoPtr, REBAR_BAND *lpBand) | |
| { | |
| lpBand->fDraw = 0; | |
| /* set initial caption image rectangle */ | |
| SetRect32 (&lpBand->rcCapImage, 0, 0, 0, 0); | |
| /* image is visible */ | |
| if ((lpBand->iImage > -1) && (infoPtr->himl)) { | |
| lpBand->fDraw |= DRAW_IMAGE; | |
| lpBand->rcCapImage.right = lpBand->rcCapImage.left + infoPtr->imageSize.cx; | |
| lpBand->rcCapImage.bottom = lpBand->rcCapImage.top + infoPtr->imageSize.cy; | |
| /* update band width */ | |
| if (lpBand->uMinHeight < infoPtr->imageSize.cx + 2) { | |
| lpBand->uMinHeight = infoPtr->imageSize.cx + 2; | |
| lpBand->rcBand.right = lpBand->rcBand.left + lpBand->uMinHeight; | |
| } | |
| } | |
| /* set initial caption text rectangle */ | |
| lpBand->rcCapText.left = lpBand->rcBand.left + 1; | |
| lpBand->rcCapText.top = lpBand->rcCapImage.bottom; | |
| lpBand->rcCapText.right = lpBand->rcBand.right - 1; | |
| lpBand->rcCapText.bottom = lpBand->rcCapText.top; | |
| /* text is visible */ | |
| if (lpBand->lpText) { | |
| HDC32 hdc = GetDC32 (0); | |
| HFONT32 hOldFont = SelectObject32 (hdc, infoPtr->hFont); | |
| SIZE32 size; | |
| lpBand->fDraw |= DRAW_TEXT; | |
| GetTextExtentPoint32W (hdc, lpBand->lpText, | |
| lstrlen32W (lpBand->lpText), &size); | |
| /* lpBand->rcCapText.right += size.cx; */ | |
| lpBand->rcCapText.bottom += size.cy; | |
| SelectObject32 (hdc, hOldFont); | |
| ReleaseDC32 (0, hdc); | |
| } | |
| /* set initial child window rectangle */ | |
| if (lpBand->fStyle & RBBS_FIXEDSIZE) { | |
| lpBand->rcChild.left = lpBand->rcBand.left; | |
| lpBand->rcChild.top = lpBand->rcCapText.bottom; | |
| lpBand->rcChild.right = lpBand->rcBand.right; | |
| lpBand->rcChild.bottom = lpBand->rcBand.bottom; | |
| } | |
| else { | |
| lpBand->rcChild.left = lpBand->rcBand.left + 2; | |
| lpBand->rcChild.top = lpBand->rcCapText.bottom + 4; | |
| lpBand->rcChild.right = lpBand->rcBand.right - 2; | |
| lpBand->rcChild.bottom = lpBand->rcBand.bottom - 4; | |
| } | |
| /* calculate gripper rectangle */ | |
| if ((!(lpBand->fStyle & RBBS_NOGRIPPER)) && | |
| (!(lpBand->fStyle & RBBS_FIXEDSIZE)) && | |
| ((lpBand->fStyle & RBBS_GRIPPERALWAYS) || | |
| (infoPtr->uNumBands > 1))) { | |
| lpBand->fDraw |= DRAW_GRIPPER; | |
| if (wndPtr->dwStyle & RBS_VERTICALGRIPPER) { | |
| /* adjust band width */ | |
| lpBand->rcBand.right += GRIPPER_WIDTH; | |
| lpBand->uMinHeight += GRIPPER_WIDTH; | |
| lpBand->rcGripper.left = lpBand->rcBand.left + 3; | |
| lpBand->rcGripper.right = lpBand->rcGripper.left + 3; | |
| lpBand->rcGripper.top = lpBand->rcBand.top + 3; | |
| lpBand->rcGripper.bottom = lpBand->rcBand.bottom - 3; | |
| /* move caption rectangles */ | |
| OffsetRect32 (&lpBand->rcCapImage, GRIPPER_WIDTH, 0); | |
| OffsetRect32 (&lpBand->rcCapText, GRIPPER_WIDTH, 0); | |
| /* adjust child rectangle */ | |
| lpBand->rcChild.left += GRIPPER_WIDTH; | |
| } | |
| else { | |
| lpBand->rcGripper.left = lpBand->rcBand.left + 3; | |
| lpBand->rcGripper.right = lpBand->rcBand.right - 3; | |
| lpBand->rcGripper.top = lpBand->rcBand.top + 3; | |
| lpBand->rcGripper.bottom = lpBand->rcGripper.top + 3; | |
| /* move caption rectangles */ | |
| OffsetRect32 (&lpBand->rcCapImage, 0, GRIPPER_WIDTH); | |
| OffsetRect32 (&lpBand->rcCapText, 0, GRIPPER_WIDTH); | |
| /* adjust child rectangle */ | |
| lpBand->rcChild.top += GRIPPER_WIDTH; | |
| } | |
| } | |
| } | |
| static VOID | |
| REBAR_Layout (WND *wndPtr, LPRECT32 lpRect) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| REBAR_BAND *lpBand; | |
| RECT32 rcClient; | |
| INT32 x, y, cx, cy; | |
| UINT32 i; | |
| if (lpRect) | |
| rcClient = *lpRect; | |
| else | |
| GetClientRect32 (wndPtr->hwndSelf, &rcClient); | |
| x = 0; | |
| y = 0; | |
| if (wndPtr->dwStyle & CCS_VERT) { | |
| cx = 20; /* FIXME: fixed height */ | |
| cy = rcClient.bottom - rcClient.top; | |
| } | |
| else { | |
| cx = rcClient.right - rcClient.left; | |
| cy = 20; /* FIXME: fixed height */ | |
| } | |
| for (i = 0; i < infoPtr->uNumBands; i++) { | |
| lpBand = &infoPtr->bands[i]; | |
| if ((lpBand->fStyle & RBBS_HIDDEN) || | |
| ((wndPtr->dwStyle & CCS_VERT) && (lpBand->fStyle & RBBS_NOVERT))) | |
| continue; | |
| if (wndPtr->dwStyle & CCS_VERT) { | |
| if (lpBand->fStyle & RBBS_VARIABLEHEIGHT) | |
| cx = lpBand->cyMaxChild; | |
| else if (lpBand->fStyle & RBBIM_CHILDSIZE) | |
| cx = lpBand->cyMinChild; | |
| else | |
| cx = 20; /* FIXME */ | |
| lpBand->rcBand.left = x; | |
| lpBand->rcBand.right = x + cx; | |
| lpBand->rcBand.top = y; | |
| lpBand->rcBand.bottom = y + cy; | |
| lpBand->uMinHeight = cx; | |
| } | |
| else { | |
| if (lpBand->fStyle & RBBS_VARIABLEHEIGHT) | |
| cy = lpBand->cyMaxChild; | |
| else if (lpBand->fStyle & RBBIM_CHILDSIZE) | |
| cy = lpBand->cyMinChild; | |
| else | |
| cy = 20; /* FIXME */ | |
| lpBand->rcBand.left = x; | |
| lpBand->rcBand.right = x + cx; | |
| lpBand->rcBand.top = y; | |
| lpBand->rcBand.bottom = y + cy; | |
| lpBand->uMinHeight = cy; | |
| } | |
| if (wndPtr->dwStyle & CCS_VERT) { | |
| REBAR_CalcVertBand (wndPtr, infoPtr, lpBand); | |
| x += lpBand->uMinHeight; | |
| } | |
| else { | |
| REBAR_CalcHorzBand (infoPtr, lpBand); | |
| y += lpBand->uMinHeight; | |
| } | |
| } | |
| if (wndPtr->dwStyle & CCS_VERT) { | |
| infoPtr->calcSize.cx = x; | |
| infoPtr->calcSize.cy = rcClient.bottom - rcClient.top; | |
| } | |
| else { | |
| infoPtr->calcSize.cx = rcClient.right - rcClient.left; | |
| infoPtr->calcSize.cy = y; | |
| } | |
| } | |
| static VOID | |
| REBAR_ForceResize (WND *wndPtr) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| RECT32 rc; | |
| TRACE (rebar, " to [%d x %d]!\n", | |
| infoPtr->calcSize.cx, infoPtr->calcSize.cy); | |
| infoPtr->bAutoResize = TRUE; | |
| rc.left = 0; | |
| rc.top = 0; | |
| rc.right = infoPtr->calcSize.cx; | |
| rc.bottom = infoPtr->calcSize.cy; | |
| if (wndPtr->dwStyle & WS_BORDER) { | |
| InflateRect32 (&rc, sysMetrics[SM_CXEDGE], sysMetrics[SM_CYEDGE]); | |
| } | |
| SetWindowPos32 (wndPtr->hwndSelf, 0, 0, 0, | |
| rc.right - rc.left, rc.bottom - rc.top, | |
| SWP_NOMOVE | SWP_NOZORDER | SWP_SHOWWINDOW); | |
| } | |
| static VOID | |
| REBAR_MoveChildWindows (WND *wndPtr) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| REBAR_BAND *lpBand; | |
| UINT32 i; | |
| for (i = 0; i < infoPtr->uNumBands; i++) { | |
| lpBand = &infoPtr->bands[i]; | |
| if (lpBand->fStyle & RBBS_HIDDEN) | |
| continue; | |
| if (lpBand->hwndChild) { | |
| TRACE (rebar, "hwndChild = %x\n", lpBand->hwndChild); | |
| if (WIDGETS_IsControl32 (WIN_FindWndPtr(lpBand->hwndChild), BIC32_COMBO)) { | |
| INT32 nEditHeight, yPos; | |
| RECT32 rc; | |
| /* special placement code for combo box */ | |
| /* get size of edit line */ | |
| GetWindowRect32 (lpBand->hwndChild, &rc); | |
| nEditHeight = rc.bottom - rc.top; | |
| yPos = (lpBand->rcChild.bottom + lpBand->rcChild.top - nEditHeight)/2; | |
| /* center combo box inside child area */ | |
| SetWindowPos32 (lpBand->hwndChild, HWND_TOP, | |
| lpBand->rcChild.left, /*lpBand->rcChild.top*/ yPos, | |
| lpBand->rcChild.right - lpBand->rcChild.left, | |
| nEditHeight, | |
| SWP_SHOWWINDOW); | |
| } | |
| #if 0 | |
| else if () { | |
| /* special placement code for extended combo box */ | |
| } | |
| #endif | |
| else { | |
| SetWindowPos32 (lpBand->hwndChild, HWND_TOP, | |
| lpBand->rcChild.left, lpBand->rcChild.top, | |
| lpBand->rcChild.right - lpBand->rcChild.left, | |
| lpBand->rcChild.bottom - lpBand->rcChild.top, | |
| SWP_SHOWWINDOW); | |
| } | |
| } | |
| } | |
| } | |
| static void | |
| REBAR_InternalHitTest (WND *wndPtr, LPPOINT32 lpPt, UINT32 *pFlags, INT32 *pBand) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr(wndPtr); | |
| REBAR_BAND *lpBand; | |
| RECT32 rect; | |
| INT32 iCount; | |
| GetClientRect32 (wndPtr->hwndSelf, &rect); | |
| *pFlags = RBHT_NOWHERE; | |
| if (PtInRect32 (&rect, *lpPt)) | |
| { | |
| if (infoPtr->uNumBands == 0) { | |
| *pFlags = RBHT_NOWHERE; | |
| if (pBand) | |
| *pBand = -1; | |
| TRACE (rebar, "NOWHERE\n"); | |
| return; | |
| } | |
| else { | |
| /* somewhere inside */ | |
| for (iCount = 0; iCount < infoPtr->uNumBands; iCount++) { | |
| lpBand = &infoPtr->bands[iCount]; | |
| if (PtInRect32 (&lpBand->rcBand, *lpPt)) { | |
| if (pBand) | |
| *pBand = iCount; | |
| if (PtInRect32 (&lpBand->rcGripper, *lpPt)) { | |
| *pFlags = RBHT_GRABBER; | |
| TRACE (rebar, "ON GRABBER %d\n", iCount); | |
| return; | |
| } | |
| else if (PtInRect32 (&lpBand->rcCapImage, *lpPt)) { | |
| *pFlags = RBHT_CAPTION; | |
| TRACE (rebar, "ON CAPTION %d\n", iCount); | |
| return; | |
| } | |
| else if (PtInRect32 (&lpBand->rcCapText, *lpPt)) { | |
| *pFlags = RBHT_CAPTION; | |
| TRACE (rebar, "ON CAPTION %d\n", iCount); | |
| return; | |
| } | |
| else if (PtInRect32 (&lpBand->rcChild, *lpPt)) { | |
| *pFlags = RBHT_CLIENT; | |
| TRACE (rebar, "ON CLIENT %d\n", iCount); | |
| return; | |
| } | |
| else { | |
| *pFlags = RBHT_NOWHERE; | |
| TRACE (rebar, "NOWHERE %d\n", iCount); | |
| return; | |
| } | |
| } | |
| } | |
| *pFlags = RBHT_NOWHERE; | |
| if (pBand) | |
| *pBand = -1; | |
| TRACE (rebar, "NOWHERE\n"); | |
| return; | |
| } | |
| } | |
| else { | |
| *pFlags = RBHT_NOWHERE; | |
| if (pBand) | |
| *pBand = -1; | |
| TRACE (rebar, "NOWHERE\n"); | |
| return; | |
| } | |
| TRACE (rebar, "flags=0x%X\n", *pFlags); | |
| return; | |
| } | |
| /* << REBAR_BeginDrag >> */ | |
| static LRESULT | |
| REBAR_DeleteBand (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| UINT32 uBand = (UINT32)wParam; | |
| if (uBand >= infoPtr->uNumBands) | |
| return FALSE; | |
| TRACE (rebar, "deleting band %u!\n", uBand); | |
| if (infoPtr->uNumBands == 1) { | |
| TRACE (rebar, " simple delete!\n"); | |
| COMCTL32_Free (infoPtr->bands); | |
| infoPtr->bands = NULL; | |
| infoPtr->uNumBands = 0; | |
| } | |
| else { | |
| REBAR_BAND *oldBands = infoPtr->bands; | |
| TRACE(rebar, "complex delete! [uBand=%u]\n", uBand); | |
| infoPtr->uNumBands--; | |
| infoPtr->bands = COMCTL32_Alloc (sizeof (REBAR_BAND) * infoPtr->uNumBands); | |
| if (uBand > 0) { | |
| memcpy (&infoPtr->bands[0], &oldBands[0], | |
| uBand * sizeof(REBAR_BAND)); | |
| } | |
| if (uBand < infoPtr->uNumBands) { | |
| memcpy (&infoPtr->bands[uBand], &oldBands[uBand+1], | |
| (infoPtr->uNumBands - uBand) * sizeof(REBAR_BAND)); | |
| } | |
| COMCTL32_Free (oldBands); | |
| } | |
| REBAR_Layout (wndPtr, NULL); | |
| REBAR_ForceResize (wndPtr); | |
| REBAR_MoveChildWindows (wndPtr); | |
| return TRUE; | |
| } | |
| /* << REBAR_DragMove >> */ | |
| /* << REBAR_EndDrag >> */ | |
| static LRESULT | |
| REBAR_GetBandBorders (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| /* LPRECT32 lpRect = (LPRECT32)lParam; */ | |
| REBAR_BAND *lpBand; | |
| if (!lParam) | |
| return 0; | |
| if ((UINT32)wParam >= infoPtr->uNumBands) | |
| return 0; | |
| lpBand = &infoPtr->bands[(UINT32)wParam]; | |
| if (wndPtr->dwStyle & RBS_BANDBORDERS) { | |
| } | |
| else { | |
| } | |
| return 0; | |
| } | |
| __inline__ static LRESULT | |
| REBAR_GetBandCount (WND *wndPtr) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| TRACE (rebar, "band count %u!\n", infoPtr->uNumBands); | |
| return infoPtr->uNumBands; | |
| } | |
| static LRESULT | |
| REBAR_GetBandInfo32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| LPREBARBANDINFO32A lprbbi = (LPREBARBANDINFO32A)lParam; | |
| REBAR_BAND *lpBand; | |
| if (lprbbi == NULL) | |
| return FALSE; | |
| if (lprbbi->cbSize < REBARBANDINFO_V3_SIZE32A) | |
| return FALSE; | |
| if ((UINT32)wParam >= infoPtr->uNumBands) | |
| return FALSE; | |
| TRACE (rebar, "index %u\n", (UINT32)wParam); | |
| /* copy band information */ | |
| lpBand = &infoPtr->bands[(UINT32)wParam]; | |
| if (lprbbi->fMask & RBBIM_STYLE) | |
| lprbbi->fStyle = lpBand->fStyle; | |
| if (lprbbi->fMask & RBBIM_COLORS) { | |
| lprbbi->clrFore = lpBand->clrFore; | |
| lprbbi->clrBack = lpBand->clrBack; | |
| } | |
| if ((lprbbi->fMask & RBBIM_TEXT) && | |
| (lprbbi->lpText) && (lpBand->lpText)) { | |
| lstrcpynWtoA (lprbbi->lpText, lpBand->lpText, lprbbi->cch); | |
| } | |
| if (lprbbi->fMask & RBBIM_IMAGE) | |
| lprbbi->iImage = lpBand->iImage; | |
| if (lprbbi->fMask & RBBIM_CHILD) | |
| lprbbi->hwndChild = lpBand->hwndChild; | |
| if (lprbbi->fMask & RBBIM_CHILDSIZE) { | |
| lprbbi->cxMinChild = lpBand->cxMinChild; | |
| lprbbi->cyMinChild = lpBand->cyMinChild; | |
| lprbbi->cyMaxChild = lpBand->cyMaxChild; | |
| lprbbi->cyChild = lpBand->cyChild; | |
| lprbbi->cyIntegral = lpBand->cyIntegral; | |
| } | |
| if (lprbbi->fMask & RBBIM_SIZE) | |
| lprbbi->cx = lpBand->cx; | |
| if (lprbbi->fMask & RBBIM_BACKGROUND) | |
| lprbbi->hbmBack = lpBand->hbmBack; | |
| if (lprbbi->fMask & RBBIM_ID) | |
| lprbbi->wID = lpBand->wID; | |
| /* check for additional data */ | |
| if (lprbbi->cbSize >= sizeof (REBARBANDINFO32A)) { | |
| if (lprbbi->fMask & RBBIM_IDEALSIZE) | |
| lprbbi->cxIdeal = lpBand->cxIdeal; | |
| if (lprbbi->fMask & RBBIM_LPARAM) | |
| lprbbi->lParam = lpBand->lParam; | |
| if (lprbbi->fMask & RBBIM_HEADERSIZE) | |
| lprbbi->cxHeader = lpBand->cxHeader; | |
| } | |
| return TRUE; | |
| } | |
| static LRESULT | |
| REBAR_GetBandInfo32W (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| LPREBARBANDINFO32W lprbbi = (LPREBARBANDINFO32W)lParam; | |
| REBAR_BAND *lpBand; | |
| if (lprbbi == NULL) | |
| return FALSE; | |
| if (lprbbi->cbSize < REBARBANDINFO_V3_SIZE32W) | |
| return FALSE; | |
| if ((UINT32)wParam >= infoPtr->uNumBands) | |
| return FALSE; | |
| TRACE (rebar, "index %u\n", (UINT32)wParam); | |
| /* copy band information */ | |
| lpBand = &infoPtr->bands[(UINT32)wParam]; | |
| if (lprbbi->fMask & RBBIM_STYLE) | |
| lprbbi->fStyle = lpBand->fStyle; | |
| if (lprbbi->fMask & RBBIM_COLORS) { | |
| lprbbi->clrFore = lpBand->clrFore; | |
| lprbbi->clrBack = lpBand->clrBack; | |
| } | |
| if ((lprbbi->fMask & RBBIM_TEXT) && | |
| (lprbbi->lpText) && (lpBand->lpText)) { | |
| lstrcpyn32W (lprbbi->lpText, lpBand->lpText, lprbbi->cch); | |
| } | |
| if (lprbbi->fMask & RBBIM_IMAGE) | |
| lprbbi->iImage = lpBand->iImage; | |
| if (lprbbi->fMask & RBBIM_CHILD) | |
| lprbbi->hwndChild = lpBand->hwndChild; | |
| if (lprbbi->fMask & RBBIM_CHILDSIZE) { | |
| lprbbi->cxMinChild = lpBand->cxMinChild; | |
| lprbbi->cyMinChild = lpBand->cyMinChild; | |
| lprbbi->cyMaxChild = lpBand->cyMaxChild; | |
| lprbbi->cyChild = lpBand->cyChild; | |
| lprbbi->cyIntegral = lpBand->cyIntegral; | |
| } | |
| if (lprbbi->fMask & RBBIM_SIZE) | |
| lprbbi->cx = lpBand->cx; | |
| if (lprbbi->fMask & RBBIM_BACKGROUND) | |
| lprbbi->hbmBack = lpBand->hbmBack; | |
| if (lprbbi->fMask & RBBIM_ID) | |
| lprbbi->wID = lpBand->wID; | |
| /* check for additional data */ | |
| if (lprbbi->cbSize >= sizeof (REBARBANDINFO32A)) { | |
| if (lprbbi->fMask & RBBIM_IDEALSIZE) | |
| lprbbi->cxIdeal = lpBand->cxIdeal; | |
| if (lprbbi->fMask & RBBIM_LPARAM) | |
| lprbbi->lParam = lpBand->lParam; | |
| if (lprbbi->fMask & RBBIM_HEADERSIZE) | |
| lprbbi->cxHeader = lpBand->cxHeader; | |
| } | |
| return TRUE; | |
| } | |
| static LRESULT | |
| REBAR_GetBarHeight (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| INT32 nHeight; | |
| REBAR_Layout (wndPtr, NULL); | |
| nHeight = infoPtr->calcSize.cy; | |
| if (wndPtr->dwStyle & WS_BORDER) | |
| nHeight += (2 * sysMetrics[SM_CYEDGE]); | |
| FIXME (rebar, "height = %d\n", nHeight); | |
| return nHeight; | |
| } | |
| static LRESULT | |
| REBAR_GetBarInfo (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| LPREBARINFO lpInfo = (LPREBARINFO)lParam; | |
| if (lpInfo == NULL) | |
| return FALSE; | |
| if (lpInfo->cbSize < sizeof (REBARINFO)) | |
| return FALSE; | |
| TRACE (rebar, "getting bar info!\n"); | |
| if (infoPtr->himl) { | |
| lpInfo->himl = infoPtr->himl; | |
| lpInfo->fMask |= RBIM_IMAGELIST; | |
| } | |
| return TRUE; | |
| } | |
| __inline__ static LRESULT | |
| REBAR_GetBkColor (WND *wndPtr) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| TRACE (rebar, "background color 0x%06lx!\n", infoPtr->clrBk); | |
| return infoPtr->clrBk; | |
| } | |
| /* << REBAR_GetColorScheme >> */ | |
| /* << REBAR_GetDropTarget >> */ | |
| static LRESULT | |
| REBAR_GetPalette (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| FIXME (rebar, "empty stub!\n"); | |
| return 0; | |
| } | |
| static LRESULT | |
| REBAR_GetRect (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| INT32 iBand = (INT32)wParam; | |
| LPRECT32 lprc = (LPRECT32)lParam; | |
| REBAR_BAND *lpBand; | |
| if ((iBand < 0) && ((UINT32)iBand >= infoPtr->uNumBands)) | |
| return FALSE; | |
| if (!lprc) | |
| return FALSE; | |
| TRACE (rebar, "band %d\n", iBand); | |
| lpBand = &infoPtr->bands[iBand]; | |
| CopyRect32 (lprc, &lpBand->rcBand); | |
| /* | |
| lprc->left = lpBand->rcBand.left; | |
| lprc->top = lpBand->rcBand.top; | |
| lprc->right = lpBand->rcBand.right; | |
| lprc->bottom = lpBand->rcBand.bottom; | |
| */ | |
| return TRUE; | |
| } | |
| __inline__ static LRESULT | |
| REBAR_GetRowCount (WND *wndPtr) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| FIXME (rebar, "%u : semi stub!\n", infoPtr->uNumBands); | |
| return infoPtr->uNumBands; | |
| } | |
| static LRESULT | |
| REBAR_GetRowHeight (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| /* REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); */ | |
| FIXME (rebar, "-- height = 20: semi stub!\n"); | |
| return 20; | |
| } | |
| __inline__ static LRESULT | |
| REBAR_GetTextColor (WND *wndPtr) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| TRACE (rebar, "text color 0x%06lx!\n", infoPtr->clrText); | |
| return infoPtr->clrText; | |
| } | |
| __inline__ static LRESULT | |
| REBAR_GetToolTips (WND *wndPtr) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| return infoPtr->hwndToolTip; | |
| } | |
| __inline__ static LRESULT | |
| REBAR_GetUnicodeFormat (WND *wndPtr) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| return infoPtr->bUnicode; | |
| } | |
| static LRESULT | |
| REBAR_HitTest (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| /* REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); */ | |
| LPRBHITTESTINFO lprbht = (LPRBHITTESTINFO)lParam; | |
| if (!lprbht) | |
| return -1; | |
| REBAR_InternalHitTest (wndPtr, &lprbht->pt, | |
| &lprbht->flags, &lprbht->iBand); | |
| return lprbht->iBand; | |
| } | |
| static LRESULT | |
| REBAR_IdToIndex (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| UINT32 i; | |
| if (infoPtr == NULL) | |
| return -1; | |
| if (infoPtr->uNumBands < 1) | |
| return -1; | |
| TRACE (rebar, "id %u\n", (UINT32)wParam); | |
| for (i = 0; i < infoPtr->uNumBands; i++) { | |
| if (infoPtr->bands[i].wID == (UINT32)wParam) { | |
| TRACE (rebar, "band %u found!\n", i); | |
| return i; | |
| } | |
| } | |
| TRACE (rebar, "no band found!\n"); | |
| return -1; | |
| } | |
| static LRESULT | |
| REBAR_InsertBand32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| LPREBARBANDINFO32A lprbbi = (LPREBARBANDINFO32A)lParam; | |
| UINT32 uIndex = (UINT32)wParam; | |
| REBAR_BAND *lpBand; | |
| if (infoPtr == NULL) | |
| return FALSE; | |
| if (lprbbi == NULL) | |
| return FALSE; | |
| if (lprbbi->cbSize < REBARBANDINFO_V3_SIZE32A) | |
| return FALSE; | |
| TRACE (rebar, "insert band at %u!\n", uIndex); | |
| if (infoPtr->uNumBands == 0) { | |
| infoPtr->bands = (REBAR_BAND *)COMCTL32_Alloc (sizeof (REBAR_BAND)); | |
| uIndex = 0; | |
| } | |
| else { | |
| REBAR_BAND *oldBands = infoPtr->bands; | |
| infoPtr->bands = | |
| (REBAR_BAND *)COMCTL32_Alloc ((infoPtr->uNumBands+1)*sizeof(REBAR_BAND)); | |
| if (((INT32)uIndex == -1) || (uIndex > infoPtr->uNumBands)) | |
| uIndex = infoPtr->uNumBands; | |
| /* pre insert copy */ | |
| if (uIndex > 0) { | |
| memcpy (&infoPtr->bands[0], &oldBands[0], | |
| uIndex * sizeof(REBAR_BAND)); | |
| } | |
| /* post copy */ | |
| if (uIndex < infoPtr->uNumBands - 1) { | |
| memcpy (&infoPtr->bands[uIndex+1], &oldBands[uIndex], | |
| (infoPtr->uNumBands - uIndex - 1) * sizeof(REBAR_BAND)); | |
| } | |
| COMCTL32_Free (oldBands); | |
| } | |
| infoPtr->uNumBands++; | |
| TRACE (rebar, "index %u!\n", uIndex); | |
| /* initialize band (infoPtr->bands[uIndex])*/ | |
| lpBand = &infoPtr->bands[uIndex]; | |
| if (lprbbi->fMask & RBBIM_STYLE) | |
| lpBand->fStyle = lprbbi->fStyle; | |
| if (lprbbi->fMask & RBBIM_COLORS) { | |
| lpBand->clrFore = lprbbi->clrFore; | |
| lpBand->clrBack = lprbbi->clrBack; | |
| } | |
| else { | |
| lpBand->clrFore = CLR_NONE; | |
| lpBand->clrBack = CLR_NONE; | |
| } | |
| if ((lprbbi->fMask & RBBIM_TEXT) && (lprbbi->lpText)) { | |
| INT32 len = lstrlen32A (lprbbi->lpText); | |
| if (len > 0) { | |
| lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR)); | |
| lstrcpyAtoW (lpBand->lpText, lprbbi->lpText); | |
| } | |
| } | |
| if (lprbbi->fMask & RBBIM_IMAGE) | |
| lpBand->iImage = lprbbi->iImage; | |
| else | |
| lpBand->iImage = -1; | |
| if (lprbbi->fMask & RBBIM_CHILD) { | |
| TRACE (rebar, "hwndChild = %x\n", lprbbi->hwndChild); | |
| lpBand->hwndChild = lprbbi->hwndChild; | |
| lpBand->hwndPrevParent = | |
| SetParent32 (lpBand->hwndChild, wndPtr->hwndSelf); | |
| } | |
| if (lprbbi->fMask & RBBIM_CHILDSIZE) { | |
| lpBand->cxMinChild = lprbbi->cxMinChild; | |
| lpBand->cyMinChild = lprbbi->cyMinChild; | |
| lpBand->cyMaxChild = lprbbi->cyMaxChild; | |
| lpBand->cyChild = lprbbi->cyChild; | |
| lpBand->cyIntegral = lprbbi->cyIntegral; | |
| } | |
| else { | |
| lpBand->cxMinChild = -1; | |
| lpBand->cyMinChild = -1; | |
| lpBand->cyMaxChild = -1; | |
| lpBand->cyChild = -1; | |
| lpBand->cyIntegral = -1; | |
| } | |
| if (lprbbi->fMask & RBBIM_SIZE) | |
| lpBand->cx = lprbbi->cx; | |
| else | |
| lpBand->cx = -1; | |
| if (lprbbi->fMask & RBBIM_BACKGROUND) | |
| lpBand->hbmBack = lprbbi->hbmBack; | |
| if (lprbbi->fMask & RBBIM_ID) | |
| lpBand->wID = lprbbi->wID; | |
| /* check for additional data */ | |
| if (lprbbi->cbSize >= sizeof (REBARBANDINFO32A)) { | |
| if (lprbbi->fMask & RBBIM_IDEALSIZE) | |
| lpBand->cxIdeal = lprbbi->cxIdeal; | |
| if (lprbbi->fMask & RBBIM_LPARAM) | |
| lpBand->lParam = lprbbi->lParam; | |
| if (lprbbi->fMask & RBBIM_HEADERSIZE) | |
| lpBand->cxHeader = lprbbi->cxHeader; | |
| } | |
| REBAR_Layout (wndPtr, NULL); | |
| REBAR_ForceResize (wndPtr); | |
| REBAR_MoveChildWindows (wndPtr); | |
| return TRUE; | |
| } | |
| static LRESULT | |
| REBAR_InsertBand32W (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| LPREBARBANDINFO32W lprbbi = (LPREBARBANDINFO32W)lParam; | |
| UINT32 uIndex = (UINT32)wParam; | |
| REBAR_BAND *lpBand; | |
| if (infoPtr == NULL) | |
| return FALSE; | |
| if (lprbbi == NULL) | |
| return FALSE; | |
| if (lprbbi->cbSize < REBARBANDINFO_V3_SIZE32W) | |
| return FALSE; | |
| TRACE (rebar, "insert band at %u!\n", uIndex); | |
| if (infoPtr->uNumBands == 0) { | |
| infoPtr->bands = (REBAR_BAND *)COMCTL32_Alloc (sizeof (REBAR_BAND)); | |
| uIndex = 0; | |
| } | |
| else { | |
| REBAR_BAND *oldBands = infoPtr->bands; | |
| infoPtr->bands = | |
| (REBAR_BAND *)COMCTL32_Alloc ((infoPtr->uNumBands+1)*sizeof(REBAR_BAND)); | |
| if (((INT32)uIndex == -1) || (uIndex > infoPtr->uNumBands)) | |
| uIndex = infoPtr->uNumBands; | |
| /* pre insert copy */ | |
| if (uIndex > 0) { | |
| memcpy (&infoPtr->bands[0], &oldBands[0], | |
| uIndex * sizeof(REBAR_BAND)); | |
| } | |
| /* post copy */ | |
| if (uIndex < infoPtr->uNumBands - 1) { | |
| memcpy (&infoPtr->bands[uIndex+1], &oldBands[uIndex], | |
| (infoPtr->uNumBands - uIndex - 1) * sizeof(REBAR_BAND)); | |
| } | |
| COMCTL32_Free (oldBands); | |
| } | |
| infoPtr->uNumBands++; | |
| TRACE (rebar, "index %u!\n", uIndex); | |
| /* initialize band (infoPtr->bands[uIndex])*/ | |
| lpBand = &infoPtr->bands[uIndex]; | |
| if (lprbbi->fMask & RBBIM_STYLE) | |
| lpBand->fStyle = lprbbi->fStyle; | |
| if (lprbbi->fMask & RBBIM_COLORS) { | |
| lpBand->clrFore = lprbbi->clrFore; | |
| lpBand->clrBack = lprbbi->clrBack; | |
| } | |
| else { | |
| lpBand->clrFore = CLR_NONE; | |
| lpBand->clrBack = CLR_NONE; | |
| } | |
| if ((lprbbi->fMask & RBBIM_TEXT) && (lprbbi->lpText)) { | |
| INT32 len = lstrlen32W (lprbbi->lpText); | |
| if (len > 0) { | |
| lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR)); | |
| lstrcpy32W (lpBand->lpText, lprbbi->lpText); | |
| } | |
| } | |
| if (lprbbi->fMask & RBBIM_IMAGE) | |
| lpBand->iImage = lprbbi->iImage; | |
| else | |
| lpBand->iImage = -1; | |
| if (lprbbi->fMask & RBBIM_CHILD) { | |
| TRACE (rebar, "hwndChild = %x\n", lprbbi->hwndChild); | |
| lpBand->hwndChild = lprbbi->hwndChild; | |
| lpBand->hwndPrevParent = | |
| SetParent32 (lpBand->hwndChild, wndPtr->hwndSelf); | |
| } | |
| if (lprbbi->fMask & RBBIM_CHILDSIZE) { | |
| lpBand->cxMinChild = lprbbi->cxMinChild; | |
| lpBand->cyMinChild = lprbbi->cyMinChild; | |
| lpBand->cyMaxChild = lprbbi->cyMaxChild; | |
| lpBand->cyChild = lprbbi->cyChild; | |
| lpBand->cyIntegral = lprbbi->cyIntegral; | |
| } | |
| else { | |
| lpBand->cxMinChild = -1; | |
| lpBand->cyMinChild = -1; | |
| lpBand->cyMaxChild = -1; | |
| lpBand->cyChild = -1; | |
| lpBand->cyIntegral = -1; | |
| } | |
| if (lprbbi->fMask & RBBIM_SIZE) | |
| lpBand->cx = lprbbi->cx; | |
| else | |
| lpBand->cx = -1; | |
| if (lprbbi->fMask & RBBIM_BACKGROUND) | |
| lpBand->hbmBack = lprbbi->hbmBack; | |
| if (lprbbi->fMask & RBBIM_ID) | |
| lpBand->wID = lprbbi->wID; | |
| /* check for additional data */ | |
| if (lprbbi->cbSize >= sizeof (REBARBANDINFO32W)) { | |
| if (lprbbi->fMask & RBBIM_IDEALSIZE) | |
| lpBand->cxIdeal = lprbbi->cxIdeal; | |
| if (lprbbi->fMask & RBBIM_LPARAM) | |
| lpBand->lParam = lprbbi->lParam; | |
| if (lprbbi->fMask & RBBIM_HEADERSIZE) | |
| lpBand->cxHeader = lprbbi->cxHeader; | |
| } | |
| REBAR_Layout (wndPtr, NULL); | |
| REBAR_ForceResize (wndPtr); | |
| REBAR_MoveChildWindows (wndPtr); | |
| return TRUE; | |
| } | |
| static LRESULT | |
| REBAR_MaximizeBand (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| /* REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); */ | |
| FIXME (rebar, "(uBand = %u fIdeal = %s)\n", | |
| (UINT32)wParam, lParam ? "TRUE" : "FALSE"); | |
| return 0; | |
| } | |
| static LRESULT | |
| REBAR_MinimizeBand (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| /* REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); */ | |
| FIXME (rebar, "(uBand = %u)\n", (UINT32)wParam); | |
| return 0; | |
| } | |
| static LRESULT | |
| REBAR_MoveBand (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| /* REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); */ | |
| FIXME (rebar, "(iFrom = %u iTof = %u)\n", | |
| (UINT32)wParam, (UINT32)lParam); | |
| return FALSE; | |
| } | |
| static LRESULT | |
| REBAR_SetBandInfo32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| LPREBARBANDINFO32A lprbbi = (LPREBARBANDINFO32A)lParam; | |
| REBAR_BAND *lpBand; | |
| if (lprbbi == NULL) | |
| return FALSE; | |
| if (lprbbi->cbSize < REBARBANDINFO_V3_SIZE32A) | |
| return FALSE; | |
| if ((UINT32)wParam >= infoPtr->uNumBands) | |
| return FALSE; | |
| TRACE (rebar, "index %u\n", (UINT32)wParam); | |
| /* set band information */ | |
| lpBand = &infoPtr->bands[(UINT32)wParam]; | |
| if (lprbbi->fMask & RBBIM_STYLE) | |
| lpBand->fStyle = lprbbi->fStyle; | |
| if (lprbbi->fMask & RBBIM_COLORS) { | |
| lpBand->clrFore = lprbbi->clrFore; | |
| lpBand->clrBack = lprbbi->clrBack; | |
| } | |
| if (lprbbi->fMask & RBBIM_TEXT) { | |
| if (lpBand->lpText) { | |
| COMCTL32_Free (lpBand->lpText); | |
| lpBand->lpText = NULL; | |
| } | |
| if (lprbbi->lpText) { | |
| INT32 len = lstrlen32A (lprbbi->lpText); | |
| lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR)); | |
| lstrcpyAtoW (lpBand->lpText, lprbbi->lpText); | |
| } | |
| } | |
| if (lprbbi->fMask & RBBIM_IMAGE) | |
| lpBand->iImage = lprbbi->iImage; | |
| if (lprbbi->fMask & RBBIM_CHILD) { | |
| if (lprbbi->hwndChild) { | |
| lpBand->hwndChild = lprbbi->hwndChild; | |
| lpBand->hwndPrevParent = | |
| SetParent32 (lpBand->hwndChild, wndPtr->hwndSelf); | |
| } | |
| else { | |
| TRACE (rebar, "child: 0x%x prev parent: 0x%x\n", | |
| lpBand->hwndChild, lpBand->hwndPrevParent); | |
| lpBand->hwndChild = 0; | |
| lpBand->hwndPrevParent = 0; | |
| } | |
| } | |
| if (lprbbi->fMask & RBBIM_CHILDSIZE) { | |
| lpBand->cxMinChild = lprbbi->cxMinChild; | |
| lpBand->cyMinChild = lprbbi->cyMinChild; | |
| lpBand->cyMaxChild = lprbbi->cyMaxChild; | |
| lpBand->cyChild = lprbbi->cyChild; | |
| lpBand->cyIntegral = lprbbi->cyIntegral; | |
| } | |
| if (lprbbi->fMask & RBBIM_SIZE) | |
| lpBand->cx = lprbbi->cx; | |
| if (lprbbi->fMask & RBBIM_BACKGROUND) | |
| lpBand->hbmBack = lprbbi->hbmBack; | |
| if (lprbbi->fMask & RBBIM_ID) | |
| lpBand->wID = lprbbi->wID; | |
| /* check for additional data */ | |
| if (lprbbi->cbSize >= sizeof (REBARBANDINFO32A)) { | |
| if (lprbbi->fMask & RBBIM_IDEALSIZE) | |
| lpBand->cxIdeal = lprbbi->cxIdeal; | |
| if (lprbbi->fMask & RBBIM_LPARAM) | |
| lpBand->lParam = lprbbi->lParam; | |
| if (lprbbi->fMask & RBBIM_HEADERSIZE) | |
| lpBand->cxHeader = lprbbi->cxHeader; | |
| } | |
| REBAR_Layout (wndPtr, NULL); | |
| REBAR_ForceResize (wndPtr); | |
| REBAR_MoveChildWindows (wndPtr); | |
| return TRUE; | |
| } | |
| static LRESULT | |
| REBAR_SetBandInfo32W (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| LPREBARBANDINFO32W lprbbi = (LPREBARBANDINFO32W)lParam; | |
| REBAR_BAND *lpBand; | |
| if (lprbbi == NULL) | |
| return FALSE; | |
| if (lprbbi->cbSize < REBARBANDINFO_V3_SIZE32W) | |
| return FALSE; | |
| if ((UINT32)wParam >= infoPtr->uNumBands) | |
| return FALSE; | |
| TRACE (rebar, "index %u\n", (UINT32)wParam); | |
| /* set band information */ | |
| lpBand = &infoPtr->bands[(UINT32)wParam]; | |
| if (lprbbi->fMask & RBBIM_STYLE) | |
| lpBand->fStyle = lprbbi->fStyle; | |
| if (lprbbi->fMask & RBBIM_COLORS) { | |
| lpBand->clrFore = lprbbi->clrFore; | |
| lpBand->clrBack = lprbbi->clrBack; | |
| } | |
| if (lprbbi->fMask & RBBIM_TEXT) { | |
| if (lpBand->lpText) { | |
| COMCTL32_Free (lpBand->lpText); | |
| lpBand->lpText = NULL; | |
| } | |
| if (lprbbi->lpText) { | |
| INT32 len = lstrlen32W (lprbbi->lpText); | |
| lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR)); | |
| lstrcpy32W (lpBand->lpText, lprbbi->lpText); | |
| } | |
| } | |
| if (lprbbi->fMask & RBBIM_IMAGE) | |
| lpBand->iImage = lprbbi->iImage; | |
| if (lprbbi->fMask & RBBIM_CHILD) { | |
| if (lprbbi->hwndChild) { | |
| lpBand->hwndChild = lprbbi->hwndChild; | |
| lpBand->hwndPrevParent = | |
| SetParent32 (lpBand->hwndChild, wndPtr->hwndSelf); | |
| } | |
| else { | |
| TRACE (rebar, "child: 0x%x prev parent: 0x%x\n", | |
| lpBand->hwndChild, lpBand->hwndPrevParent); | |
| lpBand->hwndChild = 0; | |
| lpBand->hwndPrevParent = 0; | |
| } | |
| } | |
| if (lprbbi->fMask & RBBIM_CHILDSIZE) { | |
| lpBand->cxMinChild = lprbbi->cxMinChild; | |
| lpBand->cyMinChild = lprbbi->cyMinChild; | |
| lpBand->cyMaxChild = lprbbi->cyMaxChild; | |
| lpBand->cyChild = lprbbi->cyChild; | |
| lpBand->cyIntegral = lprbbi->cyIntegral; | |
| } | |
| if (lprbbi->fMask & RBBIM_SIZE) | |
| lpBand->cx = lprbbi->cx; | |
| if (lprbbi->fMask & RBBIM_BACKGROUND) | |
| lpBand->hbmBack = lprbbi->hbmBack; | |
| if (lprbbi->fMask & RBBIM_ID) | |
| lpBand->wID = lprbbi->wID; | |
| /* check for additional data */ | |
| if (lprbbi->cbSize >= sizeof (REBARBANDINFO32W)) { | |
| if (lprbbi->fMask & RBBIM_IDEALSIZE) | |
| lpBand->cxIdeal = lprbbi->cxIdeal; | |
| if (lprbbi->fMask & RBBIM_LPARAM) | |
| lpBand->lParam = lprbbi->lParam; | |
| if (lprbbi->fMask & RBBIM_HEADERSIZE) | |
| lpBand->cxHeader = lprbbi->cxHeader; | |
| } | |
| REBAR_Layout (wndPtr, NULL); | |
| REBAR_ForceResize (wndPtr); | |
| REBAR_MoveChildWindows (wndPtr); | |
| return TRUE; | |
| } | |
| static LRESULT | |
| REBAR_SetBarInfo (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| LPREBARINFO lpInfo = (LPREBARINFO)lParam; | |
| if (lpInfo == NULL) | |
| return FALSE; | |
| if (lpInfo->cbSize < sizeof (REBARINFO)) | |
| return FALSE; | |
| TRACE (rebar, "setting bar info!\n"); | |
| if (lpInfo->fMask & RBIM_IMAGELIST) { | |
| infoPtr->himl = lpInfo->himl; | |
| if (infoPtr->himl) { | |
| ImageList_GetIconSize (infoPtr->himl, &infoPtr->imageSize.cx, | |
| &infoPtr->imageSize.cy); | |
| } | |
| else { | |
| infoPtr->imageSize.cx = 0; | |
| infoPtr->imageSize.cy = 0; | |
| } | |
| } | |
| return TRUE; | |
| } | |
| static LRESULT | |
| REBAR_SetBkColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| COLORREF clrTemp; | |
| clrTemp = infoPtr->clrBk; | |
| infoPtr->clrBk = (COLORREF)lParam; | |
| TRACE (rebar, "background color 0x%06lx!\n", infoPtr->clrBk); | |
| return clrTemp; | |
| } | |
| /* << REBAR_SetColorScheme >> */ | |
| /* << REBAR_SetPalette >> */ | |
| static LRESULT | |
| REBAR_SetParent (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| HWND32 hwndTemp = infoPtr->hwndNotify; | |
| infoPtr->hwndNotify = (HWND32)wParam; | |
| return (LRESULT)hwndTemp; | |
| } | |
| static LRESULT | |
| REBAR_SetTextColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| COLORREF clrTemp; | |
| clrTemp = infoPtr->clrText; | |
| infoPtr->clrText = (COLORREF)lParam; | |
| TRACE (rebar, "text color 0x%06lx!\n", infoPtr->clrText); | |
| return clrTemp; | |
| } | |
| /* << REBAR_SetTooltips >> */ | |
| __inline__ static LRESULT | |
| REBAR_SetUnicodeFormat (WND *wndPtr, WPARAM32 wParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| BOOL32 bTemp = infoPtr->bUnicode; | |
| infoPtr->bUnicode = (BOOL32)wParam; | |
| return bTemp; | |
| } | |
| static LRESULT | |
| REBAR_ShowBand (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| REBAR_BAND *lpBand; | |
| if (((INT32)wParam < 0) || ((INT32)wParam > infoPtr->uNumBands)) | |
| return FALSE; | |
| lpBand = &infoPtr->bands[(INT32)wParam]; | |
| if ((BOOL32)lParam) { | |
| TRACE (rebar, "show band %d\n", (INT32)wParam); | |
| lpBand->fStyle = lpBand->fStyle & ~RBBS_HIDDEN; | |
| if (IsWindow32 (lpBand->hwndChild)) | |
| ShowWindow32 (lpBand->hwndChild, SW_SHOW); | |
| } | |
| else { | |
| TRACE (rebar, "hide band %d\n", (INT32)wParam); | |
| lpBand->fStyle = lpBand->fStyle | RBBS_HIDDEN; | |
| if (IsWindow32 (lpBand->hwndChild)) | |
| ShowWindow32 (lpBand->hwndChild, SW_SHOW); | |
| } | |
| REBAR_Layout (wndPtr, NULL); | |
| REBAR_ForceResize (wndPtr); | |
| REBAR_MoveChildWindows (wndPtr); | |
| return TRUE; | |
| } | |
| static LRESULT | |
| REBAR_SizeToRect (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr (wndPtr); | |
| LPRECT32 lpRect = (LPRECT32)lParam; | |
| if (lpRect == NULL) | |
| return FALSE; | |
| FIXME (rebar, "layout change not implemented!\n"); | |
| FIXME (rebar, "[%d %d %d %d]\n", | |
| lpRect->left, lpRect->top, lpRect->right, lpRect->bottom); | |
| #if 0 | |
| SetWindowPos32 (wndPtr->hwndSelf, 0, lpRect->left, lpRect->top, | |
| lpRect->right - lpRect->left, lpRect->bottom - lpRect->top, | |
| SWP_NOZORDER); | |
| #endif | |
| infoPtr->calcSize.cx = lpRect->right - lpRect->left; | |
| infoPtr->calcSize.cy = lpRect->bottom - lpRect->top; | |
| REBAR_ForceResize (wndPtr); | |
| return TRUE; | |
| } | |
| static LRESULT | |
| REBAR_Create (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr; | |
| /* allocate memory for info structure */ | |
| infoPtr = (REBAR_INFO *)COMCTL32_Alloc (sizeof(REBAR_INFO)); | |
| wndPtr->wExtra[0] = (DWORD)infoPtr; | |
| if (infoPtr == NULL) { | |
| ERR (rebar, "could not allocate info memory!\n"); | |
| return 0; | |
| } | |
| if ((REBAR_INFO*)wndPtr->wExtra[0] != infoPtr) { | |
| ERR (rebar, "pointer assignment error!\n"); | |
| return 0; | |
| } | |
| /* initialize info structure */ | |
| infoPtr->clrBk = CLR_NONE; | |
| infoPtr->clrText = RGB(0, 0, 0); | |
| infoPtr->bAutoResize = FALSE; | |
| infoPtr->hcurArrow = LoadCursor32A (0, IDC_ARROW32A); | |
| infoPtr->hcurHorz = LoadCursor32A (0, IDC_SIZEWE32A); | |
| infoPtr->hcurVert = LoadCursor32A (0, IDC_SIZENS32A); | |
| infoPtr->hcurDrag = LoadCursor32A (0, IDC_SIZE32A); | |
| infoPtr->bUnicode = IsWindowUnicode (wndPtr->hwndSelf); | |
| if (wndPtr->dwStyle & RBS_AUTOSIZE) | |
| FIXME (rebar, "style RBS_AUTOSIZE set!\n"); | |
| #if 0 | |
| SendMessage32A (wndPtr->parent->hwndSelf, WM_NOTIFYFORMAT, | |
| (WPARAM32)wndPtr->hwndSelf, NF_QUERY); | |
| #endif | |
| TRACE (rebar, "created!\n"); | |
| return 0; | |
| } | |
| static LRESULT | |
| REBAR_Destroy (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr(wndPtr); | |
| REBAR_BAND *lpBand; | |
| INT32 i; | |
| /* free rebar bands */ | |
| if ((infoPtr->uNumBands > 0) && infoPtr->bands) { | |
| /* clean up each band */ | |
| for (i = 0; i < infoPtr->uNumBands; i++) { | |
| lpBand = &infoPtr->bands[i]; | |
| /* delete text strings */ | |
| if (lpBand->lpText) { | |
| COMCTL32_Free (lpBand->lpText); | |
| lpBand->lpText = NULL; | |
| } | |
| /* destroy child window */ | |
| DestroyWindow32 (lpBand->hwndChild); | |
| } | |
| /* free band array */ | |
| COMCTL32_Free (infoPtr->bands); | |
| infoPtr->bands = NULL; | |
| } | |
| DeleteObject32 (infoPtr->hcurArrow); | |
| DeleteObject32 (infoPtr->hcurHorz); | |
| DeleteObject32 (infoPtr->hcurVert); | |
| DeleteObject32 (infoPtr->hcurDrag); | |
| /* free rebar info data */ | |
| COMCTL32_Free (infoPtr); | |
| TRACE (rebar, "destroyed!\n"); | |
| return 0; | |
| } | |
| static LRESULT | |
| REBAR_GetFont (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr(wndPtr); | |
| return (LRESULT)infoPtr->hFont; | |
| } | |
| #if 0 | |
| static LRESULT | |
| REBAR_MouseMove (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr(wndPtr); | |
| return 0; | |
| } | |
| #endif | |
| __inline__ static LRESULT | |
| REBAR_NCCalcSize (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| if (wndPtr->dwStyle & WS_BORDER) { | |
| ((LPRECT32)lParam)->left += sysMetrics[SM_CXEDGE]; | |
| ((LPRECT32)lParam)->top += sysMetrics[SM_CYEDGE]; | |
| ((LPRECT32)lParam)->right -= sysMetrics[SM_CXEDGE]; | |
| ((LPRECT32)lParam)->bottom -= sysMetrics[SM_CYEDGE]; | |
| } | |
| return 0; | |
| } | |
| static LRESULT | |
| REBAR_NCPaint (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| HWND32 hwnd = wndPtr->hwndSelf; | |
| HDC32 hdc; | |
| if ( wndPtr->dwStyle & WS_MINIMIZE || | |
| !WIN_IsWindowDrawable( wndPtr, 0 )) return 0; /* Nothing to do */ | |
| DefWindowProc32A (hwnd, WM_NCPAINT, wParam, lParam); | |
| if (!(hdc = GetDCEx32( hwnd, 0, DCX_USESTYLE | DCX_WINDOW ))) return 0; | |
| if (ExcludeVisRect( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left, | |
| wndPtr->rectClient.top-wndPtr->rectWindow.top, | |
| wndPtr->rectClient.right-wndPtr->rectWindow.left, | |
| wndPtr->rectClient.bottom-wndPtr->rectWindow.top ) | |
| == NULLREGION){ | |
| ReleaseDC32( hwnd, hdc ); | |
| return 0; | |
| } | |
| if (!(wndPtr->flags & WIN_MANAGED) && (wndPtr->dwStyle & WS_BORDER)) | |
| DrawEdge32 (hdc, &wndPtr->rectWindow, EDGE_ETCHED, BF_RECT); | |
| ReleaseDC32( hwnd, hdc ); | |
| return 0; | |
| } | |
| static LRESULT | |
| REBAR_Paint (WND *wndPtr, WPARAM32 wParam) | |
| { | |
| HDC32 hdc; | |
| PAINTSTRUCT32 ps; | |
| hdc = wParam==0 ? BeginPaint32 (wndPtr->hwndSelf, &ps) : (HDC32)wParam; | |
| REBAR_Refresh (wndPtr, hdc); | |
| if (!wParam) | |
| EndPaint32 (wndPtr->hwndSelf, &ps); | |
| return 0; | |
| } | |
| static LRESULT | |
| REBAR_SetCursor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr(wndPtr); | |
| POINT32 pt; | |
| UINT32 flags; | |
| TRACE (rebar, "code=0x%X id=0x%X\n", LOWORD(lParam), HIWORD(lParam)); | |
| GetCursorPos32 (&pt); | |
| ScreenToClient32 (wndPtr->hwndSelf, &pt); | |
| REBAR_InternalHitTest (wndPtr, &pt, &flags, NULL); | |
| if (flags == RBHT_GRABBER) { | |
| if ((wndPtr->dwStyle & CCS_VERT) && | |
| !(wndPtr->dwStyle & RBS_VERTICALGRIPPER)) | |
| SetCursor32 (infoPtr->hcurVert); | |
| else | |
| SetCursor32 (infoPtr->hcurHorz); | |
| } | |
| else if (flags != RBHT_CLIENT) | |
| SetCursor32 (infoPtr->hcurArrow); | |
| return 0; | |
| } | |
| static LRESULT | |
| REBAR_SetFont (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr(wndPtr); | |
| /* TEXTMETRIC32A tm; */ | |
| HFONT32 hFont /*, hOldFont */; | |
| /* HDC32 hdc; */ | |
| infoPtr->hFont = (HFONT32)wParam; | |
| hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject32 (SYSTEM_FONT); | |
| /* | |
| hdc = GetDC32 (0); | |
| hOldFont = SelectObject32 (hdc, hFont); | |
| GetTextMetrics32A (hdc, &tm); | |
| infoPtr->nHeight = tm.tmHeight + VERT_BORDER; | |
| SelectObject32 (hdc, hOldFont); | |
| ReleaseDC32 (0, hdc); | |
| */ | |
| if (lParam) { | |
| /* | |
| REBAR_Layout (wndPtr); | |
| hdc = GetDC32 (wndPtr->hwndSelf); | |
| REBAR_Refresh (wndPtr, hdc); | |
| ReleaseDC32 (wndPtr->hwndSelf, hdc); | |
| */ | |
| } | |
| return 0; | |
| } | |
| static LRESULT | |
| REBAR_Size (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| REBAR_INFO *infoPtr = REBAR_GetInfoPtr(wndPtr); | |
| RECT32 rcParent; | |
| /* INT32 x, y, cx, cy; */ | |
| /* auto resize deadlock check */ | |
| if (infoPtr->bAutoResize) { | |
| infoPtr->bAutoResize = FALSE; | |
| return 0; | |
| } | |
| TRACE (rebar, "sizing rebar!\n"); | |
| /* get parent rectangle */ | |
| GetClientRect32 (GetParent32 (wndPtr->hwndSelf), &rcParent); | |
| /* | |
| REBAR_Layout (wndPtr, &rcParent); | |
| if (wndPtr->dwStyle & CCS_VERT) { | |
| if (wndPtr->dwStyle & CCS_LEFT == CCS_LEFT) { | |
| x = rcParent.left; | |
| y = rcParent.top; | |
| cx = infoPtr->calcSize.cx; | |
| cy = infoPtr->calcSize.cy; | |
| } | |
| else { | |
| x = rcParent.right - infoPtr->calcSize.cx; | |
| y = rcParent.top; | |
| cx = infoPtr->calcSize.cx; | |
| cy = infoPtr->calcSize.cy; | |
| } | |
| } | |
| else { | |
| if (wndPtr->dwStyle & CCS_TOP) { | |
| x = rcParent.left; | |
| y = rcParent.top; | |
| cx = infoPtr->calcSize.cx; | |
| cy = infoPtr->calcSize.cy; | |
| } | |
| else { | |
| x = rcParent.left; | |
| y = rcParent.bottom - infoPtr->calcSize.cy; | |
| cx = infoPtr->calcSize.cx; | |
| cy = infoPtr->calcSize.cy; | |
| } | |
| } | |
| SetWindowPos32 (wndPtr->hwndSelf, 0, x, y, cx, cy, | |
| SWP_NOZORDER | SWP_SHOWWINDOW); | |
| */ | |
| REBAR_Layout (wndPtr, NULL); | |
| REBAR_ForceResize (wndPtr); | |
| REBAR_MoveChildWindows (wndPtr); | |
| return 0; | |
| } | |
| LRESULT WINAPI | |
| REBAR_WindowProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| WND *wndPtr = WIN_FindWndPtr(hwnd); | |
| switch (uMsg) | |
| { | |
| /* case RB_BEGINDRAG: */ | |
| case RB_DELETEBAND: | |
| return REBAR_DeleteBand (wndPtr, wParam, lParam); | |
| /* case RB_DRAGMOVE: */ | |
| /* case RB_ENDDRAG: */ | |
| case RB_GETBANDBORDERS: | |
| return REBAR_GetBandBorders (wndPtr, wParam, lParam); | |
| case RB_GETBANDCOUNT: | |
| return REBAR_GetBandCount (wndPtr); | |
| /* case RB_GETBANDINFO32: */ /* outdated, just for compatibility */ | |
| case RB_GETBANDINFO32A: | |
| return REBAR_GetBandInfo32A (wndPtr, wParam, lParam); | |
| case RB_GETBANDINFO32W: | |
| return REBAR_GetBandInfo32W (wndPtr, wParam, lParam); | |
| case RB_GETBARHEIGHT: | |
| return REBAR_GetBarHeight (wndPtr, wParam, lParam); | |
| case RB_GETBARINFO: | |
| return REBAR_GetBarInfo (wndPtr, wParam, lParam); | |
| case RB_GETBKCOLOR: | |
| return REBAR_GetBkColor (wndPtr); | |
| /* case RB_GETCOLORSCHEME: */ | |
| /* case RB_GETDROPTARGET: */ | |
| case RB_GETPALETTE: | |
| return REBAR_GetPalette (wndPtr, wParam, lParam); | |
| case RB_GETRECT: | |
| return REBAR_GetRect (wndPtr, wParam, lParam); | |
| case RB_GETROWCOUNT: | |
| return REBAR_GetRowCount (wndPtr); | |
| case RB_GETROWHEIGHT: | |
| return REBAR_GetRowHeight (wndPtr, wParam, lParam); | |
| case RB_GETTEXTCOLOR: | |
| return REBAR_GetTextColor (wndPtr); | |
| case RB_GETTOOLTIPS: | |
| return REBAR_GetToolTips (wndPtr); | |
| case RB_GETUNICODEFORMAT: | |
| return REBAR_GetUnicodeFormat (wndPtr); | |
| case RB_HITTEST: | |
| return REBAR_HitTest (wndPtr, wParam, lParam); | |
| case RB_IDTOINDEX: | |
| return REBAR_IdToIndex (wndPtr, wParam, lParam); | |
| case RB_INSERTBAND32A: | |
| return REBAR_InsertBand32A (wndPtr, wParam, lParam); | |
| case RB_INSERTBAND32W: | |
| return REBAR_InsertBand32W (wndPtr, wParam, lParam); | |
| case RB_MAXIMIZEBAND: | |
| return REBAR_MaximizeBand (wndPtr, wParam, lParam); | |
| case RB_MINIMIZEBAND: | |
| return REBAR_MinimizeBand (wndPtr, wParam, lParam); | |
| case RB_MOVEBAND: | |
| return REBAR_MoveBand (wndPtr, wParam, lParam); | |
| case RB_SETBANDINFO32A: | |
| return REBAR_SetBandInfo32A (wndPtr, wParam, lParam); | |
| case RB_SETBANDINFO32W: | |
| return REBAR_SetBandInfo32W (wndPtr, wParam, lParam); | |
| case RB_SETBARINFO: | |
| return REBAR_SetBarInfo (wndPtr, wParam, lParam); | |
| case RB_SETBKCOLOR: | |
| return REBAR_SetBkColor (wndPtr, wParam, lParam); | |
| /* case RB_SETCOLORSCHEME: */ | |
| /* case RB_SETPALETTE: */ | |
| /* return REBAR_GetPalette (wndPtr, wParam, lParam); */ | |
| case RB_SETPARENT: | |
| return REBAR_SetParent (wndPtr, wParam, lParam); | |
| case RB_SETTEXTCOLOR: | |
| return REBAR_SetTextColor (wndPtr, wParam, lParam); | |
| /* case RB_SETTOOLTIPS: */ | |
| case RB_SETUNICODEFORMAT: | |
| return REBAR_SetUnicodeFormat (wndPtr, wParam); | |
| case RB_SHOWBAND: | |
| return REBAR_ShowBand (wndPtr, wParam, lParam); | |
| case RB_SIZETORECT: | |
| return REBAR_SizeToRect (wndPtr, wParam, lParam); | |
| case WM_COMMAND: | |
| return SendMessage32A (wndPtr->parent->hwndSelf, uMsg, wParam, lParam); | |
| case WM_CREATE: | |
| return REBAR_Create (wndPtr, wParam, lParam); | |
| case WM_DESTROY: | |
| return REBAR_Destroy (wndPtr, wParam, lParam); | |
| case WM_GETFONT: | |
| return REBAR_GetFont (wndPtr, wParam, lParam); | |
| /* case WM_MOUSEMOVE: */ | |
| /* return REBAR_MouseMove (wndPtr, wParam, lParam); */ | |
| case WM_NCCALCSIZE: | |
| return REBAR_NCCalcSize (wndPtr, wParam, lParam); | |
| case WM_NCPAINT: | |
| return REBAR_NCPaint (wndPtr, wParam, lParam); | |
| case WM_NOTIFY: | |
| return SendMessage32A (wndPtr->parent->hwndSelf, uMsg, wParam, lParam); | |
| case WM_PAINT: | |
| return REBAR_Paint (wndPtr, wParam); | |
| case WM_SETCURSOR: | |
| return REBAR_SetCursor (wndPtr, wParam, lParam); | |
| case WM_SETFONT: | |
| return REBAR_SetFont (wndPtr, wParam, lParam); | |
| case WM_SIZE: | |
| return REBAR_Size (wndPtr, wParam, lParam); | |
| /* case WM_TIMER: */ | |
| /* case WM_WININICHANGE: */ | |
| default: | |
| if (uMsg >= WM_USER) | |
| ERR (rebar, "unknown msg %04x wp=%08x lp=%08lx\n", | |
| uMsg, wParam, lParam); | |
| return DefWindowProc32A (hwnd, uMsg, wParam, lParam); | |
| } | |
| return 0; | |
| } | |
| VOID | |
| REBAR_Register (VOID) | |
| { | |
| WNDCLASS32A wndClass; | |
| if (GlobalFindAtom32A (REBARCLASSNAME32A)) return; | |
| ZeroMemory (&wndClass, sizeof(WNDCLASS32A)); | |
| wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS; | |
| wndClass.lpfnWndProc = (WNDPROC32)REBAR_WindowProc; | |
| wndClass.cbClsExtra = 0; | |
| wndClass.cbWndExtra = sizeof(REBAR_INFO *); | |
| wndClass.hCursor = 0; | |
| wndClass.hbrBackground = (HBRUSH32)(COLOR_BTNFACE + 1); | |
| wndClass.lpszClassName = REBARCLASSNAME32A; | |
| RegisterClass32A (&wndClass); | |
| } | |
| VOID | |
| REBAR_Unregister (VOID) | |
| { | |
| if (GlobalFindAtom32A (REBARCLASSNAME32A)) | |
| UnregisterClass32A (REBARCLASSNAME32A, (HINSTANCE32)NULL); | |
| } | |