MFC小笔记之GDI

把Image对象保存为字节数组
BOOL ImageToByte(byte **bt, Image *pImage, UINT &imagelen)

{
if (pImage == NULL)
return FALSE;


HGLOBAL m_hMem = GlobalAlloc(GMEM_MOVEABLE, 0);
IStream *pstm = NULL;
CreateStreamOnHGlobal(m_hMem, TRUE, &pstm);
CLSID clsid;
GetEncoderClsid(L"image/png", &clsid);
pImage->Save(pstm, &clsid, NULL);


if (pstm == NULL)
return FALSE;


LARGE_INTEGER liBeggining = {0};
pstm->Seek(liBeggining, STREAM_SEEK_SET, NULL);
long wTemp = (long)GlobalSize(m_hMem);
imagelen = wTemp;
LPBYTE lpData = (LPBYTE)GlobalLock(m_hMem);
*bt = new byte[wTemp];
memcpy((void*)*bt, (void*)lpData, wTemp);
pstm->Release();
GlobalUnlock(m_hMem);

return TRUE;
}

把字节数组变为Image对象

Image* ByteToImage(byte *bt, long len)

{
if (bt == NULL)
return NULL;


HGLOBAL m_hMem = GlobalAlloc(GMEM_FIXED, len);
IStream *pstm = NULL;
CreateStreamOnHGlobal(m_hMem, FALSE, &pstm);
BYTE* pmem = (BYTE*)GlobalLock(m_hMem);
memcpy(pmem, bt, len);
Image *pImage = Image::FromStream(pstm, FALSE);
pstm->Release();
GlobalUnlock(m_hMem);
return pImage;
}

通过流获取图片对象，非独占
Image* GetImageFromStream(CString strFileName)

{
if (!IsValidPictureFile(strFileName))
{
// AfxMessageBox(_T("不是有效的图片"));
return NULL;
}


CFile imagefile(strFileName, CFile::modeRead);


if(imagefile.m_hFile == CFile::hFileNull)
{
AfxMessageBox(strFileName + _T("图片文件已关闭"));
return NULL;
}


SIZE_T nLen = (SIZE_T)imagefile.GetLength();
HGLOBAL hMem = GlobalAlloc(GMEM_FIXED, nLen);
BYTE* pmem = (BYTE*)GlobalLock(hMem);
imagefile.Read(pmem, (UINT)nLen);
GlobalUnlock(hMem); 
IStream* pstm; 
CreateStreamOnHGlobal(hMem, FALSE, &pstm);
Image *pImage = Image::FromStream(pstm);
pstm->Release();
DeleteObject(hMem);
imagefile.Close();

return pImage;
}

从dc获取Bitmap
Bitmap* BitmapFromDC(CDC* pDC, CSize size)

{
CDC MemDC;
CBitmap Bmp;
MemDC.CreateCompatibleDC(pDC);
Bmp.CreateCompatibleBitmap(pDC, size.cx, size.cy);
MemDC.SelectObject(&Bmp);
MemDC.BitBlt(0, 0, size.cx, size.cy, pDC, 0, 0, SRCCOPY);
  Bitmap *pNewBitmap = new Bitmap(HBITMAP(Bmp), HPALETTE(MemDC.GetCurrentPalette()));
Bitmap *pBmp = new Bitmap(size.cx, size.cy, PixelFormat32bppARGB);
Graphics *grap = Graphics::FromImage(pBmp);
grap->DrawImage(pNewBitmap, 0, 0, size.cx, size.cy);
delete grap;
delete pNewBitmap;
return pBmp;
}

Bitmap透明度设置
void BitmapTranslucent(Bitmap* pBmp, BYTE bAlpha)

{
ASSERT(pBmp != NULL);


//为了不改变png图片
if (bAlpha < 1)
bAlpha = 1;


int width = pBmp->GetWidth();
int height = pBmp->GetHeight();


BitmapData bmpData;
pBmp->LockBits(&Rect(0, 0, width, height), ImageLockModeRead | ImageLockModeWrite, 
PixelFormat32bppARGB, &bmpData);


byte *p = (byte*)bmpData.Scan0;
int offset = bmpData.Stride - width * 4;


for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
if (p[3] != 0)
p[3] = bAlpha;
p += 4;
}
p += offset;
}


pBmp->UnlockBits(&bmpData);
}

快速创建位图
Bitmap* Bitmap32(int width, int height)

{
Bitmap *pBmp = new Bitmap(width, height, PixelFormat32bppARGB);
return pBmp;
}

获取图像编码

int GetEncoderClsid(const WCHAR* format, CLSID* pClsid)

