#include "stdafx.h" #include "shsSizingControlBar.h" #include "winuser.h" #ifdef _DEBUG #undef THIS_FILE static char THIS_FILE[]=__FILE__; #define new DEBUG_NEW #endif #ifndef GCL_HBRBACKGROUND #define GCL_HBRBACKGROUND (-10) #endif int CALLBACK EnumFontFamProc(ENUMLOGFONT FAR *lpelf, NEWTEXTMETRIC FAR *lpntm, int FontType, LPARAM lParam) { UNUSED_ALWAYS(lpelf); UNUSED_ALWAYS(lpntm); UNUSED_ALWAYS(FontType); UNUSED_ALWAYS(lParam); return 0; } ////////////////////////////////////////////////////////////////////////// // CHYSizingControlBar 类 IMPLEMENT_DYNAMIC(CHYSizingControlBar, CControlBar); BEGIN_MESSAGE_MAP(CHYSizingControlBar, CControlBar) //{{AFX_MSG_MAP(CHYSizingControlBar) ON_WM_CREATE() ON_WM_NCPAINT() ON_WM_NCCALCSIZE() ON_WM_PAINT() ON_WM_CAPTURECHANGED() ON_WM_SETTINGCHANGE() ON_WM_LBUTTONUP() ON_WM_LBUTTONDOWN() ON_WM_LBUTTONDBLCLK() ON_WM_RBUTTONDOWN() ON_WM_MOUSEMOVE() ON_WM_NCMOUSEMOVE() ON_WM_NCLBUTTONDOWN() ON_WM_WINDOWPOSCHANGING() ON_WM_CLOSE() ON_WM_SIZE() ON_WM_NCHITTEST() //}}AFX_MSG_MAP ON_MESSAGE(WM_SETTEXT, OnSetText) END_MESSAGE_MAP() ////////////////////////////////////////////////////////////////////// // 构造/卸构 函数 ////////////////////////////////////////////////////////////////////// CHYSizingControlBar::CHYSizingControlBar() { m_szMinHorz = CSize(50, 50); m_szMinVert = CSize(50, 50); m_szMinFloat = CSize(50, 50); m_szHorz = CSize(50, 50); m_szVert = CSize(50, 50); m_szFloat = CSize(50, 50); m_bTracking = FALSE; m_bKeepSize = FALSE; m_bParentSizing = FALSE; m_bDragShowContent = FALSE; m_nDockBarID = 0; m_dwSCBStyle = 0; m_cxEdge = 5; } CHYSizingControlBar::~CHYSizingControlBar() { } ////////////////////////////////////////////////////////////////////////// // 成员函数 ////////////////////////////////////////////////////////////////////////// BOOL CHYSizingControlBar::Create(LPCTSTR lpszWindowName, CWnd* pParentWnd, CSize sizeDefault, BOOL bHasGripper, UINT nID, DWORD dwStyle /* = WS_CHILD | WS_VISIBLE | CBRS_TOP */) { UNUSED_ALWAYS(bHasGripper); m_szHorz = m_szVert = m_szFloat = sizeDefault; return Create(lpszWindowName, pParentWnd, nID, dwStyle); } BOOL CHYSizingControlBar::Create(LPCTSTR lpszWindowName, CWnd* pParentWnd, UINT nID, DWORD dwStyle /* = WS_CHILD | WS_VISIBLE | CBRS_TOP */) { // 必须要有一个父窗口 ASSERT_VALID(pParentWnd); // 不能即使动态又是固定 // CBRS_SIZE_DYNAMIC 被用于在浮动时可修改大小 ASSERT (!((dwStyle & CBRS_SIZE_FIXED) && (dwStyle & CBRS_SIZE_DYNAMIC))); m_dwStyle = dwStyle & CBRS_ALL; // 保持控件样式 CString wndclass = ::AfxRegisterWndClass(CS_DBLCLKS, ::LoadCursor(NULL, IDC_ARROW), ::GetSysColorBrush(COLOR_BTNFACE), 0); dwStyle &= ~CBRS_ALL; // 只保留一般的窗口样式 dwStyle |= WS_CLIPCHILDREN; // 防止创建时闪烁 if (!CWnd::Create(wndclass, lpszWindowName, dwStyle, CRect(0, 0, 0, 0), pParentWnd, nID)) return FALSE; return TRUE; } ////////////////////////////////////////////////////////////////////////// #if defined(_SCB_REPLACE_MINIFRAME) && !defined(_SCB_MINIFRAME_CAPTION) void CHYSizingControlBar::EnableDocking(DWORD dwDockStyle) { // dwDockStyle样式必须是CBRS_ALIGN_***或CBRS_FLOAT_MULTI的一种 ASSERT((dwDockStyle & ~(CBRS_ALIGN_ANY|CBRS_FLOAT_MULTI)) == 0); // 样式中不能有CBRS_FLOAT_MULTI ASSERT((dwDockStyle & CBRS_FLOAT_MULTI) == 0); // 样式中必须有CBRS_SIZE_DYNAMIC ASSERT((m_dwStyle & CBRS_SIZE_DYNAMIC) != 0); m_dwDockStyle = dwDockStyle; if (m_pDockContext == NULL) m_pDockContext = new CHYSCBDockContext(this); // 始终帮定父窗口 if (m_hWndOwner == NULL) m_hWndOwner = ::GetParent(m_hWnd); } #endif ////////////////////////////////////////////////////////////////////////// const BOOL CHYSizingControlBar::IsFloating() const { return !IsHorzDocked() && !IsVertDocked(); } ////////////////////////////////////////////////////////////////////////// const BOOL CHYSizingControlBar::IsHorzDocked() const { return (m_nDockBarID == AFX_IDW_DOCKBAR_TOP || m_nDockBarID == AFX_IDW_DOCKBAR_BOTTOM); } ////////////////////////////////////////////////////////////////////////// const BOOL CHYSizingControlBar::IsVertDocked() const { return (m_nDockBarID == AFX_IDW_DOCKBAR_LEFT || m_nDockBarID == AFX_IDW_DOCKBAR_RIGHT); } ////////////////////////////////////////////////////////////////////////// const BOOL CHYSizingControlBar::IsSideTracking() const { // 当没有拖动时不要调该函数(停靠状态下调整大小) ASSERT(m_bTracking && !IsFloating()); return (m_htEdge == HTLEFT || m_htEdge == HTRIGHT) ? IsHorzDocked() : IsVertDocked(); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::LoadState(LPCTSTR lpszProfileName) { ASSERT_VALID(this); ASSERT(GetSafeHwnd()); #if defined(_SCB_REPLACE_MINIFRAME) && !defined(_SCB_MINIFRAME_CAPTION) // 在CFrameWnd::SetDockState()中补偿标题的误差 CDockState state; state.LoadState(lpszProfileName); UINT nID = GetDlgCtrlID(); for (int i = 0; i < state.m_arrBarInfo.GetSize(); i++) { CControlBarInfo* pInfo = (CControlBarInfo*)state.m_arrBarInfo[i]; ASSERT(pInfo != NULL); if (!pInfo->m_bFloating) continue; // this is a floating dockbar - check the ID array for (int j = 0; j < pInfo->m_arrBarID.GetSize(); j++) if ((DWORD) pInfo->m_arrBarID[j] == nID) { // found this bar - offset origin and save settings pInfo->m_pointPos.x++; pInfo->m_pointPos.y += ::GetSystemMetrics(SM_CYSMCAPTION) + 1; pInfo->SaveState(lpszProfileName, i); } } #endif //_SCB_REPLACE_MINIFRAME && !_SCB_MINIFRAME_CAPTION CWinApp* pApp = AfxGetApp(); TCHAR szSection[256]; wsprintf(szSection, _T("%s-SCBar-%d"), lpszProfileName, GetDlgCtrlID()); m_szHorz.cx = max(m_szMinHorz.cx, (int) pApp->GetProfileInt( szSection, _T("sizeHorzCX"), m_szHorz.cx)); m_szHorz.cy = max(m_szMinHorz.cy, (int) pApp->GetProfileInt( szSection, _T("sizeHorzCY"), m_szHorz.cy)); m_szVert.cx = max(m_szMinVert.cx, (int) pApp->GetProfileInt( szSection, _T("sizeVertCX"), m_szVert.cx)); m_szVert.cy = max(m_szMinVert.cy, (int) pApp->GetProfileInt( szSection, _T("sizeVertCY"), m_szVert.cy)); m_szFloat.cx = max(m_szMinFloat.cx, (int) pApp->GetProfileInt( szSection, _T("sizeFloatCX"), m_szFloat.cx)); m_szFloat.cy = max(m_szMinFloat.cy, (int) pApp->GetProfileInt( szSection, _T("sizeFloatCY"), m_szFloat.cy)); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::SaveState(LPCTSTR lpszProfileName) { // 保存你的控件状态SaveState或GlobalSaveState // 在CMainFrame's Onclose或DestroyWindow()中调用,而不是在OnDestroy()中调用 ASSERT_VALID(this); ASSERT(GetSafeHwnd()); CWinApp* pApp = AfxGetApp(); TCHAR szSection[256]; wsprintf(szSection, _T("%s-SCBar-%d"), lpszProfileName, GetDlgCtrlID()); pApp->WriteProfileInt(szSection, _T("sizeHorzCX"), m_szHorz.cx); pApp->WriteProfileInt(szSection, _T("sizeHorzCY"), m_szHorz.cy); pApp->WriteProfileInt(szSection, _T("sizeVertCX"), m_szVert.cx); pApp->WriteProfileInt(szSection, _T("sizeVertCY"), m_szVert.cy); pApp->WriteProfileInt(szSection, _T("sizeFloatCX"), m_szFloat.cx); pApp->WriteProfileInt(szSection, _T("sizeFloatCY"), m_szFloat.cy); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::GlobalLoadState(CFrameWnd* pFrame, LPCTSTR lpszProfileName) { POSITION pos = pFrame->m_listControlBars.GetHeadPosition(); while (pos != NULL) { CHYSizingControlBar* pBar = (CHYSizingControlBar*) pFrame->m_listControlBars.GetNext(pos); ASSERT(pBar != NULL); if (pBar->IsKindOf(RUNTIME_CLASS(CHYSizingControlBar))) pBar->LoadState(lpszProfileName); } } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::GlobalSaveState(CFrameWnd* pFrame, LPCTSTR lpszProfileName) { POSITION pos = pFrame->m_listControlBars.GetHeadPosition(); while (pos != NULL) { CHYSizingControlBar* pBar = (CHYSizingControlBar*) pFrame->m_listControlBars.GetNext(pos); ASSERT(pBar != NULL); if (pBar->IsKindOf(RUNTIME_CLASS(CHYSizingControlBar))) pBar->SaveState(lpszProfileName); } } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::SetSCBStyle(DWORD dwSCBStyle) { m_dwSCBStyle = (dwSCBStyle & ~SCBS_EDGEALL); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler) { UNUSED_ALWAYS(bDisableIfNoHndler); UNUSED_ALWAYS(pTarget); } ////////////////////////////////////////////////////////////////////////// CSize CHYSizingControlBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz) { // 如果这个bar是被拉伸过，不是dockbar的子窗口 if (bStretch) if (bHorz) return CSize(32767, m_szHorz.cy); else return CSize(m_szVert.cx, 32767); // 这里我们需要访问CDockBar的保护函数,所以从CDockbar派生了一个CHYSCBDockBar类 CHYSCBDockBar* pDockBar = (CHYSCBDockBar*) m_pDockBar; // 强制停靠 RecalcDelayShow()为所有的Sizeingbars在设置有DelayShow/DelayHide标志 // 作用是为了避免 IsVisible()问题 CHYSCBArray arrSCBars; GetRowSizingBars(arrSCBars); AFX_SIZEPARENTPARAMS layout; layout.hDWP = pDockBar->m_bLayoutQuery ? NULL : ::BeginDeferWindowPos((int)arrSCBars.GetSize()); for (int i = 0; i < arrSCBars.GetSize(); i++) if (arrSCBars[i]->m_nStateFlags & (delayHide|delayShow)) arrSCBars[i]->RecalcDelayShow(&layout); if (layout.hDWP != NULL) ::EndDeferWindowPos(layout.hDWP); // get available length CRect rc = pDockBar->m_rectLayout; if (rc.IsRectEmpty()) m_pDockSite->GetClientRect(&rc); int nLengthTotal = bHorz ? rc.Width() + 2 : rc.Height() - 2; if (IsVisible() && !IsFloating() && m_bParentSizing && arrSCBars[0] == this) if (NegotiateSpace(nLengthTotal, (bHorz != FALSE))) AlignControlBars(); m_bParentSizing = FALSE; if (bHorz) return CSize(max(m_szMinHorz.cx, m_szHorz.cx), max(m_szMinHorz.cy, m_szHorz.cy)); return CSize(max(m_szMinVert.cx, m_szVert.cx), max(m_szMinVert.cy, m_szVert.cy)); } ////////////////////////////////////////////////////////////////////////// CSize CHYSizingControlBar::CalcDynamicLayout(int nLength, DWORD dwMode) { if (dwMode & (LM_HORZDOCK | LM_VERTDOCK)) // docked ? { if (nLength == -1) m_bParentSizing = TRUE; return CControlBar::CalcDynamicLayout(nLength, dwMode); } if (dwMode & LM_MRUWIDTH) return m_szFloat; if (dwMode & LM_COMMIT) return m_szFloat; // already committed #ifndef _SCB_REPLACE_MINIFRAME // check for dialgonal resizing hit test int nHitTest = m_pDockContext->m_nHitTest; if (IsFloating() && (nHitTest == HTTOPLEFT || nHitTest == HTBOTTOMLEFT || nHitTest == HTTOPRIGHT || nHitTest == HTBOTTOMRIGHT)) { CPoint ptCursor; ::GetCursorPos(&ptCursor); CRect rFrame, rBar; GetParentFrame()->GetWindowRect(&rFrame); GetWindowRect(&rBar); if (nHitTest == HTTOPLEFT || nHitTest == HTBOTTOMLEFT) { m_szFloat.cx = rFrame.left + rBar.Width() - ptCursor.x; m_pDockContext->m_rectFrameDragHorz.left = min(ptCursor.x, rFrame.left + rBar.Width() - m_szMinFloat.cx); } if (nHitTest == HTTOPLEFT || nHitTest == HTTOPRIGHT) { m_szFloat.cy = rFrame.top + rBar.Height() - ptCursor.y; m_pDockContext->m_rectFrameDragHorz.top = min(ptCursor.y, rFrame.top + rBar.Height() - m_szMinFloat.cy); } if (nHitTest == HTTOPRIGHT || nHitTest == HTBOTTOMRIGHT) m_szFloat.cx = rBar.Width() + ptCursor.x - rFrame.right; if (nHitTest == HTBOTTOMLEFT || nHitTest == HTBOTTOMRIGHT) m_szFloat.cy = rBar.Height() + ptCursor.y - rFrame.bottom; } else #endif //_SCB_REPLACE_MINIFRAME ((dwMode & LM_LENGTHY) ? m_szFloat.cy : m_szFloat.cx) = nLength; m_szFloat.cx = max(m_szFloat.cx, m_szMinFloat.cx); m_szFloat.cy = max(m_szFloat.cy, m_szMinFloat.cy); return m_szFloat; } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::GetRowSizingBars(CHYSCBArray& arrSCBars) { int nThis; GetRowSizingBars(arrSCBars, nThis); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::GetRowSizingBars(CHYSCBArray& arrSCBars, int& nThis) { arrSCBars.RemoveAll(); int nFirstT, nLastT, nThisT; GetRowInfo(nFirstT, nLastT, nThisT); nThis = -1; for (int i = nFirstT; i <= nLastT; i++) { CHYSizingControlBar* pBar = (CHYSizingControlBar*) m_pDockBar->m_arrBars[i]; if (HIWORD(pBar) == 0) continue; // placeholder if (!pBar->IsVisible()) continue; if (pBar->IsKindOf(RUNTIME_CLASS(CHYSizingControlBar))) { if (pBar == this) nThis = (int)arrSCBars.GetSize(); arrSCBars.Add(pBar); } } } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::GetRowInfo(int& nFirst, int& nLast, int& nThis) { ASSERT_VALID(m_pDockBar); nThis = m_pDockBar->FindBar(this); ASSERT(nThis != -1); int i, nBars = (int)m_pDockBar->m_arrBars.GetSize(); // find the first and the last bar in row for (nFirst = -1, i = nThis - 1; i >= 0 && nFirst == -1; i--) if (m_pDockBar->m_arrBars[i] == NULL) nFirst = i + 1; for (nLast = -1, i = nThis + 1; i < nBars && nLast == -1; i++) if (m_pDockBar->m_arrBars[i] == NULL) nLast = i - 1; ASSERT((nLast != -1) && (nFirst != -1)); } ////////////////////////////////////////////////////////////////////////// BOOL CHYSizingControlBar::NegotiateSpace(int nLengthTotal, BOOL bHorz) { ASSERT(bHorz == IsHorzDocked()); int nFirst, nLast, nThis; GetRowInfo(nFirst, nLast, nThis); int nLengthAvail = nLengthTotal; int nLengthActual = 0; int nLengthMin = 2; int nWidthMax = 0; CHYSizingControlBar* pBar; int i=0; for ( i = nFirst; i <= nLast; i++) { pBar = (CHYSizingControlBar*) m_pDockBar->m_arrBars[i]; if (HIWORD(pBar) == 0) continue; // placeholder if (!pBar->IsVisible()) continue; BOOL bIsSizingBar = pBar->IsKindOf(RUNTIME_CLASS(CHYSizingControlBar)); int nLengthBar; // minimum length of the bar if (bIsSizingBar) nLengthBar = bHorz ? pBar->m_szMinHorz.cx - 2 : pBar->m_szMinVert.cy - 2; else { CRect rcBar; pBar->GetWindowRect(&rcBar); nLengthBar = bHorz ? rcBar.Width() - 2 : rcBar.Height() - 2; } nLengthMin += nLengthBar; if (nLengthMin > nLengthTotal) { // split the row after fixed bar if (i < nThis) { m_pDockBar->m_arrBars.InsertAt(i + 1, (CControlBar*) NULL); return FALSE; } // only this sizebar remains on the row, adjust it to minsize if (i == nThis) { if (bHorz) m_szHorz.cx = m_szMinHorz.cx; else m_szVert.cy = m_szMinVert.cy; return TRUE; // the dockbar will split the row for us } // we have enough bars - go negotiate with them m_pDockBar->m_arrBars.InsertAt(i, (CControlBar*) NULL); nLast = i - 1; break; } if (bIsSizingBar) { nLengthActual += bHorz ? pBar->m_szHorz.cx - 2 : pBar->m_szVert.cy - 2; nWidthMax = max(nWidthMax, bHorz ? pBar->m_szHorz.cy : pBar->m_szVert.cx); } else nLengthAvail -= nLengthBar; } CHYSCBArray arrSCBars; GetRowSizingBars(arrSCBars); int nNumBars = (int)arrSCBars.GetSize(); int nDelta = nLengthAvail - nLengthActual; // return faster when there is only one sizing bar per row (this one) if (nNumBars == 1) { ASSERT(arrSCBars[0] == this); if (nDelta == 0) return TRUE; m_bKeepSize = FALSE; (bHorz ? m_szHorz.cx : m_szVert.cy) += nDelta; return TRUE; } // make all the bars the same width for (i = 0; i < nNumBars; i++) if (bHorz) arrSCBars[i]->m_szHorz.cy = nWidthMax; else arrSCBars[i]->m_szVert.cx = nWidthMax; // distribute the difference between the bars, // but don't shrink them below their minsizes while (nDelta != 0) { int nDeltaOld = nDelta; for (i = 0; i < nNumBars; i++) { pBar = arrSCBars[i]; int nLMin = bHorz ? pBar->m_szMinHorz.cx : pBar->m_szMinVert.cy; int nL = bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy; if ((nL == nLMin) && (nDelta < 0) || // already at min length pBar->m_bKeepSize) // or wants to keep its size continue; // sign of nDelta int nDelta2 = (nDelta == 0) ? 0 : ((nDelta < 0) ? -1 : 1); (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) += nDelta2; nDelta -= nDelta2; if (nDelta == 0) break; } // clear m_bKeepSize flags if ((nDeltaOld == nDelta) || (nDelta == 0)) for (i = 0; i < nNumBars; i++) arrSCBars[i]->m_bKeepSize = FALSE; } return TRUE; } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::AlignControlBars() { int nFirst, nLast, nThis; GetRowInfo(nFirst, nLast, nThis); BOOL bHorz = IsHorzDocked(); BOOL bNeedRecalc = FALSE; int nAlign = bHorz ? -2 : 0; CRect rc, rcDock; m_pDockBar->GetWindowRect(&rcDock); for (int i = nFirst; i <= nLast; i++) { CHYSizingControlBar* pBar = (CHYSizingControlBar*) m_pDockBar->m_arrBars[i]; if (HIWORD(pBar) == 0) continue; // placeholder if (!pBar->IsVisible()) continue; pBar->GetWindowRect(&rc); rc.OffsetRect(-rcDock.TopLeft()); if (pBar->IsKindOf(RUNTIME_CLASS(CHYSizingControlBar))) rc = CRect(rc.TopLeft(), bHorz ? pBar->m_szHorz : pBar->m_szVert); if ((bHorz ? rc.left : rc.top) != nAlign) { if (!bHorz) rc.OffsetRect(0, nAlign - rc.top - 2); else if (m_nDockBarID == AFX_IDW_DOCKBAR_TOP) rc.OffsetRect(nAlign - rc.left, -2); else rc.OffsetRect(nAlign - rc.left, 0); pBar->MoveWindow(rc); bNeedRecalc = TRUE; } nAlign += (bHorz ? rc.Width() : rc.Height()) - 2; } if (bNeedRecalc) m_pDockSite->DelayRecalcLayout(); } ////////////////////////////////////////////////////////////////////////// UINT CHYSizingControlBar::GetEdgeHTCode(int nEdge) { if (nEdge == 0) return HTLEFT; if (nEdge == 1) return HTTOP; if (nEdge == 2) return HTRIGHT; if (nEdge == 3) return HTBOTTOM; ASSERT(FALSE); // invalid edge code return HTNOWHERE; } ////////////////////////////////////////////////////////////////////////// BOOL CHYSizingControlBar::GetEdgeRect(CRect rcWnd, UINT nHitTest, CRect& rcEdge) { rcEdge = rcWnd; if (m_dwSCBStyle & SCBS_SHOWEDGES) rcEdge.DeflateRect(1, 1); BOOL bHorz = IsHorzDocked(); switch (nHitTest) { case HTLEFT: if (!(m_dwSCBStyle & SCBS_EDGELEFT)) return FALSE; rcEdge.right = rcEdge.left + m_cxEdge; rcEdge.DeflateRect(0, bHorz ? m_cxEdge: 0); break; case HTTOP: if (!(m_dwSCBStyle & SCBS_EDGETOP)) return FALSE; rcEdge.bottom = rcEdge.top + m_cxEdge; rcEdge.DeflateRect(bHorz ? 0 : m_cxEdge, 0); break; case HTRIGHT: if (!(m_dwSCBStyle & SCBS_EDGERIGHT)) return FALSE; rcEdge.left = rcEdge.right - m_cxEdge; rcEdge.DeflateRect(0, bHorz ? m_cxEdge: 0); break; case HTBOTTOM: if (!(m_dwSCBStyle & SCBS_EDGEBOTTOM)) return FALSE; rcEdge.top = rcEdge.bottom - m_cxEdge; rcEdge.DeflateRect(bHorz ? 0 : m_cxEdge, 0); break; default: ASSERT(FALSE); // invalid hit test code } return TRUE; } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::StartTracking(UINT nHitTest, CPoint point) { SetCapture(); // make sure no updates are pending if (!m_bDragShowContent) RedrawWindow(NULL, NULL, RDW_ALLCHILDREN | RDW_UPDATENOW); m_htEdge = nHitTest; m_bTracking = TRUE; BOOL bHorz = IsHorzDocked(); BOOL bHorzTracking = m_htEdge == HTLEFT || m_htEdge == HTRIGHT; m_nTrackPosOld = bHorzTracking ? point.x : point.y; CRect rcBar, rcEdge; GetWindowRect(rcBar); GetEdgeRect(rcBar, m_htEdge, rcEdge); m_nTrackEdgeOfs = m_nTrackPosOld - (bHorzTracking ? rcEdge.CenterPoint().x : rcEdge.CenterPoint().y); CHYSCBArray arrSCBars; int nThis; GetRowSizingBars(arrSCBars, nThis); m_nTrackPosMin = m_nTrackPosMax = m_nTrackPosOld; if (!IsSideTracking()) { // calc minwidth as the max minwidth of the sizing bars on row int nMinWidth = bHorz ? m_szMinHorz.cy : m_szMinVert.cx; for (int i = 0; i < arrSCBars.GetSize(); i++) nMinWidth = max(nMinWidth, bHorz ? arrSCBars[i]->m_szMinHorz.cy : arrSCBars[i]->m_szMinVert.cx); int nExcessWidth = (bHorz ? m_szHorz.cy : m_szVert.cx) - nMinWidth; // the control bar cannot grow with more than the width of // remaining client area of the mainframe CRect rcT; m_pDockSite->RepositionBars(0, 0xFFFF, AFX_IDW_PANE_FIRST, reposQuery, &rcT, NULL, TRUE); int nMaxWidth = bHorz ? rcT.Height() - 2 : rcT.Width() - 2; BOOL bTopOrLeft = m_htEdge == HTTOP || m_htEdge == HTLEFT; m_nTrackPosMin -= bTopOrLeft ? nMaxWidth : nExcessWidth; m_nTrackPosMax += bTopOrLeft ? nExcessWidth : nMaxWidth; } else { // side tracking: // max size is the actual size plus the amount the other // sizing bars can be decreased until they reach their minsize if (m_htEdge == HTBOTTOM || m_htEdge == HTRIGHT) nThis++; for (int i = 0; i < arrSCBars.GetSize(); i++) { CHYSizingControlBar* pBar = arrSCBars[i]; int nExcessWidth = bHorz ? pBar->m_szHorz.cx - pBar->m_szMinHorz.cx : pBar->m_szVert.cy - pBar->m_szMinVert.cy; if (i < nThis) m_nTrackPosMin -= nExcessWidth; else m_nTrackPosMax += nExcessWidth; } } OnTrackInvertTracker(); // draw tracker } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::StopTracking() { OnTrackInvertTracker(); // erase tracker m_bTracking = FALSE; ReleaseCapture(); m_pDockSite->DelayRecalcLayout(); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnTrackUpdateSize(CPoint& point) { ASSERT(!IsFloating()); BOOL bHorzTrack = m_htEdge == HTLEFT || m_htEdge == HTRIGHT; int nTrackPos = bHorzTrack ? point.x : point.y; nTrackPos = max(m_nTrackPosMin, min(m_nTrackPosMax, nTrackPos)); int nDelta = nTrackPos - m_nTrackPosOld; if (nDelta == 0) return; // no pos change OnTrackInvertTracker(); // erase tracker m_nTrackPosOld = nTrackPos; BOOL bHorz = IsHorzDocked(); CSize sizeNew = bHorz ? m_szHorz : m_szVert; switch (m_htEdge) { case HTLEFT: sizeNew -= CSize(nDelta, 0); break; case HTTOP: sizeNew -= CSize(0, nDelta); break; case HTRIGHT: sizeNew += CSize(nDelta, 0); break; case HTBOTTOM: sizeNew += CSize(0, nDelta); break; } CHYSCBArray arrSCBars; int nThis; GetRowSizingBars(arrSCBars, nThis); if (!IsSideTracking()) for (int i = 0; i < arrSCBars.GetSize(); i++) { CHYSizingControlBar* pBar = arrSCBars[i]; // make same width (or height) (bHorz ? pBar->m_szHorz.cy : pBar->m_szVert.cx) = bHorz ? sizeNew.cy : sizeNew.cx; } else { int nGrowingBar = nThis; BOOL bBefore = m_htEdge == HTTOP || m_htEdge == HTLEFT; if (bBefore && nDelta > 0) nGrowingBar--; if (!bBefore && nDelta < 0) nGrowingBar++; if (nGrowingBar != nThis) bBefore = !bBefore; // nGrowing is growing nDelta = abs(nDelta); CHYSizingControlBar* pBar = arrSCBars[nGrowingBar]; (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) += nDelta; // the others are shrinking int nFirst = bBefore ? nGrowingBar - 1 : nGrowingBar + 1; int nLimit = bBefore ? -1 : (int)arrSCBars.GetSize(); for (int i = nFirst; nDelta != 0 && i != nLimit; i += (bBefore ? -1 : 1)) { CHYSizingControlBar* pBar = arrSCBars[i]; int nDeltaT = min(nDelta, (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) - (bHorz ? pBar->m_szMinHorz.cx : pBar->m_szMinVert.cy)); (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) -= nDeltaT; nDelta -= nDeltaT; } } OnTrackInvertTracker(); // redraw tracker at new pos if (m_bDragShowContent) m_pDockSite->DelayRecalcLayout(); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnTrackInvertTracker() { ASSERT(m_bTracking); if (m_bDragShowContent) return; // don't show tracker if DragFullWindows is on BOOL bHorz = IsHorzDocked(); CRect rc, rcBar, rcDock, rcFrame; GetWindowRect(rcBar); m_pDockBar->GetWindowRect(rcDock); m_pDockSite->GetWindowRect(rcFrame); VERIFY(GetEdgeRect(rcBar, m_htEdge, rc)); if (!IsSideTracking()) rc = bHorz ? CRect(rcDock.left + 1, rc.top, rcDock.right - 1, rc.bottom) : CRect(rc.left, rcDock.top + 1, rc.right, rcDock.bottom - 1); BOOL bHorzTracking = m_htEdge == HTLEFT || m_htEdge == HTRIGHT; int nOfs = m_nTrackPosOld - m_nTrackEdgeOfs; nOfs -= bHorzTracking ? rc.CenterPoint().x : rc.CenterPoint().y; rc.OffsetRect(bHorzTracking ? nOfs : 0, bHorzTracking ? 0 : nOfs); rc.OffsetRect(-rcFrame.TopLeft()); CDC *pDC = m_pDockSite->GetDCEx(NULL, DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE); CBrush* pBrush = CDC::GetHalftoneBrush(); CBrush* pBrushOld = pDC->SelectObject(pBrush); pDC->PatBlt(rc.left, rc.top, rc.Width(), rc.Height(), PATINVERT); pDC->SelectObject(pBrushOld); m_pDockSite->ReleaseDC(pDC); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::NcPaintGripper(CDC* pDC, CRect rcClient) { UNUSED_ALWAYS(pDC); UNUSED_ALWAYS(rcClient); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::NcCalcClient(LPRECT pRc, UINT nDockBarID) { CRect rc(pRc); rc.DeflateRect(3, 5, 3, 3); if (nDockBarID != AFX_IDW_DOCKBAR_FLOAT) rc.DeflateRect(2, 0, 2, 2); switch(nDockBarID) { case AFX_IDW_DOCKBAR_TOP: m_dwSCBStyle |= SCBS_EDGEBOTTOM; break; case AFX_IDW_DOCKBAR_BOTTOM: m_dwSCBStyle |= SCBS_EDGETOP; break; case AFX_IDW_DOCKBAR_LEFT: m_dwSCBStyle |= SCBS_EDGERIGHT; break; case AFX_IDW_DOCKBAR_RIGHT: m_dwSCBStyle |= SCBS_EDGELEFT; break; } // make room for edges only if they will be painted if (m_dwSCBStyle & SCBS_SHOWEDGES) rc.DeflateRect( (m_dwSCBStyle & SCBS_EDGELEFT) ? m_cxEdge : 0, (m_dwSCBStyle & SCBS_EDGETOP) ? m_cxEdge : 0, (m_dwSCBStyle & SCBS_EDGERIGHT) ? m_cxEdge : 0, (m_dwSCBStyle & SCBS_EDGEBOTTOM) ? m_cxEdge : 0); *pRc = rc; } ////////////////////////////////////////////////////////////////////////// // CHYSizingControlBar 消息函数 ////////////////////////////////////////////////////////////////////////// int CHYSizingControlBar::OnCreate(LPCREATESTRUCT lpCreateStruct) { if (CControlBar::OnCreate(lpCreateStruct) == -1) return -1; // query SPI_GETDRAGFULLWINDOWS system parameter // OnSettingChange() will update m_bDragShowContent m_bDragShowContent = FALSE; //::SystemParametersInfo(SPI_GETDRAGFULLWINDOWS, 0, // &m_bDragShowContent, 0); // uncomment this line if you want raised borders // m_dwSCBStyle |= SCBS_SHOWEDGES; return 0; } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnNcPaint() { // 得到WindowDC,这里是没有用户区域 CWindowDC dc(this); CRect rcClient, rcBar; GetClientRect(rcClient); ClientToScreen(rcClient); GetWindowRect(rcBar); rcClient.OffsetRect(-rcBar.TopLeft()); rcBar.OffsetRect(-rcBar.TopLeft()); CDC mdc; mdc.CreateCompatibleDC(&dc); CBitmap bm; bm.CreateCompatibleBitmap(&dc, rcBar.Width(), rcBar.Height()); CBitmap* pOldBm = mdc.SelectObject(&bm); // draw borders in non-client area CRect rcDraw = rcBar; DrawBorders(&mdc, rcDraw); // erase the NC background mdc.FillRect(rcDraw, CBrush::FromHandle( (HBRUSH) GetClassLong(m_hWnd, GCL_HBRBACKGROUND))); if (m_dwSCBStyle & SCBS_SHOWEDGES) { CRect rcEdge; // paint the sizing edges for (int i = 0; i < 4; i++) if (GetEdgeRect(rcBar, GetEdgeHTCode(i), rcEdge)) mdc.Draw3dRect(rcEdge, ::GetSysColor(COLOR_BTNHIGHLIGHT), ::GetSysColor(COLOR_BTNSHADOW)); } NcPaintGripper(&mdc, rcClient); // client area is not our bussiness :) dc.IntersectClipRect(rcBar); dc.ExcludeClipRect(rcClient); dc.BitBlt(0, 0, rcBar.Width(), rcBar.Height(), &mdc, 0, 0, SRCCOPY); ReleaseDC(&dc); mdc.SelectObject(pOldBm); bm.DeleteObject(); mdc.DeleteDC(); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) { UNUSED_ALWAYS(bCalcValidRects); #ifndef _SCB_REPLACE_MINIFRAME // Enable diagonal resizing for floating miniframe if (IsFloating()) { CFrameWnd* pFrame = GetParentFrame(); if (pFrame != NULL && pFrame->IsKindOf(RUNTIME_CLASS(CMiniFrameWnd))) { DWORD dwStyle = ::GetWindowLong(pFrame->m_hWnd, GWL_STYLE); if ((dwStyle & MFS_4THICKFRAME) != 0) { pFrame->ModifyStyle(MFS_4THICKFRAME, 0); // clear GetParent()->ModifyStyle(0, WS_CLIPCHILDREN); } } } #endif _SCB_REPLACE_MINIFRAME // compute the the client area m_dwSCBStyle &= ~SCBS_EDGEALL; // add resizing edges between bars on the same row if (!IsFloating() && m_pDockBar != NULL) { CHYSCBArray arrSCBars; int nThis; GetRowSizingBars(arrSCBars, nThis); BOOL bHorz = IsHorzDocked(); if (nThis > 0) m_dwSCBStyle |= bHorz ? SCBS_EDGELEFT : SCBS_EDGETOP; if (nThis < arrSCBars.GetUpperBound()) m_dwSCBStyle |= bHorz ? SCBS_EDGERIGHT : SCBS_EDGEBOTTOM; } NcCalcClient(&lpncsp->rgrc[0], m_nDockBarID); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnPaint() { CPaintDC dc(this); //dc.TextOut(0,0,_T("dkkkgk")); //CControlBar::OnPaint(); } LRESULT CHYSizingControlBar::OnNcHitTest(CPoint point) { CRect rcBar, rcEdge; GetWindowRect(rcBar); if (!IsFloating()) for (int i = 0; i < 4; i++) if (GetEdgeRect(rcBar, GetEdgeHTCode(i), rcEdge)) if (rcEdge.PtInRect(point)) return GetEdgeHTCode(i); return HTCLIENT; } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnCaptureChanged(CWnd *pWnd) { if (m_bTracking && (pWnd != this)) StopTracking(); CControlBar::OnCaptureChanged(pWnd); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnSettingChange(UINT uFlags, LPCTSTR lpszSection) { CControlBar::OnSettingChange(uFlags, lpszSection); m_bDragShowContent = FALSE; ::SystemParametersInfo(SPI_GETDRAGFULLWINDOWS, 0, &m_bDragShowContent, 0); // update } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnLButtonUp(UINT nFlags, CPoint point) { if (m_bTracking) StopTracking(); CControlBar::OnLButtonUp(nFlags, point); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnLButtonDown(UINT nFlags, CPoint point) { if (m_pDockBar != NULL) { // start the drag ASSERT(m_pDockContext != NULL); ClientToScreen(&point); m_pDockContext->StartDrag(point); } else CWnd::OnLButtonDown(nFlags, point); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnLButtonDblClk(UINT nFlags, CPoint point) { if (m_pDockBar != NULL) { // toggle docking ASSERT(m_pDockContext != NULL); m_pDockContext->ToggleDocking(); } else CWnd::OnLButtonDblClk(nFlags, point); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnRButtonDown(UINT nFlags, CPoint point) { if (m_bTracking) StopTracking(); CControlBar::OnRButtonDown(nFlags, point); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnMouseMove(UINT nFlags, CPoint point) { if (m_bTracking) { CPoint ptScreen = point; ClientToScreen(&ptScreen); OnTrackUpdateSize(ptScreen); } CControlBar::OnMouseMove(nFlags, point); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnNcLButtonDown(UINT nHitTest, CPoint point) { UNUSED_ALWAYS(point); if (m_bTracking || IsFloating()) return; if ((nHitTest >= HTSIZEFIRST) && (nHitTest <= HTSIZELAST)) StartTracking(nHitTest, point); // sizing edge hit } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos) { // force non-client recalc if moved or resized lpwndpos->flags |= SWP_FRAMECHANGED; CControlBar::OnWindowPosChanging(lpwndpos); // find on which side are we docked m_nDockBarID = GetParent()->GetDlgCtrlID(); if (!IsFloating()) if (lpwndpos->flags & SWP_SHOWWINDOW) m_bKeepSize = TRUE; } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnClose() { acutPrintf(_T("\nddkddk")); } ////////////////////////////////////////////////////////////////////////// void CHYSizingControlBar::OnSize(UINT nType, int cx, int cy) { UNUSED_ALWAYS(nType); if ((m_dwSCBStyle & SCBS_SIZECHILD) != 0) { // automatic child resizing - only one child is allowed CWnd* pWnd = GetWindow(GW_CHILD); if (pWnd != NULL) { pWnd->MoveWindow(0, 0, cx, cy); ASSERT(pWnd->GetWindow(GW_HWNDNEXT) == NULL); } } } ////////////////////////////////////////////////////////////////////////// LRESULT CHYSizingControlBar::OnSetText(WPARAM wParam, LPARAM lParam) { UNUSED_ALWAYS(wParam); LRESULT lResult = CWnd::Default(); if (IsFloating() && GetParentFrame()->IsKindOf(RUNTIME_CLASS(CMiniDockFrameWnd))) { m_pDockBar->SetWindowText((LPCTSTR) lParam); // update dockbar GetParentFrame()->DelayRecalcLayout(); // refresh miniframe } return lResult; }