Exemplo n.º 1
0
void CMemoryWatcherDlg::OnTimer(UINT_PTR nIDEvent)
{
	if (nIDEvent == 1)
	{
		if (!h)
		{
			if (m_ProcessID)
				h = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, m_ProcessID);
			else
				h = GetCurrentProcess();
			if (!h)
				return;
		}
		PROCESS_MEMORY_COUNTERS pmc;
		if (GetProcessMemoryInfo(h, &pmc, sizeof(pmc)))
		{
			points.push(pmc.WorkingSetSize);
			points_pagefile.push(pmc.PagefileUsage);
			peak = pmc.PeakWorkingSetSize;
			peak_pagefile = pmc.PeakPagefileUsage;
		}
		else
		{
			points.push(0);
			points_pagefile.push(0);
		}
		if (points.size() > m_NumSteps + 1)
		{
			points.pop();
			points_pagefile.pop();
		}
		SIZE_T l, total;
		CDC * idc = CDC::FromHandle(img->GetDC());
		CPen pen, * oldpen, * oldpen2, pen2, pen3;
		CString s;
		// setting pen color
		pen.CreatePen(PS_SOLID, 3, RGB(0, 200, 0));
		oldpen = idc->SelectObject(&pen);
		double dx = double(img->GetWidth()) / (m_NumSteps - 1), dy = double(img->GetHeight()) / (m_MaxMem - 1);
		int x, y;
		// clearing image
		idc->FillSolidRect(-1, -1, img->GetWidth() + 2, img->GetHeight() + 2, RGB(0, 0, 0));
		// drawing grid
		pen2.CreatePen(PS_SOLID, 1, RGB(150, 150, 150));
		oldpen2 = idc->SelectObject(&pen2);
		for (UINT i = 0; i < points.size(); i++)
		{
			x = int(i * dx);
			idc->MoveTo(x, 0);
			idc->LineTo(x, img->GetHeight());
		}
		for (double i = 0.0; i < img->GetHeight(); i += img->GetHeight() / 10.0)
		{
			idc->MoveTo(0, int(i));
			idc->LineTo(img->GetWidth(), int(i));
		}
		idc->SelectObject(oldpen2);
		// setting text color
		idc->SetTextColor(RGB(0, 200, 0));
		// drawing points
		for (UINT i = 0; i < points.size(); i++)
		{
			l = points._Get_container()[i];
			x = int(i * dx);
			y = img->GetHeight() - int(l * dy) - 1;
			if (!i)
			{
				idc->MoveTo(x, y);
			}
			else
			{
				idc->LineTo(x, y);
			}
			if (i == points.size() - 1)
			{
				s.Format(L"Memory: %u KB of %u KB, peak %u KB", l / 1024, m_MaxMem / 1024, peak / 1024);
				idc->TextOutW(1, 1, s);
				total = l;
			}
		}
		// drawing points_pagefile
		// setting other pen color
		pen3.CreatePen(PS_SOLID, 3, RGB(200, 0, 0));
		oldpen2 = idc->SelectObject(&pen3);
		// setting text color
		idc->SetTextColor(RGB(200, 0, 0));
		for (UINT i = 0; i < points_pagefile.size(); i++)
		{
			l = points_pagefile._Get_container()[i];
			x = int(i * dx);
			y = img->GetHeight() - int(l * dy) - 1;
			if (!i)
			{
				idc->MoveTo(x, y);
			}
			else
			{
				idc->LineTo(x, y);
			}
			if (i == points_pagefile.size() - 1)
			{
				s.Format(L"Swap: %u KB, peak %u KB", l / 1024, peak_pagefile / 1024);
				idc->TextOutW(1, 17, s);
				total += l;
			}
		}
		// setting text color
		idc->SetTextColor(RGB(200, 200, 0));
		s.Format(L"Total: %u KB, peak %u KB", total / 1024, (peak_pagefile + peak) / 1024);
		idc->TextOutW(1, 33, s);
		idc->SelectObject(oldpen2);
		idc->SelectObject(oldpen);
		img->ReleaseDC();
		// displaying image
		DrawImage();
		// saving to file
		f << l << L"\n";
	}
	CDialog::OnTimer(nIDEvent);
}
Exemplo n.º 2
0
// 画文字信息
void CPopupList::DrawWindow(CDC &dc, CRect rcClient)
{
	int nItemCount =  m_vecItem.size();
	CFont *pOldFont = dc.SelectObject(&m_font);
	COLORREF clrOld = dc.SetTextColor(RGB(0, 20, 35));
	CRect rcItem, rcText;
	CSize sizeImage;

	for(int i = 0; i < nItemCount; i++)
	{
		EditListItem &editListItem = m_vecItem.at(i);
		rcItem = editListItem.rcItem;
		sizeImage = editListItem.sizeImage;
		int nLeftStart = 47;
		if(editListItem.pImage == NULL)
		{
			nLeftStart = 5;
		}

		// 显示当前项
 		if((i == m_nHoverItem) && !editListItem.strDesc.IsEmpty())
 		{
 			dc.FillSolidRect(&rcItem, RGB(0, 147, 209));
 
			// 显示name和desc
 			dc.SetTextColor(RGB(0, 20, 35));
 			rcText.SetRect(rcItem.left + nLeftStart, rcItem.top + 6, rcItem.right - 2, rcItem.top + 24);
 			dc.DrawText(editListItem.strName, &rcText, DT_TOP | DT_LEFT | DT_SINGLELINE | DT_WORD_ELLIPSIS);
 
 			dc.SetTextColor(RGB(255, 255, 255));
 			rcText.OffsetRect(0, 21);
 			dc.DrawText(editListItem.strDesc, &rcText, DT_TOP | DT_LEFT | DT_SINGLELINE | DT_WORD_ELLIPSIS);
 		}
 		else
		{
			if(i == m_nHoverItem)
			{
				dc.FillSolidRect(&rcItem, RGB(0, 147, 209));
			}

			// 只显示name
			dc.SetTextColor(RGB(0, 20, 35));
			rcText.SetRect(rcItem.left + nLeftStart, rcItem.top, rcItem.right - 2, rcItem.bottom);
			dc.DrawText(editListItem.strName, &rcText, DT_VCENTER | DT_LEFT | DT_SINGLELINE | DT_WORD_ELLIPSIS);
		}
	}
	dc.SelectObject(pOldFont);
	dc.SetTextColor(clrOld);
}
void CXTPReportRecordItemPercentNumber::OnDrawCaption(XTP_REPORTRECORDITEM_DRAWARGS* pDrawArgs, XTP_REPORTRECORDITEM_METRICS* pMetrics)
{
	ASSERT(pDrawArgs->pItem == this);

	CString sTxt = pMetrics->strText;

	if (sTxt.Find('%') > -1)
	{
		sTxt.Replace(_T("%"), _T(""));
		int iTxt = _ttoi(sTxt);

		if (m_bPercentCompleteDisplay)
		{
			iTxt = max(0, iTxt);
			iTxt = min(100, iTxt);
			pMetrics->strText.Format(_T("%d"), iTxt);

			CDC* pDC = pDrawArgs->pDC;
			if (pDC)
			{
				CRect rc = pDrawArgs->rcItem;
				rc.DeflateRect(2, 2, 2, 2);
				int W = rc.Width();

				if (pMetrics->nColumnAlignment == xtpColumnTextLeft)
					rc.right = rc.left + W * iTxt / 100;
				else if (pMetrics->nColumnAlignment == xtpColumnTextRight)
					rc.left = rc.right - W * iTxt / 100;
				else if (pMetrics->nColumnAlignment == xtpColumnTextCenter)
				{
					rc.left += W * (100 - iTxt) / 200;
					rc.right -= W * (100 - iTxt) / 200;
				}

				if (pDrawArgs->pControl
					&& pDrawArgs->pControl->GetPaintManager()
					&& pDrawArgs->pControl->GetPaintManager()->m_bShowNonActiveInPlaceButton)
					rc.right -= rc.Height();

				pDC->FillSolidRect(rc, m_clr);

				//CRgn rgnEvent;
				//rgnEvent.CreateRoundRectRgn(rc.left, rc.top, rc.right, rc.bottom, 7, 7);
				//CXTPPaintManagerColorGradient* pGrad = new CXTPPaintManagerColorGradient(m_clr);
				//pDC->SelectClipRgn(&rgnEvent);
				//CRect rcBk = rc;
				//rcBk.DeflateRect(0, 1, 0, 1);
				//XTPDrawHelpers()->GradientFill(pDC, &rcBk, *pGrad, FALSE);
				//pDC->SelectClipRgn(NULL);
				//delete pGrad;
			}
		}
	}
	if (m_pMarkupUIElement)
	{
		CRect rcItem = pDrawArgs->rcItem;
		rcItem.DeflateRect(2, 1, 2, 0);

		XTPMarkupSetDefaultFont(XTPMarkupElementContext(m_pMarkupUIElement), (HFONT)pMetrics->pFont->GetSafeHandle(), pMetrics->clrForeground);

		XTPMarkupMeasureElement(m_pMarkupUIElement, rcItem.Width(), INT_MAX);
		XTPMarkupRenderElement(m_pMarkupUIElement, pDrawArgs->pDC->GetSafeHdc(), &rcItem);
	}
	else
	{
		pDrawArgs->pControl->GetPaintManager()->DrawItemCaption(pDrawArgs, pMetrics);
	}
}
Exemplo n.º 4
0
void CCheckListBox::PreDrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
{
	_AFX_CHECKLIST_STATE* pChecklistState = _afxChecklistState;

	DRAWITEMSTRUCT drawItem;
	memcpy(&drawItem, lpDrawItemStruct, sizeof(DRAWITEMSTRUCT));

	if ((((LONG)drawItem.itemID) >= 0) &&
	   ((drawItem.itemAction & (ODA_DRAWENTIRE | ODA_SELECT)) != 0))
	{
		int cyItem = GetItemHeight(drawItem.itemID);

		CDC* pDC = CDC::FromHandle(drawItem.hDC);

		COLORREF newBkColor = GetSysColor(COLOR_WINDOW);

		BOOL fDisabled = !IsWindowEnabled() || !IsEnabled(drawItem.itemID);
		if ((drawItem.itemState & ODS_SELECTED) && !fDisabled)
			newBkColor = GetSysColor(COLOR_HIGHLIGHT);

		COLORREF oldBkColor = pDC->SetBkColor(newBkColor);

		CDC bitmapDC;
		if (bitmapDC.CreateCompatibleDC(pDC))
		{
			int nCheck = GetCheck(drawItem.itemID);
			HBITMAP hOldBitmap = (HBITMAP)::SelectObject(bitmapDC.m_hDC, pChecklistState->m_hbitmapCheck);

			CRect rectCheck = drawItem.rcItem;
			rectCheck.left += 1;
			rectCheck.top += 1 + max(0, (cyItem - pChecklistState->m_sizeCheck.cy) / 2);
			rectCheck.right = rectCheck.left + pChecklistState->m_sizeCheck.cx;
			rectCheck.bottom = rectCheck.top + pChecklistState->m_sizeCheck.cy;

			CRect rectItem = drawItem.rcItem;
			rectItem.right = rectItem.left + pChecklistState->m_sizeCheck.cx + 2;

			CRect rectCheckBox = OnGetCheckPosition(rectItem, rectCheck);

			ASSERT(rectCheck.IntersectRect(rectItem, rectCheckBox));
			ASSERT((rectCheck == rectCheckBox) && (rectCheckBox.Size() == pChecklistState->m_sizeCheck));

			CBrush brush(newBkColor);
			pDC->FillRect(rectItem, &brush);

			pDC->BitBlt(rectCheckBox.left, rectCheckBox.top,
				pChecklistState->m_sizeCheck.cx, pChecklistState->m_sizeCheck.cy, &bitmapDC,
				pChecklistState->m_sizeCheck.cx  * nCheck, 0, SRCCOPY);

			::SelectObject(bitmapDC.m_hDC, hOldBitmap);
		}
		pDC->SetBkColor(oldBkColor);
	}

	if (drawItem.itemData != 0)
	{
		AFX_CHECK_DATA* pState = (AFX_CHECK_DATA*)drawItem.itemData;
		drawItem.itemData = pState->m_dwUserData;
	}
	drawItem.rcItem.left = drawItem.rcItem.left + pChecklistState->m_sizeCheck.cx + 2;

	DrawItem(&drawItem);
}
Exemplo n.º 5
0
//绘画函数
VOID CUserInfoView::OnPaint()
{
	CPaintDC dc(this);

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

	//建立缓冲
	CDC BufferDC;
	CBitmap ImageBuffer;
	BufferDC.CreateCompatibleDC(&dc);
	ImageBuffer.CreateCompatibleBitmap(&dc,rcClient.Width(),rcClient.Height());

	//设置 DC
	BufferDC.SetBkMode(TRANSPARENT);
	BufferDC.SelectObject(&ImageBuffer);
	BufferDC.SetTextColor(RGB(0,0,0));

	//填充背景
	BufferDC.FillSolidRect(&rcClient,COLOR_VIEW_BACKGROUND);

	//绘画边框
	CRect rcPhotoFram(PHOTO_FRAME_EXCURSION_X, PHOTO_FRAME_EXCURSION_Y, PHOTO_FRAME_EXCURSION_X+PHOTO_FRAME_WIDTH, PHOTO_FRAME_EXCURSION_Y+PHOTO_FRAME_HEIGHT);
	CPen BorderPen(PS_SOLID,2,COLOR_PHOTO_FRAM);
	CPen * pOldPen=BufferDC.SelectObject(&BorderPen);
	BufferDC.RoundRect(&rcPhotoFram,CPoint(0,00));
	BufferDC.SelectObject(pOldPen);

	//创建字体
	CFont Font;
	VERIFY(Font.CreateFont(12,0,0,0,FW_NORMAL,FALSE,FALSE,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,DEFAULT_PITCH | FF_SWISS,TEXT("宋体")));             

	CFont *pOldFont = BufferDC.SelectObject(&Font);

	//绘画用户
	if (m_pCurrentUserData!=NULL)
	{
		//变量定义
		TCHAR szString[256]=TEXT("");
		tagServerAttribute const* pGameAttribute=m_pIClientKernel->GetServerAttribute();

		//绘画标识
		if ( m_pCurrentUserData->dwCustomFaceVer == 0 )
		{
			//设置大小
			rcPhotoFram.DeflateRect(1, 1, 2, 2);

			if ( m_pCurrentUserData->cbGender != 2 )
			{
				CImageHandle ImageHandleMaleFace(&m_ImageMaleFace);
				m_ImageMaleFace.BitBlt(BufferDC.GetSafeHdc(), rcPhotoFram.left, rcPhotoFram.top);
			}
			else
			{
				CImageHandle ImageHandleFemaleFace(&m_ImageFemaleFace);
				m_ImageFemaleFace.BitBlt(BufferDC.GetSafeHdc(), rcPhotoFram.left, rcPhotoFram.top);
			}
		}
		//用户头像
		else
		{
			ASSERT(m_pIUserFaceRes!=NULL);
			m_pIUserFaceRes->DrawCustomBigFace(&BufferDC,rcPhotoFram.left+1, rcPhotoFram.top+1,m_pCurrentUserData->dwUserID,m_pCurrentUserData->dwCustomFaceVer);
		}

		//用户属性
		INT nUserInfoCuont = 6;
		const tagUserData *pMeUserData = m_pIClientKernel->GetMeUserInfo();
		if(pMeUserData!=NULL && m_pCurrentUserData->dwUserID==pMeUserData->dwUserID)
			nUserInfoCuont++;
		for (INT i=0;i<nUserInfoCuont;i++)
		{
			//位置定义
			CRect rcString;
			rcString.SetRect(PHOTO_FRAME_EXCURSION_X+PHOTO_FRAME_WIDTH+10,6+i*20,rcClient.Width()-5,6+i*20+15);

			TCHAR szString[128];

			//绘画信息
			switch (i)
			{
			case 0:		//用户帐号
				{
					//用户帐号
					_sntprintf(szString,CountArray(szString),TEXT("用户名:%s"),m_pCurrentUserData->szName);
					BufferDC.DrawText(szString,lstrlen(szString),&rcString,DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS);

					break;
				}
			case 1:
				{
					//输出信息
					if ( m_pCurrentUserData->cbGender == 0 ) 
						_sntprintf(szString,CountArray(szString),TEXT("性别:保密"));
					else if ( m_pCurrentUserData->cbGender == 1 ) 
						_sntprintf(szString,CountArray(szString),TEXT("性别:男"));
					else _sntprintf(szString,CountArray(szString),TEXT("性别:女"));
					BufferDC.DrawText(szString,lstrlen(szString),&rcString,DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS);

					break;
				}
			case 2:
				{
					BufferDC.SetTextColor(RGB(255,0,0));
					//输出信息
					_sntprintf(szString,CountArray(szString),TEXT("魅力:%ld"),m_pCurrentUserData->lLoveliness);
					BufferDC.DrawText(szString,lstrlen(szString),&rcString,DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS);

					BufferDC.SetTextColor(RGB(0,0,0));

					break;
				}
			case 3:
				{
					//输出信息
					if ( pGameAttribute->wGameGenre == GAME_GENRE_GOLD )
						_sntprintf(szString,CountArray(szString),TEXT("游戏币:%ld"),m_pCurrentUserData->lScore);
					else
						_sntprintf(szString,CountArray(szString),TEXT("积分:%ld"),m_pCurrentUserData->lScore);
					BufferDC.DrawText(szString,lstrlen(szString),&rcString,DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS);

					break;
				}
			case 4:
				{
					CGameFrameControl *pGameFrameControl= (CGameFrameControl *)GetParent();
					CUserListView &UserListView = pGameFrameControl->m_UserListView;

					//输出信息
					_sntprintf(szString,CountArray(szString),TEXT("游戏级别:%s"),
						UserListView.m_GameRankManagerHelper->GetLevelDescribe(m_pCurrentUserData->lScore));
					BufferDC.DrawText(szString,lstrlen(szString),&rcString,DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS);

					break;
				}
			case 5:
				{
					CGameFrameControl *pGameFrameControl= (CGameFrameControl *)GetParent();
					CUserListView &UserListView = pGameFrameControl->m_UserListView;

					//会员信息
					LPCTSTR pszMemberOrder[]={TEXT("非会员"),TEXT("红钻会员"),TEXT("蓝钻会员"),TEXT("黄钻会员"),TEXT("紫钻会员")};
					if (m_pCurrentUserData->cbMemberOrder>=CountArray(pszMemberOrder))break;

					//输出信息
					_sntprintf(szString,CountArray(szString),TEXT("会员级别:%s"),pszMemberOrder[m_pCurrentUserData->cbMemberOrder]);
					BufferDC.DrawText(szString,lstrlen(szString),&rcString,DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS);

					break;
				}
			case 6:
				{
					//输出信息
					_sntprintf(szString,CountArray(szString),TEXT("银行存款:%ld"),m_pCurrentUserData->lInsureScore);
					BufferDC.DrawText(szString,lstrlen(szString),&rcString,DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS);

					break;
				}
			}
		}

		//魅力数目
		BufferDC.SetTextColor(RGB(255,0,0));
		CRect rcExchange;
		m_btExchange.GetWindowRect(rcExchange);
		ScreenToClient(rcExchange);
		CString strFlowerCount;
		strFlowerCount.Format(TEXT("%ld"), m_pCurrentUserData->lLoveliness);
		BufferDC.TextOut(rcExchange.right+4, rcExchange.top+4, strFlowerCount);
	}

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

	//清理资源	
	BufferDC.SelectObject(pOldFont);
	BufferDC.DeleteDC();
	ImageBuffer.DeleteObject();	
	Font.DeleteObject();

	return;
}
Exemplo n.º 6
0
static void 
MakeLightBitmap(CBitmap *bitmap, CPaintDC *dc, CRect *rect, COLORREF color)
{
	CBrush brush(dc->GetNearestColor(GetSysColor(COLOR_3DFACE)));
	CBrush colorBrush(dc->GetNearestColor(color));
	CPen pen(PS_SOLID, 1, dc->GetNearestColor(GetSysColor(COLOR_3DFACE)));
	CDC lightDC;
	CRect workRect;

	//Make the bitmap we'll work on:
	lightDC.CreateCompatibleDC(dc);
	bitmap->CreateCompatibleBitmap(dc,
							rect->Width(), 
							rect->Height());
	lightDC.SelectObject(bitmap);

	//The first step is to blank out the background
	lightDC.SelectObject(&brush);
	lightDC.SelectObject(&pen);

	lightDC.Rectangle(0, 0, rect->Width(), rect->Height());

	//Next, get a black pen and make a circle...
	pen.DeleteObject();
	pen.CreatePen(PS_SOLID, 1, dc->GetNearestColor(RGB(0, 0, 0)));
	lightDC.SelectObject(&pen);
	lightDC.Ellipse(rect);
	workRect = *rect;
	workRect.DeflateRect(LIGHT_WIDTH / 4, LIGHT_HEIGHT / 4);
	lightDC.Ellipse(workRect);

	//Last, fill it with the appropriate color:
	//Next, get a black pen and make a circle...
	lightDC.SelectObject(colorBrush);
	lightDC.FloodFill(LIGHT_WIDTH / 2, 
					  LIGHT_HEIGHT / 2, 
					  dc->GetNearestColor(RGB(0, 0, 0)));
}
Exemplo n.º 7
0
HBITMAP CLibraryAlbumView::CreateDragImage(const CPoint& ptMouse, CPoint& ptMiddle)
{
	CRect rcClient, rcOne, rcAll( 32000, 32000, -32000, -32000 );
	
	GetClientRect( &rcClient );
	
	for ( POSITION pos = m_pSelTrack.GetHeadPosition() ; pos ; )
	{
		CLibraryAlbumTrack* pTrack = m_pSelTrack.GetNext( pos );
		GetItemRect( pTrack, &rcOne );
		
		if ( rcOne.IntersectRect( &rcClient, &rcOne ) )
		{
			rcAll.left		= min( rcAll.left, rcOne.left );
			rcAll.top		= min( rcAll.top, rcOne.top );
			rcAll.right		= max( rcAll.right, rcOne.right );
			rcAll.bottom	= max( rcAll.bottom, rcOne.bottom );
		}
	}
	
	BOOL bClipped = rcAll.Height() > MAX_DRAG_SIZE;
	
	if ( bClipped )
	{
		rcAll.left		= max( rcAll.left, ptMouse.x - MAX_DRAG_SIZE_2 );
		rcAll.right		= max( rcAll.right, ptMouse.x + MAX_DRAG_SIZE_2 );
		rcAll.top		= max( rcAll.top, ptMouse.y - MAX_DRAG_SIZE_2 );
		rcAll.bottom	= max( rcAll.bottom, ptMouse.y + MAX_DRAG_SIZE_2 );
	}
	
	CClientDC dcClient( this );
	CBitmap bmDrag;
	CDC dcDrag;
	
	if ( ! dcDrag.CreateCompatibleDC( &dcClient ) )
		return NULL;
	if ( ! bmDrag.CreateCompatibleBitmap( &dcClient, rcAll.Width(), rcAll.Height() ) )
		return NULL;
	
	CBitmap *pOldDrag = dcDrag.SelectObject( &bmDrag );
	
	dcDrag.FillSolidRect( 0, 0, rcAll.Width(), rcAll.Height(), DRAG_COLOR_KEY );
	
	CRgn pRgn;
	
	ptMiddle.SetPoint( ptMouse.x - rcAll.left, ptMouse.y - rcAll.top );
	if ( bClipped )
	{
		pRgn.CreateEllipticRgn(	ptMiddle.x - MAX_DRAG_SIZE_2, ptMiddle.y - MAX_DRAG_SIZE_2,
								ptMiddle.x + MAX_DRAG_SIZE_2, ptMiddle.y + MAX_DRAG_SIZE_2 );
		dcDrag.SelectClipRgn( &pRgn );
	}
	
	CDC* pBuffer = CoolInterface.GetBuffer( dcClient, m_szTrack );
	CRect rcBuffer( 0, 0, m_szTrack.cx, m_szTrack.cy );
	
	CFont* pOldFont = (CFont*)pBuffer->SelectObject( &CoolInterface.m_fntNormal );
	
	for ( POSITION pos = m_pSelTrack.GetHeadPosition() ; pos ; )
	{
		CLibraryAlbumTrack* pTrack = m_pSelTrack.GetNext( pos );
		GetItemRect( pTrack, &rcOne );
		CRect rcDummy;
		
		if ( rcDummy.IntersectRect( &rcAll, &rcOne ) )
		{
			pBuffer->FillSolidRect( &rcBuffer, DRAG_COLOR_KEY );
			pTrack->Paint( this, pBuffer, rcBuffer, -1 );
			dcDrag.BitBlt( rcOne.left - rcAll.left, rcOne.top - rcAll.top,
				m_szTrack.cx, m_szTrack.cy, pBuffer, 0, 0, SRCCOPY );
		}
	}
	
	pBuffer->SelectObject( pOldFont );
	dcDrag.SelectObject( pOldDrag );
	dcDrag.DeleteDC();

	return (HBITMAP) bmDrag.Detach();
}
Exemplo n.º 8
0
void CWndImage::OnPaint() 
{
  DWORD style = GetStyle();
  if (!(style & WS_VISIBLE)) return;

  CPaintDC dc(this); 
  CRect r;
  GetClientRect(&r);

  CDC memdc;
  memdc.CreateCompatibleDC( &dc );
  CBitmap * prev = memdc.SelectObject(&m_bmp);

  dc.SetStretchBltMode(HALFTONE);  // works only under NT/2000, anyway..

  CRect & src = m_srcRect;
  CRect & dst = m_dstRect;

  if (m_bltMode == bltTile) 
  {
    if (!src.IsRectEmpty()) {
      for(int x=m_origin.x; x < r.right; x+=src.Width()) {
        if (x>-r.right) {
          for(int y=m_origin.y; y<r.bottom; y+=src.right) {
            if (y>-r.bottom) {
              dc.BitBlt(x, y, src.Width(), src.Height(), &memdc, src.left, src.top, 
                        SRCCOPY);
            }
          }
        }
      }
    }
  }

  else {
    dc.StretchBlt(dst.left, dst.top, dst.Width(), dst.Height(),
                  &memdc, 
                  src.left, src.top, src.Width(), src.Height(),
                  SRCCOPY);

      // clean background
    CRect wipe;
    if (dst.left > 0) {
      wipe.SetRect(0,0, dst.left, r.bottom);
     ::FillRect(dc.m_hDC, &wipe, m_backBrush);
    }

    if (dst.top > 0) {
      wipe.SetRect(dst.left, 0, dst.right, dst.top);
     ::FillRect(dc.m_hDC, &wipe, m_backBrush);
    }

    if (dst.right < r.right) {
      wipe.SetRect(dst.right, 0, r.right, r.bottom);
     ::FillRect(dc.m_hDC, &wipe, m_backBrush);
    }

    if (dst.bottom < r.bottom) {
      wipe.SetRect(dst.left, dst.bottom, dst.right, r.bottom);
     ::FillRect(dc.m_hDC, &wipe, m_backBrush);
    }
  }
  memdc.SelectObject( prev );
}
Exemplo n.º 9
0
void
CMainFrame::updateImageInfo()
{
   const CFlyCapDoc* pDoc = (CFlyCapDoc*)GetActiveDocument();
   CView* pView = (CView*)GetActiveView();   
   
   if( m_wndStatusBar &&
      pDoc != NULL && 
      pView != NULL )
   {
      char pszText[ 64 ];
      
      if( m_ImageInfoMode == TIMESTAMP )
      {
         // Setup the timestamp information
         FlyCaptureTimestamp timeStamp = pDoc->m_imageRaw.timeStamp;  
         
#if defined (WIN64)  
         __time64_t  tmpTime = timeStamp.ulSeconds;
         char* pszTemp = ::_ctime64( &tmpTime );
#elif defined (WIN32)
         time_t lTemp = timeStamp.ulSeconds;      
         char* pszTemp = ::ctime( &lTemp );
#else
#error ** No time conversion **
#endif
         if( pszTemp == NULL )
         {
            return;
         }
         int iMilliSec = timeStamp.ulMicroSeconds / 1000;
         sprintf(
            pszText,
            "%.19s.%.03d %s (%03u,%04u)\n",
            pszTemp,
            iMilliSec,
            &pszTemp[ 20 ],
            timeStamp.ulCycleSeconds,
            timeStamp.ulCycleCount );         
      }
      else if( m_ImageInfoMode == CURSOR )
      {
         // Setup the cursor and image information
         CRect rect;
         CPoint pt;
         COLORREF cr;
         int iWidth = 0;
         int iHeight = 0;
         int iSBOffsetX = 0; // the offset of the horizontal scrollbar
         int iSBOffsetY = 0; // the offset of the vertical scrollbar

         // get the position of the scroll bars.
         // used to calculate the co-ordinates of the image.
         iSBOffsetX = pView->GetScrollPos(SB_HORZ);
         iSBOffsetY = pView->GetScrollPos(SB_VERT);
         
         pDoc->getImageSize( &iWidth, &iHeight );
         CDC* pDC = pView->GetDC();
         pDC->GetClipBox( &rect );         
         GetCursorPos( &pt );                  
         pView->ScreenToClient( &pt );
         cr = GetPixel( pDC->GetSafeHdc(), pt.x, pt.y );
         pView->ReleaseDC( pDC );

         // Check that this window is active and 
         // that the cursor is within bounds of the clipping rect
         if( this == GetActiveWindow() &&
            pt.x >= 0 && pt.x < rect.Width() && pt.y >= 0 && pt.y < rect.Height() )
         {
            sprintf( pszText, "Image(%dx%d) Cursor(%d,%d) RGB(%u,%u,%u)", 
               iWidth, 
               iHeight, 
               pt.x + iSBOffsetX,
               pt.y + iSBOffsetY,
               cr & 0xFF, 
               (cr & 0xFF00) >> 8, 
               (cr & 0xFF0000) >> 16 );
         }
Exemplo n.º 10
0
void CMainDlg::DrawPhoto()
{
	if (m_BitmapEx.IsValid())
	{

		//CBitmapEx m_PhotoBitmapEx;

		//int tX,tY;
		
		CDC *pDC = m_ctl_photo.GetDC();

		CDC memDC;
		memDC.CreateCompatibleDC(pDC);

		CBitmap bmp;
		bmp.CreateCompatibleBitmap(pDC, m_PhotoBitmapEx.GetWidth(), m_PhotoBitmapEx.GetHeight());
		memDC.SelectObject(bmp);

		CRect rect(0,0,m_PhotoBitmapEx.GetWidth(),m_PhotoBitmapEx.GetHeight());
		CBrush bBlack(GetSysColor(COLOR_3DFACE));

		memDC.FillRect(&rect, &bBlack);
		m_PhotoBitmapEx.Draw(memDC);

		pDC->FillRect(&m_PhotoRect, &bBlack);

		pDC->SetStretchBltMode(HALFTONE);
		pDC->StretchBlt(0,0,m_PhotoRect.Width(), m_PhotoRect.Height(),
			&memDC, 
			0,0,
			m_CutRect.Width(), m_CutRect.Height(),
			SRCCOPY);

		/*CDC *pDC = m_ctl_photo.GetDC();

		CDC memDC;
		memDC.CreateCompatibleDC(pDC);

		CBitmap bmp;
		bmp.CreateCompatibleBitmap(pDC, m_PhotoBitmapEx.GetWidth(), m_PhotoBitmapEx.GetHeight());
		memDC.SelectObject(bmp);

		CRect rect(0,0,m_PhotoBitmapEx.GetWidth(),m_PhotoBitmapEx.GetHeight());
		CBrush bBlack(GetSysColor(COLOR_3DFACE));

		memDC.FillRect(&rect, &bBlack);

		m_PhotoBitmapEx.Draw(memDC);

		pDC->FillRect(&m_PhotoRect, &bBlack);

		pDC->SetStretchBltMode(HALFTONE);
		pDC->StretchBlt(0,0,m_PhotoRect.Width(), m_PhotoRect.Height(),
			&memDC, 
			0,0,
			m_PhotoBitmapEx.GetWidth(), m_PhotoBitmapEx.GetHeight(),
			SRCCOPY);*/

		memDC.DeleteDC();
		ReleaseDC(pDC);
	}
	else
	{
		CDC *pDC = m_ctl_photo.GetDC();
		CBrush bBlack(GetSysColor(COLOR_3DFACE));
		pDC->FillRect(m_PhotoRect,&bBlack);
	}
}
Exemplo n.º 11
0
void CMyHeaderCtrl::OnPaint()
{
	CPaintDC dc(this); 
	CRect rect,rectItem;
	GetClientRect(&rect);

	CDC hdcMem;
	hdcMem.CreateCompatibleDC(NULL);
	CBitmap hBitmap;
	hBitmap.CreateCompatibleBitmap(&dc,rect.Width(),rect.Height());
	hdcMem.SelectObject(&hBitmap);

	//CMemDC memDC(&dc, rect);
	int nItems = GetItemCount();

	if( m_pBitmapBk != NULL )
	{
		m_pBitmapBk->SetCDibRect( rect );
		m_pBitmapBk->Draw( &hdcMem,FALSE );
	}

	
	CFont* def_font;
	CFont font;
	LOGFONT lf;
	memset(&lf, 0, sizeof(LOGFONT));
	lf.lfHeight = 12;
	strcpy(lf.lfFaceName, "宋体");
	font.CreateFontIndirect(&lf);
	def_font = hdcMem.SelectObject(&font);	


	hdcMem.SetBkMode(TRANSPARENT);
	hdcMem.SetTextColor(m_fontColor) ;
			
	for(int i = 0; i <nItems; i++)
	{
		TCHAR buf1[256];
		HD_ITEM hditem1;
		
		hditem1.mask = HDI_TEXT | HDI_FORMAT | HDI_ORDER;
		hditem1.pszText = buf1;
		hditem1.cchTextMax = 255;
		GetItem( i, &hditem1 );	
		GetItemRect(i, &rect);

		if( m_nHoverItem == i )
		{
			if(this->m_bLButtonDown)
			{
				m_pBitmapBkDown->SetCDibRect( rect );
				m_pBitmapBkDown->Draw( &hdcMem,FALSE );
			}
			else
			{
				m_pBitmapBkOver->SetCDibRect( rect );
				m_pBitmapBkOver->Draw( &hdcMem,FALSE );
			}
		}
		if( m_pBitmapMidLine != NULL )
		{
			if(m_nHoverItem == i)
			{
				m_pBitmapMidLineOver->SetCDibRect(CRect(rect.BottomRight().x-1,rect.TopLeft().y,rect.BottomRight().x,rect.BottomRight().y));
				m_pBitmapMidLineOver->Draw(&hdcMem,FALSE);
// 				int start = rect.TopLeft().x == 0 ? 0 : rect.TopLeft().x - 1;
// 				m_pBitmapMidLineOver->SetCDibRect(CRect(start ,rect.TopLeft().y,start + 1,rect.BottomRight().y));
// 				m_pBitmapMidLineOver->Draw(&hdcMem,FALSE);
			}
			else
			{
// 				m_pBitmapMidLine->SetCDibRect(CRect(rect.BottomRight().x-1,rect.TopLeft().y,rect.BottomRight().x+2,rect.BottomRight().y));
// 				m_pBitmapMidLine->Draw(&hdcMem,FALSE);

				m_pBitmapMidLineOver->SetCDibRect(CRect(rect.BottomRight().x-1,rect.TopLeft().y,rect.BottomRight().x,rect.BottomRight().y));
				m_pBitmapMidLineOver->Draw(&hdcMem,FALSE);
			}
		}

		GetItemRect(i, &rectItem);
		//DRAWITEMSTRUCT	DrawItemStruct;
		//		
		//DrawItemStruct.CtlType		= ODT_HEADER;
		//DrawItemStruct.hDC			= dc.GetSafeHdc();
		//DrawItemStruct.itemAction	= ODA_DRAWENTIRE; 
		//DrawItemStruct.hwndItem 	= GetSafeHwnd(); 
		//DrawItemStruct.rcItem	= rectItem;
		//DrawItemStruct.itemID	= i;*/
////		DrawItem(&DrawItemStruct);
		
		UINT uFormat = DT_SINGLELINE | DT_NOPREFIX | DT_TOP |DT_CENTER | DT_END_ELLIPSIS | DT_VCENTER;

		rectItem.DeflateRect(2,2,2,2);
		
		TCHAR buf[256];
		HD_ITEM hditem;
		
		hditem.mask = HDI_TEXT | HDI_FORMAT | HDI_ORDER ;
		hditem.pszText = buf;
		hditem.cchTextMax = 255;
		GetItem( i, &hditem );
		
		CRect calRect = rectItem;
		hdcMem.DrawText(buf, &calRect, DT_CALCRECT | DT_CENTER |DT_VCENTER);
		hdcMem.DrawText(buf, &rectItem, uFormat);
		

		if( i == m_pList->m_iSortItem )
		{
			CDibBitmap * pBmp = NULL;

			if( !m_pList->m_bAsc )
			{
				pBmp = m_pBitmapAsc;
			}
			else
			{
				pBmp = m_pBitmapDesc;
			}

			CSize imaSize;
			CPoint p;

			imaSize = pBmp->GetDimensions();
			p.x = calRect.right + 2 + rectItem.Width() / 2 - calRect.Width() / 2;
			p.y = rectItem.CenterPoint().y - imaSize.cy / 2;
			
			if(p.x  < rectItem.right)
			{
				if(p.x + imaSize.cx > rectItem.right)
				{
					imaSize.cx = rectItem.right - p.x;
				}
				pBmp->SetCDibRect(CRect(p, imaSize));
				pBmp->Draw(&hdcMem,  true);
			}
		}
	}

	GetClientRect(&rect);
	dc.BitBlt(rect.TopLeft().x,rect.TopLeft().y,rect.Width(),rect.Height(),&hdcMem,0,0,SRCCOPY);

	hdcMem.SelectObject(def_font);
	font.DeleteObject();
}
Exemplo n.º 12
0
void CMainDlg::DrawPicture()
{
	int tX,tY;
	if (m_SBitmapEx.IsValid())
	{
		m_BitmapEx.Create(m_SBitmapEx.GetWidth(),m_SBitmapEx.GetHeight());
		m_BitmapEx.Draw(0,0,m_SBitmapEx.GetWidth(),m_SBitmapEx.GetHeight(),m_SBitmapEx,0,0);
		m_BitmapEx.Scale(m_nScale,m_nScale);

		CDC *pDC = m_ctl_image.GetDC();

		CDC memDC,memDC1;
		memDC.CreateCompatibleDC(pDC);
		memDC1.CreateCompatibleDC(pDC);

		CBitmap bmp;
		bmp.CreateCompatibleBitmap(pDC, m_BitmapEx.GetWidth(), m_BitmapEx.GetHeight());
		memDC.SelectObject(bmp);
		m_BitmapEx.Draw(memDC);

		CBitmap bmp1;
		bmp1.CreateCompatibleBitmap(pDC, m_ImageRect.Width(), m_ImageRect.Height());
		memDC1.SelectObject(bmp1);

		CPen pen;
		CPen* pOldPen;
		CFont wFont,wFont1;
		CFont *pOldFont;
		CString title;

		//清除背景
		CRgn rgn;
		rgn.CreateRectRgn(0,0,m_ImageRect.Width(),m_ImageRect.Height());
		CBrush bBlack(GetSysColor(COLOR_3DFACE));
		memDC1.FillRgn(&rgn, &bBlack);

		//memDC1.SetStretchBltMode(HALFTONE);
		tX = (m_ImageRect.Width() - m_BitmapEx.GetWidth())/2;
		tY = (m_ImageRect.Height() - m_BitmapEx.GetHeight())/2;

		memDC1.BitBlt(tX,tY,m_BitmapEx.GetWidth(),m_BitmapEx.GetHeight(),&memDC,m_pLeft,m_pTop,SRCCOPY);

		pen.CreatePen(PS_SOLID, 1, RGB (255, 0, 0));

		pOldPen = memDC1.SelectObject (&pen);
		memDC1.MoveTo(m_CutRect.left,m_CutRect.top);
		memDC1.LineTo(m_CutRect.right,m_CutRect.top);
		memDC1.LineTo(m_CutRect.right,m_CutRect.bottom);
		memDC1.LineTo(m_CutRect.left,m_CutRect.bottom);
		memDC1.LineTo(m_CutRect.left,m_CutRect.top);
		memDC1.SelectObject (pOldPen);

		/*
		if (m_PicEditStatus)
		{
			//清除背景
			
			if (m_DrawRect.left > 0)
			{
				CRgn rGap1,rGap2,rGap3,rGap4;
				rGap1.CreateRectRgn(0, 0, m_DrawRect.left+10,m_ImageRect.Height());
				rGap2.CreateRectRgn(m_DrawRect.right-10, 0, m_ImageRect.right,m_ImageRect.Height());
				rGap3.CreateRectRgn(0, 0, m_ImageRect.Width(),m_DrawRect.top+10);
				rGap4.CreateRectRgn(0, m_DrawRect.bottom-10, m_ImageRect.Width(),m_ImageRect.bottom);

				rGap1.CombineRgn(&rGap1,&rGap2,RGN_OR);
				rGap1.CombineRgn(&rGap1,&rGap3,RGN_OR);
				rGap1.CombineRgn(&rGap1,&rGap4,RGN_OR);

				CBrush bBlack(GetSysColor(COLOR_3DFACE));
				memDC1.FillRgn(&rGap1, &bBlack);
			}

			memDC1.SetStretchBltMode(HALFTONE);

			if (m_Factor>=0)
			{
				memDC1.StretchBlt(0,0,m_ImageRect.Width(), m_ImageRect.Height(),
					&memDC, 
					(m_BitmapEx.GetWidth())*m_Factor/2,(m_BitmapEx.GetHeight())*m_Factor/2
					,(m_BitmapEx.GetWidth())*(1-m_Factor), (m_BitmapEx.GetHeight())*(1-m_Factor)
					,SRCCOPY);
				m_DrawRect = m_ImageRect;
			}
			else
			{
				memDC1.StretchBlt((m_ImageRect.Width())*(-m_Factor)/2,(m_ImageRect.Height())*(-m_Factor)/2
					,(m_ImageRect.Width())*(1+m_Factor), (m_ImageRect.Height())*(1+m_Factor)
					,&memDC, 
					0,0,m_BitmapEx.GetWidth(),m_BitmapEx.GetHeight()
					,SRCCOPY);
				m_DrawRect.left = (m_ImageRect.Width())*(-m_Factor)/2;
				m_DrawRect.top = (m_ImageRect.Height())*(-m_Factor)/2;
				m_DrawRect.right = 
					(m_ImageRect.Width())*(-m_Factor)/2 + (m_ImageRect.Width())*(1+m_Factor) - 1;
				m_DrawRect.bottom = 
					(m_ImageRect.Height())*(-m_Factor)/2 + (m_ImageRect.Height())*(1+m_Factor) - 1; 
			}


			pen.CreatePen(PS_SOLID, 1, RGB (255, 0, 0));
			pOldPen = memDC1.SelectObject (&pen);
			memDC1.MoveTo(m_CutRect.left,m_CutRect.top);
			memDC1.LineTo(m_CutRect.right,m_CutRect.top);
			memDC1.LineTo(m_CutRect.right,m_CutRect.bottom);
			memDC1.LineTo(m_CutRect.left,m_CutRect.bottom);
			memDC1.LineTo(m_CutRect.left,m_CutRect.top);
			memDC1.SelectObject (pOldPen);

			
			title.Format(_T("%d*%d"),
				m_Factor>=0 ? (int)(((double)m_BitmapEx.GetWidth()*(1-m_Factor)) * ((double)m_CutRect.Width()/m_ImageRect.Width())) 
					: (int)(((double)m_BitmapEx.GetWidth()/(1+m_Factor)) * ((double)m_CutRect.Width()/m_ImageRect.Width())),
				m_Factor>=0 ? (int)(((double)m_BitmapEx.GetHeight()*(1-m_Factor)) * ((double)m_CutRect.Height()/m_ImageRect.Height()))  
					: (int)(((double)m_BitmapEx.GetHeight()/(1+m_Factor)) * ((double)m_CutRect.Height()/m_ImageRect.Height())));
			wFont1.CreateFont(12, 0, 0, 0, 0,
				0, 0, 0,
				0, 0, 0, 0,
				VARIABLE_PITCH | FF_SWISS, _T("MS Sans Serif"));
			pOldFont = memDC1.SelectObject(&wFont1);
			memDC1.SetTextColor(RGB(255,0,0));
			memDC1.SetBkMode(TRANSPARENT);
			memDC1.TextOut(m_CutRect.left+2,m_CutRect.top+2, title);
			memDC1.SelectObject(pOldFont);

			
			title.Format(_T("状态:编辑  分辨率:%d*%d"),
				m_Factor>=0 ? (int)((double)m_BitmapEx.GetWidth()*(1-m_Factor)) : (int)((double)m_BitmapEx.GetWidth()/(1+m_Factor)),
				m_Factor>=0 ? (int)((double)m_BitmapEx.GetHeight()*(1-m_Factor))  : (int)((double)m_BitmapEx.GetHeight()/(1+m_Factor)));
			
		}
		else
		{
			memDC1.SetStretchBltMode(HALFTONE);

			memDC1.StretchBlt(0,0,m_ImageRect.Width(), m_ImageRect.Height(),
					&memDC, 
					0,0,m_BitmapEx.GetWidth(),m_BitmapEx.GetHeight(),
					SRCCOPY);

			title.Format(_T("状态:显示  分辨率:%d*%d"),m_BitmapEx.GetWidth(),m_BitmapEx.GetHeight());
		}
		*/

		title.Format(_T("缩放:%d:100"),m_nScale);
		
		wFont.CreateFont(12, 0, 0, 0, 0,
			0, 0, 0,
			0, 0, 0, 0,
			VARIABLE_PITCH | FF_SWISS, _T("MS Sans Serif"));
		pOldFont = memDC1.SelectObject(&wFont);
		memDC1.SetTextColor(RGB(255,0,0));
		memDC1.SetBkMode(TRANSPARENT);
		memDC1.TextOut(2,m_ImageRect.bottom-14, title);
		memDC1.SelectObject(pOldFont);

		pDC->BitBlt(0,0,m_ImageRect.Width(), m_ImageRect.Height(),&memDC1,0,0,SRCCOPY);

		memDC.DeleteDC();
		memDC1.DeleteDC();

		ReleaseDC(pDC);

		tX = (m_BitmapEx.GetWidth() - m_CutRect.Width())/2;
		tY = (m_BitmapEx.GetHeight() - m_CutRect.Height())/2;

		m_PhotoBitmapEx.Create(m_CutRect.Width(),m_CutRect.Height());
		m_PhotoBitmapEx.Draw(0,0,m_CutRect.Width(),m_CutRect.Height(),m_BitmapEx,tX + m_pLeft,tY + m_pTop);

		DrawPhoto();

	}else
	{
		CDC *pDC = m_ctl_image.GetDC();
		CBrush bBlack(GetSysColor(COLOR_3DFACE));
		pDC->FillRect(m_ImageRect,&bBlack);

		//m_PhotoBitmapEx.Create(0,0);
		
		//DrawPhoto();
	}
}
Exemplo n.º 13
0
void CListBoxST::DrawItem(LPDRAWITEMSTRUCT pDIStruct)
{
  CDC*			pDC = CDC::FromHandle(pDIStruct->hDC);
  BOOL			bIsSelected = FALSE;
  BOOL			bIsFocused = FALSE;
  BOOL			bIsDisabled = FALSE;
  COLORREF		crNormal = GetSysColor(COLOR_WINDOW);
  COLORREF		crSelected = GetSysColor(COLOR_HIGHLIGHT);
  COLORREF		crText = GetSysColor(COLOR_WINDOWTEXT);
  COLORREF		crColor = RGB(0, 0, 0);
  CString			sText;					// List box item text
  STRUCT_LBDATA*	lpLBData = NULL;
  
  lpLBData = (STRUCT_LBDATA*)CListBox::GetItemDataPtr(pDIStruct->itemID);
  if (lpLBData == NULL || lpLBData == (LPVOID)-1L)	return;
  
  bIsSelected = (pDIStruct->itemState & ODS_SELECTED);
  bIsFocused = (pDIStruct->itemState & ODS_FOCUS);
  bIsDisabled = ((pDIStruct->itemState & ODS_DISABLED) || ((lpLBData->dwFlags & TEST_BIT0) == TEST_BIT0));
  
  CRect rcItem = pDIStruct->rcItem;
  CRect rcIcon = pDIStruct->rcItem;
  CRect rcText = pDIStruct->rcItem;
  CRect rcCenteredText = pDIStruct->rcItem;
  
  pDC->SetBkMode(TRANSPARENT);
  
  // ONLY FOR DEBUG 
  CBrush brBtnShadow(RGB(0, 0, 255));
//  pDC->FrameRect(&rcItem, &brBtnShadow);
//  pDC->Rectangle(&rcItem);
  
  // Calculate rcIcon
  if (m_pImageList)
  {
    rcIcon.right = rcIcon.left + m_szImage.cx + CX_BORDER*3;
    rcIcon.bottom = rcIcon.top + m_szImage.cy + CY_BORDER*3;
  } // if
  else rcIcon.SetRect(0, 0, 0, 0);
  
  // Calculate rcText
  rcText.left = rcIcon.right;
  
  // Calculate rcCenteredText
  // Get list box item text
  CListBox::GetText(pDIStruct->itemID, sText);
  rcCenteredText = rcText;
  pDC->DrawText(sText, -1, rcCenteredText, DT_WORDBREAK | DT_EXPANDTABS| DT_CALCRECT | lpLBData->nFormat);
  rcCenteredText.OffsetRect(0, (rcText.Height() - rcCenteredText.Height())/2);
  
  // Draw rcIcon background
  if (m_pImageList)
  {
    if (bIsSelected && (m_byRowSelect == ST_FULLROWSELECT) && !bIsDisabled)
      crColor = crSelected;
    else
      crColor = crNormal;
    
    OnDrawIconBackground(pDIStruct->itemID, pDC, &rcItem, &rcIcon, bIsDisabled, bIsSelected, crColor);
  } // if
  
  // Draw rcText/rcCenteredText background
  if (bIsDisabled)
  {
    pDC->SetTextColor(GetSysColor(COLOR_GRAYTEXT));
    crColor = crNormal;
  } // if
  else
  {
    if (bIsSelected)
    {
      pDC->SetTextColor(0x00FFFFFF & ~crText);
      crColor = crSelected;
    } // if
    else
    {
      pDC->SetTextColor(crText);
      crColor = crNormal;
    } // else
  } // else
  
  if (m_byRowSelect == ST_TEXTSELECT)
    //pDC->FillSolidRect(&rcCenteredText, crColor);
    OnDrawTextBackground(pDIStruct->itemID, pDC, &rcItem, &rcCenteredText, bIsDisabled, bIsSelected, crColor);
  else
    //pDC->FillSolidRect(&rcText, crColor);
    OnDrawTextBackground(pDIStruct->itemID, pDC, &rcItem, &rcText, bIsDisabled, bIsSelected, crColor);
  
  // Draw the icon (if any)
  if (m_pImageList)
    OnDrawIcon(pDIStruct->itemID, pDC, &rcItem, &rcIcon, lpLBData->nImage, bIsDisabled, bIsSelected);
  
  // Draw text
  pDC->DrawText(sText, -1, rcCenteredText, DT_WORDBREAK | DT_EXPANDTABS | lpLBData->nFormat);
  
  // Draw focus rectangle
  if (bIsFocused && !bIsDisabled)
  {
    switch (m_byRowSelect)
    {
    case ST_FULLROWSELECT:
      pDC->DrawFocusRect(&rcItem);
      break;
    case ST_FULLTEXTSELECT:
      pDC->DrawFocusRect(&rcText);
      break;
    case ST_TEXTSELECT:
    default:
      pDC->DrawFocusRect(&rcCenteredText);
      break;
    } // switch
  } // if
} // End of DrawItem
Exemplo n.º 14
0
void COBDPNDDlgConfigNowFCC::OnPaint()
{
	if (m_memdcBkBmp != NULL)
	{
		CClientDC pDC(this);

		CRect rect; 
		CDC   memDC; 

		GetWindowRect(&rect); 	
		memDC.CreateCompatibleDC(&pDC); 	

		CBitmap* pOldMemBmp = NULL; 
		pOldMemBmp = memDC.SelectObject(&m_cBitmapBkBmp);
		memDC.BitBlt(0,0,rect.Width(),rect.Height(),&m_memdcBkBmp,0,0,SRCCOPY);

		memDC.SetBkMode(TRANSPARENT);	

		fDrawTitleText(&memDC);

		memDC.SelectObject(m_fontText);
		memDC.SetTextColor(theMainDlg->m_clrTitle);
		CString strText;			
		DWORD dwCurrVss = theMainDlg->fGetDataStreamValueF(0x00000D00);
		if (dwCurrVss == INVALID_DATASTREAM_VALUE)
			dwCurrVss = 0;
		strText.Format(_T("%s%d"),m_strText[0],dwCurrVss); 
		memDC.DrawText(strText, -1, &m_rectList[0], DT_LEFT);	
		float fValue = theMainDlg->fGetDataStreamValueF(0xFF010001);
		if (fValue == INVALID_DATASTREAM_VALUE)
			fValue = 0;
		strText.Format(_T("%s%0.1f"),fValue);
		memDC.DrawText(strText, -1, &m_rectList[1], DT_LEFT);	

		CPen pen(PS_SOLID,2,RGB(255,255,255));
		CPen *oldPen = memDC.SelectObject(&pen);
		memDC.MoveTo(30, m_rectList[1].bottom + (m_rectList[2].top - m_rectList[1].bottom)/2); 
		memDC.LineTo(theMainDlg->m_rectWin.right-30, m_rectList[1].bottom + (m_rectList[2].top - m_rectList[1].bottom)/2);

		memDC.SelectObject(m_fontText3);
		if (dwCurrVss > 0 && dwCurrVss > m_wSetupSpeed-2 && dwCurrVss < m_wSetupSpeed+2)
		{
			strText.Format(_T("%s[%d]"),m_strText[3],8-m_wCountTime);

			if (!m_bCountDown)
			{
				SetTimer(1,1000,NULL);
				m_bCountDown = TRUE; 
				m_wCountTime = 0;
			}
		}
		else
		{
			strText.Format(_T("%s"),m_strText[2]);

			KillTimer(1);
			m_bCountDown = FALSE;
			m_wCountTime = 0;
		}

		memDC.DrawText(strText, -1, &m_rectList[2],DT_CENTER );	//DT_LEFT|DT_EDITCONTROL|DT_WORDBREAK

		fDrawFootText(&memDC);

		//将背景位图复制到窗口客户区 
		pDC.BitBlt(0,0,rect.Width(),rect.Height(),&memDC,0,0,SRCCOPY); 

		if(pOldMemBmp)   
			memDC.SelectObject(pOldMemBmp); 

		DeleteObject(pOldMemBmp);	
		DeleteDC(memDC);

	}
	CDialog::OnPaint();
}
Exemplo n.º 15
0
CString CRichEditCtrlExtn::GetTextFormatting(const CString &csHTML, int &iError)
{
  CString csText, csToken, csHTMLTag;
  int iCurrentFontSize, iCurrentFontPointSize;
  int iDefaultFontSize, iDefaultFontPointSize;
  int iTextPosition(0);
  int curPos, oldPos;

  int ierrorcode(0);
  bool bHTMLTag;

  m_vFormat.clear();
  m_vALink.clear();

  st_format this_format;

  ALink this_ALink;

  std::bitset<3> bsFontChange;  // facename, size, color

  std::vector<CString> vLastFacenames;
  std::vector<COLORREF> vLastColours;
  std::vector<int> vLastSizes;
  std::vector<int> vFontChangeStart;
  std::vector<std::bitset<3>> vFontChange;
  std::stack<st_format> format_stack;
  std::stack<int> type_stack;

  // Validate the HTML
  curPos = 0;
  oldPos = 0;
  int iBold(0), iItalic(0), iUnderline(0), iFont(0), iAnchor(0);
  bool bNestedBold(false), bNestedItalic(false), bNestedUnderline(false),
       bNestedAnchor(false), bOverlapped(false);

  csToken = csHTML.Tokenize(L"<>", curPos);
  while (csToken != L"" && curPos != -1) {
    oldPos = curPos - csToken.GetLength() - 1;
    CString a = csHTML.Mid(oldPos - 1, 1);
    CString b = csHTML.Mid(curPos - 1, 1);
    if (csHTML.Mid(oldPos - 1, 1) == L"<" &&
      csHTML.Mid(curPos - 1, 1) == L">") {
        bHTMLTag = true;
    } else
      bHTMLTag = false;

    if (bHTMLTag) {
      // Must be a HTML Tag
      csHTMLTag = csToken;
      csHTMLTag.MakeLower();
      if (csHTMLTag == L"b") {
        type_stack.push(Bold);
        iBold++;
        if (iBold != 1) bNestedBold = true;
        goto vnext;
      } else if (csHTMLTag == L"/b") {
        int &iLastType = type_stack.top();
        if (iLastType != Bold)
          bOverlapped = true;
        iBold--;
        type_stack.pop();
        goto vnext;
      } else if (csHTMLTag == L"i") {
        type_stack.push(Italic);
        iItalic++;
        if (iItalic != 1) bNestedItalic = true;
        goto vnext;
      } else if (csHTMLTag == L"/i") {
        int &iLastType = type_stack.top();
        if (iLastType != Italic)
          bOverlapped = true;
        iItalic--;
        type_stack.pop();
        goto vnext;
      } else if (csHTMLTag == L"u") {
        type_stack.push(Underline);
        iUnderline++;
        if (iUnderline != 1) bNestedUnderline = true;
        goto vnext;
      } else if (csHTMLTag == L"/u") {
        int &iLastType = type_stack.top();
        if (iLastType != Underline)
          bOverlapped = true;
        iUnderline--;
        type_stack.pop();
        goto vnext;
      } else if (csHTMLTag.Left(4) == L"font") {
        type_stack.push(Font);
        iFont++;
        goto vnext;
      } else if (csHTMLTag == L"/font") {
        int &iLastType = type_stack.top();
        if (iLastType != Font)
          bOverlapped = true;
        iFont--;
        type_stack.pop();
        goto vnext;
      } else if (csHTMLTag.Left(6) == L"a href") {
        type_stack.push(Link);
        iAnchor++;
        if (iAnchor != 1) bNestedAnchor = true;
        goto vnext;
      } else if (csHTMLTag == L"/a") {
        int &iLastType = type_stack.top();
        if (iLastType != Link)
          bOverlapped = true;
        iAnchor--;
        type_stack.pop();
        goto vnext;
      } else { // unsupported tag or typo - return raw string
        return csHTML;
      }
    }

vnext:
    oldPos = curPos;
    csToken = csHTML.Tokenize(L"<>", curPos);
  };

  if (bNestedBold)
    ierrorcode += 1;
  if (iBold != 0)
    ierrorcode += 2;
  if (bNestedItalic)
    ierrorcode += 4;
  if (iItalic != 0)
    ierrorcode += 8;
  if (bNestedUnderline)
    ierrorcode += 16;
  if (iUnderline != 0)
    ierrorcode += 32;
  if (bNestedAnchor)
    ierrorcode += 64;
  if (iAnchor != 0)
    ierrorcode += 128;
  if (iFont != 0)
    ierrorcode += 256;
  if (bOverlapped)
    ierrorcode +=512;

  iError = ierrorcode;

  if (ierrorcode != 0) {
    return L"";
  }

  // Now really process the HTML
  NONCLIENTMETRICS ncm ={0};
  ncm.cbSize = sizeof(NONCLIENTMETRICS);

  SystemParametersInfo(SPI_GETNONCLIENTMETRICS,
                       sizeof(NONCLIENTMETRICS), &ncm, NULL);

  CWnd *pWndDesk = GetDesktopWindow();
  CDC *pDCDesk = pWndDesk->GetWindowDC();
  int logPixY = pDCDesk->GetDeviceCaps(LOGPIXELSY);
  pWndDesk->ReleaseDC(pDCDesk);

  iDefaultFontPointSize = MulDiv(ncm.lfMessageFont.lfHeight, 72, logPixY);
  iCurrentFontPointSize = iDefaultFontPointSize;
  iDefaultFontSize = ConvertPointsToSize(iCurrentFontPointSize);
  iCurrentFontSize = iDefaultFontSize;

  curPos = 0;
  oldPos = 0;

  csToken = csHTML.Tokenize(L"<>", curPos);
  while (csToken != L"" && curPos != -1) {
    oldPos = curPos - csToken.GetLength() - 1;
    CString a = csHTML.Mid(oldPos - 1, 1);
    CString b = csHTML.Mid(curPos - 1, 1);
    if (csHTML.Mid(oldPos - 1, 1) == L"<" &&
        csHTML.Mid(curPos - 1, 1) == L">") {
      bHTMLTag = true;
    } else
      bHTMLTag = false;

    if (!bHTMLTag && iAnchor != 0)
      goto next;

    if (bHTMLTag) {
      // Must be a HTML Tag
      csHTMLTag = csToken;
      csHTMLTag.MakeLower();
      if (csHTMLTag == L"b") {
        this_format.entrytype = Bold;
        this_format.iStart = iTextPosition;
        format_stack.push(this_format);
        goto next;
      } else
      if (csHTMLTag == L"/b") {
        st_format& cur_format = format_stack.top();
        cur_format.iEnd = iTextPosition;
        m_vFormat.push_back(cur_format);
        format_stack.pop();
        goto next;
      } else
      if (csHTMLTag == L"i") {
        this_format.entrytype = Italic;
        this_format.iStart = iTextPosition;
        format_stack.push(this_format);
        goto next;
      } else
      if (csHTMLTag == L"/i") {
        st_format& cur_format = format_stack.top();
        cur_format.iEnd = iTextPosition;
        m_vFormat.push_back(cur_format);
        format_stack.pop();
        goto next;
      } else
      if (csHTMLTag == L"u") {
        this_format.entrytype = Underline;
        this_format.iStart = iTextPosition;
        format_stack.push(this_format);
        goto next;
      } else
      if (csHTMLTag == L"/u") {
        st_format& cur_format = format_stack.top();
        cur_format.iEnd = iTextPosition;
        m_vFormat.push_back(cur_format);
        format_stack.pop();
        goto next;
      } else
      if (csHTMLTag == L"/font") {
        if (vFontChange.empty()) { // malformed <font> token
          return csHTML;
        }
        std::bitset<3> &bsLastFont = vFontChange.back();
        int &iFontChangeStart = vFontChangeStart.back();
        st_format& cur_format = format_stack.top();
        if (bsLastFont.test(FACENAMECHANGED)) {
          CString &csLastFaceName = vLastFacenames.back();
          cur_format.entrytype = Name;
          cur_format.iStart = iFontChangeStart;
          cur_format.iEnd = iTextPosition;
          SecureZeroMemory(cur_format.tcszFACENAME, sizeof(cur_format.tcszFACENAME));
#if (_MSC_VER >= 1400)
          wcscpy_s(cur_format.tcszFACENAME, LF_FACESIZE, (LPCWSTR)csLastFaceName);
#else
          wcscpy(cur_format.tcszFACENAME, (LPCWSTR)csLastFaceName);
#endif
          m_vFormat.push_back(cur_format);
          vLastFacenames.pop_back();
        }
        if (bsLastFont.test(SIZECHANGED)) {
          int &iLastSize = vLastSizes.back();
          cur_format.entrytype = Size;
          cur_format.iStart = iFontChangeStart;
          cur_format.iEnd = iTextPosition;
          cur_format.iSize = iLastSize;
          m_vFormat.push_back(cur_format);
          vLastSizes.pop_back();
          if (!vLastSizes.empty()) {
            int &i = vLastSizes.back();
            iCurrentFontPointSize = i;
            iCurrentFontSize = ConvertPointsToSize(iCurrentFontPointSize);
          } else {
            iCurrentFontPointSize = iDefaultFontPointSize;
            iCurrentFontSize = iDefaultFontSize;
          }
        }
        if (bsLastFont.test(COLOURCHANGED)) {
          COLORREF &c = vLastColours.back();
          cur_format.entrytype = Colour;
          cur_format.iStart = iFontChangeStart;
          cur_format.iEnd = iTextPosition;
          cur_format.cr = c;
          m_vFormat.push_back(cur_format);
          vLastColours.pop_back();
        }
        vFontChange.pop_back();
        vFontChangeStart.pop_back();
        format_stack.pop();
        goto next;
      } else if (csHTMLTag == L"/a") {
        goto next;
      }

      // Check for fonts
      // <font face="xxxxx" size="n" color="xxxxx">....</font>
      if (csHTMLTag.Left(5) == L"font ") {
        CString csFontToken, csFontVerb, csFontVerbValue;
        int curFontPos(0);

        bsFontChange.reset();
        csFontToken = csHTMLTag.Tokenize(L"\"", curFontPos);
        csFontVerb = csFontToken.Right(6);
        csFontVerb.TrimLeft();
        // Skip over first token of 'font verb='
        csFontVerbValue = csHTMLTag.Tokenize(L"\"", curFontPos);
        while (csFontVerbValue != L"" && curFontPos != -1) {
          if (csFontVerb == L"face=") {
            bsFontChange.set(FACENAMECHANGED);
            vLastFacenames.push_back(csFontVerbValue);
          } else
            if (csFontVerb == L"size=") {
              bsFontChange.set(SIZECHANGED);
              iCurrentFontPointSize = ConvertSizeToPoints(csFontVerbValue, iCurrentFontSize);
              vLastSizes.push_back(iCurrentFontPointSize);
            } else
              if (csFontVerb == L"color=") {
                bsFontChange.set(COLOURCHANGED);
                COLORREF crNewFontColour = ConvertColourToColorRef(csFontVerbValue);
                vLastColours.push_back(crNewFontColour);
              }

              csFontVerb = csHTMLTag.Tokenize(L"\"", curFontPos);
              if (csFontVerb.IsEmpty() && curFontPos == -1)
                break;
              csFontVerbValue = csHTMLTag.Tokenize(L"\"", curFontPos);
        };
        vFontChange.push_back(bsFontChange);
        vFontChangeStart.push_back(iTextPosition);
        format_stack.push(this_format);
        goto next;
      }

      // check for hyperlink
      // <a href="http://www.microsoft.com">Friendly name</a>

      if (csHTMLTag.Left(7) == L"a href=") {
        long dwTEnd;
        CString csURL;
        dwTEnd = csHTMLTag.Find(L"\"", 8);
        if (dwTEnd >= 0) {
          csURL = csHTMLTag.Mid(8, dwTEnd - 8);
          if (!csURL.IsEmpty()) {
            csURL.MakeLower();
#if (_MSC_VER >= 1400)
            wcscpy_s(this_ALink.tcszURL, _MAX_PATH, csURL);
#else
            wcscpy(this_ALink.tcszURL, csURL);
#endif
          }
        }
        // Now get Friendly Name (note doing this within the while loop!)
        oldPos = curPos;
        csToken = csHTML.Tokenize(L"<>", curPos);
        csText += csToken;
        this_ALink.iStart = iTextPosition;
        iTextPosition += csToken.GetLength();
        this_ALink.iEnd = iTextPosition;
        m_vALink.push_back(this_ALink);
        goto next;
      }
    }

    csToken.Replace(L"&lt;", L"<");
    csToken.Replace(L"&gt;", L">");
    // Real text or unknown HTML tag
    if (bHTMLTag) {
      // We didn't recognise it! Put back the < & >
      csText += L"<" + csToken + L">";
      iTextPosition += csToken.GetLength() + 2;
    } else {
      csText += csToken;
      iTextPosition += csToken.GetLength();
    }

next:
    oldPos = curPos;
    csToken = csHTML.Tokenize(L"<>", curPos);
  };

  return csText;
}
Exemplo n.º 16
0
void ImageHandler::CreateRelativeImage(const CDC& dc, std::shared_ptr<BackgroundImage>& bkImage)
{
  CriticalSectionLock	lock(bkImage->updateCritSec);

  bkImage->dwImageWidth	= ::GetSystemMetrics(SM_CXVIRTUALSCREEN);
  bkImage->dwImageHeight	= ::GetSystemMetrics(SM_CYVIRTUALSCREEN);

  // create background DC
  bkImage->dcImage.CreateCompatibleDC(NULL);

  // create background bitmap
  Helpers::CreateBitmap(dc, bkImage->dwImageWidth, bkImage->dwImageHeight, bkImage->image);
  bkImage->dcImage.SelectBitmap(bkImage->image);

  // paint background
  CBrush	backgroundBrush(::CreateSolidBrush(bkImage->imageData.crBackground));
  CRect	rect(0, 0, bkImage->dwImageWidth, bkImage->dwImageHeight);
  bkImage->dcImage.FillRect(&rect, backgroundBrush);

  // this can be false only for desktop backgrounds with no wallpaper image
  if (bkImage->originalImage.get() != NULL)
  {
    if (bkImage->imageData.imagePosition == imagePositionTile ||
        bkImage->imageData.bExtend ||
        !ImageHandler::IsWin8())
    {
      // create template image
      CDC     dcTemplate;
      CBitmap	bmpTemplate;
      dcTemplate.CreateCompatibleDC(NULL);

      // Windows 7 or older wallpaper (Stretch, Fit & Fill) use the primary monitor to rescale picture for each monitor
      DWORD dwNewWidth  = ::GetSystemMetrics(SM_CXSCREEN);
      DWORD dwNewHeight = ::GetSystemMetrics(SM_CYSCREEN);
      PaintRelativeImage(dc, bmpTemplate, bkImage, dwNewWidth, dwNewHeight);

      dcTemplate.SelectBitmap(bmpTemplate);

      if (bkImage->imageData.imagePosition == imagePositionTile)
      {
        ImageHandler::TileTemplateImage(
          dcTemplate,
          ImageHandler::IsWin8() ? 0 : ::GetSystemMetrics(SM_XVIRTUALSCREEN), // Windows 8 wallpaper tiles starts
          ImageHandler::IsWin8() ? 0 : ::GetSystemMetrics(SM_YVIRTUALSCREEN), // in the top left corner of virtual screen
          bkImage);
      }
      else if (bkImage->imageData.bExtend)
      {
        ImageHandler::PaintTemplateImage(
          dcTemplate,
          0,
          0,
          dwNewWidth,
          dwNewHeight,
          bkImage->dwImageWidth,
          bkImage->dwImageHeight,
          bkImage);
      }
      else
      {
        MonitorEnumData	enumData(dcTemplate, bkImage);
        ::EnumDisplayMonitors(NULL, NULL, ImageHandler::MonitorEnumProc, reinterpret_cast<LPARAM>(&enumData));
      }
    }
    else
    {
      // Windows 8 wallpaper (Stretch, Fit & Fill) is handled separately for each monitor
      MonitorEnumData enumData(dc, bkImage);
#if _WIN32_WINNT >= 0x0602
      ImageHandler::LoadDesktopWallpaperWin8(&enumData);
#else
      ::EnumDisplayMonitors(NULL, NULL, ImageHandler::MonitorEnumProcWin8, reinterpret_cast<LPARAM>(&enumData));
#endif
    }
  }

  if (bkImage->imageData.byTintOpacity > 0) TintImage(dc, bkImage);
}
Exemplo n.º 17
0
void CClosableTabCtrl::DrawItem(LPDRAWITEMSTRUCT lpDIS)
{
	CRect rect(lpDIS->rcItem);
	int nTabIndex = lpDIS->itemID;
	if (nTabIndex < 0)
		return;

	TCHAR szLabel[256];
	TC_ITEM tci;
	tci.mask = TCIF_TEXT | TCIF_IMAGE | TCIF_STATE;
	tci.pszText = szLabel;
	tci.cchTextMax = _countof(szLabel);
	tci.dwStateMask = TCIS_HIGHLIGHTED;
	if (!GetItem(nTabIndex, &tci))
		return;
	szLabel[_countof(szLabel) - 1] = _T('\0');
	//TRACE("CClosableTabCtrl::DrawItem: item=%u, state=%08x, color=%08x, rc=%3d,%3d,%3dx%3d\n", nTabIndex, tci.dwState, GetTextColor(lpDIS->hDC), lpDIS->rcItem.left, lpDIS->rcItem.top, lpDIS->rcItem.right - lpDIS->rcItem.left, lpDIS->rcItem.bottom - lpDIS->rcItem.top);

	CDC* pDC = CDC::FromHandle(lpDIS->hDC);
	if (!pDC)
		return;

	CRect rcFullItem(lpDIS->rcItem);
	bool bSelected = (lpDIS->itemState & ODS_SELECTED) != 0;

	///////////////////////////////////////////////////////////////////////////////////////
	// Adding support for XP Styles (Vista Themes) for owner drawn tab controls simply
	// does *not* work under Vista. Maybe it works under XP (did not try), but that is
	// meaningless because under XP a owner drawn tab control is already rendered *with*
	// the proper XP Styles. So, for XP there is no need to care about the theme API at all.
	//
	// However, under Vista, a tab control which has the TCS_OWNERDRAWFIXED
	// style gets additional 3D-borders which are applied by Vista *after* WM_DRAWITEM
	// was processed. Thus, there is no known workaround available to prevent Vista from
	// adding those old fashioned 3D-borders. We can render the tab control items within
	// the WM_DRAWITEM handler in whatever style we want, but Vista will in each case
	// overwrite the borders of each tab control item with old fashioned 3D-borders...
	//
	// To complete this experience, tab controls also do not support NMCUSTOMDRAW. So, the
	// only known way to customize a tab control is by using TCS_OWNERDRAWFIXED which does
	// however not work properly under Vista.
	//
	// The "solution" which is currently implemented to prevent Vista from drawing those
	// 3D-borders is by using "ExcludeClipRect" to reduce the drawing area which is used
	// by Windows after WM_DRAWITEM was processed. This "solution" is very sensitive to
	// the used rectangles and offsets in general. Incrementing/Decrementing one of the
	// "rcItem", "rcFullItem", etc. rectangles makes the entire "solution" flawed again
	// because some borders would become visible again.
	//
	HTHEME hTheme = NULL;
	int iPartId = TABP_TABITEM;
	int iStateId = TIS_NORMAL;
	bool bVistaHotTracked = false;
	bool bVistaThemeActive = theApp.IsVistaThemeActive();
	if (bVistaThemeActive)
	{
		// To determine if the current item is in 'hot tracking' mode, we need to evaluate
		// the current foreground color - there is no flag which would indicate this state 
		// more safely. This applies only for Vista and for tab controls which have the
		// TCS_OWNERDRAWFIXED style.
		bVistaHotTracked = pDC->GetTextColor() == GetSysColor(COLOR_HOTLIGHT);

		hTheme = g_xpStyle.OpenThemeData(m_hWnd, L"TAB");
		if (hTheme)
		{
			if (bSelected) {
				// get the real tab item rect
				rcFullItem.left += 1;
				rcFullItem.right -= 1;
				rcFullItem.bottom -= 1;
			}
			else
				rcFullItem.InflateRect(2, 2); // get the real tab item rect

			CRect rcBk(rcFullItem);
			if (bSelected)
			{
				iStateId = TTIS_SELECTED;
				if (nTabIndex == 0) {
					// First item
					if (nTabIndex == GetItemCount() - 1)
						iPartId = TABP_TOPTABITEMBOTHEDGE; // First & Last item
					else
						iPartId = TABP_TOPTABITEMLEFTEDGE;
				}
				else if (nTabIndex == GetItemCount() - 1) {
					// Last item
					iPartId = TABP_TOPTABITEMRIGHTEDGE;
				}
				else {
					iPartId = TABP_TOPTABITEM;
				}
			}
			else
			{
				rcBk.top += 2;
				iStateId = bVistaHotTracked ? TIS_HOT : TIS_NORMAL;
				if (nTabIndex == 0) {
					// First item
					if (nTabIndex == GetItemCount() - 1)
						iPartId = TABP_TABITEMBOTHEDGE; // First & Last item
					else
						iPartId = TABP_TABITEMLEFTEDGE;
				}
				else if (nTabIndex == GetItemCount() - 1) {
					// Last item
					iPartId = TABP_TABITEMRIGHTEDGE;
				}
				else {
					iPartId = TABP_TABITEM;
				}
			}
			if (g_xpStyle.IsThemeBackgroundPartiallyTransparent(hTheme, iPartId, iStateId))
				g_xpStyle.DrawThemeParentBackground(m_hWnd, *pDC, &rcFullItem);
			g_xpStyle.DrawThemeBackground(hTheme, *pDC, iPartId, iStateId, &rcBk, NULL);
		}
	}

	// Following background clearing is needed for:
	//	WinXP/Vista (when used without an application theme)
	//	Vista (when used with an application theme but without a theme for the tab control)
	if (   (!g_xpStyle.IsThemeActive() || !g_xpStyle.IsAppThemed())
		|| (hTheme == NULL && bVistaThemeActive) )
		pDC->FillSolidRect(&lpDIS->rcItem, GetSysColor(COLOR_BTNFACE));

	int iOldBkMode = pDC->SetBkMode(TRANSPARENT);

	// Draw image on left side
	CImageList *piml = GetImageList();
	if (tci.iImage >= 0 && piml && piml->m_hImageList)
	{
		IMAGEINFO ii;
		piml->GetImageInfo(0, &ii);
		rect.left += bSelected ? 8 : 4;
		piml->Draw(pDC, tci.iImage, CPoint(rect.left, rect.top + 2), ILD_TRANSPARENT);
		rect.left += (ii.rcImage.right - ii.rcImage.left);
		if (!bSelected)
			rect.left += 4;
	}

	bool bCloseable = m_bCloseable;
	if (bCloseable && GetParent()->SendMessage(UM_QUERYTAB, nTabIndex))
		bCloseable = false;

	// Draw 'Close button' at right side
	if (bCloseable && m_ImgLstCloseButton.m_hImageList)
	{
		CRect rcCloseButton;
		GetCloseButtonRect(nTabIndex, rect, rcCloseButton, bSelected, bVistaThemeActive);

		HTHEME hThemeNC = bVistaThemeActive ? g_xpStyle.OpenThemeData(m_hWnd, _T("WINDOW")) : NULL;
		if (hThemeNC) {
			// Possible "Close" parts: WP_CLOSEBUTTON, WP_SMALLCLOSEBUTTON, WP_MDICLOSEBUTTON
			int iPartId = WP_SMALLCLOSEBUTTON;
			int iStateId = (bSelected || bVistaHotTracked) ? CBS_NORMAL : CBS_DISABLED;
			if (g_xpStyle.IsThemeBackgroundPartiallyTransparent(hTheme, iPartId, iStateId))
				g_xpStyle.DrawThemeParentBackground(m_hWnd, *pDC, &rcCloseButton);
			g_xpStyle.DrawThemeBackground(hThemeNC, *pDC, iPartId, iStateId, rcCloseButton, NULL);
			g_xpStyle.CloseThemeData(hThemeNC);
		}
		else {
			m_ImgLstCloseButton.Draw(pDC, (bSelected || bVistaHotTracked) ? 0 : 1, rcCloseButton.TopLeft(), ILD_TRANSPARENT);
		}

		rect.right = rcCloseButton.left - 2;
		if (bSelected)
			rect.left += hTheme ? 4 : 2;
	}

	COLORREF crOldColor = CLR_NONE;
	if (tci.dwState & TCIS_HIGHLIGHTED)
		crOldColor = pDC->SetTextColor(RGB(192, 0, 0));
	else if (bVistaHotTracked)
		crOldColor = pDC->SetTextColor(GetSysColor(COLOR_BTNTEXT));

	rect.top += bSelected ? 4 : 3;
	// Vista: Tab control has troubles with determining the width of a tab if the
	// label contains one '&' character. To get around this, we use the old code which
	// replaces one '&' character with two '&' characters and we do not specify DT_NOPREFIX
	// here when drawing the text.
	//
	// Vista: "DrawThemeText" can not be used in case we need a certain foreground color. Thus we always us
	// "DrawText" to always get the same font and metrics (just for safety).
	pDC->DrawText(szLabel, rect, DT_SINGLELINE | DT_TOP | DT_CENTER /*| DT_NOPREFIX*/);

	if (crOldColor != CLR_NONE)
		pDC->SetTextColor(crOldColor);
	pDC->SetBkMode(iOldBkMode);

	if (hTheme)
	{
		CRect rcClip(rcFullItem);
		if (bSelected) {
			rcClip.left -= 2 + 1;
			rcClip.right += 2 + 1;
		}
		else {
			rcClip.top += 2;
		}
		pDC->ExcludeClipRect(&rcClip);
		g_xpStyle.CloseThemeData(hTheme);
	}
}
Exemplo n.º 18
0
void ImageHandler::CreateImage(const CDC& dc, const CRect& clientRect, std::shared_ptr<BackgroundImage>& bkImage)
{
	CriticalSectionLock	lock(bkImage->updateCritSec);

	bkImage->dwImageWidth = clientRect.Width();
	bkImage->dwImageHeight= clientRect.Height();

	// create background DC
	if (bkImage->dcImage.IsNull()) bkImage->dcImage.CreateCompatibleDC(NULL);

	// create background bitmap
	if (!bkImage->image.IsNull()) bkImage->image.DeleteObject();
	Helpers::CreateBitmap(dc, bkImage->dwImageWidth, bkImage->dwImageHeight, bkImage->image);
	bkImage->dcImage.SelectBitmap(bkImage->image);

	// paint background
	CBrush backgroundBrush(::CreateSolidBrush(bkImage->imageData.crBackground));
	bkImage->dcImage.FillRect(&clientRect, backgroundBrush);

	// this can be false only for desktop backgrounds with no wallpaper image
	if (bkImage->originalImage.get() != NULL)
	{
		// create template image
		CDC		dcTemplate;
		CBitmap	bmpTemplate;

		dcTemplate.CreateCompatibleDC(NULL);

    DWORD dwNewWidth  = bkImage->dwImageWidth;
    DWORD dwNewHeight = bkImage->dwImageHeight;

		if ( (bkImage->imageData.imagePosition == imagePositionStretch ||
          bkImage->imageData.imagePosition == imagePositionFit     ||
          bkImage->imageData.imagePosition == imagePositionFill)
         &&
         (bkImage->originalImage->getWidth()  != dwNewWidth        ||
          bkImage->originalImage->getHeight() != dwNewHeight) )
		{
			// resize background image
			ImageHandler::CalcRescale(dwNewWidth, dwNewHeight, bkImage);
			fipImage tempImage(*(bkImage->originalImage));
			tempImage.rescale(dwNewWidth, dwNewHeight, FILTER_BILINEAR);

			bmpTemplate.CreateDIBitmap(
							dc,
							tempImage.getInfoHeader(),
							CBM_INIT,
							tempImage.accessPixels(),
							tempImage.getInfo(),
							DIB_RGB_COLORS);
		}
		else
		{
			bmpTemplate.CreateDIBitmap(
							dc,
							bkImage->originalImage->getInfoHeader(),
							CBM_INIT,
							bkImage->originalImage->accessPixels(),
							bkImage->originalImage->getInfo(),
							DIB_RGB_COLORS);
		}

		dcTemplate.SelectBitmap(bmpTemplate);

		if (bkImage->imageData.imagePosition == imagePositionTile)
		{
			TileTemplateImage(
				dcTemplate,
				0,
				0,
				bkImage);

		}
		else
		{
			PaintTemplateImage(
				dcTemplate,
				0,
				0,
				dwNewWidth,
				dwNewHeight,
				bkImage->dwImageWidth,
				bkImage->dwImageHeight,
				bkImage);
		}
	}

	if (bkImage->imageData.byTintOpacity > 0) TintImage(dc, bkImage);
}
Exemplo n.º 19
0
void CLibraryAlbumView::OnPaint() 
{
	CPaintDC dc( this );
	
	CRect rcBuffer( 0, 0, m_szTrack.cx, m_szTrack.cy );
	CDC* pBuffer = CoolInterface.GetBuffer( dc, m_szTrack );
	if ( Settings.General.LanguageRTL ) pBuffer->SetTextAlign( TA_RTLREADING );
	
	CFont* pOldFont = (CFont*)pBuffer->SelectObject( &CoolInterface.m_fntNormal );
	pBuffer->SetBkMode( OPAQUE );
	pBuffer->SetBkColor( CoolInterface.m_crWindow );
	pBuffer->SetTextColor( CoolInterface.m_crText );
	
	m_crRows[0] = CCoolInterface::CalculateColour( CoolInterface.m_crWindow, Skin.m_crSchemaRow[0], 128 );
	m_crRows[1] = CCoolInterface::CalculateColour( CoolInterface.m_crWindow, Skin.m_crSchemaRow[1], 128 );
	
	CRect rcClient, rcTrack;
	GetClientRect( &rcClient );
	
	rcTrack = rcBuffer;
	rcTrack.OffsetRect( rcClient.left, 0 );
	
	CLibraryAlbumTrack** pList = m_pList;

	pBuffer->SelectObject( &CoolInterface.m_fntBold );
	CRect rcLine(rcTrack);
	rcLine.left += 22;
	rcLine.right -= 78;
	pBuffer->FillSolidRect( &rcBuffer, CoolInterface.m_crWindow );
	if ( m_pStyle == CSchema::uriMusicAlbum )
	{
		// Track, Title, Length, Bitrate
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine,  0,   5, IDS_LIBRARY_ALBUM_TRACK, TRUE );
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine,  5,  84, IDS_LIBRARY_ALBUM_TITLE );
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine, 84,  92, IDS_LIBRARY_ALBUM_LENGTH, TRUE );
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine, 92, 100, IDS_LIBRARY_ALBUM_BITRATE, TRUE );
		
		rcLine.left = rcLine.right;
		rcLine.right += 78;
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine, 0, 100, IDS_LIBRARY_ALBUM_RATING );
	}
	else if ( m_pStyle == CSchema::uriMusicArtist )
	{
		// Album, Title, Length, Bitrate
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine,  0,  30, IDS_LIBRARY_ALBUM_ALBUM );
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine, 30,  84, IDS_LIBRARY_ALBUM_TITLE );
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine, 84,  92, IDS_LIBRARY_ALBUM_LENGTH, TRUE );
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine, 92, 100, IDS_LIBRARY_ALBUM_BITRATE, TRUE );

		rcLine.left = rcLine.right;
		rcLine.right += 78;
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine, 0, 100, IDS_LIBRARY_ALBUM_RATING );
	}
	else
	{
		// Artist, Album, Title, Length, Bitrate
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine,  0,  25, IDS_LIBRARY_ALBUM_ARTIST );
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine, 25,  50, IDS_LIBRARY_ALBUM_ALBUM );
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine, 50,  84, IDS_LIBRARY_ALBUM_TITLE );
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine, 84,  92, IDS_LIBRARY_ALBUM_LENGTH, TRUE );
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine, 92, 100, IDS_LIBRARY_ALBUM_BITRATE, TRUE );

		rcLine.left = rcLine.right;
		rcLine.right += 78;
		CLibraryAlbumTrack::PaintText( pBuffer, rcLine, 0, 100, IDS_LIBRARY_ALBUM_RATING );
	}

	pBuffer->SelectObject( &CoolInterface.m_fntNormal );

	dc.BitBlt( rcTrack.left, rcTrack.top, rcBuffer.right, rcBuffer.bottom,
		pBuffer, 0, 0, SRCCOPY );
	dc.ExcludeClipRect( &rcTrack );
	rcTrack.OffsetRect( 0, rcClient.top - m_nScroll );
	rcTrack.OffsetRect( 0, m_szTrack.cy );

	for ( int nItem = 0 ; nItem < m_nCount && rcTrack.top < rcClient.bottom ; nItem++, pList++ )
	{
		CLibraryAlbumTrack* pTrack = *pList;
		
		if ( rcTrack.bottom >= rcClient.top && dc.RectVisible( &rcTrack ) )
		{
			pBuffer->FillSolidRect( &rcBuffer, CoolInterface.m_crWindow );
			pTrack->Paint( this, pBuffer, rcBuffer, nItem );
			dc.BitBlt( rcTrack.left, rcTrack.top, rcBuffer.right, rcBuffer.bottom,
				pBuffer, 0, 0, SRCCOPY );
			dc.ExcludeClipRect( &rcTrack );
		}
		
		rcTrack.OffsetRect( 0, m_szTrack.cy );
	}
	
	pBuffer->SelectObject( pOldFont );
	dc.FillSolidRect( &rcClient, CoolInterface.m_crWindow );
}
Exemplo n.º 20
0
void ImageHandler::LoadDesktopWallpaperWin8(MonitorEnumData* pEnumData)
{
	CComPtr<IDesktopWallpaper> desktopWallpaper;
	HRESULT hr = desktopWallpaper.CoCreateInstance(CLSID_DesktopWallpaper, nullptr, CLSCTX_ALL);
	if(FAILED(hr)) return;

	UINT count;
	hr = desktopWallpaper->GetMonitorDevicePathCount(&count);
	if(FAILED(hr)) return;

	for(UINT i = 0; i < count; i++)
	{
		// Get the device path for the monitor.
		CComHeapPtr<wchar_t> spszId;
		hr = desktopWallpaper->GetMonitorDevicePathAt(i, &spszId);
		if(FAILED(hr)) continue;

		// Get the monitor location.
		CRect rectMonitor;
		hr = desktopWallpaper->GetMonitorRECT(spszId, (LPRECT)rectMonitor);
		if(FAILED(hr)) continue;

		// Get the wallpaper on that monitor.
		CComHeapPtr<wchar_t> spszWallpaper;
		hr = desktopWallpaper->GetWallpaper(spszId, &spszWallpaper);
		if(FAILED(hr)) continue;

		TRACE(
			L"wallpaper picture on '%s' (%ix%i)-(%ix%i) is '%s'\n",
			static_cast<wchar_t*>(spszId),
			rectMonitor.left, rectMonitor.top,
			rectMonitor.right, rectMonitor.bottom,
			static_cast<wchar_t*>(spszWallpaper));

		std::shared_ptr<BackgroundImage> bkImage;

		if(spszWallpaper.m_pData && *spszWallpaper.m_pData)
		{
			bkImage.reset(new BackgroundImage (pEnumData->bkImage->imageData));
			bkImage->imageData.strFilename = spszWallpaper.m_pData;
			bkImage->bWallpaper = true;
			ImageHandler::LoadImageW(bkImage);
		}
		else
		{
			bkImage = pEnumData->bkImage;
		}

		// create template image
		CDC     dcTemplate;
		CBitmap	bmpTemplate;
		dcTemplate.CreateCompatibleDC(NULL);

		DWORD dwNewWidth = rectMonitor.Width();
		DWORD dwNewHeight = rectMonitor.Height();
		ImageHandler::PaintRelativeImage(pEnumData->dcTemplate, bmpTemplate, bkImage, dwNewWidth, dwNewHeight);

		dcTemplate.SelectBitmap(bmpTemplate);

		ImageHandler::PaintTemplateImage(
			dcTemplate,
			rectMonitor.left - ::GetSystemMetrics(SM_XVIRTUALSCREEN),
			rectMonitor.top - ::GetSystemMetrics(SM_YVIRTUALSCREEN),
			dwNewWidth,
			dwNewHeight,
			rectMonitor.Width(),
			rectMonitor.Height(),
			pEnumData->bkImage);
	}
}
Exemplo n.º 21
0
void CDlg_Chat_Clt::OnlineUserInfo(DWORD dwUserId, CStringArrayEx *pstrUserInfo)
{
    if (NULL == pstrUserInfo) return;

    int nImageId = atoi((LPCTSTR)(*pstrUserInfo)[3]);
    m_wndOutlookBar.InsertItem(0, m_wndOutlookBar.GetItemCount(0), (LPCTSTR)(*pstrUserInfo)[1], nImageId, dwUserId);

    CString strCount;
    strCount.Format(_T("在线用户 (%d)"), m_wndOutlookBar.GetItemCount(0));
    m_wndOutlookBar.SetFolderText(0, (LPCTSTR)strCount);

    if (m_dwMyId == dwUserId)
    {
        IMAGEINFO ImageInfo = {0};
        g_ProFile.m_ImageList.GetImageInfo(nImageId, &ImageInfo);
        CSize szImage = CRect(ImageInfo.rcImage).Size();
        CPoint pt(10, 50-szImage.cy-1);
        CDC dc;
        dc.Attach(m_hCompDC);
        g_ProFile.m_ImageList.Draw(&dc, nImageId, pt, ILD_NORMAL);
        dc.Detach();

        RECT rcText = {15+szImage.cx, 30, 180, 50};
        ::DrawText(m_hCompDC, (LPCTSTR)(*pstrUserInfo)[1], (*pstrUserInfo)[1].GetLength(), &rcText, DT_VCENTER|DT_SINGLELINE|DT_WORD_ELLIPSIS);
    }

    m_OnlineUserIdArray.Add(dwUserId);

    if (NULL == m_pFriendIdArray) return;

    for (int i = 0; i < m_pFriendIdArray->GetCount(); i++)
    {
        if (dwUserId == (*m_pFriendIdArray)[i])
        {
            int j = 0;
            for (; j < m_OnlineFriendIdArray.GetCount(); j++)
            {
                if (dwUserId == m_OnlineFriendIdArray[j]) break;
            }

            if (j == m_OnlineFriendIdArray.GetCount())
            {
                m_OnlineFriendIdArray.Add(dwUserId);

                int nImageId = atoi((LPCTSTR)(*pstrUserInfo)[3]);
                m_wndOutlookBar.InsertItem(1, j, (LPCTSTR)(*pstrUserInfo)[1], nImageId, dwUserId);

                strCount.Format(_T("我的好友 (%d/%d)"), m_OnlineFriendIdArray.GetCount(), m_pFriendIdArray->GetCount());
                m_wndOutlookBar.SetFolderText(1, (LPCTSTR)strCount);
            }
/*
            m_wndOutlookBar.RemoveItem(1, i);

            int nImageId = atoi((LPCTSTR)(*pstrUserInfo)[3]);
            m_wndOutlookBar.InsertItem(1, i, (LPCTSTR)(*pstrUserInfo)[1], nImageId, dwUserId);

            strCount.Format(_T("我的好友 (%d/%d)"), ++m_nOnlineFriends, m_wndOutlookBar.GetItemCount(1));
            m_wndOutlookBar.SetFolderText(1, (LPCTSTR)strCount);
*/
            break;
        }
    }

    m_wndOutlookBar.Invalidate();
}
Exemplo n.º 22
0
BOOL CALLBACK ImageHandler::MonitorEnumProcWin8(HMONITOR hMonitor, HDC /*hdcMonitor*/, LPRECT lprcMonitor, LPARAM lpData)
{
  MONITORINFOEX miex;
  miex.cbSize = sizeof(miex);
  ::GetMonitorInfo(hMonitor, &miex);

  DISPLAY_DEVICE dd;
  dd.cb = sizeof(dd);
  ::EnumDisplayDevices(miex.szDevice, 0, &dd, EDD_GET_DEVICE_INTERFACE_NAME);

#if 0
  TRACE(L"name %s String %s DeviceID %s Key %s StateFlags %lu\n",
    dd.DeviceName,
    dd.DeviceString,
    dd.DeviceID,
    dd.DeviceKey,
    dd.StateFlags);
#endif

  wchar_t szTranscodedImage [_MAX_PATH] = L"";

  TRACE(
    L"searching for %s ('%s') ...\n",
    miex.szDevice,
    dd.DeviceID);

  try
  {
    DWORD dwTranscodedImageCount = 0;
    DWORD dwType;
    DWORD dwValueSize;
    LSTATUS rc;

    HKEY hkey;
    rc = ::RegOpenKeyEx(
      HKEY_CURRENT_USER,
      L"Control Panel\\Desktop",
      0,
      KEY_READ,
      &hkey);

    if( rc != ERROR_SUCCESS )
      Win32Exception::Throw("RegOpenKeyEx", rc);

    unique_ptr<HKEY__, RegCloseKeyHelper>hkeyPtr(hkey);

    rc = ::RegQueryValueEx(
      hkeyPtr.get(),
      L"TranscodedImageCount",
      nullptr,
      &dwType,
      reinterpret_cast<LPBYTE>(&dwTranscodedImageCount),
      &(dwValueSize = static_cast<DWORD>(sizeof(dwTranscodedImageCount))));

    if( rc != ERROR_SUCCESS )
      Win32Exception::Throw("RegQueryValueEx", rc);

    for(DWORD i = 0; i < dwTranscodedImageCount; ++i)
    {
      wchar_t szValueName [32];
      _snwprintf_s(
        szValueName, ARRAYSIZE(szValueName),
        _TRUNCATE,
        L"TranscodedImageCache_%03lu",
        i);

      BYTE binTranscodedImageCache [0x320];
      rc = ::RegQueryValueEx(
        hkeyPtr.get(),
        szValueName,
        nullptr,
        &dwType,
        binTranscodedImageCache,
        &(dwValueSize = static_cast<DWORD>(sizeof(binTranscodedImageCache))));

      if( rc != ERROR_SUCCESS )
        Win32Exception::Throw("RegQueryValueEx", rc);

      TRACE(
        L"\twallpaper picture on ('%s') is '%s'\n",
        reinterpret_cast<wchar_t*>(binTranscodedImageCache + 0x220),
        reinterpret_cast<wchar_t*>(binTranscodedImageCache + 0x18));

      wchar_t* szDeviceID1 = dd.DeviceID;
      wchar_t* szDeviceID2 = reinterpret_cast<wchar_t*>(binTranscodedImageCache + 0x220);

      // when monitor device id is "Default_Monitor"
      // \\?\DISPLAY#Default_Monitor#...
      // there is no device id in TranscodedImageCache_xxx file

      if( ( *szDeviceID2 == 0 && 
            wcsncmp(szDeviceID1, L"\\\\?\\DISPLAY#Default_Monitor#", 28) == 0 ) ||
          wcsncmp(szDeviceID1, szDeviceID2, 128) == 0 )
      {
        wcsncpy_s(
          szTranscodedImage, _MAX_PATH,
          reinterpret_cast<wchar_t*>(binTranscodedImageCache + 0x18),
          _TRUNCATE);

        break;
      }
    }
  }
  catch(Win32Exception&)
  {
  }

  MonitorEnumData* pEnumData = reinterpret_cast<MonitorEnumData*>(lpData);

  std::shared_ptr<BackgroundImage> bkImage;

  if( szTranscodedImage[0] )
  {
    TRACE(
      L"wallpaper picture on %s ('%s') is '%s'\n",
      miex.szDevice,
      dd.DeviceID,
      szTranscodedImage);

    bkImage.reset(new BackgroundImage (pEnumData->bkImage->imageData));
    bkImage->imageData.strFilename = szTranscodedImage;
    bkImage->bWallpaper = true;
    ImageHandler::LoadImageW(bkImage);
  }
  else
  {
    bkImage = pEnumData->bkImage;
  }

  CRect   rectMonitor(lprcMonitor);

  // create template image
  CDC     dcTemplate;
  CBitmap	bmpTemplate;
  dcTemplate.CreateCompatibleDC(NULL);

  DWORD dwNewWidth  = rectMonitor.Width();
  DWORD dwNewHeight = rectMonitor.Height();
  ImageHandler::PaintRelativeImage(pEnumData->dcTemplate, bmpTemplate, bkImage, dwNewWidth, dwNewHeight);

  dcTemplate.SelectBitmap(bmpTemplate);

  ImageHandler::PaintTemplateImage(
    dcTemplate, 
    rectMonitor.left - ::GetSystemMetrics(SM_XVIRTUALSCREEN), 
    rectMonitor.top  - ::GetSystemMetrics(SM_YVIRTUALSCREEN), 
    dwNewWidth,
    dwNewHeight,
    rectMonitor.Width(), 
    rectMonitor.Height(), 
    pEnumData->bkImage);

  return TRUE;
}
Exemplo n.º 23
0
BOOL CSetDBID::OnInitDialog()
{
  CPWDialog::OnInitDialog();

  // Trying to get our icon to get background colour (failed when System Tray
  // icon created in ThisMafApp as too early - no main dialog HWND).
  // Windows 10 default is black but Windows 7 seems to be white
  NOTIFYICONIDENTIFIER nii = { sizeof(nii) };
  nii.hWnd = m_pParent->GetSafeHwnd();
  nii.uID = PWS_MSG_ICON_NOTIFY;
  nii.guidItem = GUID_NULL;
  RECT rcIcon;
  HRESULT hr = Shell_NotifyIconGetRect(&nii, &rcIcon);

  COLORREF clr = (COLORREF)-1;
  if (SUCCEEDED(hr)) {
    CWnd *pWnd = CWnd::GetDesktopWindow();
    CDC *pDC = pWnd->GetDC();
    clr = pDC->GetPixel(rcIcon.right + 1, rcIcon.top + 1);
    pws_os::Trace(L"clr: %06x; R=%d; G=%d; B=%d\n", clr, GetRValue(clr), GetGValue(clr), GetBValue(clr));
    clr = RGB(GetRValue(clr), GetGValue(clr), GetBValue(clr));
    ReleaseDC(pDC);
  }

  m_clrBackground = (clr != (COLORREF)-1) ? clr : GetSysColor(COLOR_BACKGROUND);

  m_Brush.CreateSolidBrush(m_clrBackground);

  VERIFY(m_bmLocked.Attach(::LoadImage(
    ::AfxFindResourceHandle(MAKEINTRESOURCE(IDB_LOCKED_TRAY_INDEX), RT_BITMAP),
    MAKEINTRESOURCE(IDB_LOCKED_TRAY_INDEX), IMAGE_BITMAP, 0, 0,
                                    (LR_DEFAULTSIZE | LR_CREATEDIBSECTION))));

  VERIFY(m_bmUnlocked.Attach(::LoadImage(
    ::AfxFindResourceHandle(MAKEINTRESOURCE(IDB_UNLOCKED_TRAY_INDEX), RT_BITMAP),
    MAKEINTRESOURCE(IDB_UNLOCKED_TRAY_INDEX), IMAGE_BITMAP, 0, 0,
                                    (LR_DEFAULTSIZE | LR_CREATEDIBSECTION))));

  SetBitmapBackground(m_bmLocked);
  SetBitmapBackground(m_bmUnlocked);

  m_clrLockedTextColour = m_pParent->GetLockedIndexColour();
  m_clrUnlockedTextColour = m_pParent->GetUnlockedIndexColour();

  for (int i = 0; i < 4; i++) {
    if (m_clrLockedTextOptions[i] == m_clrLockedTextColour) {
      m_iLockedTextColour = i;
      break;
    }
  }

  for (int i = 0; i < 4; i++) {
    if (m_clrUnlockedTextOptions[i] == m_clrUnlockedTextColour) {
      m_iUnLockedTextColour = i;
      break;
    }
  }

  CreateIndexBitmap(55, m_clrLockedTextColour, true);
  CreateIndexBitmap(55, m_clrUnlockedTextColour, false);

  // Index if between 1 & 99
  m_edtSBIndex.SetLimitText(2);

  UpdateData(FALSE);

  GotoDlgCtrl((CWnd *)&m_edtSBIndex);

  m_bInitDone = true;

  return FALSE;  // return TRUE unless you set the focus to a control
}
Exemplo n.º 24
0
void CClientListCtrl::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
{
	if (!theApp.emuledlg->IsRunning())
		return;
	if (!lpDrawItemStruct->itemData)
		return;
	CDC* odc = CDC::FromHandle(lpDrawItemStruct->hDC);
	BOOL bCtrlFocused = ((GetFocus() == this) || (GetStyle() & LVS_SHOWSELALWAYS));
	if (lpDrawItemStruct->itemState & ODS_SELECTED) {
		if (bCtrlFocused)
			odc->SetBkColor(m_crHighlight);
		else
			odc->SetBkColor(m_crNoHighlight);
	}
	else
		odc->SetBkColor(GetBkColor());
	const CUpDownClient* client = (CUpDownClient*)lpDrawItemStruct->itemData;
	CMemDC dc(odc, &lpDrawItemStruct->rcItem);
	CFont* pOldFont = dc.SelectObject(GetFont());
	CRect cur_rec(lpDrawItemStruct->rcItem);
	COLORREF crOldTextColor = dc.SetTextColor((lpDrawItemStruct->itemState & ODS_SELECTED) ? m_crHighlightText : m_crWindowText);

	int iOldBkMode;
	if (m_crWindowTextBk == CLR_NONE){
		DefWindowProc(WM_ERASEBKGND, (WPARAM)(HDC)dc, 0);
		iOldBkMode = dc.SetBkMode(TRANSPARENT);
	}
	else
		iOldBkMode = OPAQUE;

	CHeaderCtrl *pHeaderCtrl = GetHeaderCtrl();
	int iCount = pHeaderCtrl->GetItemCount();
	cur_rec.right = cur_rec.left - 8;
	cur_rec.left += 4;
	CString Sbuffer;
	for(int iCurrent = 0; iCurrent < iCount; iCurrent++){
		int iColumn = pHeaderCtrl->OrderToIndex(iCurrent);
		if( !IsColumnHidden(iColumn) ){
			cur_rec.right += GetColumnWidth(iColumn);
			switch(iColumn){
				case 0:{
					uint8 image;
					if (client->IsFriend())
						image = 2;
					else if (client->GetClientSoft() == SO_EDONKEYHYBRID)
						image = 4;
					else if (client->GetClientSoft() == SO_MLDONKEY)
						image = 3;
					else if (client->GetClientSoft() == SO_SHAREAZA)
						image = 5;
					else if (client->GetClientSoft() == SO_URL)
						image = 6;
					else if (client->GetClientSoft() == SO_AMULE)
						image = 7;
					else if (client->GetClientSoft() == SO_LPHANT)
						image = 8;
					else if (client->ExtProtocolAvailable())
						image = 1;
					else
						image = 0;

					uint32 nOverlayImage = 0;
					if ((client->Credits() && client->Credits()->GetCurrentIdentState(client->GetIP()) == IS_IDENTIFIED))
						nOverlayImage |= 1;
					if (client->IsObfuscatedConnectionEstablished())
						nOverlayImage |= 2;
					POINT point = {cur_rec.left, cur_rec.top+1};
					imagelist.Draw(dc,image, point, ILD_NORMAL | ((client->Credits() && client->Credits()->GetCurrentIdentState(client->GetIP()) == IS_IDENTIFIED) ? INDEXTOOVERLAYMASK(1) : 0));
					if (client->GetUserName()==NULL)
						Sbuffer.Format(_T("(%s)"), GetResString(IDS_UNKNOWN));
					else
						Sbuffer = client->GetUserName();

					//EastShare Start - added by AndCycle, IP to Country
 					CString tempStr;
 						tempStr.Format(_T("%s%s"), client->GetCountryName(), Sbuffer);
 					Sbuffer = tempStr;
 
 					if(CGlobalVariable::ip2country->ShowCountryFlag()){
 							cur_rec.left+=20;
 							POINT point2= {cur_rec.left,cur_rec.top+1};
 						CGlobalVariable::ip2country->GetFlagImageList()->DrawIndirect(dc, client->GetCountryFlagIndex(), point2, CSize(18,16), CPoint(0,0), ILD_NORMAL);
 					}
 					//EastShare End - added by AndCycle, IP to Country

					cur_rec.left +=20;
					dc.DrawText(Sbuffer,Sbuffer.GetLength(),&cur_rec,DLC_DT_TEXT);
					cur_rec.left -=20;

 					//EastShare Start - added by AndCycle, IP to Country
 					if(CGlobalVariable::ip2country->ShowCountryFlag()){
 						cur_rec.left-=20;
 					}
 					//EastShare End - added by AndCycle, IP to Country

					break;
				}
				case 1:{
					Sbuffer = client->GetUploadStateDisplayString();
					break;
				}
				case 2:{
					if(client->credits)
						Sbuffer = CastItoXBytes(client->credits->GetUploadedTotal(), false, false);
					else
						Sbuffer.Empty();
					break;
				}
				case 3:{
					Sbuffer = client->GetDownloadStateDisplayString();
					break;
				}
				case 4:{
					if(client->credits)
						Sbuffer = CastItoXBytes(client->credits->GetDownloadedTotal(), false, false);
					else
						Sbuffer.Empty();
					break;
				}
				case 5:{
					Sbuffer = client->GetClientSoftVer();
					if (Sbuffer.IsEmpty())
						Sbuffer = GetResString(IDS_UNKNOWN);
					break;
				}
				case 6:{
					if(client->socket){
						if(client->socket->IsConnected()){
							Sbuffer = GetResString(IDS_YES);
							break;
						}
					}
					Sbuffer = GetResString(IDS_NO);
					break;
				}
				case 7:
					Sbuffer = md4str(client->GetUserHash());
					break;
			}
			if( iColumn != 0)
				dc.DrawText(Sbuffer,Sbuffer.GetLength(),&cur_rec,DLC_DT_TEXT);
			cur_rec.left += GetColumnWidth(iColumn);
		}
	}

	// draw rectangle around selected item(s)
	if (lpDrawItemStruct->itemState & ODS_SELECTED)
	{
		RECT outline_rec = lpDrawItemStruct->rcItem;

		outline_rec.top--;
		outline_rec.bottom++;
		dc.FrameRect(&outline_rec, &CBrush(GetBkColor()));
		outline_rec.top++;
		outline_rec.bottom--;
		outline_rec.left++;
		outline_rec.right--;

		if(bCtrlFocused)
			dc.FrameRect(&outline_rec, &CBrush(m_crFocusLine));
		else
			dc.FrameRect(&outline_rec, &CBrush(m_crNoFocusLine));
	}

	if (m_crWindowTextBk == CLR_NONE)
		dc.SetBkMode(iOldBkMode);
	dc.SelectObject(pOldFont);
	dc.SetTextColor(crOldTextColor);
}
Exemplo n.º 25
0
BOOL CInfoDlg::OnEraseBkgnd(CDC* pDC) 
{
	// TODO: Add your message handler code here and/or call default
	CPoint point;
	CRect rect;
	GetWindowRect(&rect);
	GetClientRect(&m_rect);
	CDC memdc;     //定义一个显示设备对象 
	CBitmap bmp;       //定义一个位图对象 
	memdc.CreateCompatibleDC(pDC);     //建立与屏幕显示兼容的内存显示设备 
	bmp.CreateCompatibleBitmap(pDC,rect.Width(),rect.Height());//建立一个与屏幕显示兼容的位图
	memdc.SetBkMode(TRANSPARENT);
	//	memdc.FillSolidRect(0,0,rect.Width(),rect.Height(),RGB(93,250,255)); 	//用背景色将位图清除干净
	CBitmap* pOldBmp = memdc.SelectObject(&bmp);            //将位图选入到内存显示设备中		
	
	DWORD style = DT_CENTER|DT_SINGLELINE|DT_VCENTER;
	
	
	m_DlgPic.Load(IDR_JPG_DIALOG1);
	if(m_DlgPic != NULL)
		m_DlgPic.Render(&memdc,m_rect);
	
	if (m_bflag)
	{
		m_DlgPic.Load(IDR_CLOSEX1);
		
	}
	else
	{
		m_DlgPic.Load(IDR_CLOSEX);
	}
	m_DlgPic.Render(&memdc,m_rtclose);
	CFont font;
	if (g_Language)
	{
		font.CreatePointFont(88, "Verdana");
	}
	else
	{
		font.CreatePointFont(100,/*"Verdana"*/"宋体");
	}	

	CFont   *pOldfont = (CFont *)memdc.SelectObject(&font); 
    memdc.SetTextColor(RGB(0, 0, 0)); 
	//memdc.SetBkColor(TRANSPARENT);

	memdc.DrawText(m_strCaption,CRect(8,5,180,25),DT_LEFT| DT_VCENTER | DT_SINGLELINE);
	for (int i=0; i<8 ;i++)
	{
		memdc.DrawText(m_strText[i], m_rcaption[i],DT_RIGHT  | DT_VCENTER | DT_SINGLELINE);
	}

	for (i =0; i < 9; i++)
	{
		memdc.DrawText(m_strInfo[i], m_rctext[i],DT_LEFT | DT_VCENTER | DT_SINGLELINE);
		
	}
	pDC->BitBlt(0,0,m_rect.Width(),m_rect.Height(),&memdc,0,0,SRCCOPY);
	font.DeleteObject();
	bmp.DeleteObject();
	memdc.DeleteDC();
	ReleaseDC(pDC);
	return true;
	
}
Exemplo n.º 26
0
void CSearchResultsBox::OnPaint() 
{
	CString strFormat, strText;
	CPaintDC dc( this );
	CRect rc;
	
	GetClientRect( &rc );
	
	CSize size = rc.Size();
	CDC* pDC = CoolInterface.GetBuffer( dc, size );
	if ( ! CoolInterface.DrawWatermark( pDC, &rc, CBitmap::FromHandle( m_hbmWatermark ) ) )
	{
		pDC->FillSolidRect( &rc, CoolInterface.m_crTaskBoxClient );
	}

	CFont* pOldFont = (CFont*)pDC->SelectObject( &CoolInterface.m_fntBold );

	pDC->SetTextColor( CoolInterface.m_crText );
	pDC->SetBkMode( TRANSPARENT );
	pDC->SetBkColor( CoolInterface.m_crTaskBoxClient );

	LoadString( strText, IDS_SEARCH_PANEL_RESULTS_STATUS );
	DrawText( pDC, BOX_MARGIN, BOX_MARGIN, ETO_CLIPPED, strText );
	LoadString( strText, IDS_SEARCH_PANEL_RESULTS_FOUND );
	DrawText( pDC, BOX_MARGIN, BOX_MARGIN + 32, ETO_CLIPPED, strText );

	pDC->SelectObject( &CoolInterface.m_fntNormal );

	if ( m_bActive )
	{
		LoadString( strFormat, IDS_SEARCH_PANEL_RESULTS_ACTIVE );
		strText.Format( strFormat, m_nHubs, m_nLeaves );
	}
	else
	{
		LoadString( strText, IDS_SEARCH_PANEL_RESULTS_INACTIVE );
	}

	DrawText( pDC, BOX_MARGIN + 8, BOX_MARGIN + 14, ETO_CLIPPED, strText );

	if ( m_nFiles )
	{
		LoadString( strFormat, IDS_SEARCH_PANEL_RESULTS_FORMAT );
		
		if ( strFormat.Find( '|' ) >= 0 )
		{
			if ( m_nFiles == 1 && m_nHits == 1 )
				Skin.SelectCaption( strFormat, 0 );
			else if ( m_nFiles == 1 )
				Skin.SelectCaption( strFormat, 1 );
			else
				Skin.SelectCaption( strFormat, 2 );
			
			strText.Format( strFormat,
				m_nFiles, m_nHits );
		}
		else
		{
			strText.Format( strFormat,
				m_nFiles, m_nFiles != 1 ? _T("s") : _T(""),
				m_nHits, m_nHits != 1 ? _T("s") : _T("") );
		}
	}
	else
	{
		LoadString( strText, IDS_SEARCH_PANEL_RESULTS_NONE );
	}

	DrawText( pDC, BOX_MARGIN + 8, BOX_MARGIN + 32 + 14, ETO_CLIPPED, strText );

	pDC->SelectObject( pOldFont );

	dc.BitBlt( 0, 0, rc.Width(), rc.Height(), pDC, 0, 0, SRCCOPY );
	dc.ExcludeClipRect( &rc );
}
Exemplo n.º 27
0
void CLabel::OnPaint() 
{
	CPaintDC dc(this); // device context for painting

	DWORD dwFlags = 0;

	CRect rc;
	GetClientRect(rc);
	CString strText( m_sText );

	CBitmap bmp;


	///////////////////////////////////////////////////////
	//
	// Set up for double buffering...
	//
	CDC* pDCMem;
	CBitmap*	pOldBitmap = NULL;

	if (!m_bTransparent)
	{
		pDCMem = new CDC;
		pDCMem->CreateCompatibleDC(&dc);
		bmp.CreateCompatibleBitmap(&dc,rc.Width(),rc.Height());
		pOldBitmap = pDCMem->SelectObject(&bmp);
	}
	else
	{
		pDCMem = &dc;
	}

	UINT nMode = pDCMem->SetBkMode(TRANSPARENT);


	COLORREF crText = pDCMem->SetTextColor(m_crText);
	CFont *pOldFont = pDCMem->SelectObject(&m_font);


	// Fill in backgound if not transparent
	if (!m_bTransparent)
	{
		if (m_fillmode == Normal)
		{
			CBrush br;
			
			if (m_hBackBrush != NULL)
				br.Attach(m_hBackBrush);
			else
				br.Attach(m_hwndBrush);
					
			pDCMem->FillRect(rc,&br);

			br.Detach();
		}
		else // Gradient Fill
		{
			DrawGradientFill(pDCMem, &rc, m_crLoColor, m_crHiColor, 100);
		}

	}
	

	// If the text is flashing turn the text color on
	// then to the color of the window background.

	LOGBRUSH lb;
	ZeroMemory(&lb,sizeof(lb));

	// Stop Checking complaining
	if (m_hBackBrush)
		::GetObject(m_hBackBrush,sizeof(lb),&lb);


	// Something to do with flashing
	if (!m_bState && m_Type == Text)
		pDCMem->SetTextColor(lb.lbColor);

	DWORD style = GetStyle();
	
	switch (style & SS_TYPEMASK)
	{
		case SS_RIGHT: 
			dwFlags = DT_RIGHT | DT_WORDBREAK; 
			break; 
		
		case SS_CENTER: 
			dwFlags = SS_CENTER | DT_WORDBREAK;
			break;

		case SS_LEFTNOWORDWRAP: 
			dwFlags = DT_LEFT; 
			break;

		default: // treat other types as left
			case SS_LEFT: 
				dwFlags = DT_LEFT | DT_WORDBREAK; 
				break;
	}	

		
	// Added to expand tabs...
	if(strText.Find(_T('\t')) != -1)
		dwFlags |= DT_EXPANDTABS;

	// If the text centered make an assumtion that
	// the will want to center verticly as well
	if (style & SS_CENTERIMAGE)
	{
		dwFlags = DT_CENTER;

		// Apply 
		if (strText.Find(_T("\r\n")) == -1)
		{
			dwFlags |= DT_VCENTER;

			// And because DT_VCENTER only works with single lines
			dwFlags |= DT_SINGLELINE; 
		}

	}

	//
	// 3333   DDDDD
	//     3  D    D
	//   33   D     D    E F X 
	//     3  D    D
	// 3333   DDDDD
	//
	//
	if (m_bRotation)
	{
		int nAlign = pDCMem->SetTextAlign (TA_BASELINE);

		CPoint pt;
		GetViewportOrgEx (pDCMem->m_hDC,&pt) ;
		SetViewportOrgEx (pDCMem->m_hDC,rc.Width() / 2, rc.Height() / 2, NULL) ;
		pDCMem->TextOut (0, 0, strText) ;
		SetViewportOrgEx (pDCMem->m_hDC,pt.x / 2, pt.y / 2, NULL) ;
		pDCMem->SetTextAlign (nAlign);
	}
	else
	{
		// convert to UNICODE and use the WIDE version of DrawText()
		// Why?  because DrawText seems to have a bug with Japanese 
		// characters.

		USES_CONVERSION;

		WCHAR* wsz = T2OLE( strText );
		::DrawTextExW( *pDCMem, wsz, (int)(::wcslen( wsz )), rc, dwFlags, NULL ); 
		if (m_bFont3d)
		{
			pDCMem->SetTextColor(m_cr3DHiliteColor);

			if (m_3dType == Raised)
				rc.OffsetRect(-1,-1);
			else
				rc.OffsetRect(1,1);

//			::DrawTextW( *pDCMem, wsz, ::wcslen( wsz ), rc, dwFlags ); 
		}
	}

	// Restore DC's State
	pDCMem->SetBkMode(nMode);
	pDCMem->SelectObject(pOldFont);
	pDCMem->SetTextColor(crText);

	if (!m_bTransparent)
	{
		dc.BitBlt(0,0,rc.Width(),rc.Height(),pDCMem,0,0,SRCCOPY);
		// continue DC restore 
		pDCMem->SelectObject ( pOldBitmap ) ;
		delete pDCMem;
	}
}
Exemplo n.º 28
0
void CQListCtrl::OnCustomdrawList(NMHDR* pNMHDR, LRESULT* pResult)
{
	NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNMHDR );
    
    *pResult = 0;
	
    // Request item-specific notifications if this is the
    // beginning of the paint cycle.
    if ( CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage )
	{
        *pResult = CDRF_NOTIFYITEMDRAW;
	}
    else if ( CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage )
	{
        LVITEM   rItem;
        int      nItem = static_cast<int>( pLVCD->nmcd.dwItemSpec );
        CDC*     pDC   = CDC::FromHandle ( pLVCD->nmcd.hdc );
        COLORREF crBkgnd;
        BOOL     bListHasFocus;
        CRect    rcItem;
		
        bListHasFocus = ( GetSafeHwnd() == ::GetFocus() );
        
        // Get the image index and selected/focused state of the
        // item being drawn.
        ZeroMemory ( &rItem, sizeof(LVITEM) );
        rItem.mask  = LVIF_STATE;
        rItem.iItem = nItem;
        rItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
        GetItem(&rItem);
		
        // Get the rect that bounds the text label.
        GetItemRect(nItem, rcItem, LVIR_LABEL);
		rcItem.left -= DUMMY_COL_WIDTH;
		
		COLORREF OldColor = -1;
		int nOldBKMode = -1;

		CString csText;
		LPTSTR lpszText = csText.GetBufferSetLength(g_Opt.m_bDescTextSize);
		GetItemText(nItem, 0, lpszText, g_Opt.m_bDescTextSize);
		csText.ReleaseBuffer();

		// extract symbols
		CString strSymbols;
		int nSymEnd = csText.Find('|');
		if (nSymEnd >= 0)
		{
			strSymbols = csText.Left(nSymEnd);
			csText = csText.Mid(nSymEnd + 1);
		}
		
		// Draw the background of the list item.  Colors are selected 
		// according to the item's state.
		if(rItem.state & LVIS_SELECTED)
		{
            if(bListHasFocus)
			{
                crBkgnd = g_Opt.m_Theme.ListBoxSelectedBG();
                OldColor = pDC->SetTextColor(g_Opt.m_Theme.ListBoxSelectedText());
			}
            else
			{
                crBkgnd = g_Opt.m_Theme.ListBoxSelectedNoFocusBG();
                OldColor = pDC->SetTextColor(g_Opt.m_Theme.ListBoxSelectedNoFocusText());
			}
		}
        else
		{
            //Shade alternating Rows
			if((nItem % 2) == 0)
			{
				crBkgnd = g_Opt.m_Theme.ListBoxOddRowsBG();
				OldColor = pDC->SetTextColor(g_Opt.m_Theme.ListBoxOddRowsText());
			}
			else
			{
				crBkgnd = g_Opt.m_Theme.ListBoxEvenRowsBG();
				OldColor = pDC->SetTextColor(g_Opt.m_Theme.ListBoxEvenRowsText());
			}
		}
		
        pDC->FillSolidRect(rcItem, crBkgnd);
        nOldBKMode = pDC->SetBkMode(TRANSPARENT);
		
        CRect rcText = rcItem;
        rcText.left += ROW_LEFT_BORDER;
		rcText.top++;
		
		if (m_showIfClipWasPasted &&
			strSymbols.GetLength() > 0 &&
			strSymbols.Find(_T("<pasted>")) >= 0) //clip was pasted from ditto 
		{
			CRect pastedRect(rcItem);
			pastedRect.left++;
			pastedRect.right = rcItem.left + theApp.m_metrics.ScaleX(3);
				
			pDC->FillSolidRect(pastedRect, g_Opt.m_Theme.ClipPastedColor());

			rcText.left += theApp.m_metrics.ScaleX(4);
		}
		        		
		// set firstTenNum to the first ten number (1-10) corresponding to
		//  the current nItem.
		// -1 means that nItem is not in the FirstTen block.
		int firstTenNum = GetFirstTenNum(nItem);
		
		if( m_bShowTextForFirstTenHotKeys && firstTenNum > 0 )
		{
			rcText.left += theApp.m_metrics.ScaleX(12);
		}
		
		bool drawInGroupIcon = true;
		// if we are inside a group, don't display the "in group" flag
		if( theApp.m_GroupID > 0 )
		{
			int nFlag = strSymbols.Find(_T("<ingroup>"));
			if (nFlag >= 0)
				drawInGroupIcon = false;
		}
		
		DrawBitMap(nItem, rcText, pDC, csText);			

		// draw the symbol box
		if( strSymbols.GetLength() > 0 )
		{
			if(strSymbols.Find(_T("<group>")) >= 0) //group 
			{
				m_groupFolder.Draw(pDC, this, rcText.left, rcText.top, false, false);
				rcText.left += m_groupFolder.ImageWidth() + theApp.m_metrics.ScaleX(2);
			}
			if (strSymbols.Find(_T("<noautodelete>")) >= 0 &&
				strSymbols.Find(_T("<group>")) < 0 &&
				strSymbols.Find(_T("<sticky>")) < 0) //don't auto delete
			{
				m_dontDeleteImage.Draw(pDC, this, rcText.left, rcText.top, false, false);
				rcText.left += m_dontDeleteImage.ImageWidth() + theApp.m_metrics.ScaleX(2);
			}
			if (strSymbols.Find(_T("<shortcut>")) >= 0) // has shortcut
			{
				m_shortCutImage.Draw(pDC, this, rcText.left, rcText.top, false, false);
				rcText.left += m_shortCutImage.ImageWidth() + theApp.m_metrics.ScaleX(2);
			}
			if (drawInGroupIcon &&
				strSymbols.Find(_T("<ingroup>")) >= 0) // in group
			{
				m_inFolderImage.Draw(pDC, this, rcText.left, rcText.top, false, false);
				rcText.left += m_inFolderImage.ImageWidth() + theApp.m_metrics.ScaleX(2);
			}
			if (strSymbols.Find(_T("<qpastetext>")) >= 0) // has quick paste text
			{
			}
			if (strSymbols.Find(_T("<sticky>")) >= 0) //sticky clip
			{
				m_stickyImage.Draw(pDC, this, rcText.left, rcText.top, false, false);
				rcText.left += m_stickyImage.ImageWidth() + theApp.m_metrics.ScaleX(2);
			}			
		}
		
		if(DrawRtfText(nItem, rcText, pDC) == FALSE)
		{
			if (m_searchText.GetLength() > 0 &&
				FindNoCaseAndInsert(csText, m_searchText, _T("<font color='#ff0000'>"), _T("</font>")) > 0)
			{				
				DrawHTML(pDC->m_hDC, csText, csText.GetLength(), rcText, DT_VCENTER | DT_EXPANDTABS | DT_NOPREFIX);
			}
			else
			{
				pDC->DrawText(csText, rcText, DT_VCENTER | DT_EXPANDTABS | DT_NOPREFIX);
			}
		}
		
        // Draw a focus rect around the item if necessary.
        if(bListHasFocus && (rItem.state & LVIS_FOCUSED))
			pDC->DrawFocusRect(rcItem);
						
		if( m_bShowTextForFirstTenHotKeys && firstTenNum > 0 )
		{
			CString cs;
			if( firstTenNum == 10 )
				cs = "0";
			else
				cs.Format(_T("%d"), firstTenNum);
			
			CRect crClient;
			
			GetWindowRect(crClient);
			ScreenToClient(crClient);
			
			CRect crHotKey = rcItem;

			int extraFromClipWasPaste = 0;
			if (m_showIfClipWasPasted)
				extraFromClipWasPaste = 3;
			
			crHotKey.right = crHotKey.left + theApp.m_metrics.ScaleX(11);
			crHotKey.left += theApp.m_metrics.ScaleX(1 + extraFromClipWasPaste);
			crHotKey.top += theApp.m_metrics.ScaleX(1 + extraFromClipWasPaste);
			
			HFONT hOldFont = (HFONT)pDC->SelectObject(m_SmallFont);
			
			pDC->DrawText(cs, crHotKey, DT_BOTTOM);
			
			pDC->MoveTo(CPoint(rcItem.left + theApp.m_metrics.ScaleX(8 + extraFromClipWasPaste), rcItem.top));
			pDC->LineTo(CPoint(rcItem.left + theApp.m_metrics.ScaleX(8 + extraFromClipWasPaste), rcItem.bottom));
			
			pDC->SelectObject(hOldFont);
		}
		
		// restore the previous values		
		if(OldColor > -1)
			pDC->SetTextColor(OldColor);
		
		if(nOldBKMode > -1)
			pDC->SetBkMode(nOldBKMode);
		
        *pResult = CDRF_SKIPDEFAULT;    // We've painted everything.
	}
}
Exemplo n.º 29
0
void CMFECToolTip::DisplayInfo( ToolTipInfo* pToolTip )
{
	if( pToolTip->nInfoSize <= 0 )
		return;

	ASSERT(m_pParentWnd);

	CDC* pDC = m_pParentWnd->GetDC();

	CRect		oInfoRect;
	CBrush		oBrush, *pOldBrush, oBorderBrush;
	int			nX, nY;
	TEXTMETRIC	TM;
	int			nTextHigh;
	CFont		oFont, *pOldFont;
	CWnd*		pWnd = NULL;
	
	oBrush.CreateSolidBrush( pToolTip->nBackColor );

	pOldBrush = pDC->SelectObject( &oBrush );
	pDC->SetTextColor( pToolTip->nTextColor );

	//calculate the width and height of the box dynamically
	CalculateHeightAndWidth( pToolTip->nControlInfo ); 
	CalculateInfoBoxRect( pToolTip->nControlID, &oInfoRect );

	oFont.CreateFont(m_nFontSize, 0, 0, 0, FW_REGULAR, 0, 0, 0, 0, 0, 0, 0, 0, "���ו");
	pOldFont = pDC->SelectObject(&oFont);	
	pDC->FillRect(&oInfoRect, &oBrush);
	pDC->SelectObject(pOldBrush);
	oBrush.DeleteObject();

	oBorderBrush.CreateSolidBrush( pToolTip->nTextColor );
	pOldBrush = pDC->SelectObject(&oBorderBrush);

  pDC->DrawEdge(&oInfoRect, BDR_RAISEDINNER  , BF_RECT);

	pDC->SetTextAlign(TA_LEFT);
	pDC->GetTextMetrics(&TM);
	nTextHigh = TM.tmHeight + TM.tmExternalLeading - 2;
	nX = oInfoRect.left + 2;
	nY = oInfoRect.top + 3; 

	for( register UINT i = 0; i < pToolTip->nInfoSize; i++)
	{
		pDC->TextOut(nX, nY, pToolTip->nControlInfo[i]);
		nY += m_nFontSize - 1;
	}

	pDC->SelectObject(pOldBrush);
	oBorderBrush.DeleteObject();	
	m_pParentWnd->ReleaseDC(pDC);
}	
Exemplo n.º 30
0
LRESULT CTDCTaskListCtrl::OnListCustomDraw(NMLVCUSTOMDRAW* pLVCD)
{
	HWND hwndList = pLVCD->nmcd.hdr.hwndFrom;
	int nItem = (int)pLVCD->nmcd.dwItemSpec;
	DWORD dwTaskID = pLVCD->nmcd.lItemlParam;

	if (hwndList == m_lcColumns)
	{
		// columns handled by base class
		return CTDCTaskCtrlBase::OnListCustomDraw(pLVCD);
	}

	switch (pLVCD->nmcd.dwDrawStage)
	{
	case CDDS_PREPAINT:
		return CDRF_NOTIFYITEMDRAW;
								
	case CDDS_ITEMPREPAINT:
		{
			CDC* pDC = CDC::FromHandle(pLVCD->nmcd.hdc);
			BOOL bAlternate = (IsColumnLineOdd(nItem) && HasColor(m_crAltLine));

			COLORREF crBack = (bAlternate ? m_crAltLine : GetSysColor(COLOR_WINDOW));

			if (HasStyle(TDCS_TASKCOLORISBACKGROUND))
			{
				GetTaskTextColors(dwTaskID, pLVCD->clrText, pLVCD->clrTextBk);

				if (pLVCD->clrTextBk != CLR_NONE)
					crBack = pLVCD->clrTextBk;
			}
			pLVCD->clrTextBk = pLVCD->clrText = crBack;

 			if (!OsIsXP())
			{
				GraphicsMisc::FillItemRect(pDC, &pLVCD->nmcd.rc, crBack, m_lcTasks);
				ListView_SetBkColor(m_lcTasks, crBack);
			}
		
			return (CDRF_NOTIFYPOSTPAINT | CDRF_NEWFONT); // always
		}
		break;

	case CDDS_ITEMPOSTPAINT:
		{
			const TODOITEM* pTDI = NULL;
			const TODOSTRUCTURE* pTDS = NULL;
			
			DWORD dwTaskID = GetTaskID(nItem), dwTrueID(dwTaskID);
			
			if (m_data.GetTask(dwTrueID, pTDI, pTDS))
			{
				CDC* pDC = CDC::FromHandle(pLVCD->nmcd.hdc);
				CFont* pOldFont = pDC->SelectObject(GetTaskFont(pTDI, pTDS, FALSE));

				GM_ITEMSTATE nState = GetListItemState(nItem);

				BOOL bSelected = (nState != GMIS_NONE);
				BOOL bAlternate = (IsColumnLineOdd(nItem) && HasColor(m_crAltLine));
				
				COLORREF crBack, crText;
				VERIFY(GetTaskTextColors(pTDI, pTDS, crText, crBack, (dwTaskID != dwTrueID), bSelected));

				// draw background
				CRect rRow(pLVCD->nmcd.rc);

				// extra for XP
				if (OsIsXP())
					m_lcTasks.GetItemRect(nItem, rRow, LVIR_BOUNDS);
		
				CRect rItem;
				GetItemTitleRect(nItem, TDCTR_LABEL, rItem, pDC, pTDI->sTitle);
				
				DrawTasksRowBackground(pDC, rRow, rItem, nState, bAlternate, crBack);
				
				// draw text
				DrawColumnText(pDC, pTDI->sTitle, rItem, DT_LEFT, crText, TRUE);
				rItem.right = (rItem.left + pDC->GetTextExtent(pTDI->sTitle).cx + LV_COLPADDING);
				
				// cleanup
				pDC->SelectObject(pOldFont);

				// render comment text
				DrawCommentsText(pDC, rRow, rItem, pTDI, pTDS);
			}

			// restore default back colour
			ListView_SetBkColor(m_lcTasks, GetSysColor(COLOR_WINDOW));

			return CDRF_SKIPDEFAULT; // always
		}
		break;
	}
	
	return CDRF_DODEFAULT;
}