{

UINT  num = 0, size = 0;       
ImageCodecInfo* pImageCodecInfo = NULL;
GetImageEncodersSize(&num, &size);

if(size == 0)
return -1;  


pImageCodecInfo = (ImageCodecInfo*)(malloc(size));

if(pImageCodecInfo == NULL)
return -1;  


GetImageEncoders(num, size, pImageCodecInfo);


for(UINT j = 0; j < num; ++j)
{
if( wcscmp(pImageCodecInfo[j].MimeType, format ) == 0 )
{
*pClsid = pImageCodecInfo[j].Clsid;
free(pImageCodecInfo);
return j;
}    
}
free(pImageCodecInfo);
return -1;

}

把Image对象保存为png图片

void PublicFunctions::SaveImageToPng(Image *pImage, WCHAR *filename)
{
if (pImage == NULL)
return;

CLSID clsid;
GetEncoderClsid(L"image/png", &clsid);
pImage->Save(filename, &clsid, NULL);
}

拷贝屏幕

 Image*  GetScreenImage(POINT pt1, POINT pt2)

{
int left = pt1.x;
int top = pt1.y;
int width = pt2.x - pt1.x;
int height = pt2.y - pt1.y;


if (left > pt2.x)
{
left = pt2.x;
width = pt1.x - pt2.x;
}
if (top > pt2.y)
{
top = pt2.y; 
height = pt1.y - pt2.y;
}


CDC ScreenDC;
ScreenDC.CreateDC(_T("DISPLAY"), NULL, NULL, NULL);
CDC MemoryDC;
CBitmap bitmap;
MemoryDC.CreateCompatibleDC(&ScreenDC);
bitmap.CreateCompatibleBitmap(&ScreenDC, width, height);
MemoryDC.SelectObject(&bitmap);
MemoryDC.BitBlt(0, 0, width, height, &ScreenDC, left, top, SRCCOPY);
Bitmap *pNewBitmap = new Bitmap(HBITMAP(bitmap), HPALETTE(MemoryDC.GetCurrentPalette()));
Image *pScreenImage = pNewBitmap->Clone(Rect(0, 0, width, height), PixelFormatDontCare);
ASSERT(pScreenImage != NULL);
delete pNewBitmap;
return pScreenImage;
}

获取窗口内容的画布
CBitmap* BitmapFromWnd(CWnd *pWnd)

{
CRect rect;
pWnd->GetClientRect(&rect);
CDC *pDC = pWnd->GetDC();
CDC *pMemDC = new CDC;
pMemDC->CreateCompatibleDC(pDC);
CBitmap *pMemBmp = new CBitmap;
pMemBmp->CreateCompatibleBitmap(pDC, rect.Width(), rect.Height());
pMemDC->SelectObject(pMemBmp);
pMemDC->BitBlt(rect.left, rect.top, rect.Width(), rect.Height(),
pDC, rect.left, rect.top, SRCCOPY);
delete pMemDC;
pWnd->ReleaseDC(pDC);
return pMemBmp;
}

获取应用程序图标图片
Bitmap* BitmapFromAppIcon(CString strAppPath)

{
SHFILEINFO  shFileInfo;
if (::SHGetFileInfo(strAppPath, 0, &shFileInfo,sizeof(shFileInfo), SHGFI_ICON))
{
HICON  hIcon = shFileInfo.hIcon; 
Bitmap  *pBmp = Bitmap::FromHICON(hIcon);
return pBmp;
}
return NULL;
}

画线

GraphicsPath path;
PointF pPoints[30];

Matrix* m_pPenMatrix = new Matrix;    //对象矩阵

path.AddLines(pPoints, 30);
path.Transform(m_pPenMatrix);
Pen pen(m_Color, m_fLineWidth);

Graphics graphics(pDC->m_hDC);
graphics.SetSmoothingMode(SmoothingModeHighQuality);
graphics.DrawPath(&pen, &path);

画图

graphics.SetTransform(m_pPenMatrix);

graphics.DrawImage(Image*);

水平垂直镜像

GraphicsPath outsidepath;

Rect  m_rcOutside；
outsidepath.AddRectangle(m_rcOutside);
outsidepath.Transform(m_pPenMatrix);

Rect rect;
outsidepath.GetBounds(&rect);

Point pts[3];

pts[0] = Point(rect.GetRight(), rect.GetTop());
pts[1] = Point(rect.GetLeft(), rect.GetTop());
pts[2] = Point(rect.GetRight(), rect.GetBottom());


m_pPenMatrix->Multiply(&Matrix(rect, pts));

pts[0] = Point(rect.GetLeft(), rect.GetBottom());
pts[1] = Point(rect.GetRight(), rect.GetBottom());
pts[2] = Point(rect.GetLeft(), rect.GetTop());


