C++ StringFormat::SetAlignment方法代码示例

void StringFormat::SetAlignment(StringAlignment sa) {
    Gdiplus::StringFormat* sf =  reinterpret_cast<Gdiplus::StringFormat*>(_private);
    switch(sa) {
    case StringAlignmentNear:
        sf->SetAlignment(Gdiplus::StringAlignmentNear);
        break;

    case StringAlignmentFar:
        sf->SetAlignment(Gdiplus::StringAlignmentFar);
        break;

    case StringAlignmentCenter:
        sf->SetAlignment(Gdiplus::StringAlignmentCenter);
        break;
    }
}

void winbox::draw_text_lines()
{
	if (m_lines.empty())
		return;

	Gdiplus::SolidBrush brush(m_log_back_color);
	m_graphics->FillRectangle(&brush, m_log_box);

	Gdiplus::Font font(L"宋体", 12);
	Gdiplus::StringFormat format;
	
	format.SetAlignment(Gdiplus::StringAlignment::StringAlignmentNear);
	format.SetLineAlignment(Gdiplus::StringAlignment::StringAlignmentCenter);

	float line_pos = m_log_box.GetBottom();
	float fontHeight = font.GetHeight(m_graphics) + 3;
	m_graphics->SetClip(m_log_box);
	for (auto it = m_lines.begin(); it != m_lines.end(); ++it)
	{
		if (line_pos < m_log_box.Y)
		{
			m_lines.erase(it, m_lines.end());
			break;
		}
		Gdiplus::RectF rect(m_log_box.X, line_pos - fontHeight, m_log_box.Width, fontHeight);
		brush.SetColor(it->tp == log_type::err ? m_log_err_color : m_log_txt_color);
		m_graphics->DrawString(it->ws.c_str(), (int)it->ws.size(), &font, rect, &format, &brush);
		line_pos -= fontHeight;
	}
	m_graphics->ResetClip();

	Gdiplus::Pen pen(m_log_edge_color);
	m_graphics->DrawRectangle(&pen, m_log_box);
}

bool CanvasGDIP::MeasureTextLinesW(const WCHAR* str, UINT strLen, const TextFormat& format, Gdiplus::RectF& rect, UINT& lines)
{
	Gdiplus::StringFormat& stringFormat = ((TextFormatGDIP&)format).m_StringFormat;
	Gdiplus::StringFormat tStringFormat = Gdiplus::StringFormat::GenericTypographic();

	// Set trimming and format temporarily.
	const Gdiplus::StringTrimming stringTrimming = stringFormat.GetTrimming();
	stringFormat.SetTrimming(Gdiplus::StringTrimmingNone);

	const INT stringFormatFlags = stringFormat.GetFormatFlags();
	stringFormat.SetFormatFlags(Gdiplus::StringFormatFlagsNoClip);

	if (m_AccurateText)
	{
		tStringFormat.SetTrimming(stringFormat.GetTrimming());
		tStringFormat.SetFormatFlags(stringFormat.GetFormatFlags());
		tStringFormat.SetAlignment(stringFormat.GetAlignment());
		tStringFormat.SetLineAlignment(stringFormat.GetLineAlignment());
	}

	INT linesFilled = 0;
	const Gdiplus::Status status = m_Graphics->MeasureString(
		str, (INT)strLen, ((TextFormatGDIP&)format).m_Font.get(), rect,
		m_AccurateText ? &tStringFormat : &stringFormat, &rect, nullptr, &linesFilled);
	lines = linesFilled;

	// Restore old options.
	stringFormat.SetTrimming(stringTrimming);
	stringFormat.SetFormatFlags(stringFormatFlags);

	return status == Gdiplus::Ok;
}

//
// draw_label
//
int Component_Decorator_Impl::draw_label (Gdiplus::Graphics * g)
{
  float height = (float)this->location_.height ();
  float px = static_cast <float> (this->location_.x_) + (this->location_.width () / 2.0f);
  float py = static_cast <float> (this->location_.y_) + (height + 15.0f);

  static const Gdiplus::Font font (L"Arial", 10);
  static const Gdiplus::SolidBrush brush (Gdiplus::Color (0, 0, 0));

  Gdiplus::StringFormat format;
  format.SetAlignment (Gdiplus::StringAlignmentCenter);
  format.SetLineAlignment (Gdiplus::StringAlignmentCenter);

  CComBSTR bstr (this->label_.length (), this->label_.c_str ());

  // Draw the label for the element.
  g->DrawString (bstr,
                 this->label_.length (),
                 &font,
                 Gdiplus::PointF (px, py),
                 &format,
                 &brush);

  return 0;
}

