// SampleView.cpp : implementation file
|
//
|
|
#include "stdafx.h"
|
#include "Server_MemDC.h"
|
#include "SlimScrollView.h"
|
#include "Global_Define.h"
|
|
#ifdef _DEBUG
|
#define new DEBUG_NEW
|
#undef THIS_FILE
|
static char THIS_FILE[] = __FILE__;
|
#endif
|
|
/////////////////////////////////////////////////////////////////////////////
|
// CSlimScrollView
|
#define UM_MOUSE_MOVE (WM_USER + 7650)
|
#define UM_MOUSE_LBUTTON_DOWN (WM_USER + 7651)
|
#define UM_MOUSE_RBUTTON_UP (WM_USER + 7652)
|
#define UM_MOUSE_LBUTTON_UP (WM_USER + 7653)
|
|
IMPLEMENT_DYNCREATE(CSlimScrollView, CScrollView)
|
|
CSlimScrollView::CSlimScrollView()
|
{
|
//m_Bitmap.LoadBitmap (IDB_BITMAP1);
|
|
m_hMemDC = NULL;
|
m_hMainDC = NULL;
|
m_pBMI = NULL;
|
|
m_pParents = NULL;
|
m_pSetupIMG = NULL;
|
m_pScaleIMg = NULL;
|
m_pBrightHWnd = NULL;
|
m_hBitmap = NULL;
|
|
m_rtDefect.SetRect(0,0,0,0);
|
m_rtRect.SetRect(0,0,0,0);
|
m_bDefect = FALSE;
|
m_bRect = FALSE;
|
m_bZoomMode = FALSE;
|
|
m_pSetupIMG = new BYTE[SLIM_IMG_MAX_WIDTH*SLIM_IMG_MAX_HEIGHT*sizeof(BYTE)];
|
//m_pSetupIMG = (BYTE*)::VirtualAlloc(NULL, (SLIM_IMG_MAX_WIDTH*SLIM_IMG_MAX_HEIGHT)*sizeof(BYTE), MEM_COMMIT | MEM_RESERVE | MEM_TOP_DOWN, PAGE_READWRITE);
|
|
ZeroMemory(m_pSetupIMG,sizeof(BYTE)*SLIM_IMG_MAX_WIDTH*SLIM_IMG_MAX_HEIGHT);
|
m_pDispBuf = m_pSetupIMG;
|
|
m_zoomScale = 1.0;
|
m_ScaleWidth = m_ScaleHeight = m_ImageWidth = m_ImageHeight = 0;
|
|
m_bMessage = FALSE;
|
|
m_width = 0;
|
m_height = 0;
|
|
m_OriginPos = m_OffsetPos = m_MousePoint = CPoint(0,0);
|
|
m_pointSplineOffset = CPoint(0,0);
|
|
DWORD bufsize = sizeof(BITMAPINFOHEADER)+ 256*sizeof(RGBQUAD);
|
|
m_pBMI = (BITMAPINFO *)new BYTE[bufsize];
|
// Set Bitmap information
|
m_pBMI->bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
|
m_pBMI->bmiHeader.biPlanes=1;
|
m_pBMI->bmiHeader.biBitCount=8;
|
m_pBMI->bmiHeader.biCompression=0; //BI_RGB;
|
m_pBMI->bmiHeader.biXPelsPerMeter=0;
|
m_pBMI->bmiHeader.biYPelsPerMeter=0;
|
m_pBMI->bmiHeader.biClrUsed=256;
|
m_pBMI->bmiHeader.biClrImportant=0;
|
|
// Set Palette
|
for(WORD i=0 ; i< 256 ; i++) {
|
m_pBMI->bmiColors[i].rgbRed = (BYTE)i;
|
m_pBMI->bmiColors[i].rgbGreen = (BYTE)i;
|
m_pBMI->bmiColors[i].rgbBlue = (BYTE)i;
|
m_pBMI->bmiColors[i].rgbReserved = 0;
|
}
|
|
m_nNotchInsListIdx = -1;//20140528
|
m_bNotchInsPosMod = FALSE;//20140528
|
}
|
|
CSlimScrollView::~CSlimScrollView()
|
{
|
if(m_pBMI)
|
{
|
delete[] m_pBMI,m_pBMI = NULL;
|
}
|
ReleaseMemory();
|
}
|
|
void CSlimScrollView::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
|
{
|
int scroll_Pos;
|
|
if ( nSBCode==SB_ENDSCROLL ) {
|
scroll_Pos = GetScrollPos(SB_HORZ);
|
}
|
|
::PostMessage(this->GetParent()->GetSafeHwnd(),MSG_SCANVIEW,NULL,NULL);
|
|
CScrollView::OnHScroll(nSBCode, nPos, pScrollBar);
|
}
|
|
void CSlimScrollView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
|
{
|
int scroll_Pos;
|
|
if ( nSBCode==SB_ENDSCROLL ) {
|
scroll_Pos = GetScrollPos(SB_VERT);
|
}
|
|
CScrollView::OnVScroll(nSBCode, nPos, pScrollBar);
|
}
|
|
void CSlimScrollView::EnlargeImage(BYTE *pInBuff, LONG wSrcWidth, LONG wSrcHeight,
|
BYTE *pOutBuff, LONG wDestWidth, LONG wDestHeight,double scale)
|
|
{
|
if (scale <= 1)
|
return;
|
|
double dFactor = 1 / scale;
|
double dXSrc = 0;
|
CSize sizeSrc;
|
|
sizeSrc.cx = wSrcWidth;
|
sizeSrc.cy = wSrcHeight;
|
|
for (int nX = 0; nX < wDestWidth; nX++)
|
{
|
double dYSrc = 0;
|
|
for (int nY = 0; nY < wDestHeight; nY++)
|
{
|
pOutBuff[nY * wDestWidth + nX] = CalcWeightedColor(pInBuff, sizeSrc, dXSrc, dYSrc);
|
|
dYSrc += dFactor; // next dest pixel in source coords
|
}
|
|
dXSrc += dFactor; // next dest pixel in source coords
|
}
|
|
return;
|
}
|
|
BYTE CSlimScrollView::CalcWeightedColor(BYTE* pPixels, CSize size, double dX, double dY)
|
{
|
// interpolate between the current pixel and its pixel to the right and down
|
int nX = (int)dX;
|
int nY = (int)dY;
|
|
if (dX < 0 || dY < 0)
|
return pPixels[max(0, nY) * size.cx + max(0, nX)]; // closest
|
|
BYTE* pVal = &pPixels[nY * size.cx + nX]; // current
|
|
double dXFraction = dX - nX;
|
double dX1MinusFraction = 1 - dXFraction;
|
|
double dYFraction = dY - nY;
|
double dY1MinusFraction = 1 - dYFraction;
|
|
BYTE* pXP = &pPixels[nY * size.cx + CHKMIN(nX + 1, size.cx - 1)]; // x + 1
|
BYTE* pYP = &pPixels[CHKMIN(nY + 1, size.cy - 1) * size.cx + nX]; // y + 1
|
|
int result = (int)((dX1MinusFraction * *pVal +
|
dXFraction * *pXP +
|
dY1MinusFraction * *pVal +
|
dYFraction * *pYP) / 2);
|
|
return result;
|
}
|
|
void CSlimScrollView::ShrinkImage(BYTE *pInBuff, LONG wSrcWidth, LONG wSrcHeight,
|
BYTE *pOutBuff, LONG wDestWidth, LONG wDestHeight,double scale)
|
{
|
ASSERT (scale < 1 && scale > 0);
|
|
if (scale >= 1 || scale <= 0)
|
return;
|
|
double dFactor = 1 / scale;
|
double dXEnd = -dFactor / 2;
|
int nXStart, nXEnd = -1;
|
|
for (int nX = 0; nX < wDestWidth; nX++)
|
{
|
int nYStart, nYEnd = -1;
|
double dYEnd = -dFactor / 2;
|
|
nXStart = nXEnd + 1;
|
dXEnd += dFactor;
|
nXEnd = CHKMIN(wSrcWidth - 1, (int)dXEnd + 1);
|
|
if (nXStart > nXEnd)
|
continue;
|
|
for (int nY = 0; nY < wDestHeight; nY++)
|
{
|
nYStart = nYEnd + 1;
|
dYEnd += dFactor;
|
nYEnd = CHKMIN(wSrcHeight - 1, (int)dYEnd + 1);
|
|
if (nYStart > nYEnd)
|
continue;
|
|
int nCount = 0, nVal = 0;
|
|
// average the pixels over the range
|
for (int nXSub = nXStart; nXSub <= nXEnd; nXSub++)
|
{
|
for (int nYSub = nYStart; nYSub <= nYEnd; nYSub++)
|
{
|
nVal += pInBuff[nYSub * wSrcWidth + nXSub];
|
nCount++;
|
}
|
}
|
|
pOutBuff[nY * wDestWidth + nX] = nVal/nCount;
|
}
|
}
|
|
return;
|
}
|
|
BOOL CSlimScrollView::DoZoomInOut()
|
{
|
if(m_pSetupIMG == NULL) return FALSE;
|
|
CSize sizeTotal;
|
|
if(m_pScaleIMg != NULL) delete[] m_pScaleIMg, m_pScaleIMg=NULL;
|
m_pScaleIMg = new BYTE[m_ScaleWidth*m_ScaleHeight];
|
|
if(m_ImageWidth == m_ScaleWidth && m_ImageHeight == m_ScaleHeight)
|
{
|
m_pDispBuf = m_pSetupIMG;
|
}
|
else
|
{
|
EnlargeImage(m_pSetupIMG,m_ImageWidth,m_ImageHeight,m_pScaleIMg,m_ScaleWidth,m_ScaleHeight,m_zoomScale);
|
m_pDispBuf = m_pScaleIMg;
|
}
|
|
InitGDI(m_ScaleWidth,m_ScaleHeight,TRUE);
|
|
sizeTotal.cx = m_ScaleWidth;
|
sizeTotal.cy = m_ScaleHeight;
|
|
SetScrollSizes(MM_TEXT, sizeTotal);
|
SetScrollRange(SB_HORZ,0,sizeTotal.cx,TRUE);
|
SetScrollRange(SB_VERT,0,sizeTotal.cy,TRUE);
|
EnableScrollBar(SB_BOTH,ESB_ENABLE_BOTH);
|
|
Invalidate(TRUE);
|
|
return TRUE;
|
}
|
|
BOOL CSlimScrollView::CalcScaleSize()
|
{
|
if(m_pSetupIMG == NULL) return FALSE;
|
|
double dCX,dCY;
|
LONG oldWidth,oldHeight;
|
|
oldWidth = m_ScaleWidth;
|
oldHeight = m_ScaleHeight;
|
|
dCX = (double)m_ImageWidth*m_zoomScale;
|
dCY = (double)m_ImageHeight*m_zoomScale;
|
|
if((LONG)dCX == m_ScaleWidth && (LONG)dCY == m_ScaleHeight)
|
return FALSE;
|
|
m_ScaleWidth = (LONG)dCX;
|
m_ScaleWidth = ((LONG)(m_ScaleWidth + 3) & ~3);
|
m_ScaleHeight = (LONG)dCY;
|
m_ScaleHeight = ((LONG)(m_ScaleHeight + 3) & ~3);
|
|
m_pRectPoint.x = (m_pRectPoint.x*m_ScaleWidth)/oldWidth;
|
m_pRectPoint.y = (m_pRectPoint.y*m_ScaleHeight)/oldHeight;
|
|
return TRUE;
|
}
|
|
BEGIN_MESSAGE_MAP(CSlimScrollView, CScrollView)
|
//{{AFX_MSG_MAP(CSlimScrollView)
|
ON_WM_MOUSEMOVE()
|
ON_WM_SETCURSOR()
|
ON_WM_VSCROLL()
|
ON_WM_HSCROLL()
|
ON_WM_ERASEBKGND()
|
ON_WM_MOUSEACTIVATE()
|
ON_WM_RBUTTONDOWN()
|
ON_WM_RBUTTONUP()
|
ON_WM_LBUTTONDOWN()
|
ON_WM_LBUTTONUP()
|
//}}AFX_MSG_MAP
|
ON_WM_LBUTTONDBLCLK()//20140528
|
END_MESSAGE_MAP()
|
|
/////////////////////////////////////////////////////////////////////////////
|
// CSlimScrollView drawing
|
int CSlimScrollView::OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message)
|
|
{
|
// return CView::OnMouseActivate(pDesktopWnd, nHitTest, message);
|
|
return MA_ACTIVATE;
|
|
}
|
|
|
void CSlimScrollView::OnInitialUpdate()
|
{
|
CScrollView::OnInitialUpdate();
|
|
CSize sizeTotal;
|
// TODO: calculate the total size of this view
|
sizeTotal.cx = m_ScaleWidth;
|
sizeTotal.cy = m_ScaleHeight;
|
SetScrollSizes(MM_TEXT, sizeTotal);
|
}
|
|
void CSlimScrollView::OnDraw(CDC* pDC)
|
{
|
CDocument* pDoc = GetDocument();
|
HDC hDC = pDC->GetSafeHdc();
|
|
CRect rt(0,0,m_width,m_height);
|
CControlMemDC memDC(pDC,&rt);
|
m_hMemDC = memDC.GetSafeHdc();
|
|
if(m_pDispBuf != NULL)
|
{
|
DrawImage(m_pDispBuf);
|
if(m_bDrawRect == TRUE && m_bMessage == FALSE)
|
{
|
CRect rect = m_rtRect;
|
|
rect.left = (int)((double)rect.left*m_zoomScale);
|
rect.right = (int)((double)rect.right*m_zoomScale);
|
rect.top = (int)((double)rect.top*m_zoomScale);
|
rect.bottom = (int)((double)rect.bottom*m_zoomScale);
|
DrawRectangle(rect,RGB(255,0,0));
|
CPoint point[2];
|
|
point[0] = CPoint(rect.left,rect.top+rect.Height()/2);
|
point[1] = CPoint(rect.right,rect.top+rect.Height()/2);
|
DrawLine(point[0].x,point[0].y,point[1].x,point[1].y,RGB(255,255,0));
|
|
point[0] = CPoint(rect.left+rect.Width()/2,rect.top);
|
point[1] = CPoint(rect.left+rect.Width()/2,rect.bottom);
|
DrawLine(point[0].x,point[0].y,point[1].x,point[1].y,RGB(255,255,0) );
|
}
|
|
DrawMark();
|
|
DrawPoint();
|
|
DrawNotchInsPos();//20140528
|
|
if((int)m_pSplinePos.size() > 0)
|
DrawSpline();
|
}
|
}
|
|
void CSlimScrollView::DrawSpline()
|
{
|
CPoint point;
|
std::multimap<int, CSplinePoint>::iterator it;
|
|
for(it=m_pSplinePos.begin();it!=m_pSplinePos.end();it++)
|
{
|
point = it->second.origin;
|
point.x = (int)((double)point.x*m_zoomScale);
|
point.y = (int)((double)point.y*m_zoomScale);
|
::SetPixel(m_hMemDC,point.x,point.y,RGB(255,0,0));
|
}
|
}
|
|
void CSlimScrollView::DrawMark()
|
{
|
COLORREF colorOrigin = RGB(120,255,255);
|
COLORREF colorOffset = RGB(255,50,50);
|
int nDrawS = 5;
|
|
if(m_OriginPos.x > 0 && m_OriginPos.y > 0)
|
{
|
DrawLine(m_OriginPos.x-nDrawS,m_OriginPos.y,m_OriginPos.x+nDrawS,m_OriginPos.y,colorOrigin);
|
DrawLine(m_OriginPos.x,m_OriginPos.y-nDrawS,m_OriginPos.x,m_OriginPos.y+nDrawS,colorOrigin);
|
}
|
|
if(m_OffsetPos.x > 0 && m_OffsetPos.y > 0)
|
{
|
DrawLine(m_OffsetPos.x-nDrawS,m_OffsetPos.y,m_OffsetPos.x+nDrawS,m_OffsetPos.y,colorOffset);
|
DrawLine(m_OffsetPos.x,m_OffsetPos.y-nDrawS,m_OffsetPos.x,m_OffsetPos.y+nDrawS,colorOffset);
|
}
|
}
|
|
void CSlimScrollView::DrawLine(long sx, long sy, long ex, long ey, COLORREF color,int nStyle)
|
{
|
HPEN pOldPen = (HPEN)::SelectObject(m_hMemDC,::CreatePen(nStyle, 1, color));
|
::MoveToEx(m_hMemDC, sx, sy, NULL);
|
::LineTo(m_hMemDC, ex, ey);
|
::DeleteObject(::SelectObject(m_hMemDC, (HPEN)pOldPen));
|
}
|
|
/////////////////////////////////////////////////////////////////////////////
|
// CSlimScrollView diagnostics
|
|
#ifdef _DEBUG
|
void CSlimScrollView::AssertValid() const
|
{
|
CScrollView::AssertValid();
|
}
|
|
void CSlimScrollView::Dump(CDumpContext& dc) const
|
{
|
CScrollView::Dump(dc);
|
}
|
#endif //_DEBUG
|
|
/////////////////////////////////////////////////////////////////////////////
|
// CSlimScrollView message handlers
|
|
BOOL CSlimScrollView::Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext)
|
{
|
// TODO: Add your specialized code here and/or call the base class
|
|
m_pParents = pParentWnd;
|
|
|
return CWnd::Create(lpszClassName, lpszWindowName, dwStyle, rect, pParentWnd, nID, pContext);
|
}
|
|
void CSlimScrollView::DisplayError()
|
{
|
LPVOID lpMsgBuf;
|
|
FormatMessage(
|
FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
FORMAT_MESSAGE_FROM_SYSTEM |
|
FORMAT_MESSAGE_IGNORE_INSERTS,
|
NULL,
|
GetLastError(),
|
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
|
(LPTSTR) &lpMsgBuf,
|
0,
|
NULL
|
);
|
|
CString msg = (LPCTSTR)lpMsgBuf;
|
AfxMessageBox(msg);
|
|
LocalFree( lpMsgBuf );
|
}
|
|
|
BOOL CSlimScrollView::InitGDI(int width, int height, bool bColor)
|
{
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////
|
if(m_width != width || m_height != height)
|
{
|
if(m_bZoomMode == FALSE)
|
{
|
if(m_pSetupIMG)
|
{
|
//VirtualFree(m_pSetupIMG, sizeof(BYTE)*(width*height), MEM_DECOMMIT);
|
//VirtualFree(m_pSetupIMG, 0, MEM_RELEASE);
|
delete [] m_pSetupIMG;
|
m_pSetupIMG = NULL;
|
m_pDispBuf = NULL;
|
}
|
|
if(m_pSetupIMG == NULL)
|
{
|
//m_pSetupIMG = (BYTE*)::VirtualAlloc(NULL, (width*height)*sizeof(BYTE),MEM_COMMIT | MEM_RESERVE | MEM_TOP_DOWN, PAGE_READWRITE);
|
|
m_pSetupIMG = new BYTE[width * height * sizeof(BYTE) ];
|
ZeroMemory(m_pSetupIMG,sizeof(BYTE)*width*height);
|
m_pDispBuf = m_pSetupIMG;
|
}
|
if(m_pScaleIMg)
|
{
|
delete [] m_pScaleIMg;
|
m_pScaleIMg = NULL;
|
}
|
|
m_pBMI->bmiHeader.biWidth=(LONG)width;
|
m_pBMI->bmiHeader.biHeight=-(LONG)height;
|
}
|
else
|
{
|
m_pBMI->bmiHeader.biWidth=(LONG)m_ScaleWidth;
|
m_pBMI->bmiHeader.biHeight=-(LONG)m_ScaleHeight;
|
}
|
|
|
}
|
m_width = width;
|
m_height = height;
|
|
m_pBMI->bmiHeader.biSizeImage= m_pBMI->bmiHeader.biWidth*m_pBMI->bmiHeader.biHeight;
|
|
SetScrollRange(SB_HORZ,0,m_width,TRUE);
|
SetScrollRange(SB_VERT,0,m_height,TRUE);
|
|
return TRUE;
|
}
|
|
|
void CSlimScrollView::ReleaseMemory()
|
{
|
m_pSplinePos.clear();
|
m_pNotchInsPos.clear();//20140528
|
|
if(m_pScaleIMg != NULL)
|
{
|
delete[] m_pScaleIMg, m_pScaleIMg=NULL;
|
}
|
if(m_pSetupIMG != NULL)
|
{
|
delete[] m_pSetupIMG, m_pSetupIMG=NULL;
|
}
|
m_width = 0;
|
m_height = 0;
|
}
|
|
void CSlimScrollView::DrawImage(LPBYTE pImg)
|
{
|
::SetDIBitsToDevice(m_hMemDC, 0, 0, m_width, m_height, 0, 0, 0, m_height, pImg, m_pBMI, DIB_RGB_COLORS);
|
}
|
|
void CSlimScrollView::DrawRectangle(CRect rect,COLORREF color)
|
{
|
//BYTE nFactor = (BYTE)((double)m_ScaleWidth*0.05)/2;
|
FV_ROI roi;
|
|
roi.u1 = rect.left;
|
roi.u2 = rect.right;
|
roi.v1 = rect.top;
|
roi.v2 = rect.bottom;
|
// roi.u1 = rect.left -nFactor;
|
// roi.u2 = rect.right+nFactor;
|
// roi.v1 = rect.top -nFactor;
|
// roi.v2 = rect.bottom+nFactor;
|
|
|
HPEN pOldPen = (HPEN)::SelectObject(m_hMemDC,::CreatePen(PS_SOLID, 1, color));
|
::MoveToEx(m_hMemDC, roi.u1, roi.v1, NULL);
|
::LineTo(m_hMemDC, roi.u2, roi.v1);
|
::LineTo(m_hMemDC, roi.u2, roi.v2);
|
::LineTo(m_hMemDC, roi.u1, roi.v2);
|
::LineTo(m_hMemDC, roi.u1, roi.v1);
|
::DeleteObject(::SelectObject(m_hMemDC, (HPEN)pOldPen));
|
}
|
|
void CSlimScrollView::DrawRefresh()
|
{
|
Invalidate(FALSE);
|
}
|
|
BOOL CSlimScrollView::OnEraseBkgnd(CDC* pDC)
|
{
|
// TODO: Add your message handler code here and/or call default
|
|
return TRUE;//CScrollView::OnEraseBkgnd(pDC);
|
}
|
|
void CSlimScrollView::DrawPoint()
|
{
|
if(m_pDispBuf == NULL)
|
return;
|
|
HFONT pFont, pOldFont;
|
pFont = ::CreateFont(14, 0, 0, 0, FW_BOLD, 0, 0, 0,
|
DEFAULT_CHARSET, OUT_CHARACTER_PRECIS, CLIP_CHARACTER_PRECIS,
|
PROOF_QUALITY, DEFAULT_PITCH|FF_DECORATIVE, _T("arial"));
|
pOldFont = (HFONT)::SelectObject(m_hMemDC, (HFONT)pFont);
|
|
int nOldROP2 = ::SetROP2(m_hMemDC,R2_NOT);
|
int nOldBkMode = ::SetBkMode(m_hMemDC,TRANSPARENT);
|
COLORREF clrText = ::SetTextColor(m_hMemDC,RGB(0, 0, 0));
|
UINT nOldAlign = ::SetTextAlign(m_hMemDC,TA_CENTER);
|
|
CString str,strX,strY;
|
CPoint point = m_MousePoint;
|
CRect rect;
|
CBrush brush,rectBrush;
|
int nBright = 0;
|
|
if(m_pDispBuf != NULL)
|
{
|
CSize szSize = CSize(m_ScaleWidth,m_ScaleHeight);
|
if(point.y >= szSize.cy || point.x >= szSize.cx)
|
{
|
;
|
}
|
else
|
{
|
nBright = *(m_pDispBuf+point.y*szSize.cx+point.x);
|
}
|
}
|
|
strX.Format(_T("%d"),point.x);
|
strY.Format(_T("%d"),point.y);
|
strX = GetMoneyRule(strX,1000);
|
strY = GetMoneyRule(strY,1000);
|
str.Format(_T("[%s][%s][%d]"), strX,strY,nBright);
|
|
brush.CreateSolidBrush(RGB(180,150,190));
|
rectBrush.CreateSolidBrush(RGB(5,64,128));
|
|
rect = CRect(m_MousePoint.x-(int)((double)(str.GetLength())*2.9),m_MousePoint.y+20,m_MousePoint.x+(int)((double)(str.GetLength())*2.9),m_MousePoint.y+20+16);
|
::FrameRect(m_hMemDC,rect, (HBRUSH)rectBrush);
|
rect.DeflateRect(1,1);
|
::FillRect(m_hMemDC,&rect,(HBRUSH)brush);
|
::TextOut(m_hMemDC, m_MousePoint.x, m_MousePoint.y+20, str, str.GetLength());
|
|
::SetTextColor(m_hMemDC,clrText);
|
::SetBkMode(m_hMemDC,nOldBkMode);
|
::SetROP2(m_hMemDC,nOldROP2);
|
::SetTextAlign(m_hMemDC,nOldAlign);
|
::DeleteObject(::SelectObject(m_hMemDC, (HFONT)pOldFont));
|
brush.DeleteObject();
|
rectBrush.DeleteObject();
|
}
|
|
CString CSlimScrollView::GetMoneyRule(CString strMoney, int nRuleSpace/*=0*/)
|
{
|
BOOL bMinus = FALSE;
|
if( strMoney.Find(_T("-"),0 ) >= 0 )
|
bMinus = TRUE;
|
|
double dMoney = _ttof(strMoney);
|
strMoney.Format(_T("%.0f"), dMoney);
|
|
CString strResult = _T(""), strTemp1, strTemp2, strTemp3, strTemp4;
|
|
strTemp4 = strMoney.Right(3);
|
strMoney = strMoney.Left(strMoney.GetLength()-3);
|
strTemp3 = strMoney.Right(3);
|
strMoney = strMoney.Left(strMoney.GetLength()-3);
|
strTemp2 = strMoney.Right(3);
|
strMoney = strMoney.Left(strMoney.GetLength()-3);
|
strTemp1 = strMoney.Right(3);
|
|
strResult = strTemp1 + ((strTemp1.GetLength() > 0) ? _T(",") : _T("")) + strTemp2 + ((strTemp2.GetLength() > 0) ? _T(",") : _T("")) + strTemp3 + ((strTemp3.GetLength() > 0) ? _T(",") : _T("")) + strTemp4;
|
|
if( bMinus )
|
{
|
strResult = _T("-")+strResult;
|
}
|
return strResult;
|
}
|
|
|
void CSlimScrollView::OnMouseMove(UINT nFlags, CPoint point)
|
{
|
int cx = this->GetScrollPos(SB_HORZ) + point.x;
|
int cy = this->GetScrollPos(SB_VERT) + point.y;
|
|
m_MousePoint = CPoint(cx,cy);
|
if(m_bRect)
|
{
|
m_rtRect.bottom =cy;
|
m_rtRect.right = cx;
|
}
|
|
DrawRefresh();
|
|
if(m_bMessage)
|
{
|
GetParent()->PostMessage(MSG_SCANVIEW_MOUSEPOS,cx,cy);
|
}
|
|
CScrollView::OnMouseMove(nFlags, point);
|
}
|
|
void CSlimScrollView::PostNcDestroy()
|
{
|
// TODO: Add your specialized code here and/or call the base class
|
|
CScrollView::PostNcDestroy();
|
}
|
|
BOOL CSlimScrollView::DestroyWindow()
|
{
|
// TODO: Add your specialized code here and/or call the base class
|
|
return CScrollView::DestroyWindow();
|
}
|
|
void CSlimScrollView::OnRButtonDown(UINT nFlags, CPoint point)
|
{
|
// TODO: Add your message handler code here and/or call default
|
|
CScrollView::OnRButtonDown(nFlags, point);
|
}
|
|
void CSlimScrollView::OnRButtonUp(UINT nFlags, CPoint point)
|
{
|
// TODO: Add your message handler code here and/or call default
|
|
|
CScrollView::OnRButtonUp(nFlags, point);
|
}
|
|
void CSlimScrollView::OnLButtonDown(UINT nFlags, CPoint point)
|
{
|
// TODO: Add your message handler code here and/or call default
|
|
int cx = this->GetScrollPos(SB_HORZ);
|
int cy = this->GetScrollPos(SB_VERT);
|
|
if(!m_bRect)//20140528
|
{
|
m_rtRect.top = point.y + cy;
|
m_rtRect.left = point.x + cx;
|
//m_rtRect.right = 0;
|
//m_rtRect.bottom = 0;
|
m_bRect = TRUE;
|
}
|
|
if(m_bNotchInsPosMod == TRUE)//20140528
|
{
|
m_bNotchInsPosMod = FALSE;
|
|
CPoint pointTemp;
|
|
pointTemp.y = point.y + cy;
|
pointTemp.x = point.x + cx;
|
|
// m_pNotchInsPos.insert(std::make_pair(nCount, pointTemp));
|
|
GetParent()->PostMessage(MSG_SCANVIEW_POS_MOD, pointTemp.x, pointTemp.y);
|
}
|
|
CScrollView::OnLButtonDown(nFlags, point);
|
}
|
|
void CSlimScrollView::OnLButtonUp(UINT nFlags, CPoint point)
|
{
|
// TODO: Add your message handler code here and/or call default
|
int cx = this->GetScrollPos(SB_HORZ);
|
int cy = this->GetScrollPos(SB_VERT);
|
|
if(m_bRect)
|
{
|
if( m_rtRect.top > m_rtRect.bottom)
|
{
|
int tmp = m_rtRect.top;
|
m_rtRect.top = m_rtRect.bottom;
|
m_rtRect.bottom = tmp;
|
}
|
if( m_rtRect.left > m_rtRect.right)
|
{
|
int tmp = m_rtRect.left;
|
m_rtRect.left = m_rtRect.right;
|
m_rtRect.right = tmp;
|
}
|
// if(m_bMessage)
|
// GetParent()->PostMessage(UM_MOUSE_LBUTTON_UP,MAKELONG(m_rtRect.left/m_zoomScale,m_rtRect.top/m_zoomScale),MAKELONG(m_rtRect.right/m_zoomScale,m_rtRect.bottom/m_zoomScale));
|
m_bRect = FALSE;
|
}
|
|
CScrollView::OnLButtonUp(nFlags, point);
|
}
|
|
void CSlimScrollView::OnLButtonDblClk(UINT nFlags, CPoint point)//20140528
|
{
|
// int nCount = (int)m_pNotchInsPos.size();
|
|
int cx = this->GetScrollPos(SB_HORZ);
|
int cy = this->GetScrollPos(SB_VERT);
|
|
CPoint pointTemp;
|
|
pointTemp.y = point.y + cy;
|
pointTemp.x = point.x + cx;
|
|
// m_pNotchInsPos.insert(std::make_pair(nCount, pointTemp));
|
|
GetParent()->PostMessage(MSG_SCANVIEW_POS_ADD, pointTemp.x, pointTemp.y);
|
|
CScrollView::OnLButtonDblClk(nFlags, point);
|
}
|
|
void CSlimScrollView::SetMode(SLIM_MODECOMMAND nMode)
|
{
|
m_nCurMode = nMode;
|
m_bZoomMode = TRUE;
|
switch(m_nCurMode)
|
{
|
case SLIM_MODE_ZOOMIN:
|
//m_pCursor = AfxGetApp()->LoadCursor(IDC_ARROW_CURSOR);
|
|
if(m_zoomScale < SLIM_MAXZOOMIN)
|
{
|
m_zoomScale += SLIM_SCALE_FACTOR;
|
if(m_zoomScale > SLIM_MAXZOOMIN) m_zoomScale = SLIM_MAXZOOMIN;
|
}
|
|
if(CalcScaleSize() == TRUE)
|
DoZoomInOut();
|
break;
|
case SLIM_MODE_ZOOMOUT:
|
//m_pCursor = AfxGetApp()->LoadCursor(IDC_ARROW_CURSOR);
|
if(m_zoomScale > SLIM_MAXZOOMOUT)
|
{
|
m_zoomScale -= SLIM_SCALE_FACTOR;
|
if(m_zoomScale < SLIM_MAXZOOMOUT) m_zoomScale = SLIM_MAXZOOMOUT;
|
}
|
|
if(CalcScaleSize() == TRUE)
|
DoZoomInOut();
|
break;
|
case SLIM_MODE_NORMAL:
|
DoOrigin();
|
break;
|
case SLIM_MODE_POINT:
|
//m_pCursor = AfxGetApp()->LoadCursor(IDC_ARROW_CURSOR);
|
break;
|
}
|
m_bZoomMode = FALSE;
|
Invalidate(TRUE);
|
}
|
void CSlimScrollView::DoOrigin()
|
{
|
if(m_nCurMode == SLIM_MODE_NORMAL)
|
{
|
m_ScaleWidth = m_ImageWidth;
|
m_ScaleHeight = m_ImageHeight;
|
m_zoomScale = 1;
|
DoZoomInOut();
|
}
|
DrawRefresh();
|
}
|
|
CRect CSlimScrollView::GetDrawRect()
|
{
|
if(m_rtRect.left < 0) m_rtRect.left = 0;
|
if(m_rtRect.right < 0) m_rtRect.right = 0;
|
if(m_rtRect.left >= m_ScaleWidth) m_rtRect.left = m_ScaleWidth-1;
|
if(m_rtRect.right >= m_ScaleWidth) m_rtRect.right = m_ScaleWidth-1;
|
|
if(m_rtRect.top < 0) m_rtRect.top = 0;
|
if(m_rtRect.bottom < 0) m_rtRect.bottom = 0;
|
if(m_rtRect.top >= m_ScaleHeight) m_rtRect.top = m_ScaleHeight-1;
|
if(m_rtRect.bottom >= m_ScaleHeight) m_rtRect.bottom = m_ScaleHeight-1;
|
|
return m_rtRect;
|
}
|
|
void CSlimScrollView::SetSplinePosition(std::multimap<int, CSplinePoint> *pPoint,CPoint pointOffset)
|
{
|
if(pPoint == NULL)
|
return;
|
|
m_pSplinePos.clear();
|
m_pSplinePos.insert(pPoint->begin(),pPoint->end());
|
m_pointSplineOffset = pointOffset;
|
}
|
|
void CSlimScrollView::DrawNotchInsPos()//20140528
|
{
|
if(m_bDrawNotchInsPos == TRUE)
|
{
|
std::multimap<int, CPoint>::iterator it;
|
CRect rect;
|
COLORREF color;
|
|
for(it=m_pNotchInsPos.begin();it!=m_pNotchInsPos.end();it++)
|
{
|
if(it->first == m_nNotchInsListIdx)
|
{
|
color = RGB(255,255,0);
|
|
if(m_bNotchInsPosMod == TRUE)
|
{
|
rect.left = m_MousePoint.x-2;
|
rect.right = m_MousePoint.x+2;;
|
rect.top = m_MousePoint.y-2;
|
rect.bottom = m_MousePoint.y+2;
|
}
|
else
|
{
|
rect.left = it->second.x-2;
|
rect.right = it->second.x+2;;
|
rect.top = it->second.y-2;
|
rect.bottom = it->second.y+2;
|
}
|
}
|
else
|
{
|
color = RGB(255,0,0);
|
rect.left = it->second.x-2;
|
rect.right = it->second.x+2;;
|
rect.top = it->second.y-2;
|
rect.bottom = it->second.y+2;
|
}
|
DrawRectangle(rect,color);
|
}
|
|
//DrawLine(m_nNotchCadCenterX,0,m_nNotchCadCenterX,m_ImageHeight,RGB(255,255,0));
|
DrawLine(0,m_nNotchCadCenterY,m_ImageWidth,m_nNotchCadCenterY,RGB(128,128,0));
|
|
|
}
|
}
|
|
void CSlimScrollView::SetNotchInsPosition( std::multimap<int, CPoint> *pPoint )
|
{
|
if(pPoint == NULL)
|
return;
|
|
m_pNotchInsPos.clear();
|
m_pNotchInsPos.insert(pPoint->begin(),pPoint->end());
|
|
Invalidate(FALSE);
|
}
|
|
void CSlimScrollView::SetNotchCadCenterPos( int nPosX, int nPosY )
|
{
|
m_nNotchCadCenterX = nPosX;
|
m_nNotchCadCenterY = nPosY;
|
}
|
