1205 lines
36 KiB
C++
1205 lines
36 KiB
C++
#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;
|
|
}
|