BOOL GdiplusUtilities::DrawTextOutline(Gdiplus::Graphics& graphics, 
									   LPCTSTR lpchText, int cchText, const RECT* lprc, UINT format, 
									   const LOGFONT& lf, COLORREF fill, COLORREF outline, INT outlineWidth,
									   BOOL bCalcOnly /*= FALSE*/, RECT* rcCalc/* = NULL*/)
{
	HDC hdc = graphics.GetHDC();
	Gdiplus::Font font(hdc, &lf);
	graphics.ReleaseHDC(hdc);
	Gdiplus::StringFormat sFormat;
	if (format & DT_VCENTER)
		sFormat.SetLineAlignment(Gdiplus::StringAlignmentCenter);
	else if (format & DT_BOTTOM)
		sFormat.SetLineAlignment(Gdiplus::StringAlignmentFar);
	else
		sFormat.SetLineAlignment(Gdiplus::StringAlignmentNear);

	if (format & DT_CENTER)
		sFormat.SetAlignment(Gdiplus::StringAlignmentCenter);
	else if (format & DT_RIGHT)
		sFormat.SetAlignment(Gdiplus::StringAlignmentFar);
	else
		sFormat.SetAlignment(Gdiplus::StringAlignmentNear);

	Gdiplus::Rect rcForCalc;
	Gdiplus::Rect* pRCForCalc = &rcForCalc;
	if (rcCalc == NULL)
		pRCForCalc = NULL;
	if (DrawTextOutline(graphics, lpchText, cchText, RECT2GdiplusRect(*lprc), sFormat, font, 
		COLORREF2Color(fill), COLORREF2Color(outline), outlineWidth, bCalcOnly, pRCForCalc))
	{
		if (pRCForCalc != NULL)
			*rcCalc = GdiplusRect2RECT(*pRCForCalc);
		return TRUE;
	}
	return FALSE;

}

 // sets the line's mWidth, mHeight, mAscent, mDescent, mLeading
void Line::calcExtents()
{
#if defined( CINDER_MAC )
	CFMutableAttributedStringRef attrStr = ::CFAttributedStringCreateMutable( kCFAllocatorDefault, 0 );

	// Defer internal consistency-checking and coalescing until we're done building this thing
	::CFAttributedStringBeginEditing( attrStr );
	for( vector<Run>::const_iterator runIt = mRuns.begin(); runIt != mRuns.end(); ++runIt ) {
		// create and append this run's CFAttributedString
		::CFAttributedStringRef runStr = cocoa::createCfAttributedString( runIt->mText, runIt->mFont, runIt->mColor );
		::CFAttributedStringReplaceAttributedString( attrStr, ::CFRangeMake( ::CFAttributedStringGetLength( attrStr ), 0 ), runStr );
		::CFRelease( runStr );
	}	
	// all done - coalesce
	::CFAttributedStringEndEditing( attrStr );			
	
	mCTLineRef = ::CTLineCreateWithAttributedString( attrStr );
	::CFRelease( attrStr );
	
	CGFloat ascentCG, descentCG, leadingCG;
	mWidth = ::CTLineGetTypographicBounds( mCTLineRef, &ascentCG, &descentCG, &leadingCG );
	mAscent = ascentCG;
	mDescent = descentCG;
	mLeading = leadingCG;
	mHeight = 0;
#elif defined( CINDER_MSW )
	mHeight = mWidth = mAscent = mDescent = mLeading = 0;
	for( vector<Run>::iterator runIt = mRuns.begin(); runIt != mRuns.end(); ++runIt ) {
		Gdiplus::StringFormat format;
		format.SetAlignment( Gdiplus::StringAlignmentNear ); format.SetLineAlignment( Gdiplus::StringAlignmentNear );
		Gdiplus::RectF sizeRect;
		const Gdiplus::Font *font = runIt->mFont.getGdiplusFont();;
		TextManager::instance()->getGraphics()->MeasureString( &runIt->mWideText[0], -1, font, Gdiplus::PointF( 0, 0 ), &format, &sizeRect );
		
		runIt->mWidth = sizeRect.Width;
		runIt->mAscent = runIt->mFont.getAscent();
		runIt->mDescent = runIt->mFont.getDescent();
		runIt->mLeading = runIt->mFont.getLeading();
		
		mWidth += sizeRect.Width;
		mAscent = std::max( runIt->mFont.getAscent(), mAscent );
		mDescent = std::max( runIt->mFont.getDescent(), mDescent );
		mLeading = std::max( runIt->mFont.getLeading(), mLeading );
		mHeight = std::max( mHeight, sizeRect.Height );
	}
#endif

	mHeight = std::max( mHeight, mAscent + mDescent + mLeading );
}

