cformeditorview.cpp

FormEditor,模拟Visual Basic窗口编辑界面

#ifdef _DEBUG
void CCFormEditorView::AssertValid() const
{
	CView::AssertValid();
}

void CCFormEditorView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

void CCFormEditorView::stat_PaintGradientRect(
	CDC & dc,
	const CRect & rcPaintGradient,
	COLORREF clrLeft,
	COLORREF clrRight,
	bool bHorz, // = false
	UINT nCountOfSteps // = 256
	)
{
	if(		rcPaintGradient.left >= rcPaintGradient.right
		||	rcPaintGradient.top >= rcPaintGradient.bottom
		)
		return;
	ASSERT( nCountOfSteps > 0 && nCountOfSteps <= 256 );
UINT nWidth = rcPaintGradient.Width();
UINT nHeight = rcPaintGradient.Height();
	if( bHorz )
	{
		if( nCountOfSteps > nHeight )
			nCountOfSteps = nHeight;
	}
	else
	{
		if( nCountOfSteps > nWidth )
			nCountOfSteps = nWidth;
	}

int nBitsPerPixel = stat_GetBPP();
	if( nBitsPerPixel <= 8 )
	{
		UINT nCalcStepSize = 
			bHorz
				? nHeight / nCountOfSteps
				: nWidth  / nCountOfSteps
				;
static const UINT nLowColorStepMinSize = 4;
		if( nCalcStepSize < nLowColorStepMinSize )
			nCountOfSteps =
				bHorz
					? nHeight / nLowColorStepMinSize
					: nWidth  / nLowColorStepMinSize
					;
	} // if( nBitsPerPixel <= 8 )

CRect rcItem( rcPaintGradient );
	for(	UINT nStep = 0, nBackStep = nCountOfSteps;
			nStep < nCountOfSteps;
			nStep++, nBackStep--
			)
	{
		COLORREF clrItem =
			RGB(
				(	GetRValue(clrLeft)*nBackStep
					+ GetRValue(clrRight)*nStep
					) / nCountOfSteps,
				(	GetGValue(clrLeft)*nBackStep
					+ GetGValue(clrRight)*nStep
					) / nCountOfSteps,
				(	GetBValue(clrLeft)*nBackStep
					+ GetBValue(clrRight)*nStep
					) / nCountOfSteps
				);
		if( bHorz )
		{
			rcItem.top =
				rcPaintGradient.bottom -
				MulDiv( nStep, nHeight, nCountOfSteps )
				;
			rcItem.top--;
			if( nStep == nCountOfSteps
				&& rcItem.top < rcPaintGradient.top
				)
			{
				rcItem.top = rcPaintGradient.top;
				if( rcItem.top >= rcItem.bottom )
					break;
			}
			ASSERT( rcItem.Height() >= 1 );
			if( nBitsPerPixel <= 8 )
			{
				CBrush br( clrItem );
				dc.FillRect( rcItem, &br );
			} // if( nBitsPerPixel <= 8 )
			else
			{
				dc.FillSolidRect( rcItem, clrItem );
			} // else from if( nBitsPerPixel <= 8 )
			rcItem.bottom = rcItem.top;
		}
		else
		{
			rcItem.right =
				MulDiv( nStep, nWidth, nCountOfSteps )
				+ rcPaintGradient.left
				;
			rcItem.right++;
			if( nStep == nCountOfSteps
				&& rcItem.right > rcPaintGradient.right
				)
			{
				rcItem.right = rcPaintGradient.right;
				if( rcItem.right <= rcItem.left )
					break;
			}
			ASSERT( rcItem.Width() >= 1 );
			if( nBitsPerPixel <= 8 )
			{
				CBrush br( clrItem );
				dc.FillRect( rcItem, &br );
			} // if( nBitsPerPixel <= 8 )
			else
			{
				dc.FillSolidRect( rcItem, clrItem );
			} // else from if( nBitsPerPixel <= 8 )
			rcItem.left = rcItem.right;
		}
	}
}
CCFormEditorDoc* CCFormEditorView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CCFormEditorDoc)));
	return (CCFormEditorDoc*)m_pDocument;
}
#endif //_DEBUG


/////////////////////////////////////////////////////////////////////////////
// CCFormEditorView message handlers

