bcgsizingcontrolbar.cpp

一个完整的编辑器的代码（很值得参考

            if (nDelta == 0) break;
        }
        // clear m_bKeepSize flags
        if ((nDeltaOld == nDelta) || (nDelta == 0))
            for (i = 0; i < arrSCBars.GetSize(); i++)
                arrSCBars[i]->m_bKeepSize = FALSE;
    }

    return TRUE;
}

void CBCGSizingControlBar::AlignControlBars()
{
	if (m_pDockBar == NULL)
	{
		return;
	}

    int nFirst, nLast, nThis;
    GetRowInfo(nFirst, nLast, nThis);

    BOOL bHorz = IsHorzDocked();
    BOOL bNeedRecalc = FALSE;
    int nPos, nAlign = bHorz ? /*-2*/0 : 0;

    CRect rc, rcDock;
    m_pDockBar->GetWindowRect(&rcDock);

	CControlBar* pPrevBar = 0;
    for (int i = nFirst; i <= nLast; i++)
    {
        CControlBar* pBar = (CControlBar*)m_pDockBar->m_arrBars[i];
        if (HIWORD(pBar) == 0) continue; // placeholder
        if (!pBar->IsVisible()) continue;

        pBar->GetWindowRect(&rc);
        rc.OffsetRect(-rcDock.TopLeft());

        if ((nPos = FindSizingBar(pBar)) >= 0)
            rc = CRect(rc.TopLeft(), bHorz ?
                m_arrBars[nPos]->m_szHorz : m_arrBars[nPos]->m_szVert);

        if ((bHorz ? rc.left : rc.top) != nAlign)
        {
            if (!bHorz)
                rc.OffsetRect(0, nAlign - rc.top);
            else if (m_nDockBarID == AFX_IDW_DOCKBAR_TOP)
                rc.OffsetRect(nAlign - rc.left, 0);
            else
                rc.OffsetRect(nAlign - rc.left, 0);

			pBar->SetWindowPos(NULL,
				rc.left, rc.top,
				rc.Width(), rc.Height (),
				SWP_NOACTIVATE | SWP_NOZORDER);

            bNeedRecalc = TRUE;
        }
        nAlign += (bHorz ? rc.Width() : rc.Height()) ;

		//--------------------------------------------------------------------
		// Erwin Tratar: Z-Order must be defined for overlapping control bars 
		// in order to be able to draw correct sizing edges
		//--------------------------------------------------------------------
		if(pPrevBar && bNeedRecalc) {
			pPrevBar->SetWindowPos(pBar,0,0,0,0, SWP_NOMOVE | SWP_NOSIZE );
		}
		pPrevBar = pBar;
    }

    if (bNeedRecalc)
    {
        m_pDockSite->DelayRecalcLayout();
    }
}

void CBCGSizingControlBar::LoadState(LPCTSTR lpszProfileName)
{
    ASSERT_VALID(this);
    ASSERT(GetSafeHwnd()); // must be called after Create()

	CString strProfileName = ::BCGGetRegPath (strSCBProfile, lpszProfileName);

    CWinApp* pApp = AfxGetApp();

    TCHAR szSection[256];
    wsprintf(szSection, _T("%s-SCBar-%d"), strProfileName,
        GetDlgCtrlID());

    m_szHorz.cx = max(m_szMin.cx, (int) pApp->GetProfileInt(szSection,
        _T("sizeHorzCX"), m_szHorz.cx));
    m_szHorz.cy = max(m_szMin.cy, (int) pApp->GetProfileInt(szSection, 
        _T("sizeHorzCY"), m_szHorz.cy));

    m_szVert.cx = max(m_szMin.cx, (int) pApp->GetProfileInt(szSection, 
        _T("sizeVertCX"), m_szVert.cx));
    m_szVert.cy = max(m_szMin.cy, (int) pApp->GetProfileInt(szSection, 
        _T("sizeVertCY"), m_szVert.cy));

    m_szFloat.cx = max(m_szMin.cx, (int) pApp->GetProfileInt(szSection,
        _T("sizeFloatCX"), m_szFloat.cx));
    m_szFloat.cy = max(m_szMin.cy, (int) pApp->GetProfileInt(szSection,
        _T("sizeFloatCY"), m_szFloat.cy));

	BOOL bMaximized = pApp->GetProfileInt (szSection, _T("Expanded"), FALSE);
	if (bMaximized)
	{
		ToggleExpand ();
	}
}