void cgGdiplusRender::DrawUIText( LPCTSTR lpctText, int nTextLen, 
	const cgRectF& rect, cgID font, int space , cgColor color, int style )
{
	Gdiplus::RectF kDrawRect (rect.x, rect.y, rect.w, rect.h);
	Gdiplus::StringFormat kFormat;

	if (style&DT_CENTER)
		kFormat.SetAlignment(Gdiplus::StringAlignmentCenter);
	if (style&DT_VCENTER)
		kFormat.SetLineAlignment(Gdiplus::StringAlignmentCenter);

	Gdiplus::Font * pkFont = FindFont(font);
	Gdiplus::SolidBrush brush(Gdiplus::Color((Gdiplus::ARGB)color));

	m_pkGraphics->DrawString(lpctText, nTextLen, pkFont,  kDrawRect, 
		&kFormat, &brush);
}

void CanvasGDIP::DrawTextW(const WCHAR* str, UINT strLen, const TextFormat& format, Gdiplus::RectF& rect, const Gdiplus::SolidBrush& brush)
{
	Gdiplus::StringFormat& stringFormat = ((TextFormatGDIP&)format).m_StringFormat;
	Gdiplus::StringFormat tStringFormat = Gdiplus::StringFormat::GenericTypographic();

	if (m_AccurateText)
	{
		tStringFormat.SetTrimming(stringFormat.GetTrimming());
		tStringFormat.SetFormatFlags(stringFormat.GetFormatFlags());
		tStringFormat.SetAlignment(stringFormat.GetAlignment());
		tStringFormat.SetLineAlignment(stringFormat.GetLineAlignment());
	}

	m_Graphics->DrawString(
		str, (INT)strLen, ((TextFormatGDIP&)format).m_Font.get(), rect,
		m_AccurateText ? &tStringFormat : &stringFormat, &brush);
}

bool CanvasGDIP::MeasureTextW(const WCHAR* str, UINT strLen, const TextFormat& format, Gdiplus::RectF& rect)
{
	Gdiplus::StringFormat& stringFormat = ((TextFormatGDIP&)format).m_StringFormat;
	Gdiplus::StringFormat tStringFormat = Gdiplus::StringFormat::GenericTypographic();

	if (m_AccurateText)
	{
		tStringFormat.SetTrimming(stringFormat.GetTrimming());
		tStringFormat.SetFormatFlags(stringFormat.GetFormatFlags());
		tStringFormat.SetAlignment(stringFormat.GetAlignment());
		tStringFormat.SetLineAlignment(stringFormat.GetLineAlignment());
	}

	const Gdiplus::Status status = m_Graphics->MeasureString(
		str, (INT)strLen, ((TextFormatGDIP&)format).m_Font.get(), rect,
		m_AccurateText ? &tStringFormat : &stringFormat, &rect);

	return status == Gdiplus::Ok;
}

/*!
 @brief イメージの取得

 @param [in]    pSelectItem     選択データ
 @param [out]   bitmap          イメージ
 */