void CCFormEditorView::OnOption() 
{
	// TODO: Add your command handler code here
	
    SizeDlg m_dlg;
	m_dlg.m_width=GetDocument()->g_sizeMinForm.cx;
	m_dlg.m_height=GetDocument()->g_sizeMinForm.cy;

	int x=m_dlg.DoModal();
	if(x!=IDOK)
		return;
	GetDocument()->g_sizeMinForm.cx=m_dlg.m_width;
	GetDocument()->g_sizeMinForm.cy=m_dlg.m_height;
    Invalidate();
}


CFormEditorRulerBar * CCFormEditorView::GetRuler( bool bHorz )
{
	ASSERT_VALID( this );
CFrameWnd * pFrame = GetParentFrame();
	ASSERT_VALID( pFrame );
	ASSERT_KINDOF( CMDIChildWnd, pFrame );
CControlBar * pRuler =
		pFrame->GetControlBar(
			bHorz
				? (AFX_IDW_CONTROLBAR_LAST - 1)
				: (AFX_IDW_CONTROLBAR_LAST - 2)
			);
	if( pRuler == NULL )
		return NULL;
	ASSERT_VALID( pRuler );
	ASSERT_KINDOF( CFormEditorRulerBar, pRuler );
	return (CFormEditorRulerBar *)pRuler;
}

const CFormEditorRulerBar * CCFormEditorView::GetRuler( bool bHorz ) const
{
	return
		( const_cast < CCFormEditorView * > ( this ) )
			-> GetRuler( bHorz );
}

void CCFormEditorView::RedrawRuler( bool bHorz, bool bUpdateNow )
{
CFormEditorRulerBar * pRuler = GetRuler(bHorz);
	if( pRuler == NULL )
		return;
	if( (pRuler->GetStyle() & WS_VISIBLE) == 0 )
		return;
	pRuler->Invalidate();
	if( bUpdateNow )
		pRuler->UpdateWindow();
}

