Beispiel #1
0
void CFlashingWnd::SetUpRegion(const CRect& cRect, int type)
{
	///////////////////////////////////////////////////
	//
	// Under construction ...!
	// (Just to get an idea how it works now and what previously developers had in mind)
	//
	// There is currently a pixel fault in defined region and recorded region
	// Right pixel column and Top pixel row are not recorded.  E.g. Area 200x200 becone 199x199
	// Don't know if this is only with manual setup region the case or with other screen copies as well
	// 
	//
	//    +--- wndRgn --------------------+
	//    |  +--- rgnTemp--------------+  |
    //
	// wndRgn defines a new rect with the size of the requested area but something bigger because the border lines are included either.
	// rgnTemp relative points to the area with the size of the area off interrest but inside wndRgn
	// rgnTemp2 ??
	// rgnTemp3 ??
	//
	///////////////////////////////////////////////////
	CRgn wndRgn;	
	CRgn rgnTemp;

	m_cRect = cRect;
	// TRACE( _T("## CFlashingWnd::SetUpRegion / m_cRect before / L=%d R=%d T=%d B=%d / W=%d H=%d\n"), m_cRect.left , m_cRect.right , m_cRect.top , m_cRect.bottom, m_cRect.Width(), m_cRect.Height() );

	// Type=0 stands for ... cProgramOpts.m_bAutoPan == false
	if (type == 0) {

		CRgn rgnTemp2;
		CRgn rgnTemp3;
		// ToDo: Check if all +1 are applied correctly. Parameters in function below are not checked.
        // Check if we have forgotten to apply a few or don't we need them (the +1's) at all.?
		wndRgn.CreateRectRgn(   0         , 0         , m_cRect.Width() + DOUBLETHICKNESS , m_cRect.Height() + DOUBLETHICKNESS  );
		rgnTemp.CreateRectRgn(  THICKNESS , THICKNESS , m_cRect.Width() + THICKNESS + 1   , m_cRect.Height() + THICKNESS + 1    );
		rgnTemp2.CreateRectRgn( 0         , SIDELEN2  , m_cRect.Width() + DOUBLETHICKNESS , m_cRect.Height() - SIDELEN + 1      );
		rgnTemp3.CreateRectRgn( SIDELEN2  , 0         , m_cRect.Width() - SIDELEN + 1     , m_cRect.Height() + DOUBLETHICKNESS  );

		wndRgn.CombineRgn(&wndRgn,&rgnTemp,RGN_DIFF);
		wndRgn.CombineRgn(&wndRgn,&rgnTemp2,RGN_DIFF);
		wndRgn.CombineRgn(&wndRgn,&rgnTemp3,RGN_DIFF);

		wndRgn.OffsetRgn( m_cRect.left - THICKNESS   , m_cRect.top - THICKNESS );
	} else {
		
		wndRgn.CreateRectRgn(  0             , 0             , m_cRect.Width() + DOUBLESMALLTHICKNESS , m_cRect.Height() + DOUBLESMALLTHICKNESS);
		rgnTemp.CreateRectRgn( SMALLTHICKNESS, SMALLTHICKNESS, m_cRect.Width() + SMALLTHICKNESS + 1   , m_cRect.Height() + SMALLTHICKNESS + 1);

		wndRgn.CombineRgn(&wndRgn, &rgnTemp, RGN_DIFF);

		wndRgn.OffsetRgn(m_cRect.left - SMALLTHICKNESS, m_cRect.top - SMALLTHICKNESS);
	}

	SetWindowRgn(wndRgn, TRUE);
}
Beispiel #2
0
//////////////////////////////////////////////////////////////////////////
// 画透明异形图的函数
// 注:在这里特别感谢CSDN网友: 黄凯飞, ID: hkf314
void CAnimateButton::AlphaBitmap(int nItem)
{
	CDC* pDC = GetDC();
	CDC TmpDC;
	TmpDC.CreateCompatibleDC(pDC);
	//当然,TmpBmp用来记录画的内容
	CBitmap TmpBmp;
	TmpBmp.CreateCompatibleBitmap(pDC, m_aniBtnWidth, m_aniBtnHeight);
	TmpDC.SelectObject(&TmpBmp);
	
	//把按钮下的背景拷贝过来
	TmpDC.BitBlt(0, 0, m_aniBtnWidth, m_aniBtnHeight, pDC, 0, 0, SRCCOPY);
	//把内存DC中的图像透明地画出来

	AlphaBlend(TmpDC.m_hDC, 0, 0, m_aniBtnWidth, m_aniBtnHeight, m_pMemDC->m_hDC,
		 nItem * m_aniBtnWidth, 0, m_aniBtnWidth, m_aniBtnHeight, m_bf);

	//填充异形图像以外的区域为mask色
	CRgn rgn;
	rgn.CreateRectRgn(0, 0, m_aniBtnWidth, m_aniBtnHeight);
	rgn.CombineRgn(&rgn, CRgn::FromHandle(m_arBmpRgn[nItem]), RGN_DIFF);
//	TRACE("CRgn::FromHandle(m_arBmpRgn[nItem]): %d\n", nItem);
	CBrush maskBrh;
	maskBrh.CreateSolidBrush(m_clrTrans);
	TmpDC.FillRgn(&rgn, &maskBrh);
//	TmpDC.FillRgn(CRgn::FromHandle(m_arBmpRgn[nItem]), &maskBrh);

	//抠除mask色,直接画出来
 	::TransparentBlt(pDC->m_hDC, 0, 0, m_aniBtnWidth, m_aniBtnHeight, TmpDC.m_hDC,
 		 0, 0, m_aniBtnWidth, m_aniBtnHeight, m_clrTrans);
// 	pDC->BitBlt(0, 0, m_aniBtnWidth, m_aniBtnHeight, &TmpDC, 0, 0, SRCCOPY);
// 	pDC->FillRgn(CRgn::FromHandle(m_arBmpRgn[nItem]), &maskBrh);

	ReleaseDC(pDC);
}
Beispiel #3
0
void CScoreView::SetupRgn(CDC *pDC,CSkinImage bImage,COLORREF TransColor)
{
	//bImage.GetWidth()/5;
	tagImageLoadInfo ImageIDB;
	bImage.GetLoadInfo(ImageIDB);
	CBitmap cBitmap;
	cBitmap.LoadBitmap(ImageIDB.uResourceID);//这个BITMAP是5倍长的,所以会有问题死机。
	CDC memDC;
	//创建与传入DC兼容的临时DC
	memDC.CreateCompatibleDC(pDC);

	CBitmap *pOldMemBmp=NULL;
	//将位图选入临时DC
	pOldMemBmp=memDC.SelectObject(&cBitmap);

	CRgn wndRgn;
	//创建总的窗体区域,初始region为0
	wndRgn.CreateRectRgn(0,0,0,0);


	BITMAP bit;   
	cBitmap.GetBitmap (&bit);//取得位图参数,这里要用到位图的长和宽     

	int y;
	for(y=0;y<=bit.bmHeight  ;y++)
	{
		CRgn rgnTemp; //保存临时region

		int iX = 0;
		do
		{
			//跳过透明色找到下一个非透明色的点.
			while (iX <= bit.bmWidth  && memDC.GetPixel(iX, y) == TransColor)
				iX++;

			//记住这个起始点
			int iLeftX = iX;

			//寻找下个透明色的点
			while (iX <= bit.bmWidth  && memDC.GetPixel(iX, y) != TransColor)
				++iX;

			//创建一个包含起点与重点间高为1像素的临时“region”
			rgnTemp.CreateRectRgn(iLeftX, y, iX, y+1);

			//合并到主"region".
			wndRgn.CombineRgn(&wndRgn, &rgnTemp, RGN_OR);

			//删除临时"region",否则下次创建时和出错
			rgnTemp.DeleteObject();
		}while(iX <bit.bmWidth );
		iX = 0;
	}
	if(pOldMemBmp)
		memDC.SelectObject(pOldMemBmp);
	CWnd * pWnd = pDC->GetWindow();
	pWnd->SetWindowRgn(wndRgn,TRUE);
	pWnd->SetForegroundWindow();   
} 
Beispiel #4
0
// CPhotoPubView 绘制
void CPhotoPubView::DrawImage(CDC *pDC,IplImage *pImg)
{
	int wid=0,hi=0;

	CRect ClipBox;
	GetClientRect(&ClipBox);
	if (!pImg) {
		CBitmap bkg;
		bkg.LoadBitmap(IDB_BACKGROUND);
		CBrush brush(&bkg);
		pDC->FillRect(&ClipBox,&brush);	
		return;
	}

	wid=int(pImg->width*m_ratio);
	hi=int(pImg->height*m_ratio);

	IplImage *pStub=pImg;
	IplImage *pTmp=NULL;
	if (wid!=pImg->width) {
		pTmp=cvCreateImage(cvSize(wid,hi),IPL_DEPTH_8U,3);
		cvResize(pImg,pTmp);
		pStub=pTmp;
	}
		

	CRgn WindowRgn;
	WindowRgn.CreateRectRgnIndirect(&ClipBox);
	CRect ImageRect(0,0,wid,hi);
	int top=max((ClipBox.Height()-hi)/2,0);
	int left=max((ClipBox.Width()-wid)/2,0);
	ImageRect.MoveToXY(left,top);
	CRgn ImageRgn;
	ImageRgn.CreateRectRgnIndirect(&ImageRect);
	WindowRgn.CombineRgn(&WindowRgn,&ImageRgn,RGN_DIFF);

	CBitmap bkg;
	bkg.LoadBitmap(IDB_BACKGROUND);
	CBrush brush(&bkg);
	pDC->FillRgn(&WindowRgn,&brush);	
	
	memset(m_bmih_buffer, 0, sizeof(*m_bmih_buffer));
    m_bmih_buffer->biSize = sizeof(BITMAPINFOHEADER);
    m_bmih_buffer->biWidth = wid;
    m_bmih_buffer->biHeight = -hi;
    m_bmih_buffer->biPlanes = 1;
    m_bmih_buffer->biBitCount = 24;
    m_bmih_buffer->biCompression = BI_RGB;


	SetDIBitsToDevice(
		pDC->m_hDC, 
		ImageRect.left,ImageRect.top,pStub->width,pStub->height, 
		0, 0, 0, hi, pStub->imageData, m_bmi_buffer, DIB_RGB_COLORS 
	);

	cvReleaseImage(&pTmp);

}
Beispiel #5
0
void CScoreView::SetupRgn(CDC *pDC,				//窗体的DC指针
						  CBitmap &cBitmap,		//含有窗体形状的位图对象
						  // CSkinImage skinImage,
						  COLORREF TransColor)	//透明色
{

	CDC memDC;
	//创建与传入DC兼容的临时DC
	memDC.CreateCompatibleDC(pDC);

	CBitmap *pOldMemBmp=NULL;
	//将位图选入临时DC
	pOldMemBmp=memDC.SelectObject(&cBitmap);

	CRgn wndRgn;
	//创建总的窗体区域,初始region为0
	wndRgn.CreateRectRgn(0,0,0,0);


	BITMAP bit;   
	cBitmap.GetBitmap (&bit);//取得位图参数,这里要用到位图的长和宽     

	int y;
	for(y=0;y<=bit.bmHeight  ;y++)
	{
		CRgn rgnTemp; //保存临时region

		int iX = 0;
		do
		{
			//跳过透明色找到下一个非透明色的点.
			while (iX <= bit.bmWidth  && memDC.GetPixel(iX, y) == TransColor)
				iX++;

			//记住这个起始点
			int iLeftX = iX;

			//寻找下个透明色的点
			while (iX <= bit.bmWidth  && memDC.GetPixel(iX, y) != TransColor)
				++iX;

			//创建一个包含起点与重点间高为1像素的临时“region”
			rgnTemp.CreateRectRgn(iLeftX, y, iX, y+1);

			//合并到主"region".
			wndRgn.CombineRgn(&wndRgn, &rgnTemp, RGN_OR);

			//删除临时"region",否则下次创建时和出错
			rgnTemp.DeleteObject();
		}while(iX <bit.bmWidth );
		iX = 0;
	}
	if(pOldMemBmp)
		memDC.SelectObject(pOldMemBmp);
	//HRGN wndRgn=skinImage.CreateImageRegion(RGB(255,0,255));
	CWnd * pWnd = pDC->GetWindow();
	pWnd->SetWindowRgn(wndRgn,TRUE);    
	pWnd->SetForegroundWindow();    
}
Beispiel #6
0
// Create the "4 corner" region surrounding cRect
void CFlashingWnd::MakeFixedRegion(CRgn &wndRgn, CRgn &rgnTemp, CRgn &rgnTemp2, CRgn &rgnTemp3)
{
	CRect rectWnd(0, 0, m_cRect.Width() + THICKNESS + THICKNESS, m_cRect.Height() + THICKNESS + THICKNESS);
	CRect rectTemp(THICKNESS, THICKNESS, m_cRect.Width() + THICKNESS + 1, m_cRect.Height() + THICKNESS + 1);
	CRect rectTemp2(0, SIDELEN2, m_cRect.Width() + THICKNESS + THICKNESS, m_cRect.Height() - SIDELEN + 1);
	CRect rectTemp3(SIDELEN2, 0, m_cRect.Width() - SIDELEN + 1, m_cRect.Height() + THICKNESS + THICKNESS);

	VERIFY(wndRgn.CreateRectRgnIndirect(rectWnd));
	VERIFY(rgnTemp.CreateRectRgnIndirect(rectTemp));
	VERIFY(rgnTemp2.CreateRectRgnIndirect(rectTemp2));
	VERIFY(rgnTemp3.CreateRectRgnIndirect(rectTemp3));

	VERIFY(ERROR != wndRgn.CombineRgn(&wndRgn, &rgnTemp, RGN_DIFF));
	VERIFY(ERROR != wndRgn.CombineRgn(&wndRgn, &rgnTemp2, RGN_DIFF));
	VERIFY(ERROR != wndRgn.CombineRgn(&wndRgn, &rgnTemp3, RGN_DIFF));

	VERIFY(ERROR != wndRgn.OffsetRgn(m_cRect.left - THICKNESS, m_cRect.top - THICKNESS));
}
void CMyBalloon::SetupWindowRgn()
{
	CRect rcWnd (0,0,0,0);
	
	CSize sizeReq = m_pContent->getRequiredSize ();
	
	rcWnd.right = sizeReq.cx;
	rcWnd.bottom = sizeReq.cy;

	rcWnd.InflateRect (3, 3);

	rcWnd.left += 3; rcWnd.right += 3;
	rcWnd.top  += 3; rcWnd.bottom += 3;

	int cxScreen = GetSystemMetrics (SM_CXSCREEN);
	int cyScreen = GetSystemMetrics (SM_CYSCREEN);
	
	m_bLeaderAtRight = false; m_bLeaderAtTop = false;
	if (m_ptAnchor.x + rcWnd.Width () > cxScreen)
		m_bLeaderAtRight = true;
	if (m_ptAnchor.y - rcWnd.Height () - CY_LEADER < 0)
		m_bLeaderAtTop = true;

	if (m_bLeaderAtTop)
	{
		rcWnd.top += CY_LEADER;
		rcWnd.bottom += CY_LEADER;
	}

	CPoint ptLeader [3];

	ptLeader[0].x = m_bLeaderAtRight ? rcWnd.Width () - CX_ROUNDED - CX_LEADER_MARGIN : 
	CX_ROUNDED + CX_LEADER_MARGIN;
	ptLeader[0].y = m_bLeaderAtTop ? rcWnd.top + CY_ROUNDED : rcWnd.Height() - CY_ROUNDED;
	
	ptLeader[1].x = ptLeader[0].x;
	ptLeader[1].y = m_bLeaderAtTop ? ptLeader[0].y - CY_ROUNDED - CY_LEADER : ptLeader[0].y + CY_ROUNDED + CY_LEADER;
	
	ptLeader[2].x = m_bLeaderAtRight ? ptLeader[0].x - CX_ROUNDED - CX_LEADER - CX_LEADER_MARGIN - 10 : 
		ptLeader[0].x + CX_ROUNDED + CX_LEADER + CX_LEADER_MARGIN + 10;
	ptLeader[2].y = m_bLeaderAtTop ? rcWnd.top + CY_ROUNDED + CY_LEADER : rcWnd.Height() - CY_ROUNDED - CY_LEADER;

	CRgn rgnLeader, rgnContent;

	rgnContent.CreateRoundRectRgn (rcWnd.left, rcWnd.top, rcWnd.right, rcWnd.bottom, CX_ROUNDED, CY_ROUNDED);
	rgnLeader.CreatePolygonRgn (ptLeader, 3, ALTERNATE);
	CRgn rgn; rgn.CreateRectRgn (0, 0, rcWnd.Width (), rcWnd.Height () + CY_LEADER);
	rgn.CombineRgn (&rgnContent, &rgnLeader, RGN_OR);

	SetWindowPos (CWnd::FromHandle (HWND_TOPMOST), 
		(m_bLeaderAtRight ? m_ptAnchor.x - rcWnd.Width () + CX_ROUNDED + CX_LEADER_MARGIN : m_ptAnchor.x - CX_ROUNDED - CX_LEADER_MARGIN),
		(m_bLeaderAtTop ? m_ptAnchor.y : m_ptAnchor.y - rcWnd.Height () - CY_LEADER), 
		rcWnd.Width (), rcWnd.Height () + CY_LEADER, 0);

	SetWindowRgn (rgn, FALSE);
}
Beispiel #8
0
BOOL CVisualManager::OnSetWindowRegion (CWnd* pWnd, CSize sizeWindow)
{
	ASSERT_VALID (pWnd);

	if (pWnd->GetSafeHwnd () == NULL)
	{
		return FALSE;
	}

	if (!CanDrawImage ())
	{
		return FALSE;
	}

	if (globalData.DwmIsCompositionEnabled ())
	{
		return FALSE;
	}

    CSize sz (0, 0);

	if (DYNAMIC_DOWNCAST (CBCGPFrameWnd, pWnd) != NULL)
	{
		if (pWnd->IsZoomed ())
		{
			pWnd->SetWindowRgn (NULL, TRUE);
			return TRUE;
		}

		sz  = CSize (9, 9);
	}

	if (sz != CSize (0, 0))
	{
        CRgn rgn;
		BOOL bCreated = FALSE;

		bCreated = rgn.CreateRoundRectRgn (0, 0, sizeWindow.cx + 1, sizeWindow.cy + 1, sz.cx, sz.cy);

		if (bCreated)
		{
			if (pWnd->IsKindOf (RUNTIME_CLASS (CMDIChildWnd)))
			{
				CRgn rgnWinodw;
				rgnWinodw.CreateRectRgn (0, sz.cy, sizeWindow.cx, sizeWindow.cy);

				rgn.CombineRgn (&rgn, &rgnWinodw, RGN_OR);
			}

			pWnd->SetWindowRgn ((HRGN)rgn.Detach (), TRUE);
			return TRUE;
		}
	}

	return FALSE;
}
HRGN CSkinWin::GetRegion(int w, int h)
{
    CWnd *pWnd = CWnd::FromHandle(m_hWnd);
    CRect wr;
    pWnd->GetWindowRect(wr);
	//SKIN_SHANG 右边框
	//wr.left+=m_BorderRightWidth;
    
    CRgn rgn;
    if ( m_bTrans )
    {
        CDC *pDC = pWnd->GetDC();
        CDC memDC;
        CMyBitmap bmp;
        CBitmap *obmp;
        memDC.CreateCompatibleDC(pDC);
        bmp.CreateCompatibleBitmap( pDC, w, m_TitleHeight );
        obmp = memDC.SelectObject(&bmp);
        /*
        memDC.FillSolidRect( 0, 0, w, h, 0 );
        DrawFrame( &memDC, 0, 0, w, h, 0 );
        */
        DrawTitle( &memDC, m_BorderLeftWidth , 0, 
                   wr.Width() - m_BorderRightWidth - m_BorderLeftWidth + 1, 0 );
        DrawLeft( &memDC, 0, 0, m_bmpLeft.Height(), 0 );
		//SKIN_SHANG 右边框
        DrawRight( &memDC, wr.Width() - m_BorderRightWidth , 0, m_bmpRight.Height(), 0 );
        
        memDC.SelectObject(obmp);

		//wyw
		memDC.DeleteDC();

        pWnd->ReleaseDC( pDC );

        rgn.CreateRectRgn( 0, m_TitleHeight, wr.Width(), wr.Height() );
        HRGN hrgn = bmp.CreateRgnFromFile( m_colTrans );
        CRgn newrgn;
        newrgn.CreateRectRgn( 0, m_TitleHeight, wr.Width(), wr.Height() );
        newrgn.CombineRgn( &rgn, CRgn::FromHandle(hrgn), RGN_XOR  );

		//wyw
		bmp.DeleteObject();
		DeleteObject(hrgn);
		rgn.DeleteObject();
        
        return (HRGN)newrgn.Detach();
    }
    else
        rgn.CreateRectRgn( 0, 0, wr.Width(), wr.Height() );
        
    
    return (HRGN)rgn.Detach();
}
Beispiel #10
0
void COXTabViewContainer::OnPaint() 
{
	CPaintDC dc(this); // device context for painting
	
	// TODO: Add your message handler code here

	CWnd* pWnd=GetActivePage();
	if(pWnd!=NULL)
	{
		CRect rect;
		pWnd->GetWindowRect(rect);
		ScreenToClient(rect);
		if(m_rectPage!=rect && !rect.IsRectEmpty())
		{
			CRgn rgnInTheory;
			CRgn rgnInReality;
			if(rgnInTheory.CreateRectRgnIndirect(m_rectPage) &&
				rgnInReality.CreateRectRgnIndirect(rect))
			{
				if(rgnInTheory.CombineRgn(&rgnInTheory,&rgnInReality,
					RGN_DIFF)!=ERROR)
				{
					CBrush* pBrush=NULL;
					CBrush brush;
					HBRUSH hBrush=(HBRUSH)(INT_PTR)::GetClassLongPtr(pWnd->m_hWnd,
						GCL_HBRBACKGROUND);
					if(hBrush==NULL)
					{
						if(brush.CreateSolidBrush(::GetSysColor(COLOR_WINDOW)))
							pBrush=&brush;
						else
							pBrush=dc.GetCurrentBrush();
					}
					else
					{
						pBrush=CBrush::FromHandle(hBrush);
					}
					
					if(pBrush!=NULL)
						dc.FillRgn(&rgnInTheory,pBrush);
				}
			}
		}
	}

	DrawScrollButtons(&dc);
	DrawSplitter(&dc);
	DrawSizeBar(&dc);
	DrawTabBtnArea(&dc);

	// Do not call CWnd::OnPaint() for painting messages
}
Beispiel #11
0
void CBmpButton::SetWndRng()
{
	if (NULL == m_pBmpUncheckedNormal) return;

	CRect rcDlgRect;
	GetWindowRect(rcDlgRect);

	BITMAP BmpInfo;
	m_pBmpUncheckedNormal->GetBitmap(&BmpInfo);

	MoveWindow(rcDlgRect.left, rcDlgRect.top, BmpInfo.bmWidth, BmpInfo.bmHeight);

	const int iBitWidth = BmpInfo.bmBitsPixel / 8;
	
	if(iBitWidth == 4)
	{
		//有alpha通道,则裁窗口形状

		CRgn rgn;
		rgn.CreateRectRgn(0, 0, BmpInfo.bmWidth, BmpInfo.bmHeight);

		int iBitSize = BmpInfo.bmWidth * BmpInfo.bmHeight * iBitWidth;
		BYTE *pBits = new BYTE[iBitSize];

		m_pBmpUncheckedNormal->GetBitmapBits(iBitSize, pBits);

		for (int y = 0; y < BmpInfo.bmHeight; y++)
		{
			int iRow = y * BmpInfo.bmWidth;

			for (int x = 0; x < BmpInfo.bmWidth; x++)
			{
				int iPos = (iRow + x) * iBitWidth;

				if (pBits[iPos + 3] == 0)//检测alpha是否为透明
				{
					CRgn rgnCut;
					rgnCut.CreateRectRgn(x, y, x+1, y+1);

					rgn.CombineRgn(&rgn, &rgnCut, RGN_XOR);
				}
			}
		}
		
		SetWindowRgn(rgn, FALSE);

		delete []pBits;
	}
}
Beispiel #12
0
bool ASSISTANT::Oval::ContainsPoint(Gdiplus::PointF &ptMouse)
{
   if (!visible)
      return false; 

   CRect rcObject;
   GetBoundingBox(rcObject);

   CRgn rgnElliptic;

   double dMaxDistance = (double)lineWidth / 2 + 0.5;
   BOOL bRet = TRUE;
   if (IsFilled())
   {
      CRgn rgnElliptic;
      bRet = rgnElliptic.CreateEllipticRgnIndirect(rcObject);
      
      if (!bRet)
         return false;
      if (rgnElliptic.PtInRegion((int)ptMouse.X, (int)ptMouse.Y))
         return true;
      
   }
   else
   {
      CRect rcOutside = rcObject;
      rcOutside.InflateRect(dMaxDistance, dMaxDistance, dMaxDistance, dMaxDistance);
      bRet = rgnElliptic.CreateEllipticRgnIndirect(rcOutside);
      if (!bRet)
         return false;

      CRgn rgnElliptic2;
      CRect rcInside = rcObject;
      rcInside.DeflateRect(dMaxDistance, dMaxDistance, dMaxDistance, dMaxDistance);
      bRet = rgnElliptic2.CreateEllipticRgnIndirect(rcInside);
      if (!bRet)
         return false;

      rgnElliptic.CombineRgn(&rgnElliptic, &rgnElliptic2, RGN_DIFF);
      if (rgnElliptic.PtInRegion((int)ptMouse.X, (int)ptMouse.Y))
         return true;

   }

   return false;
}
void CBCGPSDPlaceMarkerWnd::ShowTabbedAt (CRect rect, CRect rectTab)
{
    if (!m_bTabbed || m_rectLast != rect || m_rectTab != rectTab)
    {
        Hide ();

        CRgn rgnMain;
        CBCGPTabbedControlBar::m_bTabsAlwaysTop ? 
			rgnMain.CreateRectRgn (0, rectTab.Height (), rect.Width(), rect.Height() + rectTab.Height ()) :
			rgnMain.CreateRectRgn (0, 0, rect.Width(), rect.Height());

        CRgn rgnTab;
        if (CBCGPTabbedControlBar::m_bTabsAlwaysTop)
		{
			rgnTab.CreateRectRgn (rectTab.left, 0, rectTab.Width (), rectTab.Height ());
		}
		else
		{
			rgnTab.CreateRectRgnIndirect (rectTab);
		}

        rgnMain.CombineRgn (&rgnMain, &rgnTab, RGN_OR);
        SetWindowRgn (rgnMain, FALSE);

        m_bTabbed = TRUE;

        m_rectLast = rect;
		m_rectTab = rectTab;

		if (CBCGPTabbedControlBar::m_bTabsAlwaysTop)
		{
			SetWindowPos (&CWnd::wndTop, rect.left, rectTab.top, 
				rect.Width(), rect.Height() + m_rectTab.Height (),
				SWP_NOACTIVATE | SWP_SHOWWINDOW | SWP_NOREDRAW);
		}
		else
		{
			SetWindowPos (&CWnd::wndTop, rect.left, rect.top, 
				rect.Width(), rect.Height() + m_rectTab.Height (),
				SWP_NOACTIVATE | SWP_SHOWWINDOW | SWP_NOREDRAW);
		}
		m_bShown = TRUE;
        RedrawWindow ();
    }
}
// --------------------------------------------------------------------------
void CToolTipWnd::OnPaint() 
{
   CPaintDC dc( this ); // device context for painting
   
   CRect rectCl;
   GetClientRect( &rectCl );
   
   CRgn rgnComb;	
   rgnComb.CreateRectRgn( rectCl.left+10,rectCl.top,rectCl.right,rectCl.bottom );
   
   int iRetComb = rgnComb.CombineRgn( &m_rgnTri, &m_rgn, RGN_OR );
   if ( iRetComb == ERROR )
   {
      AfxMessageBox( (LPCTSTR)"ERROR in Combining Region" );
      return;
   }
   
   CBrush pBrush;
   pBrush.CreateSolidBrush( m_clrFrameColor );
   
   CBrush pBrush1;
   pBrush1.CreateSolidBrush( m_clrBkColor );
   
   dc.FillRgn( &rgnComb, &pBrush1 );
   dc.FrameRgn( &rgnComb, &pBrush, 2, 1 );
   
   dc.SetBkMode( TRANSPARENT );
   dc.SetTextColor( m_clrTextColor );
   
   CFont *pFont = dc.SelectObject( &m_strTextFont );
   
   CSize czTextWidth = dc.GetTextExtent( m_strText );
   
   if ( czTextWidth.cx < m_rectText.Width() )
      dc.DrawText( m_strText, m_rectText, DT_CENTER | DT_VCENTER | DT_SINGLELINE );
   else
      dc.DrawText( m_strText, m_rectText, DT_CENTER | DT_WORDBREAK );

   dc.SelectObject( pFont );
}
Beispiel #15
0
void CDrawCommon::GetRegionFromImage(CRgn& rgn, CBitmap &cBitmap, int threshold)
{
	CDC memDC;

	memDC.CreateCompatibleDC(NULL);
	CBitmap *pOldMemBmp = NULL;
	pOldMemBmp = memDC.SelectObject(&cBitmap);

	//创建总的窗体区域,初始region为0
	rgn.CreateRectRgn(0, 0, 0, 0);

	BITMAP bit;
	cBitmap.GetBitmap(&bit);//取得位图参数,这里要用到位图的长和宽
	int y;
	for (y = 0; y<bit.bmHeight; y++)
	{
		CRgn rgnTemp; //保存临时region
		int iX = 0;
		do
		{
			//跳过透明色找到下一个非透明色的点.
			while (iX < bit.bmWidth && GetColorBritness(memDC.GetPixel(iX, y)) <= threshold)
				iX++;
			int iLeftX = iX; //记住这个起始点

							 //寻找下个透明色的点
			while (iX < bit.bmWidth && GetColorBritness(memDC.GetPixel(iX, y)) > threshold)
				++iX;

			//创建一个包含起点与重点间高为1像素的临时“region”
			rgnTemp.CreateRectRgn(iLeftX, y, iX, y + 1);
			rgn.CombineRgn(&rgn, &rgnTemp, RGN_OR);

			//删除临时"region",否则下次创建时和出错
			rgnTemp.DeleteObject();
		} while (iX < bit.bmWidth);
	}
}
Beispiel #16
0
// @pymethod int|PyCRgn|CombineRgn|Creates a new GDI region by combining two existing regions. The regions are combined as specified by nCombineMode
// Return Values: success or failure flag (BOOL)
PyObject *
PyCRgn::combine_rgn(PyObject *self, PyObject *args)
	{
	CRgn *pRgn = PyCRgn::GetRgn(self);
	if (!pRgn) return NULL;

	PyObject *objRgn1 = Py_None;
	PyObject *objRgn2 = Py_None;
	int nCombineMode=RGN_AND;

	if (!PyArg_ParseTuple(args,"OOi:CombineRgn",
			&objRgn1,&objRgn2,&nCombineMode))
		return NULL;

	CRgn *pRgn1 = PyCRgn::GetRgn(objRgn1);
	if (!pRgn1) return NULL;
	CRgn *pRgn2 = PyCRgn::GetRgn(objRgn2);
	if (!pRgn2) return NULL;

	int result=pRgn->CombineRgn(pRgn1,pRgn2,nCombineMode);

	return Py_BuildValue("i",result);
	}