BOOL CImageFontDlg::GetBitmapImage(LPVOID pSelectItem, CImage &bitmap)
{
	CRect rect;
	GetClientRect(&rect);

	bitmap.Create(rect.Width(), rect.Height(), 32);

	HDC hDC = bitmap.GetDC();
	Gdiplus::Graphics graphics(hDC);
	graphics.Clear((Gdiplus::ARGB)Gdiplus::Color::White);

	CString strMessage;
	strMessage = _T("1234567890\n");
	strMessage += _T("abcdefghijklmnopqrstuvwxyz\n");
	strMessage += _T("ABCDEFGHIJKLMNOPQRSTUVWXYZ\n");
	strMessage += _T("あいおえおかきくけこさしすせそたちつてとなにぬねの\n");
	strMessage += _T("はひふへほまみむめもやゆよらりるれろわをん\n");

	LOGFONT *pLogfont = (LOGFONT *) pSelectItem;
	Gdiplus::Font font(hDC, pLogfont);

	Gdiplus::RectF drawLayout(0, 0, (Gdiplus::REAL)rect.Width(), (Gdiplus::REAL)rect.Height());

	Gdiplus::StringFormat stringFormat;
	stringFormat.SetAlignment(Gdiplus::StringAlignmentCenter);
	stringFormat.SetLineAlignment(Gdiplus::StringAlignmentCenter);
	stringFormat.SetTrimming(Gdiplus::StringTrimmingNone);

	Gdiplus::SolidBrush brush((Gdiplus::ARGB)Gdiplus::Color::Black);

	graphics.SetTextRenderingHint((Gdiplus::TextRenderingHint) (GetSpaceKeyDownCount() % (int)Gdiplus::TextRenderingHintClearTypeGridFit));
	graphics.DrawString(strMessage, -1, &font, drawLayout, &stringFormat,&brush);


	bitmap.ReleaseDC();

	return TRUE;
}

CSize CXTextGdiPlus::Measure( HDC dc, INT nWidthLimit )
{
	Gdiplus::Graphics graph(dc);

	graph.SetTextRenderingHint(m_Rendering);

	Gdiplus::FontFamily fontFamily(XLibST2W(m_strFontName));  
	Gdiplus::Font font(&fontFamily, m_nSize, m_FontStyle, Gdiplus::UnitPixel);  
	Gdiplus::StringFormat stringformat;
	stringformat.SetAlignment(m_AlignmentH);
	stringformat.SetLineAlignment(m_AlignmentV == Gdiplus::StringAlignmentCenter ?
		Gdiplus::StringAlignmentNear : m_AlignmentV);
	stringformat.SetFormatFlags(m_FormatFlags);
	stringformat.SetTrimming(Gdiplus::StringTrimmingEllipsisWord);
	Gdiplus::SolidBrush brush(Gdiplus::Color(m_cAlpha, m_ColorR, m_ColorG, m_ColorB));

	Gdiplus::RectF rfTargetRect(0, 0, nWidthLimit > 0 ? nWidthLimit : INFINITY, INFINITY);
	CStringW strTextToDraw(XLibST2W(m_strText));

	Gdiplus::RectF rfBoundRect(0, 0, 0, 0);
	graph.MeasureString(strTextToDraw, -1, &font, rfTargetRect, &stringformat, &rfBoundRect);

	return CSize(ceil(rfBoundRect.Width), ceil(rfBoundRect.Height));
}

void OnPaint(HDC hdc)
{
	Graphics g(hdc);
	
	gOffScreenGraphics->Clear(Color::White);

	Gdiplus::SolidBrush* redBrush = new Gdiplus::SolidBrush(Gdiplus::Color::Red);
	gOffScreenGraphics->FillRectangle(redBrush, (150 + (20 * showJoystickId)), 40, 20, 12);
	delete redBrush;

	Gdiplus::Font fontJoyState(L"ＭＳ ゴシック", 9);
	Gdiplus::Font fontJoyCaps(L"ＭＳ ゴシック", 12);
	Gdiplus::Font fontJoyInfoEx(L"ＭＳ ゴシック", 30);
	Gdiplus::SolidBrush blackBrush(Color(255, 0, 0, 0));
	Gdiplus::StringFormat format;
	format.SetAlignment(StringAlignmentNear);
	
	Gdiplus::StringFormat formatState;
	formatState.SetAlignment(StringAlignmentNear);

	REAL* tabMargins = (REAL*) malloc(sizeof(REAL) * (joyGetNumDevs() + 1));
	tabMargins[0] = 150;
	for (unsigned int i = 1; i < joyGetNumDevs() + 1; i++) { tabMargins[i] = 20; }
	formatState.SetTabStops(0, (joyGetNumDevs() + 1), tabMargins);
	free(tabMargins);
	
	gOffScreenGraphics->DrawString(
		joyStateString.ToString().c_str(),
		-1, 
		&fontJoyState, 
		RectF(0.0f, 0.0f, (float)GetSystemMetrics(SM_CXSCREEN) / 2, (float)GetSystemMetrics(SM_CYSCREEN)), 
		&format, 
		&blackBrush);

	basic_stringstream<TCHAR> stream;
	stream << _T("表示JoystickID:") << showJoystickId;
	gOffScreenGraphics->DrawString(
		stream.str().c_str(),
		-1, 
		&fontJoyState, 
		RectF(0.0f, 24.0f, (float)GetSystemMetrics(SM_CXSCREEN) / 2, (float)GetSystemMetrics(SM_CYSCREEN)), 
		&format, 
		&blackBrush);

	gOffScreenGraphics->DrawString(
		joyStateString.ToStateTabSplitString().c_str(),
		-1, 
		&fontJoyState, 
		RectF(0.0f, 40.0f, (float)GetSystemMetrics(SM_CXSCREEN) / 2, (float)GetSystemMetrics(SM_CYSCREEN)), 
		&formatState, 
		&blackBrush);

	gOffScreenGraphics->DrawString(
		joyCapsString.ToString(&joyCaps).c_str(),
		-1, 
		&fontJoyCaps, 
		RectF(0.0f, 100.0f, (float)GetSystemMetrics(SM_CXSCREEN) / 2, (float)GetSystemMetrics(SM_CYSCREEN)), 
		&format, 
		&blackBrush);
	
	gOffScreenGraphics->DrawString(
		joyInfoExString.ToString(&joyInfoEx).c_str(),
		-1, 
		&fontJoyInfoEx, 
		RectF((float)GetSystemMetrics(SM_CXSCREEN) / 2, 100.0f, (float)GetSystemMetrics(SM_CXSCREEN) / 2, (float)GetSystemMetrics(SM_CYSCREEN)), 
		&format, 
		&blackBrush);

	g.DrawImage(gOffScreenBitmap, 0, 0);
	
	return;
}