LRESULT CCFormEditorView::OnDrawRuler(WPARAM wParam, LPARAM lParam)
{
	lParam;
CFormEditorRulerBar::MSG_DRAW_RULER_DATA * p_data =
		(CFormEditorRulerBar::MSG_DRAW_RULER_DATA *) wParam;
	ASSERT( p_data != NULL );
	ASSERT_VALID( p_data->m_pRuler );
	ASSERT_KINDOF( CFormEditorRulerBar, p_data->m_pRuler );
	ASSERT( p_data->m_pRuler->GetSafeHwnd() != NULL );
	ASSERT( ::IsWindow(p_data->m_pRuler->GetSafeHwnd()) );
	ASSERT( p_data->m_pDC->GetSafeHdc() != NULL );
CRect rcMrg;
	{ // block
		CClientDC dc( this );
		rcMrg = CalcActualViewRect();
		OnPrepareDC( &dc, NULL );
		dc.LPtoDP( &rcMrg );
		ClientToScreen( &rcMrg );
		p_data->m_pRuler->ScreenToClient( &rcMrg );
	} // block

CRect rcSelection( 0, 0, 0, 0 );
	if( m_bTrackingCreation )
	{
		rcSelection.SetRect(
			min( m_rcTrackingCreation.left, m_rcTrackingCreation.right ),
			min( m_rcTrackingCreation.top, m_rcTrackingCreation.bottom ),
			max( m_rcTrackingCreation.left, m_rcTrackingCreation.right ),
			max( m_rcTrackingCreation.top, m_rcTrackingCreation.bottom )
			);
		ClientToScreen( &rcSelection );
		p_data->m_pRuler->ScreenToClient( &rcSelection );
	} // if( m_bTrackingCreation )
	else if( m_mapSelection.GetCount() > 0 )
	{
		bool bFirst = true;
		for( POSITION pos = m_mapSelection.GetStartPosition(); pos != NULL; bFirst = false )
		{
			HWND hWndChild;
			int nTmp;
			m_mapSelection.GetNextAssoc(pos,hWndChild,nTmp);
			ASSERT( hWndChild != NULL );
			ASSERT( ::IsWindow(hWndChild) );
			CRect rc;
			if( !::GetWindowRect(hWndChild,&rc) )
				continue;
			ScreenToClient( &rc );
			//dc.DPtoLP( &rc );
			if( bFirst )
				rcSelection = rc;
			else
				rcSelection.SetRect(
					min( rcSelection.left, rc.left ),
					min( rcSelection.top, rc.top ),
					max( rcSelection.right, rc.right ),
					max( rcSelection.bottom, rc.bottom )
					);
		}
		ClientToScreen( &rcSelection );
		p_data->m_pRuler->ScreenToClient( &rcSelection );
	} // else if( m_mapSelection.GetCount() > 0 )

COLORREF clrLight = ::GetSysColor( COLOR_3DHILIGHT );
COLORREF clrFace = ::GetSysColor( COLOR_3DFACE );
COLORREF clrShadow =::GetSysColor(COLOR_3DSHADOW );
COLORREF clrDkShadow =::GetSysColor( COLOR_3DDKSHADOW );
COLORREF clrWindow = ::GetSysColor(COLOR_WINDOW );
COLORREF clrText = ::GetSysColor(COLOR_BTNTEXT );

bool bHorzRuler = p_data->m_pRuler->IsHorzRuler();
CRect rcFormArea, rcClip;
	if( bHorzRuler )
	{
		rcFormArea.SetRect(
			rcMrg.left,
			p_data->m_rcDrawableArea.top,
			rcMrg.right,
			p_data->m_rcDrawableArea.bottom
			);
		rcClip.SetRect(
			max( p_data->m_rcDrawableArea.left, rcMrg.left ),
			p_data->m_rcDrawableArea.top,
			min( p_data->m_rcDrawableArea.right, rcMrg.right ),
			p_data->m_rcDrawableArea.bottom
			);
		rcClip.InflateRect( 4, 0, 5, 0 );
		if( !rcSelection.IsRectEmpty() )
		{
			rcSelection.top = rcClip.top;
			rcSelection.bottom = rcClip.bottom;
		}
	} // if( bHorzRuler )
	else
	{
		rcFormArea.SetRect(
			p_data->m_rcDrawableArea.left,
			rcMrg.top,
			p_data->m_rcDrawableArea.right,
			rcMrg.bottom
			);
		rcClip.SetRect(
			p_data->m_rcDrawableArea.left,
			max( p_data->m_rcDrawableArea.top, rcMrg.top ),
			p_data->m_rcDrawableArea.right,
			min( p_data->m_rcDrawableArea.bottom, rcMrg.bottom )
			);
		rcClip.InflateRect( 0, 24, 0, 3 );
		if( !rcSelection.IsRectEmpty() )
		{
			rcSelection.left = rcClip.left;
			rcSelection.right = rcClip.right;
		}
	} // else from if( bHorzRuler )
	if(		rcClip.right < rcClip.left
		||	rcClip.bottom < rcClip.top
		)
		return 0L;

CRgn rgnClip;
	if( rgnClip.CreateRectRgnIndirect(&rcClip) )
		p_data->m_pDC->SelectClipRgn( &rgnClip );

CRect rcDraw( rcClip );
	p_data->m_pDC->FillSolidRect( &rcDraw, clrFace );
	p_data->m_pDC->Draw3dRect( &rcDraw, clrShadow, clrLight );
	rcDraw.DeflateRect( 1, 1 );
	p_data->m_pDC->Draw3dRect( &rcDraw, clrLight, clrShadow );

	rcDraw = rcFormArea;
	p_data->m_pDC->FillSolidRect( &rcDraw, clrWindow );
	if( !rcSelection.IsRectEmpty() )
		p_data->m_pDC->FillSolidRect(
			&rcSelection,
			m_bTrackingCreation ? clrShadow : clrFace
			);
	p_data->m_pDC->Draw3dRect( &rcDraw, clrDkShadow, clrLight );
	rcDraw.DeflateRect( 1, 1 );
	p_data->m_pDC->Draw3dRect( &rcDraw, clrShadow, clrFace );


int nStart = bHorzRuler
		? rcMrg.left
		: rcMrg.top
		;
int nEnd = bHorzRuler
		? rcMrg.right
		: rcMrg.bottom
		;
CPen pen( PS_SOLID, 1, clrText );
CPen * pOldPen = p_data->m_pDC->SelectObject( &pen );
int nStep = 0;
int nStepSize = bHorzRuler ? m_sizeGridStep.cx : m_sizeGridStep.cy;
	for( int i = nStart; i < nEnd; i += nStepSize, nStep++ )
	{
		int nShift = ( (nStep%5) == 0 ) ? 6 : 10;
		if( bHorzRuler )
		{
			p_data->m_pDC->MoveTo( i, rcFormArea.top + nShift );
			p_data->m_pDC->LineTo( i, rcFormArea.bottom - 4 );
		}
		else
		{
			p_data->m_pDC->MoveTo( rcFormArea.left + nShift, i );
			p_data->m_pDC->LineTo( rcFormArea.right - 4, i );
		}
	}
	p_data->m_pDC->SelectObject( pOldPen );

	p_data->m_pDC->SelectClipRgn( NULL );
	return 0L;
}