void CBCGSizingControlBar::SaveState(LPCTSTR lpszProfileName)
{
    // place your SaveState or GlobalSaveState call in
    // CMainFrame::DestroyWindow(), not in OnDestroy()
    ASSERT_VALID(this);
    ASSERT(GetSafeHwnd());

	CString strProfileName = ::BCGGetRegPath (strSCBProfile, lpszProfileName);

    CWinApp* pApp = AfxGetApp();

    TCHAR szSection[256];
    wsprintf(szSection, _T("%s-SCBar-%d"), strProfileName,
        GetDlgCtrlID());

	CSize szHorz = m_szHorz;
	CSize szVert = m_szVert;

	if (m_bMaximized)
	{
		if (IsHorzDocked())
		{
			szHorz = m_szOld;
		}
		else
		{
			szVert = m_szOld;
		}
	}

    pApp->WriteProfileInt(szSection, _T("sizeHorzCX"), szHorz.cx);
    pApp->WriteProfileInt(szSection, _T("sizeHorzCY"), szHorz.cy);

    pApp->WriteProfileInt(szSection, _T("sizeVertCX"), szVert.cx);
    pApp->WriteProfileInt(szSection, _T("sizeVertCY"), szVert.cy);

    pApp->WriteProfileInt(szSection, _T("sizeFloatCX"), m_szFloat.cx);
    pApp->WriteProfileInt(szSection, _T("sizeFloatCY"), m_szFloat.cy);

	pApp->WriteProfileInt(szSection, _T("Expanded"), m_bMaximized);
}

void CBCGSizingControlBar::GlobalLoadState(LPCTSTR lpszProfileName)
{
    for (int i = 0; i < m_arrBars.GetSize(); i++)
	{
        ((CBCGSizingControlBar*) m_arrBars[i])->LoadState(lpszProfileName);
	}
}

void CBCGSizingControlBar::GlobalSaveState(LPCTSTR lpszProfileName)
{
    for (int i = 0; i < m_arrBars.GetSize(); i++)
        ((CBCGSizingControlBar*) m_arrBars[i])->SaveState(lpszProfileName);
}

/////////////////////////////////////////////////////////////////////////
// CSCBButton

CSCBButton::CSCBButton()
{
    m_bPushed = FALSE;
    m_bFocused = FALSE;
	m_nHit = (UINT) -1;
}

void CSCBButton::Paint(CDC* pDC, BOOL bHorz, BOOL bMaximized, BOOL bDisabled)
{
    CRect rc = GetRect();

	pDC->FillSolidRect (rc, ::GetSysColor (COLOR_3DFACE));

	CMenuImages::IMAGES_IDS id = m_nHit == HTCLOSE ? // else - expand button
		CMenuImages::IdCloseSmall :
		bHorz ? 
			bMaximized ? CMenuImages::IdArowLeft : 
				bDisabled ? CMenuImages::IdArowLeftDsbl : CMenuImages::IdArowRight : 
			bMaximized ? CMenuImages::IdArowDown : 
				bDisabled ? CMenuImages::IdArowUpDisabled : CMenuImages::IdArowUp;

	CPoint ptImage = rc.TopLeft () + CPoint (nBtnMargin, nBtnMargin);
	if (m_bPushed && m_bFocused)
	{
		ptImage.Offset (1, 1);
	}

	CMenuImages::Draw (pDC, id, ptImage);

	if (m_bPushed && m_bFocused)
	{
		pDC->Draw3dRect (rc, ::GetSysColor (COLOR_3DDKSHADOW), ::GetSysColor
			(COLOR_3DLIGHT));
		rc.DeflateRect (1, 1);
		pDC->Draw3dRect (rc, ::GetSysColor (COLOR_3DSHADOW), ::GetSysColor
			(COLOR_3DHILIGHT));
	}
	else if (!CBCGToolBar::IsLook2000() )
	{
		pDC->Draw3dRect (rc, ::GetSysColor (COLOR_3DHILIGHT), ::GetSysColor
			(COLOR_3DDKSHADOW));
		rc.DeflateRect (1, 1);
		pDC->Draw3dRect (rc, ::GetSysColor (COLOR_3DLIGHT), ::GetSysColor
			(COLOR_3DSHADOW));
	}
	else if ((m_bFocused || m_bPushed) && id != CMenuImages::IdArowUpDisabled
		&& id != CMenuImages::IdArowLeftDsbl)
	{
		pDC->Draw3dRect (rc, ::GetSysColor (COLOR_3DHILIGHT), ::GetSysColor
			(COLOR_3DSHADOW));
	}
}

