LRESULT CElcSkinFrameBase::TrackBorderHitTest(CPoint point)
{
	CRect rcLT(0, 0, RESIZE_BRODER, RESIZE_BRODER);
	CRect rcLB(0, m_rect.bottom-m_nBottom, m_nLeft, m_rect.bottom);
	CRect rcRT(m_rect.right-m_nRight, 0, m_rect.right, m_nRight);
	CRect rcRB(m_rect.right-m_nRight, m_rect.bottom-m_nBottom, m_rect.right, m_rect.bottom);

	CRect rcLeft(rcLT.left, rcLT.bottom, rcLT.right, rcLB.top);
	CRect rcTop(rcLT.right, rcLT.top, rcRT.left, rcLT.top+RESIZE_BRODER);
	CRect rcRight(rcRT.left, rcRT.bottom, rcRT.right, rcRB.top);
	CRect rcBottom(rcLB.right, rcLB.top, rcRB.left, rcRB.bottom);

	if (rcLT.PtInRect(point))
		return HTTOPLEFT;
	else if (rcLB.PtInRect(point))
		return HTBOTTOMLEFT;
	else if (rcRT.PtInRect(point))
		return HTTOPRIGHT;
	else if (rcRB.PtInRect(point))
		return HTBOTTOMRIGHT;
	else if (rcLeft.PtInRect(point))
		return HTLEFT;
	else if (rcTop.PtInRect(point))
		return HTTOP;
	else if (rcRight.PtInRect(point))
		return HTRIGHT;
	else if (rcBottom.PtInRect(point))
		return HTBOTTOM;
	else 
		return HTCAPTION;
}
Beispiel #2
0
void Editor::setSize( const CRect& rcSize )
{
    if( childFrame_ ) 
    {
        CCoord middle = rcSize.width() - 276;
        CCoord bottom = rcSize.height() - 55;

	    CRect rcLeft( 0, 0, middle, bottom );
	    CRect rcRight( middle, 0, rcSize.right-8, bottom );
        
        programView_->setPreferredSize( rcLeft );
        ctrlView_->setPreferredSize( rcRight );
    }
}
Beispiel #3
0
// 绘制菜单顶背景
void CUIMenu::DrawBg(HDC hDC, CRect& rect)
{
	if (m_lpBgImgL != NULL && !m_lpBgImgL->IsNull())
	{
		CRect rcLeft(rect);
		rcLeft.right = rcLeft.left + m_nLMargin;
		m_lpBgImgL->Draw(hDC, rcLeft);
	}

	if (m_lpBgImgR != NULL && !m_lpBgImgR->IsNull())
	{
		CRect rcRight(rect);
		rcRight.left += m_nLMargin;
		m_lpBgImgR->Draw(hDC, rcRight);
	}
}
Beispiel #4
0
// 绘制菜单图标
void CUIMenu::DrawIcon(HDC hDC, CRect& rect, CImageEx * lpIconImg)
{
	if (lpIconImg != NULL && !lpIconImg->IsNull())
	{
		int cxIcon = lpIconImg->GetWidth();
		int cyIcon = lpIconImg->GetHeight();

		CRect rcLeft(rect);
		rcLeft.right = rcLeft.left + m_nLMargin;

		int x = (rcLeft.Width() - cxIcon + 1) / 2;
		int y = (rcLeft.Height() - cyIcon + 1) / 2;

		CRect rcIcon(x, y, x + cxIcon, y + cyIcon);
		lpIconImg->Draw(hDC, rcIcon);
	}
}
Beispiel #5
0
void CToolBarPopup::SetPosition( UINT nFlags, CPoint pt, CRect& rcExclude )
{
    // The main purpose of this functions is to find proper position of
    // the popup window, so that we neither exceed screen dimensions nor
    // intersect rcExclude rectangle.  The function also takes into account
    // control flags specified by the user.

    // Calc initial position
    CRect rc;
    m_tbCtrl.GetWindowRect( rc );

    CalcWindowRect( rc, CWnd::adjustBorder );
    rc.OffsetRect( -rc.TopLeft() );
    rc.OffsetRect(
        ( nFlags & TPM_CENTERALIGN ) ? ( pt.x - rc.Width() / 2 ) :
        ( nFlags & TPM_RIGHTALIGN  ) ? ( pt.x - rc.Width() ) : pt.x, 0 );
    rc.OffsetRect( 0,
        ( nFlags & TPM_VCENTERALIGN ) ? ( pt.y - rc.Height() / 2 ) :
        ( nFlags & TPM_BOTTOMALIGN  ) ? ( pt.y - rc.Height() ) : pt.y );

    // Make sure we don't exceed screen dimensions
    CRect rcDesktop;
    GetDesktopWindow()->GetWindowRect( rcDesktop );

    rc.OffsetRect(
        min( rcDesktop.right  - rc.right,  (LONG)0 ),
        min( rcDesktop.bottom - rc.bottom, (LONG)0 ) );
    rc.OffsetRect(
        max( rcDesktop.left   - rc.left,   (LONG)0 ),
        max( rcDesktop.top    - rc.top,    (LONG)0 ) );

    // Make sure we don't intersect rcExclude rectangle
    CRect rcTemp;
    if ( !rcExclude.IsRectEmpty() && rcTemp.IntersectRect( rc, rcExclude ) )
    {
        if ( nFlags & TPM_VERTICAL )
        {
            CRect rcUp( rc );
            int nUp = rc.bottom - rcExclude.top;
            rcUp.OffsetRect( 0, -nUp );

            CRect rcDown( rc );
            int nDown = rcExclude.bottom - rc.top;
            rcDown.OffsetRect( 0, nDown );

            bool bUp = false;
            if ( ( rcUp.top >= rcDesktop.top ) && ( rcDown.bottom <= rcDesktop.bottom ) )
            {
                bUp = ( nUp < nDown );
            }
            else if ( rcUp.top >= rcDesktop.top )
            {
                bUp = true;
            }
            else if ( rcDown.bottom <= rcDesktop.bottom )
            {
                bUp = false;
            }
            else
            {
                ASSERT( false );    // this case is not supported yet
            }

            rc = bUp ? rcUp : rcDown;
            nFlags &= ~( TPM_HORPOSANIMATION | TPM_HORNEGANIMATION | TPM_VERPOSANIMATION | TPM_VERNEGANIMATION );
            nFlags |=  ( bUp ? TPM_VERNEGANIMATION : TPM_VERPOSANIMATION );
        }
        else
        {
            CRect rcLeft( rc );
            int nLeft = rc.right - rcExclude.left;
            rcLeft.OffsetRect( -nLeft, 0 );

            CRect rcRight( rc );
            int nRight = rcExclude.right - rc.left;
            rcRight.OffsetRect( nRight, 0 );

            bool bLeft = false;
            if ( ( rcLeft.left >= rcDesktop.top ) && ( rcRight.right <= rcDesktop.right ) )
            {
                bLeft = ( nLeft < nRight );
            }
            else if ( rcLeft.left >= rcDesktop.left )
            {
                bLeft = true;
            }
            else if ( rcRight.right <= rcDesktop.right )
            {
                bLeft = false;
            }
            else
            {
                ASSERT( false );    // this case is not supported yet
            }

            rc = bLeft ? rcLeft : rcRight;
            nFlags &= ~( TPM_HORPOSANIMATION | TPM_HORNEGANIMATION | TPM_VERPOSANIMATION | TPM_VERNEGANIMATION );
            nFlags |=  ( bLeft ? TPM_HORNEGANIMATION : TPM_HORPOSANIMATION );
        }
    }

    Show( nFlags, rc );
}
LRESULT CElcSkinFrameBase::NcHitTest(CPoint point)
{
	GetOppositePoint(point);

	if (::IsIconic(m_hDerive)) {
		CRect rc;

		for (CFrameButtonArray::iterator it = m_arrButton.begin();
			it != m_arrButton.end();
			it ++)
		{
			if (it->type >= ESNWT_CUSTOM_BASE)
				continue;

			rc = CalcPos(it->pButton);
			if (rc.PtInRect(point)) {
				return it->type;
			}
		}

		if (m_bHasIcon) {
			rc.left = FRAME_ICON_MARGIN + FRAME_ICON_MARGIN;
			rc.right = rc.left + FRAME_ICON_SIZE;
			rc.top = (m_nCaption - FRAME_ICON_SIZE) / 2;
			rc.bottom = rc.top + FRAME_ICON_SIZE;
			if (rc.PtInRect(point))
				return HTSYSMENU;
		}
	}
	else {
		CRect rcClient, rc;

		rcClient.left = m_rect.left + m_nLeft;
		rcClient.right = m_rect.right - m_nRight;
		rcClient.top = m_rect.top + m_nCaption + m_nMenuBar;
		rcClient.bottom = m_rect.bottom - m_nCaption;

		CRect rcLT(0, 0, RESIZE_BRODER, RESIZE_BRODER);
		CRect rcLB(0, m_rect.bottom-m_nBottom, m_nLeft, m_rect.bottom);
		CRect rcRT(m_rect.right-m_nRight, 0, m_rect.right, m_nRight);
		CRect rcRB(m_rect.right-m_nRight, m_rect.bottom-m_nBottom, m_rect.right, m_rect.bottom);

		CRect rcLeft(rcLT.left, rcLT.bottom, rcLT.right, rcLB.top);
		CRect rcTop(rcLT.right, rcLT.top, rcRT.left, rcLT.top+RESIZE_BRODER);
		CRect rcRight(rcRT.left, rcRT.bottom, rcRT.right, rcRB.top);
		CRect rcBottom(rcLB.right, rcLB.top, rcRB.left, rcRB.bottom);

		LONG style = GetWindowLong(m_hDerive, GWL_STYLE);

		if (rcClient.PtInRect(point)) {
			return HTCLIENT;
		}
		else {
			if (style & WS_THICKFRAME) {
				LRESULT lRet = TrackBorderHitTest(point);
				if (lRet != HTCAPTION)
					return lRet;
			}

			for (CFrameButtonArray::iterator it = m_arrButton.begin();
				it != m_arrButton.end();
				it ++)
			{
				rc = CalcPos(it->pButton);
				if (rc.PtInRect(point)) {
					return it->type;
				}
			}

			if (m_nMenuBar > 0) {
				rc = m_rect;
				rc.top = m_nCaption;
				rc.bottom = m_nCaption + m_nMenuBar;
				if (rc.PtInRect(point))
					return HTMENU;
			}

			if (m_bHasIcon) {
				rc.left = FRAME_ICON_MARGIN + FRAME_ICON_MARGIN;
				rc.right = rc.left + FRAME_ICON_SIZE;
				rc.top = (m_nCaption - FRAME_ICON_SIZE) / 2;
				rc.bottom = rc.top + FRAME_ICON_SIZE;
				if (rc.PtInRect(point))
					return HTSYSMENU;
			}
		}
	}

	return HTCAPTION;
}
Beispiel #7
0
void CSkinToolBar::OnMouseMove(UINT nFlags, CPoint point)
{
    if (m_nPressIndex != -1)
        return;

    if (!m_bMouseTracking)
    {
        TrackMouseLeave(GetSafeHwnd());
        m_bMouseTracking = TRUE;
    }

    int nIndex;
    BOOL bHoverLorR = FALSE;

    nIndex = HitTest(point);
    if (nIndex != -1)
    {
        CSkinToolBarItem * lpItem = GetItemByIndex(nIndex);
        if (lpItem != NULL)
        {
            CRect rcItem;
            GetItemRectByIndex(nIndex, rcItem);

            if (lpItem->m_dwStyle & STBI_STYLE_DROPDOWN ||
                    lpItem->m_dwStyle & STBI_STYLE_WHOLEDROPDOWN)
            {
                CRect rcLeft(rcItem);
                rcLeft.right = rcLeft.left + lpItem->m_nLeftWidth;

                CRect rcRight(rcItem);
                rcRight.left += lpItem->m_nLeftWidth;
                rcRight.right = rcRight.left + lpItem->m_nRightWidth;

                if (rcLeft.PtInRect(point))
                    bHoverLorR = TRUE;

                if (rcRight.PtInRect(point))
                    bHoverLorR = FALSE;
            }

            if (nIndex != m_nHoverIndex && lpItem->m_strToolTipText.GetLength() > 0)
            {
                if (!m_ToolTipCtrl.GetSafeHwnd())
                {
                    m_ToolTipCtrl.Create(this);
                    m_ToolTipCtrl.SetMaxTipWidth(200);
                }

                if (m_ToolTipCtrl.GetSafeHwnd())
                {
                    if (m_ToolTipCtrl.GetToolCount() <= 0)
                    {
                        m_ToolTipCtrl.Activate(TRUE);
                        m_ToolTipCtrl.AddTool(this, lpItem->m_strToolTipText.GetBuffer(), &rcItem, 1);
                    }
                    else
                    {
                        m_ToolTipCtrl.Activate(TRUE);
                        m_ToolTipCtrl.UpdateTipText(lpItem->m_strToolTipText.GetBuffer(), this, 1);
                        m_ToolTipCtrl.SetToolRect(this, 1, &rcItem);
                    }
                }
            }
        }
    }

    if (nIndex != m_nHoverIndex || m_bHoverLorR != bHoverLorR)
    {
        m_nHoverIndex = nIndex;
        m_bHoverLorR = bHoverLorR;
        Invalidate(FALSE);
    }

    __super::OnMouseMove(nFlags, point);
}