m_pPenMatrix->Multiply(&Matrix(rect, pts));

旋转

m_pPenMatrix->RotateAt(IN REAL angle, IN const PointF& center, IN MatrixOrder order = MatrixOrderPrepend)；

移动

m_pPenMatrix->Translate(IN REAL offsetX,  IN REAL offsetY,  IN MatrixOrder order = MatrixOrderPrepend)；

放大缩小

void PenNode::Scale(float scalex, float scaley)
{
PointF ptCenter;    //中心点
m_pPenMatrix->Translate(-ptCenter.X, -ptCenter.Y, MatrixOrderAppend);
m_pPenMatrix->Scale(scalex, scaley, MatrixOrderAppend);
m_pPenMatrix->Translate(ptCenter.X, ptCenter.Y, MatrixOrderAppend);
}

获取字符串绘画大小

HDC hdc = GetDC(NULL);
RectF layoutRect(0, 0, float(20), float(12)）;
RectF boundRect;
Graphics g(hdc);
g.MeasureString(strText, len, pFont, layoutRect, &boundRect);
ReleaseDC(NULL, hdc);

在矩形中居中添加文字
void AddStringToPath(GraphicsPath &path, CString str, float fontsize, CRect rect, BOOL bCenter = TRUE)

{
Gdiplus::Font font(_T("Times New Roman"), fontsize);
Size size = MeasureStringSize(str, &font);


float top = float(rect.top + 2);


if (size.Height < rect.Height())
top = float(rect.top + 2) + float(rect.Height() - size.Height) / 2.0f;


RectF layoutRect((float)rect.left, top, (float)rect.Width(), (float)size.Height);
StringFormat format;


if (bCenter)
format.SetAlignment(StringAlignmentCenter);
else
format.SetAlignment(StringAlignmentNear);


FontFamily  fontfamily(L"Times New Roman");
path.AddString(str, str.GetLength(), &fontfamily, 
FontStyleRegular, fontsize, layoutRect, &format);
}

在矩形框中添加竖直文字
void AddVerticalStringToRect(GraphicsPath &path, CString str,float fontsize, CRect rect, BOOL bCenter = TRUE)

{
Gdiplus::Font font(L"Times New Roman", fontsize);
Size size = MeasureStringSize(str, &font);
 
  float left = float(rect.left + 3);
if (size.Width < rect.Width())
left = float(rect.left + 3) + (rect.Width() - size.Width) / 2.0f;
 
  RectF bound(left, (float)rect.top, (float)size.Width, (float)rect.Height());
  StringFormat format;
format.SetFormatFlags(StringFormatFlagsDirectionVertical);
 
  if (bCenter)
  format.SetAlignment(StringAlignmentCenter);
  else
  format.SetAlignment(StringAlignmentNear);
 
FontFamily  fontfamily(L"Times New Roman");
  path.AddString(str, str.GetLength(), &fontfamily, 
  FontStyleRegular, fontsize, bound, &format);
}

画字符串

void DrawString(Graphics* g, Color color, CString str, float fontsize,
 CRect rect, BOOL bCenter /* = TRUE */)
{
g->SetSmoothingMode(SmoothingModeHighQuality);
g->SetCompositingMode(CompositingModeSourceOver);


Gdiplus::Font font(_T("Times New Roman"), fontsize);
Size size = PublicFunctions::MeasureStringSize(str, &font, rect);
int top = rect.top + 2;


if (size.Height < rect.Height())
top = top + (rect.Height() - size.Height) / 2;


RectF layoutRect((float)rect.left, (float)top, (float)rect.Width(), (float)size.Height);
StringFormat format;


if (bCenter)
format.SetAlignment(StringAlignmentCenter);
else
format.SetAlignment(StringAlignmentNear);


g->DrawString(str, str.GetLength(), &font, layoutRect, &format, &SolidBrush(color));
}

透明窗口

SetWindowLong(hwnd, GWL_EXSTYLE, wndStyle ^ WS_EX_LAYERED);

Graphics graphics(pSrcDC->m_hDC);

Color bkColor = Color(1, 255, 255, 255);

graphics.FillRectangle(&SolidBrush(bkColor), 0, 0, width, height);

BLENDFUNCTION blend;
blend.BlendOp = 0;
blend.BlendFlags = 0;
blend.AlphaFormat = 1;
blend.SourceConstantAlpha = 255;


SIZE szWnd = {rect.Width(), rect.Height()};
POINT ptSrcPos = {0, 0};
POINT ptWndPos = {0, 0};


CWnd::UpdateLayeredWindow(pDesDC, &ptWndPos, &szWnd, 
pSrcDC, &ptSrcPos, 0, &blend, ULW_ALPHA);