//************************************************************************************
BOOL CBCGSizingControlBar::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
{
	if (!IsFloating ())
	{
		CPoint ptCursor;
		::GetCursorPos (&ptCursor);

		switch (OnNcHitTest (ptCursor))
		{
		case HTLEFT:
		case HTRIGHT:
			::SetCursor (globalData.m_hcurStretch);
			return TRUE;

		case HTTOP:
		case HTBOTTOM:
			::SetCursor (globalData.m_hcurStretchVert);
			return TRUE;
		}
	}
	
	return CControlBar::OnSetCursor(pWnd, nHitTest, message);
}
//*************************************************************************************
BOOL CBCGSizingControlBar::IsAlmostRight ()
{
	if (m_pDockBar == NULL)
	{
		return FALSE;
	}

    int nFirst, nLast, nThis;
    GetRowInfo(nFirst, nLast, nThis);

	return nLast == nThis;
}
//*************************************************************************************
BOOL CBCGSizingControlBar::IsNotFirst ()
{
	if (m_pDockBar == NULL)
	{
		return FALSE;
	}

    int nFirst, nLast, nThis;
    GetRowInfo(nFirst, nLast, nThis);

	return nFirst != nThis;
}
//*************************************************************************************
BOOL CBCGSizingControlBar::IsEdgeVisible (UINT nHitTest)
{
    switch (nHitTest)
    {
    case HTLEFT:
		return (m_nDockBarID == AFX_IDW_DOCKBAR_RIGHT) &&
			(m_dwSCBStyle & SCBS_EDGELEFT);

    case HTTOP:
		return (m_nDockBarID == AFX_IDW_DOCKBAR_BOTTOM) &&
			(m_dwSCBStyle & SCBS_EDGETOP);

    case HTRIGHT:
		return (m_nDockBarID == AFX_IDW_DOCKBAR_LEFT || !IsAlmostRight ()) &&
			(m_dwSCBStyle & SCBS_EDGERIGHT);

    case HTBOTTOM:
		return (m_nDockBarID == AFX_IDW_DOCKBAR_TOP || !IsAlmostRight () &&
			(m_dwSCBStyle & SCBS_EDGEBOTTOM));

    default:
        ASSERT(FALSE); // invalid hit test code
    }

	return FALSE;
}
//************************************************************************************
void CBCGSizingControlBar::ToggleExpand ()
{
	if (IsFloating () || m_bIsSingleInRow)
	{
		return;
	}

    BOOL bHorz = IsHorzDocked();
	m_bMaximized = !m_bMaximized;

    CSCBArray arrSCBars;
    GetRowSizingBars(arrSCBars);

    // dirty cast - using CBCGDockBar to access protected CDockBar members
    CBCGDockBar* pDockBar = (CBCGDockBar*) m_pDockBar;

	CRect rc = pDockBar->m_rectLayout;
	if (rc.IsRectEmpty())
	{
		m_pDockSite->GetClientRect(&rc);
	}

	for (int i = 0; i < arrSCBars.GetSize(); i++)
	{
		CBCGSizingControlBar* pBar = arrSCBars[i];

		if (m_bMaximized)
		{
			pBar->m_szOld = bHorz ? pBar->m_szHorz : pBar->m_szVert;

			if (pBar == this)
			{
				if (bHorz)
				{
					m_szHorz.cx = rc.Width() + 2;
				}
				else
				{
					m_szVert.cy = rc.Height() - 2;
				}
			}
			else
			{
				if (bHorz)
				{
					pBar->m_szHorz.cx = pBar->m_szMin.cx;
				}
				else
				{
					pBar->m_szVert.cy = pBar->m_szMin.cy;
				}
			}
		}
		else
		{
			if (bHorz)
			{
				pBar->m_szHorz = pBar->m_szOld;
			}
			else
			{
				pBar->m_szVert = pBar->m_szOld;
			}
		}
	}

	{
		CBCGLocalResource localRes;
		m_wndToolTip.UpdateTipText (
			m_bMaximized ? IDS_BCGBARRES_CONTRACT_BAR : IDS_BCGBARRES_EXPAND_BAR,
			this, 2);
	}

    m_pDockSite->DelayRecalcLayout();
}