void CClipMonView::ReDrawBkBuffer()
{
	if (!m_bUseBkBuffer)
	{
		return;
	}
	CSize szView = GetScrollViewSize();
	if (szView.cx == 0 || szView.cy == 0)
	{
		return;
	}
	
	CRect rcClient;
	TxGetClientRect(rcClient);
	CRect rcViewShowBuffer(rcClient);
	rcViewShowBuffer.MoveToXY(0,0);

	rcViewShowBuffer.OffsetRect(GetScrollPos(SB_HORZ), GetScrollPos(SB_VERT));
	
	CRect rcBk(0,0, m_szbmpBackBuffer.cx, m_szbmpBackBuffer.cy);
	rcBk = GetCenterRect(rcViewShowBuffer, rcBk);
	
	if (rcBk.left < 0)
	{
		rcBk.MoveToX(0);
	}
	if (rcBk.top < 0)
	{
		rcBk.MoveToY(0);
	}
	m_rcViewBkBuffer = rcBk;
	m_BkBufferlock.Lock();
	ASSERT(m_pBmpBackBuffer != NULL);
	Graphics gc(m_pBmpBackBuffer);
	SolidBrush bkBrush(m_drawParam.bkColor);
	Rect rCet = CRect2Rect(CRect(0,0, rcBk.Width(),  rcBk.Height()));
	gc.FillRectangle(&bkBrush, rCet);
	CRect rcView(0, 0, szView.cx, szView.cy);
	//calc In Bound Item
	int nBegin = (rcBk.top - rcView.top) / m_drawParam.nItemHeight;
	int nCount = rcBk.Height() /m_drawParam.nItemHeight +1;
	VECTMPITEM vData;
	g_monDataMgr.GetRangeData(nBegin, nCount, vData);
	nCount = vData.size();
	if (nCount == 0)
	{
		return;
	}
	CTxListHeader& headerCtrl = GetListHeader();
	int nTopPos = rcView.top + (nBegin * m_drawParam.nItemHeight)- rcBk.top;
	Gdiplus::StringFormat fmt;
	fmt.SetAlignment(StringAlignmentCenter);
	fmt.SetLineAlignment(StringAlignmentCenter);
	fmt.SetTrimming(StringTrimmingEllipsisCharacter);
	fmt.SetFormatFlags(StringFormatFlagsLineLimit|StringFormatFlagsNoWrap);
	Pen pen(g_globalInfo.viewSetting.clrSeparateLine, 1.0);
	Rect rRowBk(0, nTopPos, rcBk.Width(), m_drawParam.nItemHeight);

	for (int i = 0; i < nCount; i++)
	{
		ARGB clr = 0xff000000;
		ARGB clrBk = 0xffffffff;
		vData[i].GetMonColor(clr, clrBk);
		bkBrush.SetColor(clrBk);
		gc.FillRectangle(&bkBrush, rRowBk);
		int nLeftPos = 0-rcBk.left;
		CRect rcItem(nLeftPos,nTopPos, 0, nTopPos + m_drawParam.nItemHeight);
		for (int cIdx = 0;  cIdx < m_ColSetting.m_vTmpCols.size(); cIdx++)
		{
			if (rcItem.left > rcBk.right)
			{
				break;
			}
			rcItem.right = rcItem.left + headerCtrl.GetHeaderWidth(cIdx);
			if (rcItem.right >= rcBk.left)
			{
				ENUM_MONTYPE nMonType = (ENUM_MONTYPE)(m_ColSetting.m_vTmpCols[cIdx].nPosInType);
				if (nMonType != MONTYPE_TIMEREMAIN)
				{
					CString strText = vData[i].GetValue(nMonType);
					GPDrawShadowTextSimple(gc, strText, rcItem, *m_drawParam.pFont, clr, 0, 2,2, &fmt);
					//GPDrawShadowText(gc, strText, rcItem, *m_drawParam.pFont, clr, 0x22000000,0,0,0,0,&fmt);
				}
				//draw separate line
				gc.DrawLine(&pen, rcItem.right-1, rcItem.top, rcItem.right-1, rcItem.bottom);

			}
			rcItem.OffsetRect(rcItem.Width(), 0);

		}
		gc.DrawLine(&pen, rcBk.left, rcItem.bottom-1, rcBk.right, rcItem.bottom-1);
		nTopPos += m_drawParam.nItemHeight;

		rRowBk.Offset(0, m_drawParam.nItemHeight);
	}

	m_BkBufferlock.Unlock();
}

