771 lines
14 KiB
C++
771 lines
14 KiB
C++
//-------------------------------------------------------------------------------------------------------+
|
|
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
|
|
// = FileName : TImageDrawDC 类
|
|
// = Version : ver2.0
|
|
// = Author : wlw
|
|
// = CreateDate : 2002-09-09
|
|
// = Description: TImageDrawDC 定义
|
|
// = Maintainers:
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------+
|
|
|
|
#include "StdAfx.h"
|
|
#include "TImageDrawDC.h"
|
|
#include "TGGiJpegStorage.h"
|
|
#include "TGGiBitmapStorage.h"
|
|
#include "TSplitpathOperator.h"
|
|
#include "io.h"
|
|
#include "TPushMemVar.h"
|
|
|
|
//#ifdef _WIN64
|
|
#include "ximage.h"
|
|
//#else
|
|
//#include "planydec.h"
|
|
//#include "plwinbmp.h"
|
|
//#endif
|
|
|
|
#include "TAString.h"
|
|
#include "TchGlobalFunc.h"
|
|
|
|
//#ifndef _WIN64
|
|
//HDIB ReadJpeg(FILE *input_file);
|
|
//#endif
|
|
|
|
|
|
TImageDrawDC::TImageDrawDC()
|
|
: m_bAutoScale(TRUE), m_bUniformScale(TRUE), m_bHighlight(FALSE)
|
|
{
|
|
m_pDC = NULL;
|
|
m_palDIB = NULL;
|
|
m_hDIB = NULL;
|
|
m_nIT = IT_NONE;
|
|
m_bkColor = RGB(0,0,0);
|
|
m_nRotation = 0.0;
|
|
m_nMirror = 0;
|
|
}
|
|
|
|
TImageDrawDC::TImageDrawDC(CDC *pDC, const CRect &rect, COLORREF bkcolor)
|
|
: m_pDC(pDC), m_rectDC(rect), m_bAutoScale(TRUE), m_bUniformScale(TRUE), m_bHighlight(FALSE)
|
|
{
|
|
m_palDIB = NULL;
|
|
m_hDIB = NULL;
|
|
m_nIT = IT_NONE;
|
|
m_bkColor = bkcolor;
|
|
m_nRotation = 0.0;
|
|
m_nMirror = 0;
|
|
}
|
|
|
|
TImageDrawDC::~TImageDrawDC()
|
|
{
|
|
if(m_palDIB)
|
|
{
|
|
delete m_palDIB;
|
|
}
|
|
|
|
if(m_hDIB)
|
|
{
|
|
::GlobalUnlock((HGLOBAL) m_hDIB);
|
|
::GlobalFree((HGLOBAL)m_hDIB);
|
|
}
|
|
}
|
|
|
|
void TImageDrawDC::SetSlideMirror(int nXY)
|
|
{
|
|
m_nMirror = nXY;
|
|
}
|
|
|
|
void TImageDrawDC::SetAutoScale(BOOL bAuto)
|
|
{
|
|
m_bAutoScale = bAuto;
|
|
}
|
|
|
|
void TImageDrawDC::SetUniformScale(BOOL bTrue)
|
|
{
|
|
m_bUniformScale = bTrue;
|
|
}
|
|
|
|
void TImageDrawDC::GetRectDC(CRect &rectDC) const
|
|
{
|
|
rectDC = m_rectDC;
|
|
}
|
|
void TImageDrawDC::SetRectDC(const CRect &rect)
|
|
{
|
|
m_rectDC = rect;
|
|
}
|
|
void TImageDrawDC::SetDC(CDC *pDc)
|
|
{
|
|
m_pDC = pDc;
|
|
}
|
|
void TImageDrawDC::SetRotation(double nRot)
|
|
{
|
|
m_nRotation = nRot;
|
|
}
|
|
void TImageDrawDC::SetBackColor(COLORREF co)
|
|
{
|
|
m_bkColor = co;
|
|
}
|
|
|
|
BOOL TImageDrawDC::IsImageLoaded()
|
|
{
|
|
return (m_hDIB ? TRUE : FALSE);
|
|
}
|
|
|
|
BOOL TImageDrawDC::IsHighlight() const
|
|
{
|
|
return m_bHighlight;
|
|
}
|
|
|
|
void TImageDrawDC::SetHighlight(BOOL bTrue)
|
|
{
|
|
m_bHighlight = bTrue;
|
|
}
|
|
|
|
void TImageDrawDC::InitDC(CDC *pDC, const CRect &rect, COLORREF bkcolor/*=RGB(0,0,0)*/)
|
|
{
|
|
m_pDC = pDC;
|
|
m_rectDC = rect;
|
|
m_bkColor = bkcolor;
|
|
}
|
|
|
|
COLORREF TImageDrawDC::GetBkColor()
|
|
{
|
|
return m_bkColor;
|
|
}
|
|
|
|
BOOL TImageDrawDC::PaintJpeg(const TCHAR *pJpgFile)
|
|
{
|
|
m_nIT = IT_BITMAP;
|
|
|
|
if(m_palDIB)
|
|
{
|
|
delete m_palDIB;
|
|
}
|
|
|
|
if(m_hDIB)
|
|
{
|
|
::GlobalUnlock((HGLOBAL) m_hDIB);
|
|
::GlobalFree((HGLOBAL)m_hDIB);
|
|
}
|
|
m_palDIB = NULL;
|
|
m_hDIB = NULL;
|
|
|
|
if(!pJpgFile || !pJpgFile[0])
|
|
{
|
|
Fill(RGB(192,192,192));
|
|
return TRUE;
|
|
}
|
|
TCString sLib, sJpg;
|
|
if(!SplitLibraryPath(pJpgFile, sLib, sJpg))
|
|
{
|
|
return PaintImageOnly(pJpgFile);
|
|
}
|
|
|
|
TCString strFilePath(256);
|
|
strFilePath << sLib << _T(".JPB");
|
|
|
|
TGGiJpegStorage lib(strFilePath, _ios::in|_ios::binary);
|
|
TCString sTempPath(256);
|
|
GetTempPath(255, sTempPath);
|
|
|
|
int nStrLen=_tcslen(sTempPath);
|
|
if(nStrLen && sTempPath[nStrLen-1] != _T('\\'))
|
|
{
|
|
|
|
sTempPath << _T("\\");
|
|
}
|
|
|
|
sTempPath << sJpg;
|
|
int nRet = lib.QuickCopy(sTempPath);
|
|
|
|
if(nRet)
|
|
{
|
|
sTempPath << _T(".JPG");
|
|
}
|
|
else
|
|
{
|
|
Fill(m_bkColor);
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL bRet = PaintImageOnly(sTempPath);
|
|
_tremove(sTempPath);
|
|
return bRet;
|
|
}
|
|
|
|
// pszImageFile FullPath of Image file, like:
|
|
// <Path>A.BMP, A.JPG, A(a1)
|
|
// Support BMP, JPG format (both stand along or from LIB)
|
|
// if pszImageFile == NULL, then clear it
|
|
BOOL TImageDrawDC::PaintImage(const TCHAR *pszImageFile)
|
|
{
|
|
m_nIT = IT_BITMAP;
|
|
|
|
if(m_palDIB)
|
|
{
|
|
delete m_palDIB;
|
|
}
|
|
|
|
if(m_hDIB)
|
|
{
|
|
::GlobalUnlock((HGLOBAL) m_hDIB);
|
|
::GlobalFree((HGLOBAL)m_hDIB);
|
|
}
|
|
m_palDIB = NULL;
|
|
m_hDIB = NULL;
|
|
|
|
if(!pszImageFile || !pszImageFile[0])
|
|
{
|
|
Fill(RGB(192,192,192));
|
|
return TRUE;
|
|
}
|
|
|
|
TCString sLib, sJpg;
|
|
if(!SplitLibraryPath(pszImageFile, sLib, sJpg))
|
|
{
|
|
return PaintImageOnly(pszImageFile);
|
|
}
|
|
|
|
TCString strFilePath(256);
|
|
strFilePath << sLib << _T(".BMB");
|
|
|
|
TGGiBitmapStorage lib(strFilePath, _ios::in|_ios::binary);
|
|
TCString sTempPath(256);
|
|
GetTempPath(255, sTempPath);
|
|
|
|
int nStrLen = _tcslen(sTempPath);
|
|
if(nStrLen && sTempPath[nStrLen-1] != _T('\\'))
|
|
{
|
|
sTempPath << _T("\\");
|
|
}
|
|
sTempPath << sJpg;
|
|
int nRet = lib.QuickCopy(sTempPath);
|
|
|
|
|
|
if(nRet == 1)
|
|
{
|
|
sTempPath << _T(".BMP");
|
|
}
|
|
else if(nRet == 2)
|
|
{
|
|
sTempPath << _T(".JPG");
|
|
}
|
|
else
|
|
{
|
|
Fill(m_bkColor);
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL bRet = PaintImageOnly(sTempPath);
|
|
_tremove(sTempPath);
|
|
return bRet;
|
|
}
|
|
|
|
BOOL TImageDrawDC::PaintDIB(HDIB hDib) // DIB is keep here
|
|
{
|
|
if(m_palDIB)
|
|
{
|
|
delete m_palDIB;
|
|
}
|
|
if(m_hDIB)
|
|
{
|
|
::GlobalUnlock((HGLOBAL) m_hDIB);
|
|
::GlobalFree((HGLOBAL)m_hDIB);
|
|
}
|
|
m_hDIB=hDib;
|
|
m_palDIB = new CPalette;
|
|
::CreateDIBPalette(m_hDIB, m_palDIB);
|
|
|
|
m_nIT = IT_BITMAP;
|
|
return PaintImage();
|
|
}
|
|
|
|
// Paint Image, not include from LIB
|
|
BOOL TImageDrawDC::PaintImageOnly(const TCHAR *pszFile)
|
|
{
|
|
//#ifndef _WIN64
|
|
// extern int g_iSrcImgType;
|
|
// extern int WriteJpeg(FILE* input_file, FILE* output_file);
|
|
//#endif
|
|
m_nIT = IT_BITMAP;
|
|
|
|
if(m_palDIB)
|
|
{
|
|
delete m_palDIB;
|
|
}
|
|
|
|
if(m_hDIB)
|
|
{
|
|
::GlobalUnlock((HGLOBAL) m_hDIB);
|
|
::GlobalFree((HGLOBAL)m_hDIB);
|
|
}
|
|
m_palDIB = NULL;
|
|
m_hDIB = NULL;
|
|
|
|
|
|
TSplitpathOperator parser(pszFile);
|
|
const TCHAR *pszExt = parser.m_sExt;
|
|
if(!pszExt[0])
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if(_tcsicmp(pszExt, _T(".BMP")) == 0)
|
|
{
|
|
CFile file;
|
|
if (!file.Open(pszFile, CFile::modeRead | CFile::shareDenyWrite))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
m_hDIB = ::ReadDIBFile(file);
|
|
}
|
|
else if(_tcsicmp(pszExt, _T(".JPG")) == 0)
|
|
{
|
|
//#ifdef _WIN64
|
|
m_hDIB = (HDIB)CTangentImage::ReadJpeg(pszFile);
|
|
//#else
|
|
// FILE *fp = _tfopen(pszFile, _T("rb"));
|
|
// if(!fp)
|
|
// {
|
|
// return FALSE;
|
|
// }
|
|
//
|
|
// if(_filelength(_fileno(fp)) == 0)
|
|
// {
|
|
// fclose(fp);
|
|
// return FALSE;
|
|
// }
|
|
// m_hDIB = ReadJpeg(fp);
|
|
// fclose(fp);
|
|
//#endif
|
|
|
|
}
|
|
else
|
|
{
|
|
//#ifdef _WIN64
|
|
m_hDIB = (HDIB)CTangentImage::GetCopyToHandle(pszFile, CXIMAGE_FORMAT_BMP);
|
|
if (m_hDIB)
|
|
return FALSE;
|
|
//#else
|
|
// PLAnyPicDecoder Decoder;
|
|
// PLWinBmp NewBmp;
|
|
// BOOL bError = FALSE;
|
|
// try
|
|
// {
|
|
// Decoder.MakeBmpFromFile (_AS(pszFile), &NewBmp);
|
|
// m_hDIB = (HDIB)NewBmp.createCopyHandle();
|
|
// if(!m_hDIB)
|
|
// {
|
|
// return FALSE;
|
|
// }
|
|
// }
|
|
// catch (PLTextException e)
|
|
// {
|
|
// bError=TRUE;
|
|
// }
|
|
// catch (CMemoryException e)
|
|
// {
|
|
// bError = TRUE;
|
|
// }
|
|
//#endif
|
|
//
|
|
//#ifdef _WIN64
|
|
if(_tcsicmp(pszExt, _T(".gif")) == 0 || _tcsicmp(pszExt, _T(".tga")) == 0)
|
|
//#else
|
|
// if(bError && (_tcsicmp(pszExt, _T(".gif")) == 0 || _tcsicmp(pszExt, _T(".tga")) == 0))
|
|
//#endif
|
|
{
|
|
int nImgType=(_tcsicmp(pszExt, _T(".gif")) == 0 ? 1 : 2);
|
|
// TPushMemVar<int> vTemp(g_iSrcImgType, nImgType);
|
|
TCString sTempFile=GetTempFileName(_T(".jpg"));
|
|
//#ifdef _WIN64
|
|
int nType = (1 == nImgType) ? CXIMAGE_FORMAT_GIF : CXIMAGE_FORMAT_TGA;
|
|
BOOL bRet = CTangentImage::WriteJpeg(pszFile, sTempFile, nType);
|
|
//#else
|
|
// FILE *fp = _tfopen(pszFile, _T("rb"));
|
|
//
|
|
// if(!fp)
|
|
// {
|
|
// return FALSE;
|
|
// }
|
|
//
|
|
// if(_filelength(_fileno(fp)) == 0)
|
|
// {
|
|
// fclose(fp);
|
|
// return FALSE;
|
|
// }
|
|
// FILE *fpOut=_tfopen(sTempFile, _T("wb"));
|
|
// if(!fpOut)
|
|
// {
|
|
// fclose(fp);
|
|
// return FALSE;
|
|
// }
|
|
//
|
|
// BOOL bRet=WriteJpeg(fp, fpOut);
|
|
// fclose(fp);
|
|
// fclose(fpOut);
|
|
//#endif
|
|
if(bRet)
|
|
{
|
|
bRet=PaintImageOnly(sTempFile);
|
|
}
|
|
_tremove(sTempFile);
|
|
return bRet;
|
|
}
|
|
//#ifndef _WIN64
|
|
// else if(bError)
|
|
// {
|
|
// return FALSE;
|
|
// }
|
|
//#endif
|
|
}
|
|
|
|
m_palDIB = new CPalette;
|
|
::CreateDIBPalette(m_hDIB, m_palDIB);
|
|
|
|
return PaintImage();
|
|
}
|
|
|
|
BOOL TImageDrawDC::GetImageSize(CSize &sizeImage) const
|
|
{
|
|
if(!m_hDIB || !m_palDIB)
|
|
return FALSE;
|
|
|
|
LPSTR lpDIB = (LPSTR) ::GlobalLock((HGLOBAL) m_hDIB);
|
|
sizeImage.cx = (int) ::DIBWidth(lpDIB); // Size of DIB - x
|
|
sizeImage.cy = (int) ::DIBHeight(lpDIB); // Size of DIB - y
|
|
::GlobalUnlock((HGLOBAL) m_hDIB);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TImageDrawDC::PaintImage()
|
|
{
|
|
if(!m_pDC)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
m_nIT = IT_BITMAP;
|
|
|
|
if(!m_hDIB || !m_palDIB)
|
|
{
|
|
Fill(RGB(192,192,192));
|
|
return FALSE;
|
|
}
|
|
Fill(m_bkColor);
|
|
|
|
LPSTR lpDIB = (LPSTR) ::GlobalLock((HGLOBAL) m_hDIB);
|
|
int cxDIB = (int) ::DIBWidth(lpDIB); // Size of DIB - x
|
|
int cyDIB = (int) ::DIBHeight(lpDIB); // Size of DIB - y
|
|
::GlobalUnlock((HGLOBAL) m_hDIB);
|
|
|
|
CRect rcDIB;
|
|
rcDIB.top = rcDIB.left = 0;
|
|
rcDIB.right = cxDIB;
|
|
rcDIB.bottom = cyDIB;
|
|
if(!m_bAutoScale)
|
|
{
|
|
CRect rectDest = m_rectDC;
|
|
rectDest.right = rectDest.left + cxDIB;
|
|
rectDest.bottom = rectDest.top + cyDIB;
|
|
::PaintDIB(m_pDC->m_hDC, &rectDest, m_hDIB, &rcDIB, m_palDIB);
|
|
}
|
|
else if(m_bUniformScale)
|
|
{
|
|
// Do uniform scale, so adjust rectDC
|
|
CRect rectDC = m_rectDC;
|
|
double nWidthDIB = rcDIB.Width(),
|
|
nWidthDC=m_rectDC.Width(),
|
|
nHeightDIB = rcDIB.Height(),
|
|
nHeightDC = m_rectDC.Height();
|
|
|
|
double nScale = min(nWidthDC / nWidthDIB, nHeightDC / nHeightDIB);
|
|
|
|
// 平移到中心的距离
|
|
double nMoveX=0, nMoveY=0;
|
|
nMoveX = (m_rectDC.Width() - nScale * rcDIB.Width()) / 2.0;
|
|
nMoveY = (m_rectDC.Height() - nScale * rcDIB.Height()) / 2.0;
|
|
|
|
rectDC.DeflateRect(int(nMoveX), int(nMoveY));
|
|
::PaintDIB(m_pDC->m_hDC, &rectDC, m_hDIB, &rcDIB, m_palDIB);
|
|
}
|
|
else
|
|
{ // not uniform scale
|
|
CRect rectDest=m_rectDC;
|
|
::PaintDIB(m_pDC->m_hDC, &rectDest, m_hDIB, &rcDIB, m_palDIB);
|
|
}
|
|
|
|
if(m_bHighlight)
|
|
{
|
|
CRect rect = m_rectDC;
|
|
m_pDC->Draw3dRect(rect,RGB(128,128,128),RGB(240,240,240)); //3D
|
|
rect.DeflateRect(1, 1);
|
|
m_pDC->Draw3dRect(rect,RGB(128,128,128),RGB(240,240,240)); //3D
|
|
rect.DeflateRect(1,1);
|
|
|
|
CBrush brush(RGB(255,0,0));
|
|
m_pDC->FrameRect(&rect, &brush);
|
|
rect.DeflateRect(1,1);
|
|
m_pDC->FrameRect(&rect, &brush);
|
|
}
|
|
else
|
|
{
|
|
CBrush brush(GetBkColor());
|
|
CRect rect = m_rectDC;
|
|
m_pDC->FrameRect(&rect, &brush);
|
|
rect.DeflateRect(1,1);
|
|
m_pDC->FrameRect(&rect, &brush);
|
|
rect.DeflateRect(1,1);
|
|
m_pDC->FrameRect(&rect, &brush);
|
|
rect.DeflateRect(1,1);
|
|
m_pDC->FrameRect(&rect, &brush);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TImageDrawDC::PaintSlide(const TCHAR *pszSlideFile)
|
|
{
|
|
if(!m_pDC)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
m_nIT = IT_SLIDE;
|
|
m_slide.Reset();
|
|
if(!pszSlideFile || !pszSlideFile[0])
|
|
{
|
|
Fill(RGB(192,192,192));
|
|
return TRUE;
|
|
}
|
|
|
|
if(m_slide.FromSlide(pszSlideFile) != RTNORM)
|
|
{
|
|
Fill(RGB(192,192,192));
|
|
return FALSE;
|
|
}
|
|
return PaintSlide();
|
|
}
|
|
|
|
BOOL TImageDrawDC::PaintSlide()
|
|
{
|
|
if(!m_pDC)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if(!m_slide)
|
|
{
|
|
Fill(RGB(192,192,192));
|
|
return FALSE;
|
|
}
|
|
|
|
if(m_bHighlight)
|
|
{
|
|
Fill(RGB(0,128,192));
|
|
}
|
|
else
|
|
{
|
|
Fill(m_bkColor);
|
|
}
|
|
|
|
TGGeColorLineList lstVectors;
|
|
lstVectors = m_slide;
|
|
ads_matrix mat;
|
|
if(fabs(m_nRotation) > 1.0E-6)
|
|
{
|
|
TADSGePoint3d().GetRotationMatrix(m_nRotation, mat);
|
|
for(int n = 0; n < lstVectors.Length(); n++)
|
|
{
|
|
TGGeColorLine &buf = *lstVectors[n];
|
|
TADSGePoint3d ptStart = buf.GetStartPoint(),
|
|
ptEnd = buf.GetEndPoint();
|
|
|
|
ptStart.TransformBy(mat);
|
|
ptEnd.TransformBy(mat);
|
|
|
|
buf.SetStartPoint(ptStart);
|
|
buf.SetEndPoint(ptEnd);
|
|
}
|
|
|
|
for(n = 0; n < lstVectors.m_lstSolid.Length(); n++)
|
|
{
|
|
TGGeColorSolid &buf = *lstVectors.m_lstSolid[n];
|
|
buf.TransUCS(mat);
|
|
}
|
|
}
|
|
|
|
if (m_nMirror > 0)
|
|
{//镜像 1时为y轴镜像，2时为x轴镜像，3时xy一起镜像
|
|
AcGePoint3d pt(0,0,0),ptx(1,0,0),pty(0,1,0);
|
|
AcGeLine3d lnmiry,lnmirx;
|
|
lnmiry.set(pt, pty);
|
|
lnmirx.set(pt, ptx);
|
|
AcGeMatrix3d mat3d,mat3dy,mat3dx;
|
|
mat3dy.setToMirroring(lnmiry);
|
|
mat3dx.setToMirroring(lnmirx);
|
|
|
|
if (m_nMirror == 1)
|
|
{
|
|
mat3d = mat3dy;
|
|
AsAdsMatrix(mat3d, mat);
|
|
}
|
|
if (m_nMirror == 2)
|
|
{
|
|
mat3d = mat3dx;
|
|
AsAdsMatrix(mat3d, mat);
|
|
}
|
|
if (m_nMirror == 3)
|
|
{
|
|
mat3d = mat3dy * mat3dx;
|
|
AsAdsMatrix(mat3d, mat);
|
|
}
|
|
AsAdsMatrix(mat3d, mat);
|
|
for(int n = 0; n < lstVectors.Length(); n++)
|
|
{
|
|
TGGeColorLine &buf = *lstVectors[n];
|
|
buf.TransformBy(mat);
|
|
}
|
|
|
|
for(n = 0; n < lstVectors.m_lstSolid.Length(); n++)
|
|
{
|
|
TGGeColorSolid &bufs = *lstVectors.m_lstSolid[n];
|
|
bufs.TransUCS(mat);
|
|
}
|
|
}
|
|
|
|
lstVectors.WcsToDcs(m_rectDC.Width(), m_rectDC.Height(), 5);
|
|
for(int i = lstVectors.Length() - 1; i >= 0; i--)
|
|
{
|
|
TGGeColorLine &buf=*lstVectors[i];
|
|
CPoint ptStart(m_rectDC.left + AS_INT(buf.GetStartPoint().x), m_rectDC.top + AS_INT(buf.GetStartPoint().y));
|
|
CPoint ptEnd(m_rectDC.left + AS_INT(buf.GetEndPoint().x), m_rectDC.top + AS_INT(buf.GetEndPoint().y));
|
|
int nR, nG, nB;
|
|
ColorToRGB(buf.nColorIndex, &nR, &nG, &nB);
|
|
|
|
if(m_bkColor == RGB(255,255,255))
|
|
{//白底
|
|
nR = 255 - nR;
|
|
nG = 255 - nG;
|
|
nB = 255 - nB;
|
|
}
|
|
|
|
CPen pen(PS_SOLID, 1, RGB(nR, nG, nB));
|
|
CPen *pOld = m_pDC->SelectObject(&pen);
|
|
|
|
m_pDC->MoveTo(ptStart);
|
|
if(ptStart == ptEnd)
|
|
{
|
|
ptEnd.x += 1;
|
|
ptEnd.y += 1;
|
|
}
|
|
m_pDC->LineTo(ptEnd);
|
|
m_pDC->SelectObject(pOld);
|
|
}
|
|
|
|
for(i = 0; i < lstVectors.m_lstSolid.Length(); i++)
|
|
{
|
|
TGGeColorSolid &ln = *lstVectors.m_lstSolid[i];
|
|
int nR, nG, nB;
|
|
ColorToRGB(ln.m_nColor, &nR, &nG, &nB);
|
|
if(m_bkColor == RGB(255,255,255))
|
|
{//白底
|
|
nR = 255 - nR;
|
|
nG = 255 - nG;
|
|
nB = 255 - nB;
|
|
}
|
|
|
|
CBrush brush;
|
|
brush.CreateSolidBrush(RGB(nR,nG,nB));
|
|
|
|
CBrush *pOld = m_pDC->SelectObject(&brush);
|
|
|
|
CPoint *verts = new CPoint[ln.Length()];
|
|
for(int j = 0; j < ln.Length(); j++)
|
|
{
|
|
TADSGePoint3d pt = *ln[j];
|
|
verts[j].x = m_rectDC.left + AS_INT(pt.x);
|
|
verts[j].y = m_rectDC.top + AS_INT(pt.y);
|
|
}
|
|
|
|
CRgn rgn;
|
|
rgn.CreatePolygonRgn(verts,ln.Length(),ALTERNATE);
|
|
|
|
m_pDC->FillRgn(&rgn,&brush);
|
|
m_pDC->SelectObject(pOld);
|
|
brush.DeleteObject();
|
|
}
|
|
|
|
m_nIT = IT_SLIDE;
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TImageDrawDC::PaintBitmap(CBitmap &bmp)
|
|
{
|
|
if(!m_pDC || !bmp.GetSafeHandle())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BITMAP bmpInfo;
|
|
bmp.GetBitmap(&bmpInfo);
|
|
|
|
CDC dcTmp;
|
|
dcTmp.CreateCompatibleDC(m_pDC);
|
|
dcTmp.SelectObject(&bmp);
|
|
|
|
m_pDC->StretchBlt(m_rectDC.left, m_rectDC.top, m_rectDC.Width(), m_rectDC.Height(),
|
|
&dcTmp, 0, 0, bmpInfo.bmWidth, bmpInfo.bmHeight, SRCCOPY);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Refresh the image
|
|
BOOL TImageDrawDC::Redraw()
|
|
{
|
|
//Fill(m_bkColor);
|
|
if(m_nIT == IT_SLIDE)
|
|
{
|
|
|
|
return PaintSlide();
|
|
}
|
|
|
|
else if(m_nIT == IT_BITMAP)
|
|
{
|
|
return PaintImage();
|
|
}
|
|
else
|
|
{
|
|
Fill(RGB(192,192,192));
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void TImageDrawDC::Fill(COLORREF cref)
|
|
{
|
|
if(!m_pDC)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(!cref)
|
|
{
|
|
m_pDC->FillSolidRect(&m_rectDC, m_bkColor);
|
|
}
|
|
else
|
|
{
|
|
m_pDC->FillSolidRect(&m_rectDC, cref);
|
|
}
|
|
}
|
|
|
|
BOOL TImageDrawDC::PaintImageNormal(const TCHAR * pszImageFile)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TImageDrawDC::PaintImageOnlyNormal(const TCHAR * pszImageFile)
|
|
{
|
|
return TRUE;
|
|
|
|
}
|