void CBCGSizingControlBar::OnUpdateCmdUI(class CFrameWnd *pTarget, int bDisableIfNoHndler)
{
    UpdateDialogControls(pTarget, bDisableIfNoHndler);
}

BOOL CBCGSizingControlBar::PreTranslateMessage(MSG* pMsg) 
{
	m_wndToolTip.RelayEvent (pMsg);
	return CControlBar::PreTranslateMessage(pMsg);
}

void CBCGSizingControlBar::SetCustomizationMode (BOOL bCustMode)
{
	ASSERT_VALID (this);

	CWnd* pWndChild = GetWindow (GW_CHILD);
	while (pWndChild != NULL)
	{
		pWndChild->EnableWindow (!bCustMode);
		pWndChild = pWndChild->GetNextWindow ();
	}
}

// Erwin Tratar:
void CBCGSizingControlBar::OnNcLButtonDblClk(UINT nHitTest, CPoint point) 
{
    if (m_pDockBar != NULL)
    {
		if ((nHitTest < HTSIZEFIRST) || (nHitTest > HTSIZELAST))
		{
			// Not on edges,
			// toggle docking
			ASSERT(m_pDockContext != NULL);
			m_pDockContext->ToggleDocking();
		}
    }
    else
	{
        CControlBar::OnNcLButtonDblClk(nHitTest, point);
	}
}

void CBCGSizingControlBar::OnTimer(UINT nIDEvent) 
{
	CRect rcBar;
	GetWindowRect (rcBar);

	CPoint ptCursor;
	GetCursorPos(&ptCursor);

	for (int i = 0; i < CBCGSIZINGCONTROLBAR_BUTTONS_NUM; i ++)
	{
		CSCBButton& btn = m_Buttons [i];

		BOOL m_bWasFocused = btn.m_bFocused;

		CRect rc = btn.GetRect();
		rc.OffsetRect(rcBar.TopLeft());

		// do not track other buttons if one is pushed
		if( m_nTrackingPushedButton == -1 || i == m_nTrackingPushedButton) {

			btn.m_bFocused = rc.PtInRect(ptCursor);

			if ((CBCGToolBar::IsLook2000() || btn.m_bPushed) &&
				m_bWasFocused != btn.m_bFocused)
			{
				RedrawWindow (btn.GetRect (), NULL,
					RDW_INVALIDATE | RDW_UPDATENOW | RDW_FRAME);

				if (!btn.m_bFocused)
				{
					KillTimer (uiHotBtnTimerId);
				}

			}

			if (btn.m_bFocused)
			{
				SetTimer (uiHotBtnTimerId, uiHotBtnTimerDelay, NULL);
			}
		}
	}
	
	CControlBar::OnTimer(nIDEvent);
}
///////////////////////////////////////////////////////////////////////////
void CBCGSizingControlBar::OnNcRButtonUp(UINT nHitTest, CPoint point) 
{
	if (!CBCGToolBar::IsCustomizeMode ())
	{
		CFrameWnd* pParentFrame = (m_pDockSite == NULL) ?
			GetDockingFrame() : m_pDockSite;
		ASSERT_VALID(pParentFrame);

		pParentFrame->SendMessage (BCGM_TOOLBARMENU,
			(WPARAM) GetSafeHwnd (),
			MAKELPARAM(point.x, point.y));
		return;
	}
	
	CControlBar::OnNcRButtonUp(nHitTest, point);
}