BOOL CXTextGdiPlus::RefreashBufferDC(HDC hDCSrc)
{	
	ReleaseBufferDC();

	m_dcBuffer = ::CreateCompatibleDC(hDCSrc);
	m_hBufferOldBmp = ::SelectObject(m_dcBuffer, (HGDIOBJ)Util::CreateDIBSection32(m_rcDst.Width(), m_rcDst.Height()));

	Gdiplus::Graphics graph(m_dcBuffer);
	graph.SetTextRenderingHint(m_Rendering);

	Gdiplus::FontFamily fontFamily(XLibST2W(m_strFontName));  
	Gdiplus::Font font(&fontFamily, m_nSize, m_FontStyle, Gdiplus::UnitPixel);  
	Gdiplus::StringFormat stringformat;
	stringformat.SetAlignment(m_AlignmentH);
	stringformat.SetLineAlignment(m_AlignmentV == Gdiplus::StringAlignmentCenter ?
		Gdiplus::StringAlignmentNear : m_AlignmentV);
	stringformat.SetFormatFlags(m_FormatFlags);
	stringformat.SetTrimming(Gdiplus::StringTrimmingEllipsisWord);
	Gdiplus::SolidBrush brush(Gdiplus::Color(m_cAlpha, m_ColorR, m_ColorG, m_ColorB));

	Gdiplus::RectF rfTargetRect(0, 0, m_rcDst.Width(), m_rcDst.Height());
	CStringW strTextToDraw(XLibST2W(m_strText));

	// When centering texts vertically, gdi+ will put the texts a litter higher, 
	// so we'll handle vertically centering ourselves. 
	if (m_AlignmentV == Gdiplus::StringAlignmentCenter)
	{
		Gdiplus::RectF rfBoundRect(0, 0, 0, 0);
		graph.MeasureString(strTextToDraw, -1, &font, rfTargetRect, &stringformat, &rfBoundRect);
		UINT nBufferWidth = rfTargetRect.Width, nBufferHeight = ceil(rfBoundRect.Height);

		UINT32 *pBufferBmp = NULL;
		HDC dcBuffer = ::CreateCompatibleDC(m_dcBuffer);
		HGDIOBJ hOldBmp = ::SelectObject(dcBuffer, (HGDIOBJ)Util::CreateDIBSection32(nBufferWidth, nBufferHeight, (BYTE **)&pBufferBmp));

		Gdiplus::Graphics graBuffer(dcBuffer);
		graBuffer.SetTextRenderingHint(m_Rendering);

		graBuffer.DrawString(strTextToDraw, -1, &font, rfTargetRect, &stringformat, &brush);

		CRect rcStrictBound(0, 0, nBufferWidth, nBufferHeight);
		BOOL bTopFound = FALSE, bBottomFound = FALSE;
		for (UINT line = 0; line < nBufferHeight; line++)
		{
			for (UINT col = 0; col < nBufferWidth; col++)
			{
				// bottom bits. 
				if (!bBottomFound && *(pBufferBmp + line * nBufferWidth + col) != 0)
				{
					bBottomFound = TRUE;
					rcStrictBound.bottom -= line;
				}

				// top bits. 
				if (!bTopFound && *(pBufferBmp + (nBufferHeight - line - 1) * nBufferWidth + col) != 0)
				{
					bTopFound = TRUE;
					rcStrictBound.top += line;
				}

				if (bBottomFound && bTopFound) break;
			}

			if (bBottomFound && bTopFound) break;
		}

		CRect rcTarget(0, (m_rcDst.Height() - rcStrictBound.Height()) / 2, 0, 0);
		rcTarget.right = rcTarget.left + rcStrictBound.Width();
		rcTarget.bottom = rcTarget.top + rcStrictBound.Height();

		Util::BitBlt(dcBuffer, rcStrictBound, m_dcBuffer, rcTarget);

		::DeleteObject(::SelectObject(dcBuffer, hOldBmp));
		::DeleteDC(dcBuffer);
	}
	else
		graph.DrawString(strTextToDraw, -1, &font, rfTargetRect, &stringformat, &brush);
	
	return TRUE;
}