//************************************************************************************
void CBCGPRadialMenu::SetRgn()
{
	if (m_pRadialMenuObject != NULL)
	{
		CRect rect;
		GetClientRect(rect);

		int cx = rect.Width();
		int cy = rect.Height();

		CRgn rgn;
		rgn.CreateEllipticRgn(0, 0, cx, cy);

		if (!m_pRadialMenuObject->m_bHasCenterButton)
		{
			double rx = INTERNAL_PART * cx;
			double ry = INTERNAL_PART * cy;

			int x1 = (int)(.5 + .5 * cx - rx);
			int x2 = (int)(.5 + .5 * cx + rx);
			int y1 = (int)(.5 +.5 * cy - ry);
			int y2 = (int)(.5 + .5 * cy + ry);

			CRgn rgnCenter;
			rgnCenter.CreateEllipticRgn(x1, y1, x2, y2);

			rgn.CombineRgn(&rgn, &rgnCenter, RGN_XOR);
		}

		SetWindowRgn(rgn, FALSE);
	}
	else
	{
		SetWindowRgn(NULL, FALSE);
	}
}
Beispiel #18
0
void CTTCheckBtnGroup::OnPaint()
{
	CPaintDC dc(this); 

	CRect clientRect;
	GetClientRect(clientRect);

	if (clientRect.Width() <= 0 || clientRect.Height() <= 0)
		return;

	CMemDC memDC(dc, clientRect);

	CDC* pDC = &memDC.GetDC();

	DrawThemeParentBackground(GetSafeHwnd(), memDC.GetDC().GetSafeHdc(), clientRect);

	Graphics graphics(pDC->GetSafeHdc());
	graphics.SetSmoothingMode(SmoothingModeAntiAlias);
	graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);
	graphics.SetTextRenderingHint(TextRenderingHintSingleBitPerPixel);

	// clear background
	CRgn bkgndRgn;
	CRect bkgndRect(clientRect);
	bkgndRect.left += 1;
	bkgndRect.top += 1;
	CreateRectRgnInDevicePoints(pDC, &bkgndRgn, bkgndRect, m_CornerRadius);
	pDC->SelectClipRgn(&bkgndRgn);

	pDC->FillSolidRect(&clientRect, RGB(255, 255, 255));

	CRgn clientRgn;
	CreateRectRgnInDevicePoints(pDC, &clientRgn, clientRect);
	pDC->SelectClipRgn(&clientRgn);

	// Whole border
	Gdiplus::Rect borderRect(clientRect.left, clientRect.top, clientRect.Width(), clientRect.Height());
	borderRect.Inflate(-1, -1);

	if (m_Buttons.size() == 0)
	{
		COLORREF borderColor = m_ColorMap.GetColor(Normal, Border);
		DrawRectArea(borderRect, graphics, borderColor, m_CornerRadius, m_BorderPenWidth);
	}

	for (int btnId = 0; btnId < m_Buttons.size(); ++btnId)
	{
		BtnInfo* pBtnInfo = &m_Buttons[btnId];

		CRgn btnRgn;
		CRect t(pBtnInfo->m_rect);
		t.right += 1; t.bottom += 1;
		CreateRectRgnInDevicePoints(pDC, &btnRgn, t);
		btnRgn.CombineRgn(&btnRgn, &bkgndRgn, RGN_AND);
		pDC->SelectClipRgn(&btnRgn);
		
		ControlState buttonState = GetButtonState(pBtnInfo);

		// Highlight
		if (buttonState != Press)		
			pDC->FillSolidRect(pBtnInfo->m_rect, m_ColorMap.GetColor(buttonState, BorderLight));

		// Border
		graphics.SetClip(btnRgn);
		COLORREF borderColor = m_ColorMap.GetColor(buttonState, Border);
		DrawRectArea(borderRect, graphics, borderColor, m_CornerRadius, m_BorderPenWidth);
		graphics.ResetClip();

		CRgn offsetRgn1;
		offsetRgn1.CreateRectRgn(0, 0, 0, 0);
		offsetRgn1.CopyRgn(&btnRgn);
		offsetRgn1.OffsetRgn(m_BorderPenWidth + 1, m_BorderPenWidth + 1);

		CRgn offsetRgn2;
		offsetRgn2.CreateRectRgn(0, 0, 0, 0);
		offsetRgn2.CopyRgn(&btnRgn);
		offsetRgn2.OffsetRgn(-(m_BorderPenWidth + 1), -(m_BorderPenWidth + 1));

		CRgn backRgn;
		backRgn.CreateRectRgn(0, 0, 0, 0);
		backRgn.CombineRgn(&offsetRgn1, &offsetRgn2, RGN_AND);
		pDC->SelectClipRgn(&backRgn);

		if (buttonState != Mouseover)
		{
			DrawGradient(pDC, t);
			/*Draw4ColorsGradientRect(t, *pDC,
				m_ColorMap.GetColor(buttonState, BackgroundTopGradientStart),
				m_ColorMap.GetColor(buttonState, BackgroundTopGradientFinish),
				m_ColorMap.GetColor(buttonState, BackgroundBottomGradientStart),
				m_ColorMap.GetColor(buttonState, BackgroundBottomGradientFinish),
				m_CornerRadius, TRUE);*/
		}

		COLORREF textColor = RGB(80,80,80);//COLOR_GRAYTEXT;//COLOR_BTNTEXT;
		/*if (buttonState == Press)
			textColor = RGB(0, 122, 224);*/

		pDC->SelectClipRgn(&btnRgn);
		CFont* pFont = GetFont();
		
		int nFormat = DT_CENTER | DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS;
		CTTButton::DrawCaptionText(pDC, &pBtnInfo->m_rect, &pBtnInfo->m_rect, pBtnInfo->m_text, nFormat, pFont, textColor);
	}

	pDC->SelectClipRgn(&clientRgn);
	for (int btnId = 1; btnId < m_Buttons.size(); ++btnId)
	{
		BtnInfo* pPrevBtnInfo = &m_Buttons[btnId - 1];
		BtnInfo* pCurBtnInfo = &m_Buttons[btnId];

		ControlState prevBtnState = GetButtonState(pPrevBtnInfo);
		ControlState curBtnState = GetButtonState(pCurBtnInfo);

		ControlState state = Normal;
		if (prevBtnState == Press || curBtnState == Press)
			state = Press;
		else if (prevBtnState == Mouseover || curBtnState == Mouseover)
			state = Mouseover;

		COLORREF borderColor = m_ColorMap.GetColor(state, Border);

		CPen borderPen(PS_SOLID, m_BorderPenWidth, borderColor);
		pDC->SelectObject(borderPen);

		pDC->MoveTo(pPrevBtnInfo->m_rect.right, pPrevBtnInfo->m_rect.top);
		pDC->LineTo(pPrevBtnInfo->m_rect.right, pPrevBtnInfo->m_rect.bottom);
	}
}
void CImconView::OnDraw(CDC* pDC)
{
	CImconDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	// TODO: add draw code for native data here
  if (pDC->IsPrinting())
    {  // Print image
     pDC->SetMapMode(MM_TWIPS);
     pDoc->m_Dib.Stretch(pDC->m_hDC, pDoc->m_hPal,
                         pDoc->m_uLeftMargin, - (int) pDoc->m_uTopMargin,
                         pDoc->m_uHorzPrintSize, - (int) pDoc->m_uVertPrintSize);
    }
   else
    {  // Draw image on screen
     // Draw background
     RECT Rect;
     CBrush Brush;
     Brush.CreateHatchBrush(HS_BDIAGONAL, RGB(192, 192, 192));
     GetClientRect(&Rect);
     Rect.right  = max(Rect.right,  (int) pDoc->m_uWidth);
     Rect.bottom = max(Rect.bottom, (int) pDoc->m_uHeight);
     CPoint ptScrollPos = GetScrollPosition();
     pDC->SetBrushOrg(-ptScrollPos.x, -ptScrollPos.y);
     CRgn rgnImage;
     CRgn rgnWindow;
     rgnImage.CreateRectRgn(0, 0, pDoc->m_uWidth, pDoc->m_uHeight);
     rgnWindow.CreateRectRgnIndirect(&Rect);
     rgnWindow.CombineRgn(&rgnWindow, &rgnImage, RGN_DIFF);
     pDC->FillRgn(&rgnWindow, &Brush);
//     pDC->FillRect(&Rect, &Brush);

     // Draw image
     HPALETTE hPal;
     CPalette *pOldPal = NULL;
     if (m_bActive)
       hPal = pDoc->m_hPal;
      else
       {
        hPal = NULL;
        CPalette *pPal = CPalette::FromHandle(pDoc->m_hPal);
        pOldPal = pDC->SelectPalette(pPal, TRUE);
        pDC->RealizePalette();
       }

     RECT rcClientArea;
     GetClientRect(&rcClientArea);
     if (m_bScaleToWindow)
       if (m_bUseDib)
         pDoc->m_Dib.Stretch(pDC->m_hDC, hPal, 0, 0,
                             rcClientArea.right - rcClientArea.left,
                             rcClientArea.bottom - rcClientArea.top);
        else
         pDoc->m_Ddb.Stretch(pDC->m_hDC, hPal, 0, 0,
                             rcClientArea.right - rcClientArea.left,
                             rcClientArea.bottom - rcClientArea.top);
      else
       if (m_bUseDib)
         pDoc->m_Dib.Draw(pDC->m_hDC, hPal, 0, 0);
        else
         pDoc->m_Ddb.Draw(pDC->m_hDC, hPal, 0, 0);

     if (pOldPal)
       pDC->SelectPalette(pOldPal, FALSE);

     // Draw selection
     if (m_bSelection)
       {
        LPRECT lpRect = &m_rectSelection;
        pDC->PatBlt(lpRect->left, lpRect->top,
                    lpRect->right - lpRect->left, 1,
                    DSTINVERT);
        pDC->PatBlt(lpRect->left, lpRect->bottom,
                    1, -(lpRect->bottom - lpRect->top),
                    DSTINVERT);
        pDC->PatBlt(lpRect->right - 1, lpRect->top,
                    1, lpRect->bottom - lpRect->top,
                    DSTINVERT);
        pDC->PatBlt(lpRect->right, lpRect->bottom - 1,
                    -(lpRect->right - lpRect->left), 1,
                    DSTINVERT);
       }
    }
}
Beispiel #20
0
void CDC::DrawDragRect(LPCRECT lpRect, SIZE size,
	LPCRECT lpRectLast, SIZE sizeLast, CBrush* pBrush, CBrush* pBrushLast)
{
	ASSERT(AfxIsValidAddress(lpRect, sizeof(RECT), FALSE));
	ASSERT(lpRectLast == NULL ||
		AfxIsValidAddress(lpRectLast, sizeof(RECT), FALSE));

	// first, determine the update region and select it
	CRgn rgnNew;
	CRgn rgnOutside, rgnInside;
	rgnOutside.CreateRectRgnIndirect(lpRect);
	CRect rect = *lpRect;
	rect.InflateRect(-size.cx, -size.cy);
	rect.IntersectRect(rect, lpRect);
	rgnInside.CreateRectRgnIndirect(rect);
	rgnNew.CreateRectRgn(0, 0, 0, 0);
	rgnNew.CombineRgn(&rgnOutside, &rgnInside, RGN_XOR);

	CBrush* pBrushOld = NULL;
	if (pBrush == NULL)
		pBrush = CDC::GetHalftoneBrush();
	if (pBrushLast == NULL)
		pBrushLast = pBrush;

	CRgn rgnLast, rgnUpdate;
	if (lpRectLast != NULL)
	{
		// find difference between new region and old region
		rgnLast.CreateRectRgn(0, 0, 0, 0);
		rgnOutside.SetRectRgn(lpRectLast);
		rect = *lpRectLast;
		rect.InflateRect(-sizeLast.cx, -sizeLast.cy);
		rect.IntersectRect(rect, lpRectLast);
		rgnInside.SetRectRgn(rect);
		rgnLast.CombineRgn(&rgnOutside, &rgnInside, RGN_XOR);

		// only diff them if brushes are the same
		if (pBrush->m_hObject == pBrushLast->m_hObject)
		{
			rgnUpdate.CreateRectRgn(0, 0, 0, 0);
			rgnUpdate.CombineRgn(&rgnLast, &rgnNew, RGN_XOR);
		}
	}
	if (pBrush->m_hObject != pBrushLast->m_hObject && lpRectLast != NULL)
	{
		// brushes are different -- erase old region first
		SelectClipRgn(&rgnLast);
		GetClipBox(&rect);
		pBrushOld = SelectObject(pBrushLast);
		PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), PATINVERT);
		SelectObject(pBrushOld);
		pBrushOld = NULL;
	}

	// draw into the update/new region
	SelectClipRgn(rgnUpdate.m_hObject != NULL ? &rgnUpdate : &rgnNew);
	GetClipBox(&rect);
	pBrushOld = SelectObject(pBrush);
	PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), PATINVERT);

	// cleanup DC
	if (pBrushOld != NULL)
		SelectObject(pBrushOld);
	SelectClipRgn(NULL);
}
Beispiel #21
0
STDMETHODIMP CMyCom1::DrawOffset(unsigned long m_pDC, unsigned long m_pOffset, double m_Scale, unsigned long m_pGraphInfo, BOOL scale_flag, BOOL m_active_flag)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())

	// TODO: Add your implementation code here
	CClientDC * pDC = (CClientDC*) m_pDC;
	GraphInfo * pGraphInfo;

	//设置
	if ( m_pGraphInfo != NULL )
	{
		pGraphInfo = (GraphInfo*)m_pGraphInfo;
		m_GraphInfo.SetGraphInfo(*pGraphInfo);
	}
	else
		pGraphInfo = &m_GraphInfo;
	
		
	//计算偏移量
	if ( m_pOffset != NULL )
	{
		CPoint * offset = (CPoint *)m_pOffset;
		OffsetRgn((unsigned long)offset);
	}

	//设置激活标志
	isActive = m_active_flag;

	double scale = 0;
	m_scale_flag = scale_flag;
	if ( m_scale_flag )
		scale = m_Scale;
	else
		scale = 1;

	CFont * sysFont = pDC->SelectObject(&(pGraphInfo->font));
	CPen * pen = new CPen( pGraphInfo->normal_penStyle, pGraphInfo->normal_linewidth, pGraphInfo->normal_linecolor );	//构造画笔
	CPen * sysPen = pDC->SelectObject(pen);
	CBrush * normalBrush = new CBrush( pGraphInfo->normal_regioncolor );	//普通显示的画刷
	CBrush * activeBrush = new CBrush( pGraphInfo->active_regioncolor );	//激活后的画刷
	CBrush * blackBrush = new CBrush( BLACKBRUSHCOLOR );
	
	CRgn outRgn;
	outRgn.CreateRectRgn(0, 0, 5, 5);
	CRect smallRect;
	
	//判断是否激活了,如果激活,添加outRect
	if ( isActive )	//激活
	{
		if ( m_scale_flag )	//如果是在modelview区域
		{
			//选中后,在外边画一个方框
			outRgn.CombineRgn(&upRgn, &downRgn, RGN_OR);
			outRgn.GetRgnBox(&outRect);
			outRect.InflateRect(5, 5);
			
			pDC->MoveTo(outRect.left, outRect.top);
			pDC->LineTo(outRect.right, outRect.top);
			pDC->LineTo(outRect.right, outRect.bottom);
			pDC->LineTo(outRect.left, outRect.bottom);
			pDC->LineTo(outRect.left, outRect.top);

			//画出upRgn, downRgn, 和连线
			//pDC->FillRgn(&upRgn, normalBrush);
			CRect upRect;
			upRgn.GetRgnBox(upRect);
			pDC->Rectangle(upRect);
			pDC->MoveTo(upPoints[2]);
			pDC->LineTo(upPoints[5]);

			pDC->MoveTo(topPoint);
			pDC->LineTo(bottomPoint);
			pDC->MoveTo(leftPoint);
			pDC->LineTo(rightPoint);
			pDC->FillRgn(&downRgn, normalBrush);

			inRect.SetRect(upPoints[0].x, upPoints[0].y, upPoints[2].x, upPoints[2].y);
			pDC->SetTextColor(pGraphInfo->textcolor);
			pDC->DrawText(m_name, inRect, TEXTOUTFOMAT);	//|DT_END_ELLIPSIS);
						
			//在矩形的角上,画四个小矩形,5*5象素
			smallRect.SetRect(outRect.left, outRect.top, outRect.left+5, outRect.top+5);
			pDC->FillRect(smallRect, blackBrush);
			smallRect.SetRect(outRect.right-5, outRect.top, outRect.right, outRect.top+5);
			pDC->FillRect(smallRect, blackBrush);
			smallRect.SetRect(outRect.right-5, outRect.bottom-5, outRect.right, outRect.bottom);
			pDC->FillRect(smallRect, blackBrush);
			smallRect.SetRect(outRect.left, outRect.bottom-5, outRect.left+5, outRect.bottom);
			pDC->FillRect(smallRect, blackBrush);
		}
		else	//如果是在comview区域
		{
			//选中后,在外边画一个方框
			downRgn.GetRgnBox(&outRect);
			outRect.InflateRect(5, 5);

			pDC->MoveTo(outRect.left, outRect.top);
			pDC->LineTo(outRect.right, outRect.top);
			pDC->LineTo(outRect.right, outRect.bottom);
			pDC->LineTo(outRect.left, outRect.bottom);
			pDC->LineTo(outRect.left, outRect.top);

			//画出downRgn
			pDC->FillRgn(&downRgn, normalBrush);

			//在矩形的角上,画四个小矩形,5*5象素
			smallRect.SetRect(outRect.left, outRect.top, outRect.left+5, outRect.top+5);
			pDC->FillRect(smallRect, blackBrush);
			smallRect.SetRect(outRect.right-5, outRect.top, outRect.right, outRect.top+5);
			pDC->FillRect(smallRect, blackBrush);
			smallRect.SetRect(outRect.right-5, outRect.bottom-5, outRect.right, outRect.bottom);
			pDC->FillRect(smallRect, blackBrush);
			smallRect.SetRect(outRect.left, outRect.bottom-5, outRect.left+5, outRect.bottom);
			pDC->FillRect(smallRect, blackBrush);
		}
	}
	else	//未激活
	{
		if ( m_scale_flag )	//如果是在modelview区域
		{
			//画出upRgn, downRgn, 和连线
			//pDC->FillRgn(&upRgn, normalBrush);
			CRect upRect;
			upRgn.GetRgnBox(upRect);
			pDC->Rectangle(upRect);
			pDC->MoveTo(upPoints[2]);
			pDC->LineTo(upPoints[5]);

			pDC->MoveTo(topPoint);
			pDC->LineTo(bottomPoint);
			pDC->MoveTo(leftPoint);
			pDC->LineTo(rightPoint);
			pDC->FillRgn(&downRgn, normalBrush);

			inRect.SetRect(upPoints[0].x, upPoints[0].y, upPoints[2].x, upPoints[2].y);
			pDC->SetTextColor(pGraphInfo->textcolor);
			pDC->DrawText(m_name, inRect, TEXTOUTFOMAT);	//|DT_END_ELLIPSIS);
		}
		else	//如果是在comview区域
		{
			//画出downRgn
			pDC->FillRgn(&downRgn, normalBrush);
		}
	}

		//释放
	pDC->SelectObject(sysFont);
	pDC->SelectObject(sysPen);
	
	delete(pen);
	delete(normalBrush);
	delete(activeBrush);
	delete(blackBrush);
	
	return S_OK;
}
Beispiel #22
0
void CControlResizer::DoReSize(int incrX, int incrY)
{
	INT_PTR arrayCount  = m_ResizePropArray.GetCount();
	CRgn updateRgn;
	updateRgn.CreateRectRgn(0, 0, 0, 0);
	bool bIsEmptyUpdateRgn(true);
	for (INT_PTR i = 0; i < arrayCount; i++) {
		const ResizeProp &rszProp(m_ResizePropArray.GetAt(i));
		if (IsHidden(rszProp.controlID)) continue;
		if (rszProp.uFlags & RSZF_NO_RESIZE) continue;
		RECT controlRect;
		CWnd *pControlWnd = m_pDialog->GetDlgItem(rszProp.controlID);
		pControlWnd->GetWindowRect(&controlRect);
		MapWindowPoints(NULL, m_pDialog->m_hWnd, (LPPOINT)&controlRect, 2);
		CRgn srcRgn;
		if (rszProp.uFlags & RSZF_RESIZE_UPDATE) {
			srcRgn.CreateRectRgn(controlRect.left, controlRect.top, controlRect.right, controlRect.bottom);
		}
		int widht = controlRect.right - controlRect.left;
		int height = controlRect.bottom - controlRect.top;
		int cx = incrX;
		int cy = incrY;
		if (rszProp.uFlags & RSZF_RESIZE_OPPOSITE) {
			cx = -cx;
			cy = -cy;
		}
		if (cx) {
			if (rszProp.uFlags & RSZF_SIZEX_FIXED) {
				OffsetRect(&controlRect, cx, 0);
			}
			else if (rszProp.uFlags & RSZF_RIGHT_FIXED) {
				controlRect.left = controlRect.right - widht - cx;
			}
			else if (rszProp.uFlags & RSZF_LEFT_FIXED) {
				controlRect.right = controlRect.left + widht + cx;
			}
		}
		if (cy) {
			if (rszProp.uFlags & RSZF_SIZEY_FIXED) {
				OffsetRect(&controlRect, 0, cy);
			}
			else if (rszProp.uFlags & RSZF_BOTTOM_FIXED) {
				controlRect.top = controlRect.bottom - height - cy;
			}
			else if (rszProp.uFlags & RSZF_TOP_FIXED) {
				controlRect.bottom = controlRect.top + height + cy;
			}
		}
		if (rszProp.uFlags & RSZF_RESIZE_UPDATE) {
			CRgn dst;
			dst.CreateRectRgn(controlRect.left, controlRect.top, controlRect.right, controlRect.bottom);
			updateRgn.CombineRgn(&srcRgn, &dst, RGN_OR);
			bIsEmptyUpdateRgn = false;
		}
		widht = controlRect.right - controlRect.left;
		height = controlRect.bottom - controlRect.top;
		pControlWnd->SetWindowPos(NULL, controlRect.left, controlRect.top, widht, height, SWP_NOZORDER);
	}
	if (!bIsEmptyUpdateRgn) {
		m_pDialog->InvalidateRgn(&updateRgn);
		m_pDialog->UpdateWindow();
	}
}
LRESULT CRegionSelect::OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
{
	PAINTSTRUCT ps;
	BeginPaint(&ps);

	HDC dc = ps.hdc;

	int w = ps.rcPaint.right-ps.rcPaint.left;
	int h = ps.rcPaint.bottom-ps.rcPaint.top;

	if(m_bPictureChanged)
	{
		if(Down) return 0;
		RECT rc;
		GetClientRect(&rc);
		CRgn newRegion;
		newRegion.CreateRectRgn(0,0,rc.right,rc.bottom);
		SelectClipRgn(doubleDC, newRegion);
		BitBlt(doubleDC,ps.rcPaint.left,ps.rcPaint.top,w,h,memDC2,  ps.rcPaint.left,ps.rcPaint.top,SRCCOPY);
		newRegion.CombineRgn(m_SelectionRegion,RGN_DIFF);
		CBrush br;
		SelectClipRgn(doubleDC, newRegion);
		br.CreateSolidBrush(RGB(200,200,0));
		BLENDFUNCTION bf ;
		//настройки прозрачности
		bf.BlendOp = AC_SRC_OVER;
		bf.BlendFlags = 1;
		bf.SourceConstantAlpha = 40; // прозрачность 50% (0 - 255)
		bf.AlphaFormat = 0;///*0 */ /*AC_SRC_ALPHA*/0;
		
		if(RectCount) 
			if(AlphaBlend(doubleDC, ps.rcPaint.left, ps.rcPaint.top, w,h, alphaDC, ps.rcPaint.left, ps.rcPaint.top, w,h, bf)==FALSE)
			{
				//MessageBox(_T("Alphablend failed"));
			};
		newRegion.DeleteObject();
		newRegion.CreateRectRgn(0,0,rc.right,rc.bottom);
		SelectClipRgn(doubleDC, newRegion);
		RECT SelWndRect;
		if(hSelWnd)
		{
			CRgn WindowRgn = GetWindowVisibleRegion(hSelWnd);
			WindowRgn.OffsetRgn(topLeft);
			WindowRgn.GetRgnBox(&SelWndRect);
			CRect DrawingRect = SelWndRect;
			DrawingRect.DeflateRect(2, 2);
			SelectObject(doubleDC, pen);
			SetROP2(doubleDC, R2_NOTXORPEN);
			SelectClipRgn(doubleDC, 0);
			Rectangle(doubleDC, DrawingRect.left,DrawingRect.top, DrawingRect.right, DrawingRect.bottom);
		}
		m_bPictureChanged = false;
	}
	BitBlt(dc,ps.rcPaint.left,
		ps.rcPaint.top,w,h,doubleDC,ps.rcPaint.left,
		ps.rcPaint.top,SRCCOPY);

	EndPaint(&ps);
	m_bPainted = true;
	return 0;
}
Beispiel #24
0
// this routine calculates the size and position of the window relative
// to it's anchor point, and moves the window accordingly.  The region is also
// created and set here.
void CBalloonHelp::PositionWindow()
{
	CSize sizeWnd = CalcWindowSize();
	
	CPoint ptTail[3];
	CPoint ptTopLeft(0,0);
	CPoint ptBottomRight(sizeWnd.cx, sizeWnd.cy);
	
	// force recalculation of desktop
	m_screenRect.SetRectEmpty();
	
	switch (GetBalloonQuadrant())
	{
	case BQ_TOPLEFT:
		ptTopLeft.y = nTIP_TAIL;
		ptTail[0].x = (sizeWnd.cx-nTIP_TAIL)/4 + nTIP_TAIL;
		ptTail[0].y = nTIP_TAIL+1;
		ptTail[2].x = (sizeWnd.cx-nTIP_TAIL)/4;
		ptTail[2].y = ptTail[0].y;
		ptTail[1].x = ptTail[2].x;
		ptTail[1].y = 1;
		break;
	case BQ_TOPRIGHT:
		ptTopLeft.y = nTIP_TAIL;
		ptTail[0].x = (sizeWnd.cx-nTIP_TAIL)/4*3;
		ptTail[0].y = nTIP_TAIL+1;
		ptTail[2].x = (sizeWnd.cx-nTIP_TAIL)/4*3 + nTIP_TAIL;
		ptTail[2].y = ptTail[0].y;
		ptTail[1].x = ptTail[2].x;
		ptTail[1].y = 1;
		break;
	case BQ_BOTTOMLEFT:
		ptBottomRight.y = sizeWnd.cy-nTIP_TAIL;
		ptTail[0].x = (sizeWnd.cx-nTIP_TAIL)/4 + nTIP_TAIL;
		ptTail[0].y = sizeWnd.cy-nTIP_TAIL-2;
		ptTail[2].x = (sizeWnd.cx-nTIP_TAIL)/4;
		ptTail[2].y = ptTail[0].y;
		ptTail[1].x = ptTail[2].x;
		ptTail[1].y = sizeWnd.cy-2;
		break;
	case BQ_BOTTOMRIGHT:
		ptBottomRight.y = sizeWnd.cy-nTIP_TAIL;
		ptTail[0].x = (sizeWnd.cx-nTIP_TAIL)/4*3;
		ptTail[0].y = sizeWnd.cy-nTIP_TAIL-2;
		ptTail[2].x = (sizeWnd.cx-nTIP_TAIL)/4*3 + nTIP_TAIL;
		ptTail[2].y = ptTail[0].y;
		ptTail[1].x = ptTail[2].x;
		ptTail[1].y = sizeWnd.cy-2;
		break;
				default:
					ASSERT(FALSE);
	}
	
	// adjust for very narrow balloons
	if ( ptTail[0].x < nTIP_MARGIN )
		ptTail[0].x = nTIP_MARGIN;
	if ( ptTail[0].x > sizeWnd.cx - nTIP_MARGIN )
		ptTail[0].x = sizeWnd.cx - nTIP_MARGIN;
	if ( ptTail[1].x < nTIP_MARGIN )
		ptTail[1].x = nTIP_MARGIN;
	if ( ptTail[1].x > sizeWnd.cx - nTIP_MARGIN )
		ptTail[1].x = sizeWnd.cx - nTIP_MARGIN;
	if ( ptTail[2].x < nTIP_MARGIN )
		ptTail[2].x = nTIP_MARGIN;
	if ( ptTail[2].x > sizeWnd.cx - nTIP_MARGIN )
		ptTail[2].x = sizeWnd.cx - nTIP_MARGIN;
	
	// get window position
	CPoint ptAnchor = GetAnchorPoint();
	CPoint ptOffs(ptAnchor.x - ptTail[1].x, ptAnchor.y - ptTail[1].y);
	
	// adjust position so all is visible
	CRect rectScreen;
	GetAnchorScreenBounds(rectScreen);
	int nAdjustX = 0;
	int nAdjustY = 0;
	if ( ptOffs.x < rectScreen.left )
		nAdjustX = rectScreen.left-ptOffs.x;
	else if ( ptOffs.x + sizeWnd.cx >= rectScreen.right )
		nAdjustX = rectScreen.right - (ptOffs.x + sizeWnd.cx);
	if ( ptOffs.y + nTIP_TAIL < rectScreen.top )
		nAdjustY = rectScreen.top - (ptOffs.y + nTIP_TAIL);
	else if ( ptOffs.y + sizeWnd.cy - nTIP_TAIL >= rectScreen.bottom )
		nAdjustY = rectScreen.bottom - (ptOffs.y + sizeWnd.cy - nTIP_TAIL);
	
	// reposition tail
	// uncomment two commented lines below to move entire tail 
	// instead of just anchor point
	
	//ptTail[0].x -= nAdjustX;
	ptTail[1].x -= nAdjustX;
	//ptTail[2].x -= nAdjustX;
	ptOffs.x    += nAdjustX;
	ptOffs.y    += nAdjustY;
	
	// place window
	MoveWindow(ptOffs.x, ptOffs.y, sizeWnd.cx, sizeWnd.cy, TRUE);
	
	// apply region
	CRgn region;
	CRgn regionRound;
	CRgn regionComplete;
	region.CreatePolygonRgn(&ptTail[0], 3, ALTERNATE);
	regionRound.CreateRoundRectRgn(ptTopLeft.x,ptTopLeft.y,ptBottomRight.x,ptBottomRight.y,nTIP_MARGIN*3,nTIP_MARGIN*3);
	regionComplete.CreateRectRgn(0,0,1,1);
	regionComplete.CombineRgn(&region, &regionRound, RGN_OR);
	
	if ( NULL == m_rgnComplete.m_hObject )
		m_rgnComplete.CreateRectRgn(0,0,1,1);
	
	if ( !m_rgnComplete.EqualRgn(&regionComplete) )
	{
		m_rgnComplete.CopyRgn(&regionComplete);
		SetWindowRgn((HRGN)regionComplete.Detach(), TRUE);
		
		// There is a bug with layered windows and NC changes in Win2k
		// As a workaround, redraw the entire window if the NC area changed.
		// Changing the anchor point is the ONLY thing that will change the
		// position of the client area relative to the window during normal
		// operation.
		RedrawWindow(NULL, NULL, RDW_UPDATENOW| RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
	}
}
LRESULT CRegionSelect::OnMouseMove(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	int cx = LOWORD(lParam); 
	int cy = HIWORD(lParam);
	DWORD fwKeys = wParam;
	POINT point = {cx, cy};
	HWND hNewSelWnd;

	
		/*CRect toolbarRC;
		Toolbar.GetWindowRect(&toolbarRC);
		toolbarRC.InflateRect(30,70);
		bool HideToolBar = true;
		if(toolbarRC.PtInRect(point))
		{
			if(!(fwKeys & MK_LBUTTON) && 	!(fwKeys & MK_RBUTTON))
			{
				HideToolBar = false;
				if(!m_btoolWindowTimerRunning)
				{
					SetTimer(1,400);
					m_btoolWindowTimerRunning = true;
				}
			}
		//do smth	
		}
		else
		{
			if(m_btoolWindowTimerRunning)
			KillTimer(1);
			m_btoolWindowTimerRunning = false;
			Toolbar.ShowWindow(SW_HIDE);
		}*/


	bool bUpdateWindow = false;

	if(m_SelectionMode == smWindowHandles)
	{
		POINT newP=point;
		ClientToScreen(&newP );

      if ((hNewSelWnd = WindowUnderCursor(newP,m_hWnd)) == 0)
        hNewSelWnd = ::GetDesktopWindow();
      else
      {
        /*HWND hChildWnd = MyChildWindowFromPoint(hNewSelWnd, point);
        if ( hChildWnd )
          hNewSelWnd = hChildWnd;*/
      }
		if(hNewSelWnd != hSelWnd)
      {
			CRgn FullScreenRgn;
		

			FullScreenRgn.CreateRectRgnIndirect(&m_screenBounds);
			RECT SelWndRect;
			::GetWindowRect( hNewSelWnd, &SelWndRect );
			CRgn WindowRgn;
			  
			if(::GetWindowRgn(hNewSelWnd, WindowRgn) != ERROR)
			{
				//WindowRegion.GetRgnBox( &WindowRect); 
				WindowRgn.OffsetRgn( SelWndRect.left, SelWndRect.top);
			}
		  
			CBrush br;
			br.CreateSolidBrush(RGB(200,0,0));
		
			m_bPictureChanged = true;
			m_PrevWindowRect = SelWndRect;
		  
			CRgn repaintRgn;
			repaintRgn.CreateRectRgnIndirect(&SelWndRect);
			repaintRgn.OffsetRgn(topLeft);

			if(!m_prevWindowRgn.IsNull())
			repaintRgn.CombineRgn(m_prevWindowRgn, RGN_OR);
			

			
			m_prevWindowRgn = repaintRgn;
			InvalidateRgn(repaintRgn);
			repaintRgn.Detach();
			bUpdateWindow = true;
      }
		hSelWnd = hNewSelWnd;

		if(!(wParam & MK_RBUTTON))
		{
			bUpdateWindow = true;
		}
	}
	//else
	{
		if(fwKeys & MK_LBUTTON && Down	)
		{
			HDC dc = GetDC();
			
			SelectObject(dc, pen);

			if(m_SelectionMode!=smFreeform)
			{
				SetROP2(dc, R2_NOTXORPEN);
				if(End.x>-1)
					Rectangle(dc, Start.x,Start.y, End.x, End.y);

				End.x = LOWORD(lParam); 
				End.y = HIWORD(lParam);

				bool Draw = true;
				if(m_SelectionMode == smWindowHandles)
				{
				
					if(abs(End.x-Start.x)<7 && abs(End.y-Start.y)<7)
					{
						Draw=false;
					}
					else 	
					{
						m_SelectionMode = smRectangles;
						hSelWnd = 0;
						m_bPictureChanged = true;
						/*Invalidate();*/
						bUpdateWindow = true;
					}
				}
					if(Draw) Rectangle(dc, Start.x,Start.y, End.x, End.y);
				
				
			}
			else
			{
				SetROP2(doubleDC, R2_COPYPEN);
				POINT p = m_curvePoints.back();
				MoveToEx(doubleDC, p.x, p.y,0);
				SelectObject(doubleDC, pen);
				POINT newPoint  = {LOWORD(lParam), HIWORD(lParam)};
				LineTo(doubleDC, newPoint.x, newPoint.y);
				m_curvePoints.push_back(newPoint);

				RECT RectToRepaint;
				RectToRepaint.left = min(p.x, newPoint.x) - m_brushSize;
				RectToRepaint.top = min(p.y, newPoint.y) - m_brushSize;
				RectToRepaint.right = max(p.x, newPoint.x) + m_brushSize;
				RectToRepaint.bottom = max(p.y, newPoint.y) + m_brushSize;
				InvalidateRect(&RectToRepaint, false);

			}
			ReleaseDC(dc);
		}
}
		if(wParam & MK_RBUTTON)
		{
			HGDIOBJ oldPen2 = SelectObject(memDC2, DrawingPen);

			if(cxOld != -1)
			{
				SHORT shiftState = GetAsyncKeyState(VK_SHIFT);
				if(shiftState& 0x8000) {
					if (!lineType ) {
						lineType = abs(cx-cxOld) >= abs(cy-cyOld) ? 1 : 2;
					}
					if ( lineType == 1 ) {
						cy = cyOld;
					} else {
						cx = cxOld;
					}
				}


				SelectClipRgn(memDC2, 0);
				MoveToEx(memDC2, cxOld, cyOld,0);
				LineTo(memDC2, cx,cy);

				RECT RectToRepaint;
				RectToRepaint.left = min(cxOld, cx) - m_brushSize;
				RectToRepaint.top = min(cyOld, cy) - m_brushSize;
				RectToRepaint.right = max(cxOld, cx) + m_brushSize;
				RectToRepaint.bottom = max(cyOld, cy) + m_brushSize;
				CRgn rgn;
				rgn.CreateRectRgnIndirect(&RectToRepaint);
				m_bPictureChanged = true;
				m_bDocumentChanged = true;
				InvalidateRect(&RectToRepaint);
				UpdateWindow();
			}
			cxOld = cx;
			cyOld = cy;	
		}

	if(bUpdateWindow) UpdateWindow();
	return 0;
}
Beispiel #26
0
//设置区域
VOID CLayeredWindow::InitLayeredArea(CDC * pDCImage, BYTE cbAlpha, CRect & rcUnLayered, CPoint & PointRound, bool bUnLayeredChild)
{
	//效验参数
	ASSERT((pDCImage!=NULL)&&(pDCImage->m_hDC!=NULL));
	if ((pDCImage==NULL)||(pDCImage->m_hDC==NULL)) return;

	//变量定义
	BITMAP Bitmap;
	ZeroMemory(&Bitmap,sizeof(Bitmap));

	//获取图像
	CBitmap * pBitmap=pDCImage->GetCurrentBitmap();
	if (pBitmap!=NULL) pBitmap->GetBitmap(&Bitmap);

	//获取大小
	CSize SizeImage;
	SizeImage.SetSize(Bitmap.bmWidth,Bitmap.bmHeight);

	//效验大小
	ASSERT((SizeImage.cx>0)&&(SizeImage.cy>0));
	if ((SizeImage.cx==0)||(SizeImage.cy==0)) return;

	//变量定义
	BLENDFUNCTION BlendFunction;
	ZeroMemory(&BlendFunction,sizeof(BlendFunction));

	//设置参数
	BlendFunction.BlendOp=0;
	BlendFunction.BlendFlags=0;
	BlendFunction.AlphaFormat=AC_SRC_ALPHA;
	BlendFunction.SourceConstantAlpha=cbAlpha;

	//设置分层
	CPoint ImagePoint(0,0);
	CClientDC ClientDC(this);
	UpdateLayeredWindow(&ClientDC,NULL,&SizeImage,pDCImage,&ImagePoint,0L,&BlendFunction,ULW_ALPHA);

	//创建区域
	CRgn RegionResult;
	RegionResult.CreateRectRgn(0,0,SizeImage.cx,SizeImage.cy);

	//窗口排除
	if (bUnLayeredChild==true)
	{
		//变量定义
		tagEnumChildInfo EnumChildInfo;
		ZeroMemory(&EnumChildInfo,sizeof(EnumChildInfo));

		//设置变量
		EnumChildInfo.pWndLayered=this;
		EnumChildInfo.pWndControl=m_pWndControl;
		EnumChildInfo.pRegionResult=&RegionResult;

		//枚举窗口
		ASSERT(m_pWndControl->GetSafeHwnd()!=NULL);
		EnumChildWindows(m_pWndControl->m_hWnd,EnumChildProc,(LPARAM)&EnumChildInfo);
	}

	//区域排除
	if (rcUnLayered.IsRectEmpty()==FALSE)
	{
		//创建区域
		CRgn RegionUnLayered;
		RegionUnLayered.CreateRoundRectRgn(rcUnLayered.left,rcUnLayered.top,rcUnLayered.right+1,rcUnLayered.bottom+1,PointRound.x,PointRound.y);

		//合并区域
		RegionResult.CombineRgn(&RegionResult,&RegionUnLayered,RGN_DIFF);
	}

	//设置区域
	SetWindowRgn(RegionResult,TRUE);

	return;
}