Ejemplo n.º 1
0
///////////////////////////////////////////////////////////////////////////////
// OnPaint
void CXHTMLStatic::OnPaint() 
{
	CPaintDC dc(this); // device context for painting

	// get text from control
	CString strText = _T("");
	GetWindowText(strText);

	// replace character entity names with codes

	TCHAR ent[3] = { 0 };
	ent[0] = _T('\001');	// each entity name is replaced with a two-character
							// code that begins with \001

	for (int i = 0; m_aCharEntities[i].pszName != NULL; i++)
	{
		ent[1] = m_aCharEntities[i].cCode;
		strText.Replace(m_aCharEntities[i].pszName, ent);
	}

	CString str1 = _T("");
	int index = 0;

	// set text and background colors
	COLORREF crText = m_crText;
	COLORREF prev_crText = crText;

	COLORREF crBackground = m_crBackGround;
	COLORREF prev_crBackground = crBackground;

	CFont *pOldFont = dc.SelectObject(&m_font);
	int n = strText.GetLength();

	CRect rect;
	GetClientRect(&rect);

	//dc.FillSolidRect(&rect, m_crBackGround);

	// allow for margins
	rect.left += m_nLeftMargin;
	rect.right -= m_nRightMargin;

	int nInitialXOffset = 0;//m_nLeftMargin;
	m_yStart = rect.top;

	LOGFONT lf, prev_lf;
	if (m_bLogFont)
	{
		memcpy(&lf, &m_lf, sizeof(lf));
	}
	else
	{
		CFont* cf = GetFont();
		if (cf)
			cf->GetObject(sizeof(lf), &lf);
		else
			GetObject(GetStockObject(SYSTEM_FONT), sizeof(lf), &lf);
	}
	memcpy(&prev_lf, &lf, sizeof(lf));

	CString strAnchorText = _T("");

	BOOL bSizeChange = FALSE;
	//BOOL bEndOfSizeChange = FALSE;
	TEXTMETRIC tm;
	dc.GetTextMetrics(&tm);

	while (n > 0)
	{
		///////////////////////////////////////////////////////////////////////
		if (_tcsnicmp(strText, _T("<B>"), 3) == 0)	// check for <b> or <B>
		{
			n -= 3;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			m_bBold++;// = TRUE;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("</B>"), 4) == 0)	// check for </B>
		{
			n -= 4;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			if (m_bBold)
				m_bBold--;// = FALSE;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("<I>"), 3) == 0)	// check for <I>
		{
			n -= 3;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			m_bItalic++;// = TRUE;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("</I>"), 4) == 0)	// check for </I>
		{
			n -= 4;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			if (m_bItalic)
				m_bItalic--;// = FALSE;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("<U>"), 3) == 0)		// check for <U>
		{
			n -= 3;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			m_bUnderline++;// = TRUE;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("</U>"), 4) == 0)	// check for </U>
		{
			n -= 4;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			if (m_bUnderline)
				m_bUnderline--;// = FALSE;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("<STRIKE>"), 8) == 0)	// check for <STRIKE>
		{
			n -= 8;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			m_bStrikeThrough++;// = TRUE;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("</STRIKE>"), 9) == 0)	// check for </STRIKE>
		{
			n -= 9;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			if (m_bStrikeThrough)
				m_bStrikeThrough--;// = FALSE;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("<BIG>"), 5) == 0)	// check for <BIG>
		{
			n -= 5;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			if (lf.lfHeight > 0)
				lf.lfHeight++;
			else
				lf.lfHeight--;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("</BIG>"), 6) == 0)	// check for </BIG>
		{
			n -= 6;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			if (lf.lfHeight > 0)
				lf.lfHeight--;
			else
				lf.lfHeight++;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("<SMALL>"), 7) == 0)	// check for <SMALL>
		{
			n -= 7;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			if (lf.lfHeight > 0)
				lf.lfHeight--;
			else
				lf.lfHeight++;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("</SMALL>"), 8) == 0)	// check for </SMALL>
		{
			n -= 8;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			if (lf.lfHeight > 0)
				lf.lfHeight++;
			else
				lf.lfHeight--;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("<SUB>"), 5) == 0)	// check for <SUB>
		{
			n -= 5;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			m_bSubscript++;// = TRUE;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("</SUB>"), 6) == 0)	// check for </SUB>
		{
			n -= 6;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			if (m_bSubscript)
				m_bSubscript--;// = FALSE;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("<SUP>"), 5) == 0)	// check for <SUP>
		{
			n -= 5;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			m_bSuperscript++;// = TRUE;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("</SUP>"), 6) == 0)	// check for </SUP>
		{
			n -= 6;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			if (m_bSuperscript)
				m_bSuperscript--;// = FALSE;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("<FONT"), 5) == 0)	// check for <FONT
		{
			index = strText.Find(_T('>'));
			if (index != -1)
			{
				CString strAttributes = strText.Mid(5, index-5);
				int m = strAttributes.GetLength();
				strText = strText.Mid(index+1);

				// loop to parse FONT attributes
				while (m > 0)
				{
					// trim left whitespace
					if ((strAttributes.GetLength() > 0) && 
						(strAttributes[0] == _T(' ')))
					{
						m--;
						strAttributes = strAttributes.Mid(1);
						continue;
					}

					///////////////////////////////////////////////////////////
					if (_tcsnicmp(strAttributes, _T("COLOR"), 5) == 0)
					{
						int index2 = strAttributes.Find(_T('"'));
						if (index2 != -1)
						{
							m -= index2 + 1;
							strAttributes = strAttributes.Mid(index2+1);

							index2 = strAttributes.Find(_T('"'));
							if (index2 != -1)
							{
								CString strColor = strAttributes.Left(index2);
								CXNamedColors nc(strColor);
								crText = nc.GetRGB();
								strAttributes = strAttributes.Mid(index2+1);
								m = strAttributes.GetLength();
							}
						}
						else
							break;
					}
					///////////////////////////////////////////////////////////
					else if (_tcsnicmp(strAttributes, _T("BGCOLOR"), 7) == 0)
					{
						int index2 = strAttributes.Find(_T('"'));
						if (index2 != -1)
						{
							m -= index2 + 1;
							strAttributes = strAttributes.Mid(index2+1);

							index2 = strAttributes.Find(_T('"'));
							if (index2 != -1)
							{
								CString strBgColor = strAttributes.Left(index2);
								CXNamedColors nc(strBgColor);
								crBackground = nc.GetRGB();
								strAttributes = strAttributes.Mid(index2+1);
								m = strAttributes.GetLength();
							}
						}
						else
							break;
					}
					///////////////////////////////////////////////////////////
					else if (_tcsnicmp(strAttributes, _T("FACE"), 4) == 0)
					{
						int index2 = strAttributes.Find(_T('"'));
						if (index2 != -1)
						{
							m -= index2 + 1;
							strAttributes = strAttributes.Mid(index2+1);
							index2 = strAttributes.Find(_T('"'));
							if (index2 != -1)
							{
								memset(lf.lfFaceName, 0, sizeof(lf.lfFaceName));
								_tcsncpy(lf.lfFaceName, strAttributes, index2);

								m -= index2 + 1;
								if (m > 0)
									strAttributes = strAttributes.Mid(index2+1);
								else
									strAttributes = _T("");
								m = strAttributes.GetLength();
							}
						}
						else
							break;
					}
					///////////////////////////////////////////////////////////
					else if (_tcsnicmp(strAttributes, _T("SIZE"), 4) == 0)
					{
						int index2 = strAttributes.Find(_T('"'));
						if (index2 != -1)
						{
							m -= index2 + 1;
							strAttributes = strAttributes.Mid(index2+1);
							index2 = strAttributes.Find(_T('"'));
							if (index2 != -1)
							{
								int nSize = 0;
								nSize = _ttoi(strAttributes);
								lf.lfHeight -= nSize;
								bSizeChange = TRUE;

								m -= index2 + 1;
								if (m > 0)
									strAttributes = strAttributes.Mid(index2+1);
								else
									strAttributes = _T("");
								m = strAttributes.GetLength();
							}
						}
						else
							break;
					}
					else
					{
						while ((strAttributes.GetLength() > 0) && 
							   (strAttributes[0] != _T(' ')))
						{
							m--;
							strAttributes = strAttributes.Mid(1);
						}
					}
				}
				n -= index + 1;
			}
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("</FONT>"), 7) == 0)	// check for </FONT>
		{
			n -= 7;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			crText = prev_crText;
			crBackground = prev_crBackground;
			memcpy(&lf, &prev_lf, sizeof(lf));
			if (bSizeChange)
				m_yStart += tm.tmDescent;
			bSizeChange = FALSE;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("<CODE>"), 6) == 0)	// check for <CODE>
		{
			n -= 6;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			_tcscpy(lf.lfFaceName, _T("Courier New"));
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("</CODE>"), 7) == 0)	// check for </CODE>
		{
			n -= 7;
			index = strText.Find(_T('>'));
			if (index != -1)
				strText = strText.Mid(index+1);
			memcpy(&lf, &prev_lf, sizeof(lf));
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		// <a href=www.xyz.com>XYZ Web Site</a>
		else if (_tcsnicmp(strText, _T("<A HREF="), 8) == 0)	// check for <A HREF=
		{
			index = strText.Find(_T('>'));
			if (index != -1)
			{
				strAnchorText = strText.Mid(8, index-8);
				strText = strText.Mid(index+1);
				n = strText.GetLength();
				m_bInAnchor = TRUE;
				continue;
			}
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("</A>"), 4) == 0)	// check for </A>
		{
			strText = strText.Mid(4);
			n -= 4;
			m_bInAnchor = FALSE;
			continue;
		}
		///////////////////////////////////////////////////////////////////////
		else if (_tcsnicmp(strText, _T("<HR"), 3) == 0)	// check for <HR>
		{
			index = strText.Find(_T('>'));
			if (index != -1)
			{
				CString strAttributes = strText.Mid(3); //, index-3);
				int m = strAttributes.GetLength();
				strText = strText.Mid(index+1);

				// loop to parse attributes
				while (m > 0)
				{
					// trim left whitespace
					if ((strAttributes.GetLength() > 0) && 
						(strAttributes[0] == _T(' ')))
					{
						m--;
						strAttributes = strAttributes.Mid(1);
						continue;
					}

					///////////////////////////////////////////////////////////
					if (_tcsnicmp(strAttributes, _T("SIZE"), 4) == 0)
					{
						int index2 = strAttributes.Find(_T('='));
						if (index2 != -1)
						{
							m -= index2 + 1;
							strAttributes = strAttributes.Mid(index2+1);

							index2 = strAttributes.Find(_T('>'));
							if (index2 != -1)
							{
								CString strSize = strAttributes.Left(index2);
								m_nHorizontalRuleSize = _ttoi(strSize);
								strAttributes = strAttributes.Mid(index2+1);
								m = strAttributes.GetLength();
							}
						}
						else
							break;
					}
					else
					{
						while ((strAttributes.GetLength() > 0) && 
							   (strAttributes[0] != _T(' ')))
						{
							m--;
							strAttributes = strAttributes.Mid(1);
						}
					}
				}
				n -= index + 1;
			}

			m_bHorizontalRule++;// = TRUE;
			str1 = _T("\r\n");
			m_bGeneratedText = TRUE;
		}
		///////////////////////////////////////////////////////////////////////
		// <br> or \r\n or plain text
		else
		{
			str1 = strText;
			index = str1.Find(_T('<'));
			if (index != -1)
			{
				if (_tcsnicmp(strText, _T("<BR>"), 4) == 0)	// check for <BR>
				{
					n -= 4;
					str1 = _T("\r\n");
					m_bGeneratedText = TRUE;
					strText = strText.Mid(4);
				}
				else
				{
					str1 = strText.Left(index);
					if (str1.GetLength() <= 0)
					{
						if (strText.GetLength() != 0)
						{
							str1 = strText[0];
							index = 1;
							n -= 1;
						}
					}
					strText = strText.Mid(index);
				}
			}
			else
			{
				str1 = strText;
				strText = _T("");
			}
		}

		lf.lfWeight    = m_bBold ? FW_BOLD : FW_NORMAL;
		lf.lfUnderline = (BYTE) m_bUnderline;
		lf.lfItalic    = (BYTE) m_bItalic;
		lf.lfStrikeOut = (BYTE) m_bStrikeThrough;

		m_font.DeleteObject();
		VERIFY(m_font.CreateFontIndirect(&lf));

		dc.SetTextColor(crText);
		//dc.SetBkColor(crBackground);
		dc.SetBkMode(TRANSPARENT);
		dc.SelectObject(&m_font);

		dc.GetTextMetrics(&tm);
		int nBaselineAdjust = tm.tmAscent / 2;

		if (m_bSubscript)
		{
			rect.top += nBaselineAdjust;
			rect.bottom += nBaselineAdjust;
			m_yStart += nBaselineAdjust;
		}
		if (m_bSuperscript)
		{
			rect.top -= nBaselineAdjust;
			rect.bottom -= nBaselineAdjust;
			m_yStart -= nBaselineAdjust;
		}

		nInitialXOffset = FormatText(dc.m_hDC, str1, &rect, nInitialXOffset);
		if (str1 == _T("\r\n"))
		{
			nInitialXOffset = 0;
		}

		if (m_bSubscript)
		{
			rect.top -= nBaselineAdjust;
			rect.bottom -= nBaselineAdjust;
			m_yStart -= nBaselineAdjust;
		}
		if (m_bSuperscript)
		{
			rect.top += nBaselineAdjust;
			rect.bottom += nBaselineAdjust;
			m_yStart += nBaselineAdjust;
		}

		if (m_bInAnchor)
		{
			SIZE size;
			GetTextExtentPoint32(dc.m_hDC, str1, str1.GetLength(), &size);

			CRect rectDraw = rect;
			rectDraw.bottom = rectDraw.top + size.cy;
			rectDraw.left = nInitialXOffset - size.cx;
			rectDraw.right = nInitialXOffset;

			// save rect for this text - save in window coordinates
			CRect *pRect = new CRect(rectDraw);

			m_AnchorRectPtrs.Add(pRect);
			m_AnchorUrls.Add(strAnchorText);
			TRACE(_T("added anchor:  <%s>\n"), strAnchorText);
			//TRACERECT(*pRect);

			if (!m_bHyperlinkTimer)
			{
				m_bHyperlinkTimer = TRUE;
				SetTimer(1, 80, NULL);
			}
		}

		// draw horizontal rule 
		if (m_bHorizontalRule)
		{
			int nPenWidth = m_nHorizontalRuleSize;
			CPen pen(PS_SOLID, nPenWidth, crText);
			CPen *pOldPen = dc.SelectObject(&pen);

			dc.MoveTo(rect.left-m_nLeftMargin, rect.top);
			dc.LineTo(rect.right+m_nRightMargin, rect.top);

			if (pOldPen)
				dc.SelectObject(pOldPen);

			m_yStart += nPenWidth;
			rect.top += nPenWidth;
			rect.bottom += nPenWidth;
			nInitialXOffset = 0;

			m_bHorizontalRule--;
		}

		if (!m_bGeneratedText)
			n -= str1.GetLength();
		m_bGeneratedText = FALSE;
	}

	// Restore DC's State
	dc.SelectObject(pOldFont);

	// Do not call CStatic::OnPaint() for painting messages
}
Ejemplo n.º 2
0
void CTimeEv::OnPaint() 
{
	CPaintDC dc(this); // device context for painting

	GetClientRect(m_MainRect);
	m_SpikesRect = m_MainRect;
	m_SpikesRect.left += 11;
	m_SpikesRect.top += 11;
	m_SpikesRect.right -= 100; // -10
	m_SpikesRect.bottom -= 219; //  179; // 209

	CDC dcTemp;
	CBitmap bmTemp;
	bmTemp.CreateCompatibleBitmap(&dc,m_SpikesRect.right,m_SpikesRect.bottom);
	dcTemp.CreateCompatibleDC(&dc);
	CBitmap* bmOld = dcTemp.SelectObject(&bmTemp);
	
	// main RECTANGLE
	dcTemp.Rectangle(m_SpikesRect);
	
	m_SpikesRect.left += 1;
	m_SpikesRect.right -= 1;
	m_SpikesRect.bottom -= 1;
	m_SpikesRect.top += 1;

	// AXIS for SCALE
	int raster = m_SpikesRect.Width() / 10;
	CPen rasterPen(PS_SOLID,1, RGB(230,230,230)) , rasterPenRed(PS_SOLID,1,RGB(200,0,0));
	CPen *pOldRasterPen = dcTemp.SelectObject(&rasterPen);
	for (int iRaster = 1; iRaster < 10; iRaster++)
	{	if(iRaster==5) //paint middle line as red
		{	dcTemp.SelectObject(&rasterPenRed);
			dcTemp.MoveTo(m_SpikesRect.left + iRaster*raster, m_SpikesRect.top);
			dcTemp.LineTo(m_SpikesRect.left + iRaster*raster, m_SpikesRect.bottom);
			dcTemp.SelectObject(&rasterPen);
		}
		else	//paint other lines as gray
		{	dcTemp.MoveTo(m_SpikesRect.left + iRaster*raster, m_SpikesRect.top);
			dcTemp.LineTo(m_SpikesRect.left + iRaster*raster, m_SpikesRect.bottom);
		}
	}
	dcTemp.SelectObject(pOldRasterPen);

	m_ArenaRect = m_MainRect;
	m_ArenaRect.left += 280;
	m_ArenaRect.bottom -= 47;  // 45
	m_ArenaRect.top = m_ArenaRect.bottom - 130; 
	m_ArenaRect.right = m_ArenaRect.left + 130;
	m_ArenaRect.left += 1;
	m_ArenaRect.top += 1;
	m_ArenaRect.right -= 1;
	m_ArenaRect.bottom -= 1;

	m_RoomRect = m_MainRect;
	m_RoomRect.left += 11;
	m_RoomRect.bottom -= 47; //45
	m_RoomRect.top = m_RoomRect.bottom - 130; 
	m_RoomRect.right = m_RoomRect.left + 130;
	m_RoomRect.left += 1;
	m_RoomRect.top += 1;
	m_RoomRect.right -= 1;
	m_RoomRect.bottom -= 1;

	int oldBkMode = dc.SetBkMode( TRANSPARENT );
	dc.TextOut(m_ArenaRect.left, m_ArenaRect.top - 10, "Arena");
	dc.TextOut(m_RoomRect.left, m_RoomRect.top - 10, "Room");
	dc.TextOut(m_MainRect.right - 227, m_MainRect.bottom - 207, "Time window [ms]");
	dc.TextOut(m_MainRect.right - 167, m_MainRect.bottom - 137, "PlaySpeed");
	dc.SetBkMode( oldBkMode );

	unsigned char checked = 0;
	char			params;
	unsigned char	spikesCh, eegCh;
	CRect			signalRect = m_SpikesRect;
	float oneWinY = 0.0f;
	
	if(mPrepareFlag)
		checked = GetParameters( & spikesCh, & eegCh );
	
	if (checked)
	{
		oneWinY = m_SpikesRect.Height() / ( spikesCh + eegCh );

		dc.Ellipse(m_ArenaRect);
		dc.Ellipse(m_RoomRect);

		// Arena win
		if ( (m_MainDataStack->InBpfExist & 1) || (m_MainDataStack->LoadedAdd & 1) )
		{
			params = 2; // iixxxooo, xxx - points/circles/vectors, ooo - arena/room
			params += 8 * m_wndCmbArena.GetCurSel();
				m_MainDataStack->m_MainSyncStack.DrawArenaRoom(&dc,m_ArenaRect, timeStampFirst + 10*startTime, timeWindow, params, &clView[0], m_MainDataStack->whichDraw);
		}

		// Room win
		if ( (m_MainDataStack->InBpfExist & 2) || (m_MainDataStack->LoadedAdd & 2) )
		{
			params = 4; // iixxxooo, xxx - points/circles/vectors, ooo - arena/room
			params += 8 * m_wndCmbRoom.GetCurSel();
				m_MainDataStack->m_MainSyncStack.DrawArenaRoom(&dc,m_RoomRect, timeStampFirst + 10*startTime, timeWindow, params, &clView[0], m_MainDataStack->whichDraw);
		}

		if ( spikesCh > 0 )
		{
			//	Spike win
			//	params : xxeeeeii, ii - R/S, eeee - electrode to show
			if ( timeWindow / MIN_TIME_WINDOW < 50 )
			{
				if ( !m_wndCheckSpike.GetCheck() )	// choice of R/S
					params = 0; // Raster
				else{
					if ( m_wndCheckRaster.GetCheck() )
						params = 1; // R/S
					else 
						params = 2; // Spike
				}
			}
			else
				params = 0;
			unsigned char bite = 4; // 100 b
			for ( int i = 0; i < m_MainDataStack->NUM_CHANNELS; i++ )
				params |= (m_wndListScale.GetCheck( i )) ? ( bite << i ) : 0 ;
			signalRect.bottom = spikesCh * (m_SpikesRect.bottom - m_SpikesRect.top) / checked;
			switch(m_MainDataStack->whichDraw)
			{
			case CLUST_ORIG:
			case CLUST_USER:
				m_MainDataStack->DrawTimeSpikes(&dcTemp, signalRect, startTime, timeWindow, timeStampFirst, params, &clView[0], &file);
				break;
			default:
				m_MainDataStack->DrawTimeSpikesAutoC(&dcTemp, signalRect, startTime, timeWindow, timeStampFirst, params, &clView[0], &file);
				break;
			}

			int j=0;
			for (i = 0; i < spikesCh; i++)
			{
				while ( !m_wndListScale.GetCheck( j ) )
					j++;
				char textCh[10];
				sprintf(textCh,"ch.%d",j+1);
				dcTemp.TextOut(m_SpikesRect.left + 1, m_SpikesRect.top + i * oneWinY,textCh);
				j++;
			}
		}

		if ( eegCh > 0 )
		{
			//	Spike win - EEG
			//	params : xxeeeeii, ii - R/S, eeee - electrode to show
			unsigned int paramInt=0;
			unsigned int bite = 4; // 100 b
			for ( int i = m_MainDataStack->NUM_CHANNELS; i < m_MainDataStack->NUM_CHANNELS + m_MainDataStack->m_MainEEGStack.GetChannels(); i++ )
				paramInt |= (m_wndListScale.GetCheck( i )) ? ( bite << (i-m_MainDataStack->NUM_CHANNELS) ) : 0;
			
			signalRect.top = spikesCh * (m_SpikesRect.bottom - m_SpikesRect.top) / checked;
			signalRect.bottom = m_SpikesRect.bottom;

			int iEEGChans = m_vEEGNames.size();
			double dGainSum = 0.0, dGainMin = 0.0;
			for(i=0;i<iEEGChans;i++)
			{
				if(!m_wndListScale.GetCheck( i + m_MainDataStack->NUM_CHANNELS))
					continue;
				dGainSum += m_vGainList[i];
				if(m_vGainList[i] < dGainMin)
					dGainMin = m_vGainList[i];
			}

			m_MainDataStack->m_MainEEGStack.DrawEEG(&dcTemp, signalRect, 10*startTime + timeStampFirst, timeWindow, paramInt, m_vGainList);

			int iYPos = m_SpikesRect.top + spikesCh*oneWinY;
			for (i = 0; i < iEEGChans; i++)
			{	if( !m_wndListScale.GetCheck( i + m_MainDataStack->NUM_CHANNELS) )
					continue;
				dcTemp.TextOut(m_SpikesRect.left + 1, iYPos ,m_vEEGNames[i].c_str());
				char textCh[32];
				sprintf(textCh,"%.1fX",m_vGainList[i]);
				dcTemp.TextOut(m_SpikesRect.right - 47, iYPos ,textCh);
				iYPos+=(m_vGainList[i]/dGainSum)*signalRect.Height();;
			}
		}
	}

	char textTime[20]; // time corresponds to middle of window
	sprintf(textTime,"time: %5.3f s", GetTimeMS()/1000.0 );
	dcTemp.TextOut(m_SpikesRect.left + 50,m_SpikesRect.top ,textTime);

	if(m_oAVIR.IsOpen())
		PaintVideoFrame(dc);

	dc.BitBlt(m_SpikesRect.left-1,m_SpikesRect.top-1,m_SpikesRect.Width()+2,m_SpikesRect.Height()+2,&dcTemp,m_SpikesRect.left-1,m_SpikesRect.top-1,SRCCOPY);
	dcTemp.SelectObject(bmOld);

//	char a[200];
//	sprintf(a,"%d " ,m_MainDataStack->FileType);
//	dc.TextOut(10,40,a);

	// Do not call cdxCSizingDialog::OnPaint() for painting messages
}
Ejemplo n.º 3
0
void CSHeaderCtrl::OnPaint() 
{
	CPaintDC dc(this);
	CMemDC memDC(&dc);
	DrawCtrl(&memDC);
}
Ejemplo n.º 4
0
//重画函数
void CPalatesNeck::OnPaint() 
{
	CPaintDC dc(this); 
	dc.SelectObject(&m_Font);
	dc.SetBkMode(TRANSPARENT);
	dc.SetTextColor(RGB(255,255,255));
//	dc.SelectObject(&CGameImageLink::m_HFont);

	CGameImageHelper ImageHandle(&m_BackBmp);
	ImageHandle.BitBlt(dc,0,0,ImageHandle.GetWidth(),ImageHandle.GetHeight(),0,0);

	dc.SetTextColor(RGB(0,0,0));
	dc.TextOut(81,120,"用户名",lstrlen("用户名"));
	dc.TextOut(80,121,"用户名",lstrlen("用户名"));
	dc.SetTextColor(RGB(255,255,255));
	dc.TextOut(80,120,"用户名",lstrlen("用户名"));

	dc.SetTextColor(RGB(0,0,0));
	dc.TextOut(221,120,"成绩",lstrlen("成绩"));
	dc.TextOut(220,121,"成绩",lstrlen("成绩"));
	dc.SetTextColor(RGB(255,255,255));
	dc.TextOut(220,120,"成绩",lstrlen("成绩"));

	//显示经验值
	int dJianGe=160/m_bGamePeople;
	int iStation=0;
	TCHAR szBuffer[30];
	memset(szBuffer,0,sizeof(szBuffer));
	for (BYTE i=0;i<m_bGamePeople;i++)
	{
		if (m_strName[i].IsEmpty()==false)
		{
			dc.SetTextColor(RGB(0,0,0));
			dc.TextOut(81,(int)(iStation*dJianGe+140),m_strName[i]);
			dc.TextOut(80,(int)(iStation*dJianGe+141),m_strName[i]);
			dc.SetTextColor(RGB(255,255,255));
			dc.TextOut(80,(int)(iStation*dJianGe+140),m_strName[i]);
			wsprintf(szBuffer,TEXT("%ld"),m_dwPoint[i]);

			dc.SetTextColor(RGB(0,0,0));
			dc.TextOut(221,(int)(iStation*dJianGe+140),szBuffer,lstrlen(szBuffer));
			dc.TextOut(220,(int)(iStation*dJianGe+141),szBuffer,lstrlen(szBuffer));
			dc.SetTextColor(RGB(255,255,255));
			dc.TextOut(220,(int)(iStation*dJianGe+140),szBuffer,lstrlen(szBuffer));
			iStation++;
		}
	}

	//显示税收
	if ((m_bShowTax==true)&&(iStation>0))
	{
		dc.SetTextColor(RGB(0,0,0));
		dc.TextOut(81,(int)(iStation*dJianGe+140),TEXT("交易税"),lstrlen(TEXT("交易税")));
		dc.TextOut(80,(int)(iStation*dJianGe+141),TEXT("交易税"),lstrlen(TEXT("交易税")));
		dc.SetTextColor(RGB(255,255,255));
		dc.TextOut(80,(int)(iStation*dJianGe+140),TEXT("交易税"),lstrlen(TEXT("交易税")));
		wsprintf(szBuffer,"%ld",m_dwGameTax);

		dc.SetTextColor(RGB(0,0,0));
		dc.TextOut(221,(int)(iStation*dJianGe+140),szBuffer,lstrlen(szBuffer));
		dc.TextOut(220,(int)(iStation*dJianGe+141),szBuffer,lstrlen(szBuffer));
		dc.SetTextColor(RGB(255,255,255));
		dc.TextOut(220,(int)(iStation*dJianGe+140),szBuffer,lstrlen(szBuffer));
	}

	return;
}
Ejemplo n.º 5
0
void CSplashScreenEx::OnPaint()
{
	CPaintDC dc(this); // device context for painting
	DrawWindow(&dc);
}
void CNCaptureView::ClientToDoc(CRect* pRect)
{
	CWindowDC dc(m_hWnd);
	PrepareDC(dc.m_hDC);
	dc.DPtoLP((LPPOINT)pRect, 2);
}
void CNCaptureView::DocToClient(CRect* pRect)
{
	CWindowDC dc(m_hWnd);
	PrepareDC(dc.m_hDC);
	dc.LPtoDP((LPPOINT)pRect, 2);
}
Ejemplo n.º 8
0
void IW::CRender::DrawFocusRect(LPCRECT lpRect)
{
	IW::CDCRender dc(*this);
	dc.DrawFocusRect(lpRect);
}
Ejemplo n.º 9
0
void IW::CRender::DrawIcon(HICON hIcon, int x, int y, int cx, int cy)
{
	IW::CDCRender dc(*this);
	DrawIconEx(dc, x, y, hIcon, cy, cx, 0, 0, DI_NORMAL);
}
HBRUSH CXTPPropertyPageTabNavigator::GetPageBrush(CDC* pDC, CXTPPropertyPage* pPage)
{
	COLORREF clrClient = COLORREF_NULL;

	if (GetPaintManager()->GetColor() == xtpTabColorWinNative)
	{
		clrClient = COLOR_WINXP;
	}
	else
	{
		CXTPTabManagerItem* pItem = GetSelectedItem();
		if (!pItem)
			return NULL;

		clrClient = GetPaintManager()->GetColorSet()->GetItemColor(pItem);
	}

	if (m_clrBrush != clrClient)
	{
		m_brushPage.DeleteObject();
		m_clrBrush = clrClient;
	}

	if (m_brushPage.GetSafeHandle())
		return m_brushPage;

	if (m_clrBrush == GetXtremeColor(COLOR_3DFACE))
		return 0;

	if (m_clrBrush != COLOR_WINXP)
	{
		m_brushPage.CreateSolidBrush(m_clrBrush);
		return m_brushPage;

	}

	if (m_brushPage.GetSafeHandle() == 0)
	{
		CXTPClientRect rc(pPage);
		if (rc.IsRectEmpty())
			 return 0;

		CXTPWinThemeWrapper wrapper;
		wrapper.OpenTheme(0, L"TAB");

		if (!wrapper.IsAppThemed())
			return 0;

		CBitmap bmp;
		bmp.CreateCompatibleBitmap(pDC, rc.Width(), rc.Height());
		{
			CRect   rectContent(0, 0, 0, 0);
			if (FAILED(wrapper.GetThemeBackgroundContentRect(pDC->GetSafeHdc(), TABP_PANE, 0, rc, rectContent)))
			{
				rectContent = rc;
				rectContent.DeflateRect(2, 2, 4, 4);
			}

			CRect rcPane(-rectContent.left, -rectContent.top, rc.right + (rc.right - rectContent.right),
				rc.bottom + (rc.bottom - rectContent.bottom));

			CXTPCompatibleDC dc(pDC, bmp);
			wrapper.DrawThemeBackground(dc, TABP_PANE, 0, rcPane, 0);
		}

		m_brushPage.Attach( ::CreatePatternBrush(bmp));
	}

	return m_brushPage;
}
Ejemplo n.º 11
0
void CSizingControlBar::OnPaint()
{
    // overridden to skip border painting based on clientrect
    CPaintDC dc(this);
}
Ejemplo n.º 12
0
wxSize wxRibbonPanel::DoGetNextLargerSize(wxOrientation direction,
                                        wxSize relative_to) const
{
    if(m_expanded_panel != NULL)
    {
        // Next size depends upon children, who are currently in the
        // expanded panel
        return m_expanded_panel->DoGetNextLargerSize(direction, relative_to);
    }

    if(IsMinimised(relative_to))
    {
        wxSize current = relative_to;
        wxSize min_size = GetMinNotMinimisedSize();
        switch(direction)
        {
        case wxHORIZONTAL:
            if(min_size.x > current.x && min_size.y == current.y)
                return min_size;
            break;
        case wxVERTICAL:
            if(min_size.x == current.x && min_size.y > current.y)
                return min_size;
            break;
        case wxBOTH:
            if(min_size.x > current.x && min_size.y > current.y)
                return min_size;
            break;
        default:
            break;
        }
    }

    if(m_art != NULL)
    {
        wxClientDC dc((wxRibbonPanel*) this);
        wxSize child_relative = m_art->GetPanelClientSize(dc, this, relative_to, NULL);
        wxSize larger(-1, -1);

        if(GetSizer())
        {
            // We could just let the sizer expand in flow direction but see comment
            // in IsSizingContinuous()
            larger = GetPanelSizerBestSize();
            // and adjust for page in non flow direction
            if(m_art->GetFlags() & wxRIBBON_BAR_FLOW_VERTICAL)
            {
                 if(larger.x != child_relative.x)
                    larger.x = child_relative.x;
            }
            else if(larger.y != child_relative.y)
            {
                larger.y = child_relative.y;
            }
        }
        else if(GetChildren().GetCount() == 1)
        {
            // Simple (and common) case of single ribbon child
            wxWindow* child = GetChildren().Item(0)->GetData();
            wxRibbonControl* ribbon_child = wxDynamicCast(child, wxRibbonControl);
            if(ribbon_child != NULL)
            {
                larger = ribbon_child->GetNextLargerSize(direction, child_relative);
            }
        }

        if(larger.IsFullySpecified()) // Use fallback if !(sizer/child = 1)
        {
            if(larger == child_relative)
            {
                return relative_to;
            }
            else
            {
                return m_art->GetPanelSize(dc, this, larger, NULL);
            }
        }
    }

    // Fallback: Increase by 25% (equal to a prior or subsequent 20% decrease)
    // Note that due to rounding errors, this increase may not exactly equal a
    // matching decrease - an ideal solution would not have these errors, but
    // avoiding them is non-trivial unless an increase is by 100% rather than
    // a fractional amount. This would then be non-ideal as the resizes happen
    // at very large intervals.
    wxSize current(relative_to);
    if(direction & wxHORIZONTAL)
    {
        current.x = (current.x * 5 + 3) / 4;
    }
    if(direction & wxVERTICAL)
    {
        current.y = (current.y * 5 + 3) / 4;
    }
    return current;
}
Ejemplo n.º 13
0
wxSize wxRibbonPanel::DoGetNextSmallerSize(wxOrientation direction,
                                         wxSize relative_to) const
{
    if(m_expanded_panel != NULL)
    {
        // Next size depends upon children, who are currently in the
        // expanded panel
        return m_expanded_panel->DoGetNextSmallerSize(direction, relative_to);
    }

    if(m_art != NULL)
    {
        wxClientDC dc((wxRibbonPanel*) this);
        wxSize child_relative = m_art->GetPanelClientSize(dc, this, relative_to, NULL);
        wxSize smaller(-1, -1);
        bool minimise = false;

        if(GetSizer())
        {
            // Get smallest non minimised size
            smaller = GetMinSize();
            // and adjust to child_relative for parent page
            if(m_art->GetFlags() & wxRIBBON_BAR_FLOW_VERTICAL)
            {
                 minimise = (child_relative.y <= smaller.y);
                 if(smaller.x < child_relative.x)
                    smaller.x = child_relative.x;
            }
            else
            {
                minimise = (child_relative.x <= smaller.x);
                if(smaller.y < child_relative.y)
                    smaller.y = child_relative.y;
            }
        }
        else if(GetChildren().GetCount() == 1)
        {
            // Simple (and common) case of single ribbon child or Sizer
            wxWindow* child = GetChildren().Item(0)->GetData();
            wxRibbonControl* ribbon_child = wxDynamicCast(child, wxRibbonControl);
            if(ribbon_child != NULL)
            {
                smaller = ribbon_child->GetNextSmallerSize(direction, child_relative);
                minimise = (smaller == child_relative);
            }
        }

        if(minimise)
        {
            if(CanAutoMinimise())
            {
                wxSize minimised = m_minimised_size;
                switch(direction)
                {
                case wxHORIZONTAL:
                    minimised.SetHeight(relative_to.GetHeight());
                    break;
                case wxVERTICAL:
                    minimised.SetWidth(relative_to.GetWidth());
                    break;
                default:
                    break;
                }
                return minimised;
            }
            else
            {
                return relative_to;
            }
        }
        else if(smaller.IsFullySpecified()) // Use fallback if !(sizer/child = 1)
        {
            return m_art->GetPanelSize(dc, this, smaller, NULL);
        }
    }

    // Fallback: Decrease by 20% (or minimum size, whichever larger)
    wxSize current(relative_to);
    wxSize minimum(GetMinSize());
    if(direction & wxHORIZONTAL)
    {
        current.x = (current.x * 4) / 5;
        if(current.x < minimum.x)
        {
            current.x = minimum.x;
        }
    }
    if(direction & wxVERTICAL)
    {
        current.y = (current.y * 4) / 5;
        if(current.y < minimum.y)
        {
            current.y = minimum.y;
        }
    }
    return current;
}
Ejemplo n.º 14
0
void cef_dark_aero_window::UpdateMenuBar()
{
    cef_buffered_dc dc(this);
    DrawMenuBar(dc);
}
Ejemplo n.º 15
0
void CChildView::OnPaint() 
{
CPaintDC dcPaint( this );
	CExtPaintManager::stat_ExcludeChildAreas(
		dcPaint.GetSafeHdc(),
		GetSafeHwnd()
		);
CExtMemoryDC dc( &dcPaint );

CGdiObject * pOld0, * pOld1;
CExtWndShadow _shadow;

WORD _PatternBits0[8],_PatternBits1[8];
	for( INT iPatternLine=0; iPatternLine < 8; iPatternLine++ )
	{
		_PatternBits0[iPatternLine] =
			( iPatternLine & 1 )
				? WORD(0xFFFF)
				: WORD( ~ ( 5<<iPatternLine ) )
				;
		_PatternBits1[iPatternLine] =
			( iPatternLine & 1 )
				? WORD(0xFFFF)
				: WORD( ~ ( 1<<(8-iPatternLine) ) )
				;
	}
CBitmap bmpPattern0,bmpPattern1;
CBrush brPattern0,brPattern1;
	VERIFY( bmpPattern0.CreateBitmap(8,8,1,1,_PatternBits0) );
	VERIFY( bmpPattern1.CreateBitmap(8,8,1,1,_PatternBits1) );
	VERIFY( brPattern0.CreatePatternBrush(&bmpPattern0) );
	VERIFY( brPattern1.CreatePatternBrush(&bmpPattern1) );

CRect rcPattern0(10,10,180,150), rcPattern1(40,30,80,200);

	dc.FillRect(rcPattern0,&brPattern0);
	_shadow.Paint(
		dc, rcPattern0, CRect(0,0,0,0), CRect(0,0,0,0),
		CExtWndShadow::DEF_SHADOW_SIZE,
		CExtWndShadow::DEF_BRIGHTNESS_MIN, CExtWndShadow::DEF_BRIGHTNESS_MAX,
		false
		);
	pOld0 = dc.SelectStockObject( NULL_BRUSH );
	pOld1 = dc.SelectStockObject( BLACK_PEN );
	dc.Rectangle( rcPattern0 );
	if( pOld0 != NULL )
		dc.SelectObject( pOld0 );
	if( pOld1 != NULL )
		dc.SelectObject( pOld1 );
	
	dc.FillRect(rcPattern1,&brPattern1);
	_shadow.Paint(
		dc, rcPattern1, CRect(0,0,0,0), CRect(0,0,0,0),
		CExtWndShadow::DEF_SHADOW_SIZE,
		CExtWndShadow::DEF_BRIGHTNESS_MIN, CExtWndShadow::DEF_BRIGHTNESS_MAX,
		false
		);
	pOld0 = dc.SelectStockObject( NULL_BRUSH );
	pOld1 = dc.SelectStockObject( BLACK_PEN );
	dc.Rectangle( rcPattern1 );
	if( pOld0 != NULL )
		dc.SelectObject( pOld0 );
	if( pOld1 != NULL )
		dc.SelectObject( pOld1 );

CRect rc0(20,50,160,80);
CRect rc1(160,50,210,80);
CRect rc2(rc0.left,rc0.top,rc1.right,rc1.bottom);
COLORREF clrLeft = RGB(0,255,0);
COLORREF clrMiddle = RGB(255,255,0);
COLORREF clrRight = RGB(255,0,0);
	CExtPaintManager::stat_PaintGradientRect(
		dc, rc0, clrLeft, clrMiddle );
	CExtPaintManager::stat_PaintGradientRect(
		dc, rc1, clrMiddle,clrRight );
	_shadow.Paint(
		dc, rc2, CRect(0,0,0,0), CRect(0,0,0,0),
		CExtWndShadow::DEF_SHADOW_SIZE,
		CExtWndShadow::DEF_BRIGHTNESS_MIN, CExtWndShadow::DEF_BRIGHTNESS_MAX,
		false
		);
	pOld0 = dc.SelectStockObject( NULL_BRUSH );
	pOld1 = dc.SelectStockObject( BLACK_PEN );
	dc.Rectangle(rc2);
	if( pOld0 != NULL )
		dc.SelectObject( pOld0 );
	if( pOld1 != NULL )
		dc.SelectObject( pOld1 );

CRect rc3(120,40,150,80);
CRect rc4(120,80,150,160);
CRect rc5(rc3.left,rc3.top,rc4.right,rc4.bottom);
COLORREF clrUpper = RGB(255,0,255);
COLORREF clrMiddleV = RGB(255,255,255);
COLORREF clrLower = RGB(0,0,255);
	CExtPaintManager::stat_PaintGradientRect(
		dc, rc3, clrMiddleV, clrUpper, TRUE );
	CExtPaintManager::stat_PaintGradientRect(
		dc, rc4, clrLower, clrMiddleV, TRUE );
	_shadow.Paint(
		dc, rc5, CRect(0,0,0,0), CRect(0,0,0,0),
		CExtWndShadow::DEF_SHADOW_SIZE,
		CExtWndShadow::DEF_BRIGHTNESS_MIN, CExtWndShadow::DEF_BRIGHTNESS_MAX,
		false
		);
	pOld0 = dc.SelectStockObject( NULL_BRUSH );
	pOld1 = dc.SelectStockObject( BLACK_PEN );
	dc.Rectangle(rc5);
	if( pOld0 != NULL )
		dc.SelectObject( pOld0 );
	if( pOld1 != NULL )
		dc.SelectObject( pOld1 );
}
Ejemplo n.º 16
0
void IW::CRender::DrawImageList(HIMAGELIST hImageList, int nItem, int x, int y, int cx, int cy)
{
	IW::CDCRender dc(*this);
	ImageList_DrawEx(hImageList, nItem, dc, x, y, cx, cy, CLR_NONE, CLR_NONE, ILD_TRANSPARENT);
}
void CNCaptureView::ClientToDoc(CPoint* pPoint) 
{
	CWindowDC dc(m_hWnd);
	PrepareDC(dc.m_hDC);
	dc.DPtoLP(pPoint, 1);
}
void CHandGestureRecognitionSystemDlg::OnPaint()
{
    if (IsIconic())
    {
        CPaintDC dc(this); // device context for painting

        SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

        // Center icon in client rectangle
        int cxIcon = GetSystemMetrics(SM_CXICON);
        int cyIcon = GetSystemMetrics(SM_CYICON);
        CRect rect;
        GetClientRect(&rect);
        int x = (rect.Width() - cxIcon + 1) / 2;
        int y = (rect.Height() - cyIcon + 1) / 2;

        // Draw the icon
        dc.DrawIcon(x, y, m_hIcon);
    }
    else
    {
        CDialogEx::OnPaint();
    }
    // set area
    int static_height = image_interval * 1;
    int static_width = image_interval * 20;
    MoveWindow(image_interval,
        image_interval,
        image_width * 2 + 4 * image_interval,
        image_height * 2 + 11 * image_interval);
    GetDlgItem(IDC_STATIC_CAMERA)->MoveWindow(
        image_interval * 1 + (image_width - static_width) / 2,
        image_interval * 1,
        static_width,
        static_height);
    GetDlgItem(IDC_STATIC_CAMERA)->ModifyStyle(SS_LEFT|SS_RIGHT,SS_CENTER,TRUE);
    GetDlgItem(IDC_IMAGE_CAMERA)->MoveWindow(
        image_interval * 1,
        image_interval * 3,
        image_width,
        image_height);
    GetDlgItem(IDC_STATIC_SEGMENT)->MoveWindow(
        image_interval * 1 + image_width + (image_width - static_width) / 2,
        image_interval * 1,
        static_width,
        static_height);
    GetDlgItem(IDC_STATIC_SEGMENT)->ModifyStyle(SS_LEFT|SS_RIGHT,SS_CENTER,TRUE);
    GetDlgItem(IDC_IMAGE_SEGMENT)->MoveWindow(
        image_interval * 2 + image_width,
        image_interval * 3,
        image_width,
        image_height);
    GetDlgItem(IDC_STATIC_FEATURE)->MoveWindow(
        image_interval * 1 + (image_width - static_width) / 2,
        image_interval * 4 + image_height,
        static_width,
        static_height);
    GetDlgItem(IDC_STATIC_FEATURE)->ModifyStyle(SS_LEFT|SS_RIGHT,SS_CENTER,TRUE);
    GetDlgItem(IDC_IMAGE_FEATURE)->MoveWindow(
        image_interval * 1,
        image_interval * 6 + image_height,
        image_width,
        image_height);
    GetDlgItem(IDC_STATIC_RECOGNITION)->MoveWindow(
        image_interval * 1 + image_width + (image_width - static_width) / 2,
        image_interval * 4 + image_height,
        static_width,
        static_height);
    GetDlgItem(IDC_STATIC_RECOGNITION)->ModifyStyle(SS_LEFT|SS_RIGHT,SS_CENTER,TRUE);
    GetDlgItem(IDC_IMAGE_RECOGNITION)->MoveWindow(
        image_interval * 2 + image_width,
        image_interval * 6 + image_height,
        image_width,
        image_height);
    GetDlgItem(IDC_BUTTON_PLAY_CAMERA)->MoveWindow(
        image_interval * 1,
        image_interval * 7 + image_height * 2,
        image_interval * 5,
        image_interval);
    GetDlgItem(IDC_BUTTON_STOP_CAMERA)->MoveWindow
        (image_interval * 7,
        image_interval * 7 + image_height * 2,
        image_interval * 5,
        image_interval);
    GetDlgItem(IDC_BUTTON_REFRESH_BACKGROUND)->MoveWindow(
        image_interval * 13,
        image_interval * 7 + image_height * 2,
        image_interval * 5,
        image_interval);
    GetDlgItem(ID_CLOSE)->MoveWindow(
        image_interval * 28,
        image_interval * 7 + image_height * 2,
        image_interval * 5,
        image_interval);
    // set font
    CFont testfont;
    testfont.CreatePointFont(110, "微软雅黑");
    GetDlgItem(IDC_STATIC_CAMERA)->SetFont(&testfont);
    GetDlgItem(IDC_STATIC_SEGMENT)->SetFont(&testfont);
    GetDlgItem(IDC_STATIC_FEATURE)->SetFont(&testfont);
    GetDlgItem(IDC_STATIC_RECOGNITION)->SetFont(&testfont);
    GetDlgItem(ID_CLOSE)->SetFont(&testfont);
    // set rect
    GetDlgItem(IDC_IMAGE_CAMERA)->GetClientRect(&rect_image_camera);
    GetDlgItem(IDC_IMAGE_SEGMENT)->GetClientRect(&rect_image_segment);
    GetDlgItem(IDC_IMAGE_FEATURE)->GetClientRect(&rect_image_feature);
    GetDlgItem(IDC_IMAGE_RECOGNITION)->GetClientRect(&rect_image_recognition);
}
void CNCaptureView::DocToClient(CPoint* pPoint)
{
	CWindowDC dc(m_hWnd);
	PrepareDC(dc.m_hDC);
	dc.LPtoDP(pPoint, 1);
}
Ejemplo n.º 20
0
//重画函数
void CControlWnd::OnPaint()
{
	CPaintDC dc(this);

	//获取位置
	CRect rcClient;
	GetClientRect(&rcClient);

	//创建缓冲
	CDC BufferDC;
	CBitmap BufferImage;
	BufferDC.CreateCompatibleDC(&dc);
	BufferImage.CreateCompatibleBitmap(&dc,rcClient.Width(),rcClient.Height());
	BufferDC.SelectObject(&BufferImage);

	//加载资源
	CImageHandle HandleControlTop(&m_ImageControlTop);
	CImageHandle HandleControlMid(&m_ImageControlMid);
	CImageHandle HandleControlButtom(&m_ImageControlButtom);
	CImageHandle HandleActionExplain(&m_ImageActionExplain);

	//绘画背景
	m_ImageControlTop.BitBlt(BufferDC,0,0);
	for (int nImageYPos=m_ImageControlTop.GetHeight();nImageYPos<rcClient.Height();nImageYPos+=m_ImageControlMid.GetHeight())
	{
		m_ImageControlMid.BitBlt(BufferDC,0,nImageYPos);
	}
	m_ImageControlButtom.BitBlt(BufferDC,0,rcClient.Height()-m_ImageControlButtom.GetHeight());

	//变量定义
	int nYPos=5;
	BYTE cbCurrentItem=0;
	BYTE cbExcursion[3]={0,1,2};
	BYTE cbItemKind[4]={WIK_LEFT,WIK_CENTER,WIK_RIGHT,WIK_PENG};

	//绘画扑克
	for (BYTE i=0;i<CountArray(cbItemKind);i++)
	{
		if ((m_cbActionMask&cbItemKind[i])!=0)
		{
			//绘画扑克
			for (BYTE j=0;j<3;j++)
			{
				BYTE cbCardData=m_cbCenterCard;
				if (i<CountArray(cbExcursion))
					cbCardData=m_cbCenterCard+j-cbExcursion[i];
				g_CardResource.m_ImageTableBottom.DrawCardItem(&BufferDC,cbCardData,j*26+12,nYPos+5);
			}

			//计算位置
			int nXImagePos=0;
			int nItemWidth=m_ImageActionExplain.GetWidth()/7;
			if ((m_cbActionMask&cbItemKind[i])&WIK_PENG)
				nXImagePos=nItemWidth;

			//绘画标志
			int nItemHeight=m_ImageActionExplain.GetHeight();
			m_ImageActionExplain.BitBlt(BufferDC,126,nYPos+5,nItemWidth,nItemHeight,nXImagePos,0);

			//绘画边框
			if (cbCurrentItem==m_cbCurrentItem)
			{
				BufferDC.Draw3dRect(7,nYPos,rcClient.Width()-14,ITEM_HEIGHT,RGB(255,255,0),RGB(255,255,0));
			}

			//设置变量
			++cbCurrentItem;
			nYPos+=ITEM_HEIGHT;
		}
	}

	//杠牌扑克
	for (BYTE i=0;i<CountArray(m_cbGangCard);i++)
	{
		if (m_cbGangCard[i]!=0)
		{
			//绘画扑克
			for (BYTE j=0;j<4;j++)
			{
				g_CardResource.m_ImageTableBottom.DrawCardItem(&BufferDC,m_cbGangCard[i],j*26+12,nYPos+5);
			}

			//绘画边框
			if (cbCurrentItem==m_cbCurrentItem)
			{
				BufferDC.Draw3dRect(7,nYPos,rcClient.Width()-14,ITEM_HEIGHT,RGB(255,255,0),RGB(255,255,0));
			}

			//绘画标志
			int nItemWidth=m_ImageActionExplain.GetWidth()/7;
			int nItemHeight=m_ImageActionExplain.GetHeight();
			m_ImageActionExplain.BitBlt(BufferDC,126,nYPos+5,nItemWidth,nItemHeight,nItemWidth*3,0);

			//设置变量
			cbCurrentItem++;
			nYPos+=ITEM_HEIGHT;
		}
		else
			break;
	}

	//绘画界面
	dc.BitBlt(0,0,rcClient.Width(),rcClient.Height(),&BufferDC,0,0,SRCCOPY);

	//清理资源
	BufferDC.DeleteDC();
	BufferImage.DeleteObject();

	return;
}
Ejemplo n.º 21
0
void CDockButton::OnPaint()
{
    CPaintDC dc(this); // device context for painting
    CBrush cb;
    COLORREF m_clrBorder=GuiDrawLayer::GetRGBColorShadow(GuiDrawLayer::m_Style);
    COLORREF m_clrFace=GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style);
    CPen cp(PS_SOLID,1,m_clrFace);
    CPen* cpold=dc.SelectObject(&cp);
    CRect m_rect;
    GetClientRect(m_rect);
    cb.CreateSolidBrush(m_clrFace);
    if (GuiDrawLayer::m_Style== GUISTYLE_XP)
        dc.FillRect(m_rect,&cb);
    else
    {
        CGradient M(CSize(m_rect.Width(),m_rect.Height()));
        if (m_nDockBarAling ==AFX_IDW_DOCKBAR_LEFT || m_nDockBarAling ==AFX_IDW_DOCKBAR_RIGHT)
            M.PrepareCaptionVert(&dc,GuiDrawLayer::m_Style);
        else
            M.PrepareCaption(&dc,GuiDrawLayer::m_Style);
        M.Draw(&dc,m_rect.left,m_rect.top,0,0,m_rect.Width(),m_rect.Height(),SRCCOPY);
    }

    dc.Draw3dRect(m_rect,m_clrBorder,m_clrBorder);
    GuiDrawLayer::DrawIcon(&dc,CPoint(m_rect.left+2,m_rect.top+2),m_szBtn,m_hIcon);

    switch(m_nDockBarAling)
    {


    case AFX_IDW_DOCKBAR_TOP:
        dc.MoveTo(m_rect.left,m_rect.top);
        dc.LineTo(m_rect.right,m_rect.top);
        if(m_hIcon != NULL)
            m_rect.left+=m_szBtn.cx+4;
        DrawTextHorz(&dc,m_rect);
        break;
    case AFX_IDW_DOCKBAR_LEFT:
        dc.MoveTo(m_rect.left,m_rect.top);
        dc.LineTo(m_rect.left,m_rect.bottom);
        if(m_hIcon != NULL)
            m_rect.top+=m_szBtn.cy+4;
        DrawTextVert(&dc,m_rect);
        break;
    case AFX_IDW_DOCKBAR_RIGHT:
        dc.MoveTo(m_rect.right-1,m_rect.top);
        dc.LineTo(m_rect.right-1,m_rect.bottom);
        if(m_hIcon != NULL)
            m_rect.top+=m_szBtn.cy+4;
        DrawTextVert(&dc,m_rect);
        break;
    case AFX_IDW_DOCKBAR_BOTTOM:
        dc.MoveTo(m_rect.left,m_rect.bottom-1);
        dc.LineTo(m_rect.right,m_rect.bottom-1);
        if(m_hIcon != NULL)
            m_rect.left+=m_szBtn.cx+4;
        DrawTextHorz(&dc,m_rect);
        break;
    }
    dc.SelectObject(cpold);

}
Ejemplo n.º 22
0
void wxVideoTerminal::DrawTexts()
{
	wxSize bmp_sz;

	if (mp_bitmap)
		bmp_sz = mp_bitmap->GetSize();
	
	// Calculate bitmap size according the viewport
	wxSize new_bmp_sz(m_screen_size.GetWidth() * m_font_size.GetWidth(), 
		wxMax(m_screen_size.GetHeight(),m_viewport.GetHeight()) *  m_font_size.GetHeight() );
	
	if (bmp_sz != new_bmp_sz)
	{
		if (mp_bitmap)
			delete mp_bitmap;

		mp_bitmap = new wxBitmap(new_bmp_sz.GetWidth(),  new_bmp_sz.GetHeight(), 24);

		if ( mp_bitmap )
		{
			m_redraw_bitmap = true;
			bmp_sz = new_bmp_sz;

			wxMemoryDC dc(*mp_bitmap);
			dc.SetBackground(brushes[0]);
			dc.Clear();
		}
	}

	if (!mp_bitmap) return;

	wxMemoryDC dc(*mp_bitmap);
	dc.SetFont( m_console_font );

	TCharAttr old_attr, attr;
	
	int j = m_scrollpos_row;
	int virtual_y = -1;
	{
		int scroll_gap = m_topscreen_row - m_scrollpos_row;
		virtual_y = m_screen_cur.y + scroll_gap;
	}
	
	wxPoint pt_sel_begin, pt_sel_end;
	if (m_isSelecting) {
		bool swap = false;

		if (m_ptBeginSelect.y == m_ptEndSelect.y) {
			if (m_ptBeginSelect.x > m_ptEndSelect.x) swap = true;
		} else if (m_ptBeginSelect.y > m_ptEndSelect.y) 
			swap = true;
		
		if (swap) {
			pt_sel_begin = m_ptEndSelect; 
			pt_sel_end = m_ptBeginSelect;
		} else {
			pt_sel_begin = m_ptBeginSelect; 
			pt_sel_end = m_ptEndSelect;
		}
	}

	int y;
	for (y=0; y < m_viewport.GetHeight() && j < m_botscreen_row; ++y, ++j)
	{
		wxTermLine &term_line = m_lines[j];
		// dirty if its line where cursor staying
		if (y == virtual_y || m_redraw_bitmap) term_line.dirty = true;
		if (m_isSelecting && pt_sel_begin.y <= j && pt_sel_end.y >= j) term_line.dirty = true;

		if (!term_line.dirty) continue;

		term_line.dirty = false;

		old_attr.value = 0;
		dc.SetBrush( brushes[0] );
		dc.SetPen( pens[0] );
		
		dc.DrawRectangle(0,y*m_font_size.GetHeight(), 
			bmp_sz.GetWidth(), m_font_size.GetHeight() );

		const int w = m_font_size.GetWidth();
		const int h = m_font_size.GetHeight();

		int x;
		int x2 = 0;
		int x1 = term_line.width;

		if (m_isSelecting && pt_sel_begin.y <= j && pt_sel_end.y >= j) {
			x2 = term_line.width;
			x1 = 0;
			if (j == pt_sel_begin.y)
				x1 = pt_sel_begin.x;
			if (j == pt_sel_end.y ) {
				if (pt_sel_end.x <= term_line.visible_width)
					x2 = pt_sel_end.x;
			}
		}

		for (x=0; x < m_screen_size.GetWidth(); ++x)
		{
			bool invert = (x >= x1 && x < x2) ? true : false;

			attr.value   = term_line.GetAttr(x); //.attrs[x];
			wxUniChar ch = term_line.GetChar(x); //.chars[x];
			
			if (invert) {
				char tmp_color = attr.val.bgcolor;
				attr.val.bgcolor = attr.val.fgcolor ? attr.val.fgcolor: 7;
				attr.val.fgcolor = tmp_color;
			}

			if (attr.value == 0) continue;

			if (attr.value != old_attr.value)
			{
				if (attr.val.dim)
				{

				} else
				if (attr.val.bold)
					attr.val.fgcolor = 8+(attr.val.fgcolor%8);

				if (attr.val.reverse)
				{
					unsigned char tmp = attr.val.fgcolor;
					attr.val.fgcolor = attr.val.bgcolor;
					attr.val.bgcolor = tmp;
				}
				
				dc.SetTextForeground( colors[attr.val.fgcolor] );

				if (old_attr.val.bgcolor != attr.val.bgcolor)
				{
					dc.SetBrush( brushes[attr.val.bgcolor] );
					dc.SetPen( pens[attr.val.bgcolor] );
				}
				
#if 0
				if (old_attr.val.bold != attr.val.bold)
				{
					if (attr.val.bold)
						dc.SetFont( m_console_font.Bold() );
					else
						dc.SetFont( m_console_font );
				}
#endif
				old_attr = attr;
			}

			if (attr.val.bgcolor > 0)
			{
				dc.DrawRectangle(
					x*w,
					y*h,
					w,
					h);
			}

			dc.DrawText(ch, x*w,y*h);
			if (attr.val.underline)
			{
				dc.SetPen( pens[attr.val.fgcolor] );
				dc.DrawLine( x*w, y*h+h-1, x*w+w,y*h+h-1);
			}
		}
	}

	m_redraw_bitmap = false;
	if (m_cursor_blink)
	{
		dc.SetBrush( brushes[7] );
		dc.SetPen( pens[7] );

		if (virtual_y >= 0 && virtual_y < m_viewport.y)
		{
			dc.DrawRectangle(m_screen_cur.x*m_font_size.GetWidth(),
				virtual_y * m_font_size.GetHeight(), 
				m_font_size.GetWidth(), m_font_size.GetHeight());
		}
	}
}
// WaveformViewDialog message handlers
void WaveformViewDialog::OnPaint() {
  BufferredPaintDC dc(this);
  
  CRect rectTitle;
  GetDlgItem(IDC_PLACE_CAPTION)->GetWindowRect(&rectTitle);
  ScreenToClient(&rectTitle);
  dc.FillSolidRect(rectTitle, RGB(54, 133, 214));

  CRect waveformRect;
  GetDlgItem(IDC_PLACE_WAVEFORM)->GetWindowRect(&waveformRect);
  ScreenToClient(&waveformRect);
  dc.FillSolidRect(waveformRect, RGB(0, 0, 0));

  CFont *oldFont = dc.SelectObject(GuiResources::GetInstance()->GetFont(GuiResources::FONT_NORMAL));
  dc.SetTextColor(RGB(255, 255, 255));
  dc.SetBkMode(TRANSPARENT);
  CSize textSize = dc.GetTextExtent(_T("88888"));
  waveformRect.left += textSize.cx + 8;

  if (monitor_ != NULL && cashIndex_ != -1) {
    int cashCount = monitor_->Freeze();
    if (cashIndex_ < cashCount) {
      Cash *cash = monitor_->GetCash(cashIndex_);
      CPen penYellow(PS_SOLID, 1, RGB(255, 255, 0));
      CPen penGreen(PS_SOLID, 1, RGB(0, 255, 0));
      int count = cash->GetADCSampleCount(g_ADCChannels[channel_].id);      
      if (count > 0) {
        CString title;
        title.Format(_T("%s - %s"), (LPCTSTR)CA2T(cash->GetSN()), g_ADCChannels[channel_].name);
        labelTitle_.SetWindowText(title);

        const short *codes = cash->GetADCSampleCodes(g_ADCChannels[channel_].id);
        const short *values = cash->GetADCSampleValues(g_ADCChannels[channel_].id);
        
        // draw scaler
        __int64 sum = 0;
        short minValue = SHORT_MAX, maxValue = SHORT_MIN;
        for (int i = 0; i < count; i++) {
          if (values[i] < minValue) {
            minValue = values[i];
          }
          if (values[i] > maxValue) {
            maxValue = values[i];
          }
          sum += values[i];
        }
        CPen whitePen(PS_SOLID, 1, RGB(255, 255, 255));
        CPen *oldPen = dc.SelectObject(&whitePen);
        dc.MoveTo(waveformRect.left, waveformRect.top);
        dc.LineTo(waveformRect.left, waveformRect.bottom);
        
        int height = waveformRect.Height();
        int range = g_ADCChannels[channel_].maxValue - g_ADCChannels[channel_].minValue;
        // min
        CString label;
        int x = waveformRect.left - textSize.cx - 8;
        int y = waveformRect.bottom - (minValue - g_ADCChannels[channel_].minValue) * height / range;
        dc.MoveTo(waveformRect.left - 4, y);
        dc.LineTo(waveformRect.right, y);
        label.Format(_T("%d"), minValue);
        dc.TextOut(x, y - textSize.cy / 2, label);
        // center
        short median = (short)(sum / count);
        y = waveformRect.bottom - (median - g_ADCChannels[channel_].minValue) * height / range;
        dc.MoveTo(waveformRect.left - 4, y);
        dc.LineTo(waveformRect.right, y);
        label.Format(_T("%d"), median);
        dc.TextOut(x, y - textSize.cy / 2, label);
        // max
        y = waveformRect.bottom - (maxValue - g_ADCChannels[channel_].minValue) * height / range;
        dc.MoveTo(waveformRect.left - 4, y);
        dc.LineTo(waveformRect.right, y);
        label.Format(_T("%d"), maxValue);
        dc.TextOut(x, y - textSize.cy / 2, label);

        dc.SelectObject(oldPen);

        ::DrawWaveform(&dc, waveformRect, codes, codes[0], codes[count - 1], count, &penYellow);
        ::DrawWaveform(&dc, waveformRect, values, 
            g_ADCChannels[channel_].minValue, 
            g_ADCChannels[channel_].maxValue, count, &penGreen);
      }
    }
    monitor_->Unfreeze();
  }

  dc.SelectObject(oldFont);
}
void COpenCVInterfaceDlg::OnPaint()
{
	CPaintDC dc(this); // device context for painting

	//In variabila r1 pastrez dimensiunile ferestrei picture1
	CRect r1;
	GetClientRect(&r1);

	int w,h;

	if(mainImage.cols)
	{
		//aleg minimul dintre dimensiunile imag si ale ferestrei de afisare
		if(mainImage.cols<r1.Width()) w=mainImage.cols;
		else w=r1.Width();
		if(mainImage.rows<r1.Height()) h=mainImage.rows;
		else h=r1.Height();

		//creez un dreptunghi cu dimensiunile minime si il umplu cu peria imagine
		CRect r(0,0,w-1,h-1);
		dc.FillRect(r,ImageBrush);

		CMenu* mmenu =GetMenu();
		CMenu* submenu =mmenu->GetSubMenu(1);
		UINT state = submenu->GetMenuState(ID_TOOLS_GRAYLEVELROW,MF_BYCOMMAND);
		UINT state1 = submenu->GetMenuState(ID_TOOLS_GRAYLEVELCOLUMN,MF_BYCOMMAND);
		ASSERT(state != 0xFFFFFFFF);
		ASSERT(state1 != 0xFFFFFFFF);
		if(state & MF_CHECKED)
		{ 
			if(gr->GetY()<mainImage.rows)
			{
				gr->setGCheck(true);
				CPen *pen = new CPen(PS_SOLID,1,RGB(255,0,0));
				CPen *oldPen;
				oldPen=(CPen*)dc.SelectObject(pen);
				dc.MoveTo(0,gr->GetY());
				dc.LineTo(mainImage.cols,gr->GetY());
				dc.SelectObject(oldPen);
				delete pen;
			}
		}
		else
		{
			if(state1 & MF_CHECKED)
			{
				gr->setGCheck(false);
				if(gr->GetX()<mainImage.cols)
				{
					CPen *pen = new CPen(PS_SOLID,1,RGB(255,0,0));
					CPen *oldPen;
					oldPen=(CPen*)dc.SelectObject(pen);
					dc.MoveTo(gr->GetX(),0);
					dc.LineTo(gr->GetX(),mainImage.rows);
					dc.SelectObject(oldPen);
					delete pen;
				}
			}

		}
	}
}
Ejemplo n.º 25
0
void CTimeEv::OnTeTakePict() 
{
//	CWnd*		pWnd = CWnd::GetDesktopWindow();
	CWindowDC	dc(this);
	CDC			memDC;
	CRect		rect;
	CBitmap		bitmap;
	CClientDC	pDC(this);


//	pWnd->GetWindowRect(rect);
	GetWindowRect(rect);
	memDC.CreateCompatibleDC(&dc);
//	bitmap.CreateCompatibleBitmap(&dc,rect.right,rect.bottom);
	bitmap.CreateCompatibleBitmap(&dc,rect.Width(),rect.Height());

	CBitmap *oldBM = memDC.SelectObject(&bitmap);
//	memDC.BitBlt(rect.left, rect.top, rect.Width(), rect.Height(), &dc, 0, 0, SRCCOPY);
	memDC.BitBlt(0, 0, rect.Width(), rect.Height(), &dc, 0, 0, SRCCOPY);
	
	BITMAP bm;
	bitmap.GetObject(sizeof(bm),&bm);

//	pDC.BitBlt(0, 0, rect.right, rect.bottom, &memDC, 0, 0, SRCCOPY);
	pDC.BitBlt(0, 0, rect.Width(), rect.Height(), &memDC, 0, 0, SRCCOPY);

	

	CFile file;
	file.Open("a.pcx",CFile::modeWrite | CFile::modeCreate);
	CreatePCXHeader(&file,rect.Width(),rect.Height());
	
	short *bmBit;
	RGBQUAD *rgbQuad;
	bmBit = (short*) malloc (bm.bmHeight * bm.bmWidthBytes * 2);
	int n = bitmap.GetBitmapBits(bm.bmHeight * bm.bmWidthBytes, bmBit);

	rgbQuad = (RGBQUAD*) malloc (bm.bmHeight * bm.bmWidthBytes * sizeof(RGBQUAD));
	

	for (int y=0; y< rect.Height();y++)
	{
		for (char hl=0; hl<3; hl++)
		{
			for (int x=0; x < rect.Width();x++)
			{
				char byte; RGBQUAD rgb;
				rgb = QuadFromWord( bmBit[y*rect.Width() + x]);
				if (hl == 0)
					byte = rgb.rgbRed;
				if (hl == 1)
					byte = rgb.rgbGreen;
				if (hl == 2)
					byte = rgb.rgbBlue;
				char toWr;
				toWr = (char) 0xC1;
				file.Write(&toWr,1);
				file.Write(&byte,1);
			}
		}
	}		

	free(bmBit);
	free(rgbQuad);
	
	file.Close();

	char txt[300];
	sprintf(txt,"type:%d, width:%d, height:%d, widthbytes:%d, planes:%d, BitsPixel:%d,",
		bm.bmType, bm.bmWidth, bm.bmHeight, bm.bmWidthBytes, bm.bmPlanes, bm.bmBitsPixel);
//	sprintf(txt,"%d %d", rect.left,rect.right);
	pDC.TextOut(10,10,txt);

	memDC.SelectObject(oldBM);
	MessageBeep(0);
}
Ejemplo n.º 26
0
void CEx_DrawView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
    CEx_DrawDoc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);

    m_ptLocalScroll = GetScrollPosition();
    CPoint ptLocal = point + m_ptLocalScroll;

    m_bLButtonDown = TRUE;
    m_bContextMenu = FALSE;

    SetCapture();

    CClientDC dc(this);

    UpdateWindow(); // 强制刷新
    m_backDC.BitBlt(0, 0, m_size.cx, m_size.cy, NULL, 0, 0, WHITENESS);
    m_backDC.BitBlt(0, 0, m_size.cx, m_size.cy, &dc, 0, 0, SRCCOPY);

    if (pDoc->m_GM.m_DrawType != NONE)
    {
        pDoc->m_GM.m_pt1 = ptLocal;

        m_lastPt = point;
        pDoc->m_GM.m_pts.RemoveAll();

        if (pDoc->m_GM.m_DrawType == CURVE)
        {
            GraphicMember* pGM = &pDoc->m_GM;
            m_pen.DeleteObject();
            m_pen.CreatePen(pGM->m_iPenStyle, pGM->m_iPenWidth, pGM->m_clrPen);
            m_bufferDC.BitBlt(0, 0, m_size.cx, m_size.cy, NULL, 0, 0, WHITENESS);
            m_bufferDC.BitBlt(0, 0, m_size.cx, m_size.cy, &m_backDC, 0, 0, SRCCOPY);
        }
    }
    else if (pDoc->m_GM.m_DrawType == SELECT)
    {
        BOOL bResult = FALSE;
        int last_sel = pDoc->m_sel;
        GraphicHitTest(ptLocal, bResult, pDoc->m_sel);
        if (!bResult) { pDoc->m_sel = -1; TRACE("Hit NONE\n") ;}
        else {
            CGraphic* P = Convert_To_Graphic(pDoc->m_obArray[pDoc->m_sel]);
            TRACE("Hit (%d,%d) in graphic [ID: %d TYPE: \"%s\" RECT: (%d,%d,%d,%d)]\n",
                ptLocal.x, ptLocal.y, pDoc->m_sel, P->GetName(),
                P->m_pt1.x, P->m_pt1.y, P->m_pt2.x, P->m_pt2.y);
        }
        if (last_sel != -1 && !m_bSizingMode)
        {
			if (last_sel == pDoc->m_obArray.GetSize()) last_sel--;
            CRect rt;
            Convert_To_Graphic(pDoc->m_obArray[last_sel])->GetRect(rt);
            rt.OffsetRect(-GetScrollPosition());
            InvalidateRect(&rt, TRUE);
        }
        if (pDoc->m_sel != -1)
        {
            ASSERT(m_pMoveTarget == NULL);
            
            static GraphicMember GM;
            Convert_To_Graphic(pDoc->m_obArray[pDoc->m_sel])->UpdateData(&GM, FALSE);
            m_pLogBuffer = CGraphic::CreateGraphic(&GM);
            m_pLogBuffer->m_modifiedTime = pDoc->m_GM.m_modifiedTime;
            m_pMoveTarget = CGraphic::CreateGraphic(&GM);
            if (last_sel == pDoc->m_sel) // 缩放
            {
                BOOL bRet = FALSE;
                m_sizingX = NULL;
                m_sizingY = NULL;
                m_pMoveTarget->HitSizingTest(ptLocal, bRet, &m_sizingX, &m_sizingY);
                if (bRet) m_bSizingMode = TRUE;
            }
            m_bufferDC.BitBlt(0, 0, m_size.cx, m_size.cy, NULL, 0, 0, WHITENESS);
            m_bufferDC.BitBlt(m_ptLocalScroll.x, m_ptLocalScroll.y,
                m_size.cx - m_ptLocalScroll.x, m_size.cy - m_ptLocalScroll.y, &m_backDC, 0, 0, SRCCOPY);
            m_pMoveTarget->Draw(&m_bufferDC);
            m_bufferDC.SelectObject(GetStockObject(WHITE_BRUSH));
            m_bufferDC.SelectObject(GetStockObject(BLACK_PEN));
            m_pMoveTarget->DrawSelectedEdge(&m_bufferDC);
            if (pDoc->m_bShowTab) GraphicDrawTab(&m_bufferDC, m_pMoveTarget, pDoc->m_sel);
            dc.BitBlt(0, 0, m_size.cx - m_ptLocalScroll.x, m_size.cy - m_ptLocalScroll.y, &m_bufferDC,
                m_ptLocalScroll.x, m_ptLocalScroll.y, SRCCOPY);
            m_ptCurTarget1 = m_pMoveTarget->m_pt1;
            m_ptCurTarget2 = m_pMoveTarget->m_pt2;
            m_ptOriginHit = point;
        }
    }

    m_bFirstMove = TRUE;

    if (pDoc->m_sel != -1)
    {
        static CString strPane;
        static CGraphic* P;
        P = Convert_To_Graphic(pDoc->m_obArray[pDoc->m_sel]);
        strPane.Format(_T("您选中了:%s"), P->GetName());
        m_pBar->SetPaneText(0, strPane.GetBuffer(0));
    }
    else
    {
        m_pBar->SetPaneText(0, _T("您当前没有选中任何图形"));
    }

    pDoc->UpdateAllViews(NULL, 0x4001);

    CScrollView::OnLButtonDown(nFlags, point);
}
Ejemplo n.º 27
0
void CPropPageFrameDefault::OnPaint() 
{
	CPaintDC dc(this);
	Draw(&dc);	
}
Ejemplo n.º 28
0
void CEx_DrawView::OnMouseMove(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
    CEx_DrawDoc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);

    m_ptLocalScroll = GetScrollPosition();
    CPoint ptLocal = point + m_ptLocalScroll;

    if (m_bLButtonDown)
    {
        CClientDC dc(this);
        switch (pDoc->m_GM.m_DrawType)
        {
        case SELECT:
            if (m_pMoveTarget)
            {
                if (m_bFirstMove && m_bLButtonDown)
                {                    
                    if (m_bCtrlDown && !m_bSizingMode)
                    {
                        static GraphicMember GM;
                        m_pMoveTarget->UpdateData(&GM, FALSE);
                        m_pMoveTarget = CGraphic::CreateGraphic(&GM);
                        m_pMoveTarget->m_lpszName.Format(_T("%s_%d"), m_pMoveTarget->GetName(), ++pDoc->m_createID);
                        pDoc->WriteLog(CGraphicLog::GOS_ADD, m_pMoveTarget, pDoc->m_obArray.GetSize());
                        pDoc->m_sel = pDoc->m_obArray.GetSize() - 1;
                        pDoc->UpdateAllViews(NULL, 0x4000);
                        pDoc->UpdateAllViews(NULL, 0x4001);
                        m_bDup = TRUE;
                    }

                    m_backDC.BitBlt(0, 0, m_size.cx, m_size.cy, NULL, 0, 0, WHITENESS);
                    DrawGraphic(&m_backDC, pDoc->m_sel);
                }

                static CPoint offset;                
                offset = point;
                offset -= m_ptOriginHit;
                if (m_bSizingMode)
                {
                    if (m_sizingX) *m_sizingX = ptLocal.x;
                    if (m_sizingY) *m_sizingY = ptLocal.y;
                }
                else
                {
                    m_pMoveTarget->m_pt1 = m_ptCurTarget1 + offset;
                    m_pMoveTarget->m_pt2 = m_ptCurTarget2 + offset;
                }

                m_bufferDC.BitBlt(0, 0, m_size.cx, m_size.cy, NULL, 0, 0, WHITENESS);
                m_bufferDC.BitBlt(0, 0, m_size.cx, m_size.cy, &m_backDC, 0, 0, SRCCOPY);
                m_pMoveTarget->Draw(&m_bufferDC);
                m_bufferDC.SelectObject(GetStockObject(WHITE_BRUSH));
                m_bufferDC.SelectObject(GetStockObject(BLACK_PEN));
                m_pMoveTarget->DrawSelectedEdge(&m_bufferDC);
                if (pDoc->m_bShowTab) GraphicDrawTab(&m_bufferDC, m_pMoveTarget, pDoc->m_sel);
                dc.BitBlt(0, 0, m_size.cx - m_ptLocalScroll.x, m_size.cy - m_ptLocalScroll.y, &m_bufferDC,
                    m_ptLocalScroll.x, m_ptLocalScroll.y, SRCCOPY);
            }
            break;
        case CURVE:
            pDoc->m_GM.m_pts.Add((CPoint)(ptLocal - pDoc->m_GM.m_pt1)); // 相对位置
            m_bufferDC.SelectObject(&m_pen);
            m_bufferDC.MoveTo(m_lastPt);
            m_bufferDC.LineTo(point);
            dc.BitBlt(0, 0, m_size.cx, m_size.cy, &m_bufferDC, 0, 0, SRCCOPY);
            break;
        case LINE:
        case RECTANGLE:
        case ELLIPSE:
            CGraphic* pGraphic = CGraphic::CreateGraphic(&pDoc->m_GM);
            ASSERT(pGraphic);
            pGraphic->m_pt1 -= GetScrollPosition();
            pGraphic->m_pt2 = point;
            if (m_bShiftDown)
                pGraphic->m_pt2.y = pGraphic->m_pt1.y + labs (pGraphic->m_pt2.x - pGraphic->m_pt1.x);
            m_bufferDC.BitBlt(0, 0, m_size.cx, m_size.cy, NULL, 0, 0, WHITENESS);
            m_bufferDC.BitBlt(0, 0, m_size.cx, m_size.cy, &m_backDC, 0, 0, SRCCOPY);
            pGraphic->Draw(&m_bufferDC);
            dc.BitBlt(0, 0, m_size.cx, m_size.cy, &m_bufferDC, 0, 0, SRCCOPY);
            delete pGraphic;
            break;
        }

        m_lastPt = point;
    }

    m_ptCursor = ptLocal;
    m_bFirstMove = FALSE;

	CScrollView::OnMouseMove(nFlags, point);
}
Ejemplo n.º 29
0
void CCheckerCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	SetFocus();

	DWORD dwPos = GetMessagePos();
	CPoint clickedPoint((int)(short)LOWORD(dwPos), (int)(short)HIWORD(dwPos));
	ScreenToClient(&clickedPoint);
	
	{
		CRect cRect;
		GetWindowRect(&cRect);
		ScreenToClient(&cRect);

		UINT nY = UINT(((float)clickedPoint.y / (float(cRect.Height())/float(m_nBlocksPerColumn)))+.3);

		UINT nX = UINT(((float)clickedPoint.x / (float(cRect.Width())/float(m_nBlocksPerRow)))+.3);

		UINT nIndex = nY * m_nBlocksPerRow + nX + m_nyPos * m_nBlocksPerRow;

		if(nIndex < m_nNumberofBlocks && nX < m_nBlocksPerRow)
		{

			CString strNumber;
//			strNumber.Format("%d", nIndex + m_nStartIndex+1);
			strNumber = (m_crText.GetAt(nIndex + m_nStartIndex));

			if (strNumber.GetLength())
			{
				SetCapture();
				CreateSafeTooltipRect(clickedPoint.x, clickedPoint.y, strNumber);

				GetParent()->PostMessage(9876,(WPARAM)(nIndex+m_nStartIndex+1), 0);
			
				CClientDC dc(this);
				CBrush brush;
				brush.CreateSolidBrush(GetSysColor(COLOR_INFOBK));
				dc.Rectangle(tooltipRect);
				
				tooltipRect.left++;
				tooltipRect.top++;
				tooltipRect.bottom--;
				tooltipRect.right--;
				
				dc.FillRect(tooltipRect, &brush);
				
				CFont font;
				LOGFONT logFont;
				strcpy(logFont.lfFaceName, "Verdana");
				logFont.lfHeight = -MulDiv(12, GetDeviceCaps(dc.m_hDC, LOGPIXELSY), 72);
				logFont.lfWidth = 0;
				logFont.lfEscapement = 0;
				logFont.lfItalic = FALSE;
				logFont.lfStrikeOut = FALSE;
				logFont.lfUnderline = FALSE;
				logFont.lfWeight = FW_BOLD;
				
				font.CreateFontIndirect(&logFont);
				
				dc.SelectObject(font);
				
				dc.SetTextColor(GetSysColor(COLOR_INFOTEXT));
				dc.SetBkColor(GetSysColor(COLOR_INFOBK));
				dc.DrawText(strNumber, tooltipRect, DT_VCENTER | DT_CENTER | DT_SINGLELINE);
				
				tooltipRect.left--;
				tooltipRect.top--;
				tooltipRect.bottom++;
				tooltipRect.right++;

				m_bShouldUpdated = TRUE;
			}
		}
	}

	CWnd::OnLButtonDown(nFlags, point);
}
Ejemplo n.º 30
0
/*
 * Alternatively, you can use a clientDC to paint on the panel
 * at any time. Using this generally does not free you from
 * catching paint events, since it is possible that e.g. the window
 * manager throws away your drawing when the window comes to the
 * background, and expects you will redraw it when the window comes
 * back (by sending a paint event).
 */
void wxImagePanel::PaintNow() {
     // depending on your system you may need to look at double-buffered dcs
     wxClientDC dc(this);
     Render(dc);
}