BOOL CBSObject::DrawText(HDC hDC, const LPRECT lpRect, const CString& strText, 
							  HFONT hFont, COLORREF clrText, UINT uiFormat)
{
	BOOL bResult = FALSE;

#ifdef OSK 
	HFONT hFontOld = (HFONT)::SelectObject(hDC, hFont);
	COLORREF clrTextOld = ::SetTextColor(hDC, clrText);
	int nBkModeOld = ::SetBkMode(hDC, TRANSPARENT);

    if (::DrawText(hDC, strText, strText.GetLength(), lpRect, uiFormat))
	{
		bResult = TRUE;
	}

	if (hFontOld)
	{
		::SelectObject(hDC, hFontOld);
	}
	::SetTextColor(hDC, clrTextOld);
	::SetBkMode(hDC, nBkModeOld);
#else   
    Gdiplus::Graphics graphics(hDC);
    
    Gdiplus::SolidBrush brush(Gdiplus::Color(255, GetRValue(clrText), GetGValue(clrText), GetBValue(clrText)));
    Gdiplus::Font font(hDC, hFont);
    Gdiplus::RectF  rect(lpRect->left, lpRect->top, lpRect->right - lpRect->left, lpRect->bottom - lpRect->top);

	graphics.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
	graphics.SetTextRenderingHint(Gdiplus::TextRenderingHintClearTypeGridFit);
         
    Gdiplus::StringFormat strformat;
    if (uiFormat & DT_TOP)
    {
        strformat.SetLineAlignment(Gdiplus::StringAlignmentNear);
    }

    if (uiFormat & DT_VCENTER)
    {
        strformat.SetLineAlignment(Gdiplus::StringAlignmentCenter);
    }

    if (uiFormat & DT_BOTTOM)
    {
        strformat.SetLineAlignment(Gdiplus::StringAlignmentFar);
    }

    if (uiFormat & DT_LEFT)
    {
        strformat.SetAlignment(Gdiplus::StringAlignmentNear);
    }

    if (uiFormat & DT_CENTER)
    {
        strformat.SetAlignment(Gdiplus::StringAlignmentCenter);
    }

    if (uiFormat & DT_RIGHT)
    {
        strformat.SetAlignment(Gdiplus::StringAlignmentFar);
    }

    if ((uiFormat & DT_WORDBREAK) == 0)
    {
        strformat.SetFormatFlags(Gdiplus::StringFormatFlagsNoWrap);
    }

    if (uiFormat & DT_SINGLELINE)
    {

    }

    if (uiFormat & DT_WORD_ELLIPSIS)
    {
        strformat.SetTrimming(Gdiplus::StringTrimmingEllipsisCharacter);
    }

    if (uiFormat & DT_NOCLIP)
    {
        strformat.SetFormatFlags(Gdiplus::StringFormatFlagsNoClip);
    }

    graphics.DrawString(strText, -1, &font, rect, &strformat, &brush);


#endif
	return bResult;
}