void CScrollV::DrawControl(CDC &dc, CRect rcUpdate)
{
int nWidth = m_rc.Width();
int nHeight = m_rc.Height();
if(!m_bUpdate)
{
UpdateMemDC(dc, nWidth, nHeight);
m_memDC.BitBlt(0, 0, nWidth, nHeight, &dc, m_rc.left ,m_rc.top, SRCCOPY);
if(m_bShowScroll)
{
CRect rcTemp;
//滚动条背景
if(m_bHover)
{
rcTemp.SetRect(0, 20, nWidth, nHeight - 20);
DrawRange(m_memDC, rcTemp, 0);
}
//滚动块
rcTemp.SetRect(m_rcBlock.left - m_rc.left, m_rcBlock.top - m_rc.top,m_rcBlock.left - m_rc.left + m_rcBlock.Width(), m_rcBlock.top - m_rc.top + m_rcBlock.Height());
int nXPos = m_sizeImage.cx;
if(m_enButtonState == enBSHover)
{
nXPos = m_sizeImage.cx * 2;
}
else if(m_enButtonState == enBSDown)
{
nXPos = m_sizeImage.cx * 3;
}
DrawRange(m_memDC, rcTemp, nXPos);
}
}
dc.BitBlt(m_rc.left, m_rc.top, nWidth, nHeight, &m_memDC, 0, 0, SRCCOPY);
}
bool CChartCandlestickSerie::IsPointOnSerie(const CPoint& screenPoint,
unsigned& uIndex) const
{
uIndex = INVALID_POINT;
if (!m_bIsVisible)
return false;
unsigned uFirst=0, uLast=0;
if (!GetVisiblePoints(uFirst,uLast))
return false;
if (uFirst>0)
uFirst--;
if (uLast<GetPointsCount())
uLast++;
bool bResult = false;
for (unsigned i=uFirst ; i < uLast ; i++)
{
SChartCandlestickPoint Point = GetPoint(i);
int ScreenXVal = m_pHorizontalAxis->ValueToScreen(Point.XVal);
int ScreenLow = m_pVerticalAxis->ValueToScreen(Point.Low);
int ScreenHigh = m_pVerticalAxis->ValueToScreen(Point.High);
int halfWidth = m_iCandlestickWidth/2;
CRect Rectangle;
if (ScreenLow > ScreenHigh)
Rectangle.SetRect(ScreenXVal-halfWidth, ScreenHigh,
ScreenXVal+halfWidth+1, ScreenLow+1);
else
Rectangle.SetRect(ScreenXVal-halfWidth, ScreenLow,
ScreenXVal+halfWidth+1, ScreenHigh+1);
if (Rectangle.PtInRect(screenPoint))
{
bResult = true;
uIndex = i;
break;
}
}
return bResult;
}
void CTreeListColumnDragWnd::DrawGrid( CDC* pDC, CRect rcItem )
{
// draw all grids
CTreeListColumnInfo* pColumnInfo;
int nColPos = 0;
for( int iShow = 0; iShow < m_pTreeListCtrl->m_arShows.GetSize(); iShow++, nColPos += pColumnInfo->m_nWidth )
{
int iCol;
// do NOT draw zero column;
iCol = m_pTreeListCtrl->m_arShows[ iShow ];
pColumnInfo = (CTreeListColumnInfo*)m_pTreeListCtrl->m_arColumns[iCol];
if( pColumnInfo->m_nWidth == 0 )
continue;
CRect rcColumn;
rcColumn.SetRect( 0, 0, pColumnInfo->m_nWidth, rcItem.Height() );
rcColumn.OffsetRect( nColPos, 0 );
rcColumn.OffsetRect( rcItem.left, rcItem.top );
if( iCol == 0 )
{
// draw vertical grid line of tree
if( m_pTreeListCtrl->m_dwStyle&TLC_HGRID_EXT && m_pTreeListCtrl->m_dwStyle&TLC_TGRID )
{
pDC->MoveTo( rcColumn.left, rcColumn.bottom - 1);
pDC->LineTo( rcColumn.right-1, rcColumn.bottom - 1);
}
if( m_pTreeListCtrl->m_dwStyle&TLC_VGRID_EXT )
{
pDC->MoveTo( rcColumn.right-1, rcColumn.bottom - 1);
pDC->LineTo( rcColumn.right-1, rcColumn.top - 1 );
}
}
else
{
// draw vertical grid line and horizonal grid lin
if( m_pTreeListCtrl->m_dwStyle&TLC_HGRID_EXT )
{
pDC->MoveTo( rcColumn.left, rcColumn.bottom - 1);
pDC->LineTo( rcColumn.right, rcColumn.bottom - 1);
}
if( m_pTreeListCtrl->m_dwStyle&TLC_VGRID_EXT )
{
pDC->MoveTo( rcColumn.right-1, rcColumn.bottom - 1);
pDC->LineTo( rcColumn.right-1, rcColumn.top - 1 );
}
}
}
}
void CSkinComboBox_ListBox::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
{
//变量定义
CRect rcItem=lpDrawItemStruct->rcItem;
CDC * pDCControl=CDC::FromHandle(lpDrawItemStruct->hDC);
//创建缓冲
CDC BufferDC;
CBitmap ImageBuffer;
BufferDC.CreateCompatibleDC(pDCControl);
ImageBuffer.CreateCompatibleBitmap(pDCControl,rcItem.Width(),rcItem.Height());
//设置环境
BufferDC.SelectObject(&ImageBuffer);
BufferDC.SelectObject(GetCtrlFont());
//获取字符
CString strString;
GetText(lpDrawItemStruct->itemID,strString);
//计算位置
CRect rcString;
rcString.SetRect(4,0,rcItem.Width()-8,rcItem.Height());
//颜色定义
COLORREF crTextColor=((lpDrawItemStruct->itemState&ODS_SELECTED)!=0)?m_colSelectText:m_colNormalText;
COLORREF crBackColor=((lpDrawItemStruct->itemState&ODS_SELECTED)!=0)?RGB(10,36,106):RGB(255,255,255);
//绘画背景
BufferDC.FillSolidRect(0,0,rcItem.Width(),rcItem.Height(),crBackColor);
if ( (lpDrawItemStruct->itemState&ODS_SELECTED) != 0 )
{
if ( m_pSelectImg!= NULL && !m_pSelectImg->IsNull() )
{
rcItem.DeflateRect(1,1,1,1);
m_pSelectImg->Draw(&BufferDC,CRect(0,0,rcItem.Width(),rcItem.Height()));
}
}
//绘画字符
BufferDC.SetBkMode(TRANSPARENT);
BufferDC.SetTextColor(crTextColor);
BufferDC.DrawText(strString,&rcString,DT_VCENTER|DT_SINGLELINE);
//绘画界面
pDCControl->BitBlt(rcItem.left,rcItem.top,rcItem.Width(),rcItem.Height(),&BufferDC,0,0,SRCCOPY);
//清理资源
BufferDC.DeleteDC();
ImageBuffer.DeleteObject();
}
BOOL CLookupForm::DoCreateDialog(CWnd* parent)
{
BOOL ret = Create(IDD, parent);
if (!ret) return FALSE;
// prepare titlebar
m_title.ModifyStyle(0, WS_CLIPCHILDREN);
m_title.ModifyStyleEx(0, WS_EX_CONTROLPARENT);
CRect rc;
rc.SetRect(0, 0, 60, 23);
m_btnSearch.Create(_T("&Search"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP, rc, &m_title, IDC_BUTTON_SEARCH);
m_btnSearch.SetFont(GetFont());
rc.SetRect(0, 0, 250, 23);
m_editSearch.Create(ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP, rc, &m_title, IDC_EDIT_SEARCH);
m_editSearch.SetFont(GetFont());
m_editSearch.SetFocus();
OnInitialize();
return TRUE;
};
void CTreePropSheetSplitter::OnPaint()
{
CPaintDC dc(this);
CRect rcClip, rcClipPane;
int i;
// retrieve the background brush
HWND hWnd = GetParent()->GetSafeHwnd();
// send a message to the dialog box
HBRUSH hBrush = (HBRUSH)::SendMessage(hWnd, WM_CTLCOLORDLG, (WPARAM)dc.m_ps.hdc, (LPARAM)hWnd);
ASSERT( hBrush );
CRect rcWnd;
GetAdjustedClientRect(&rcWnd);
dc.GetClipBox(&rcClip);
CRect rect;
int top, left;
if (m_nOrientation == SSP_HORZ)
{
for (i = 1; i < m_nPanes; i++)
{
left = m_orig[i] - m_nBarThickness - rcWnd.left;
top = rcClip.top;
rect.SetRect( left, top, left + m_nBarThickness, top + rcClip.Height() );
dc.FillRect( &rect, CBrush::FromHandle(hBrush) );
}
}
else
{
for (i = 1; i < m_nPanes; i++)
{
left = rcClip.left;
top = m_orig[i] - m_nBarThickness - rcWnd.top;
rect.SetRect( left, top, left + rcClip.Width(), top + m_nBarThickness );
dc.FillRect( &rect, CBrush::FromHandle(hBrush) );
}
}
}
void shape_mgr::get_rect(CRect &rect)
{
rect.SetRect(0, 0, 0 ,0);
if (shapes_.size() == 0)
return;
shapes_[0]->get_rect(rect);
for (int i=1; i<shapes_.size(); i++)
{
CRect rc;
shapes_[i]->get_rect(rc);
rect.UnionRect(&rect, &rc);
}
}
void CWndFriendCtrl::OnLButtonUp( UINT nFlags, CPoint point )
{
m_bDrag = FALSE;
CPoint pt( 3, 3 );
CRect rect;
int count = m_nDrawCount;
for( int j = 0 ; j < m_nServerCount[g_Neuz.m_uIdofMulti-1] ; ++j, ++count )
{
rect.SetRect( pt.x, pt.y, pt.x + m_rectWindow.Width() - m_wndScrollBar.GetClientRect().Width(), pt.y + m_nFontHeight );
if( rect.PtInRect( point ) )
{
m_nCurSelect = count;
return;
}
pt.y += m_nFontHeight;
}
for( j = 0 ; j < 11 ; ++j )
{
if( j == g_Neuz.m_uIdofMulti -1 )
{
continue;
}
for( int k = 0 ; k < m_nServerCount[j] ; ++k, ++count )
{
rect.SetRect( pt.x, pt.y, pt.x + m_rectWindow.Width() - m_wndScrollBar.GetClientRect().Width(), pt.y + m_nFontHeight );
if( rect.PtInRect( point ) )
{
m_nCurSelect = count;
return;
}
pt.y += m_nFontHeight;
}
}
g_WorldMng()->SetObjFocus(NULL);
}
void CBigIcon::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
{
CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
ASSERT(pDC != NULL);
CRect rect;
GetClientRect(rect);
int cxClient = rect.Width();
int cyClient = rect.Height();
// draw border around icon
CPen pen;
pen.CreateStockObject(BLACK_PEN);
CPen* pPenOld = pDC->SelectObject(&pen);
pDC->Rectangle(0, 0, cxClient-CX_SHADOW, cyClient-CY_SHADOW);
if (pPenOld)
pDC->SelectObject(pPenOld);
// draw shadows around icon
CBrush br;
br.CreateStockObject(DKGRAY_BRUSH);
rect.SetRect(cxClient-CX_SHADOW, CY_SHADOW, cxClient, cyClient);
pDC->FillRect(rect, &br);
rect.SetRect(CX_SHADOW, cyClient-CY_SHADOW, cxClient, cyClient);
pDC->FillRect(rect, &br);
// draw the bitmap contents
CDC dcMem;
if (!dcMem.CreateCompatibleDC(pDC))
return;
CBitmap* pBitmapOld = dcMem.SelectObject(&m_bitmap);
if (pBitmapOld == NULL)
return;
pDC->BitBlt(2, 2, m_sizeBitmap.cx, m_sizeBitmap.cy, &dcMem, 0, 0, SRCCOPY);
dcMem.SelectObject(pBitmapOld);
}
BOOL CSkinScrollWnd::_DoPaint()
{
//bHandled = FALSE;
CPaintDC dc ( m_hWnd );
CRect rcClient;
GetClientRect ( &rcClient );
CRect rcFill;
rcFill.SetRectEmpty();
INT32 nLeft = 0, nTop = 0;
if ( 1 == m_nAngleType ) // LeftScrollBar
{
nLeft = rcClient.left;
nTop = rcClient.bottom - m_nScrollWidth;
rcFill.SetRect ( nLeft, nTop, nLeft + m_nScrollWidth, nTop + m_nScrollWidth );
}
else if ( 2 == m_nAngleType )
{
nLeft = rcClient.right - m_nScrollWidth;
nTop = rcClient.bottom - m_nScrollWidth;
rcFill.SetRect ( nLeft, nTop, nLeft + m_nScrollWidth, nTop + m_nScrollWidth );
}
if ( !rcFill.IsRectEmpty() )
{
CRgn rgn;
rgn.CreateRectRgnIndirect(&rcFill);
dc.SelectClipRgn(rgn);
dc.FillRect(rcFill, m_brBackground);
m_imgCorner.Draw( dc.m_hDC, rcFill.left, rcFill.top, rcFill.Width(), rcFill.Height() );
}
return TRUE;
}
CRect CPlayerSeekBar::GetThumbRect()
{
// bool fEnabled = m_fEnabled || m_start >= m_stop;
CRect r = GetChannelRect();
int x = r.left + (int)((m_start < m_stop /*&& fEnabled*/) ? (__int64)r.Width() * (m_pos - m_start) / (m_stop - m_start) : 0);
int y = r.CenterPoint().y;
r.SetRect(x, y, x, y);
r.InflateRect(6, 7, 7, 8);
return(r);
}
// 绘制温度曲线图
void CDisplay::DrawGraph(CDC *pDC)
{
float fDeltaX; // x轴相邻两个绘图点的坐标距离
float fDeltaY; // y轴每个逻辑单位对应的坐标值
int nX; // 在连线时用于存储绘图点的横坐标
int nY; // 在连线时用于存储绘图点的纵坐标
// 计算fDeltaX和fDeltaY
fDeltaX = (float)m_codRect.Width() / 2 / (DATA_SIZE-1);
fDeltaY = (float)m_codRect.Height() / 50;
SetMaxAndMinTemp();
pOldPen = pDC->SelectObject(&greenPen);
// 将当前点移动到绘图控件窗口的左下角，以此为波形的起始点
pDC->MoveTo(m_codRect.left, m_codRect.bottom);
// 计算m_nzValues数组中每个点对应的坐标位置，并依次连接，最终形成曲线
for (int i = 0; i<DATA_SIZE; i++)
{
nX = m_codRect.left + (int)(i * fDeltaX);
nY = m_codRect.bottom - (int)(m_tempData.at(i).m_temperature * fDeltaY);
if (m_tempData.at(i).m_temperature == 0)
pDC->MoveTo(nX, nY);
else if (i==0)
pDC->MoveTo(m_codRect.left, nY);
else
pDC->LineTo(nX, nY);
}
//绘制预测曲线
pDC->SelectObject(&brownPen);
CBrush *oldBrush = pDC->SelectObject(&redBrush);
for (int i = 0; i<DATA_SIZE; i+=5)
{
nX = m_codRect.left+m_codRect.Width() / 2 + (int)(i * fDeltaX);
nY = m_codRect.bottom - (int)(m_forecastData.at(i).m_temperature * fDeltaY);
CRect cRect;
cRect.SetRect(CPoint(nX - 5, nY - 5), CPoint(nX + 5, nY + 5));
pDC->Ellipse(cRect);
if (i == 0)
pDC->MoveTo(m_codRect.left + m_codRect.Width() / 2, nY);
else
pDC->LineTo(nX, nY);
}
pDC->SelectObject(oldBrush);
// 恢复旧画笔
pDC->SelectObject(pOldPen);
}
void CBottomBaseView::CalcDeviceRect(CRect &rect)
{
CRect client;
GetClientRect(&client);
CPoint p1 = rect.TopLeft();
p1.x *= (float)client.Width() / (float)m_TotalSize.cx;
p1.y *= (float)client.Height() / (float)m_TotalSize.cy;
CPoint p2 = rect.BottomRight();
p2.x *= (float)client.Width() / (float)m_TotalSize.cx;
p2.y *= (float)client.Height() / (float)m_TotalSize.cy;
rect.SetRect(p1, p2);
}
static void ColorBox(CDC* pDC, CPoint pt, COLORREF clr, BOOL bHover)
{
CBrush br(clr);
CBrush* obr = pDC->SelectObject(&br);
pDC->PatBlt(pt.x, pt.y, 13, 13, PATCOPY);
pDC->SelectObject(obr);
CRect rc;
rc.SetRect(pt.x - 2, pt.y - 2, pt.x + 15, pt.y + 15);
pDC->DrawEdge(&rc, (bHover) ? BDR_SUNKENOUTER : BDR_RAISEDINNER, BF_RECT);
}
void CDlgLocalPanel::UpdateComponents()
{
CRect rcClient;
GetClientRect(&rcClient);
if (rcClient.IsRectEmpty()) return;
CRect rcPushAddr, rcEdtAddr;
CRect rcVideo;
rcVideo.SetRect(rcClient.left+VIDEO_WINDOW_BORDER_WIDTH, 0,
rcClient.right-VIDEO_WINDOW_BORDER_WIDTH, rcClient.bottom-VIDEO_WINDOW_BORDER_WIDTH);
__MOVE_WINDOW(pDlgVideo, rcVideo);
}
long CText::HitTest(long x, long y)
{
if(!m_DnyAttr.m_Linked) return TK_NONE;
CRect rtTemp;
POINT pt;
pt.x=x;
pt.y=y;
rtTemp.SetRect(Left(),Top(),Right(),Bottom());
if(rtTemp.PtInRect(pt)) return TK_PUSH;
return TK_NONE;
}
CRect Skin::stringToRect(CString in)
{
wstring input = in.GetBuffer();
vector<wstring> parts;
Split(input, parts, ',');
CRect r;
int x1,y1,x2,y2;
x1 = _wtoi(parts[0].c_str());
y1 = _wtoi(parts[1].c_str());
x2 = _wtoi(parts[2].c_str());
y2 = _wtoi(parts[3].c_str());
r.SetRect(x1,y1,x1+x2,y1+y2);
return r;
}
long CMeta::HitTest(long x, long y)
{
if(!m_DnyAttr.m_Linked) return TK_NONE;
CRect rtTemp;
POINT pt;
pt.x=x;
pt.y=y;
rtTemp.SetRect(m_lx1,m_ly1,m_lx2,m_ly2);
if(rtTemp.PtInRect(pt)) return TK_PUSH;
return TK_NONE;
}
void CSizingDialog::InvalidateCtrlBorder( // XR: erase lpRectOld - lpRectNew
LPCRECT lpRectOld, LPCRECT lpRectNew, BOOL bErase /*= TRUE*/)
{
CRect rcBorder;
// Top Part
if (lpRectNew->top > lpRectOld->top)
{
rcBorder.SetRect(lpRectOld->left, lpRectOld->top,
lpRectOld->right, lpRectNew->top);
this->InvalidateRect(&rcBorder, bErase);
}
// Bottom Part
if (lpRectNew->bottom < lpRectOld->bottom)
{
rcBorder.SetRect(lpRectOld->left, lpRectNew->bottom,
lpRectOld->right, lpRectOld->bottom);
this->InvalidateRect(&rcBorder, bErase);
}
// Left Part
if (lpRectNew->left > lpRectOld->left)
{
rcBorder.SetRect(lpRectOld->left, lpRectOld->top,
lpRectNew->left, lpRectOld->bottom);
this->InvalidateRect(&rcBorder, bErase);
}
// Right Part
if (lpRectNew->right < lpRectOld->right)
{
rcBorder.SetRect(lpRectNew->right, lpRectOld->top,
lpRectOld->right, lpRectOld->bottom);
this->InvalidateRect(&rcBorder, bErase);
}
}
int CNaviWnd::MouseTest(int x, int y)
{
int res=0;
CRect rect;
CRgn rgn;
for(int i=1;i<5;i++)
{
rect.SetRect(2+(i-1)*17,2,2+i*17,18);
rgn.CreateRectRgnIndirect(&rect);
if(rgn.PtInRegion(x,y))
res=i;
rgn.DeleteObject();
}
rect.SetRect(180,8,195,18);
rgn.CreateRectRgnIndirect(&rect);
if(rgn.PtInRegion(x,y))
res=5;
rect.SetRect(178,20,1985,40);
rgn.DeleteObject();
rgn.CreateRectRgnIndirect(&rect);
if(rgn.PtInRegion(x,y))
res=6;
return res;
}
void CPic_Earth::InitCheck()
{
CRect chkRect;
chkRect.SetRect(262, 170, 306, 190);
m_gpCheck.Create( "GPS", WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX | BS_LEFTTEXT,
chkRect, this, 1023);
m_gpCheck.SetCheck(1);
chkRect.SetRect(236, 190, 306, 210);
m_glCheck.Create( "Glonass", WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX | BS_LEFTTEXT,
chkRect, this, 1024);
m_glCheck.SetCheck(1);
chkRect.SetRect(244, 210, 306, 230);
m_bdCheck.Create( "Beidou", WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX | BS_LEFTTEXT,
chkRect, this, 1025);
m_bdCheck.SetCheck(1);
chkRect.SetRect(244, 230, 306, 250);
m_gaCheck.Create( "Galileo", WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX | BS_LEFTTEXT,
chkRect, this, 1026);
m_gaCheck.SetCheck(1);
}
void CMainFrame::OnGetMinMaxInfo(MINMAXINFO* lpMMI)
{
CFrameWnd::OnGetMinMaxInfo(lpMMI);
CRect rcWnd;
rcWnd.SetRect(0, 0, 2048, 1536);
AdjustWindowRectEx(&rcWnd, WS_OVERLAPPEDWINDOW, TRUE, WS_EX_CLIENTEDGE);
lpMMI->ptMinTrackSize.x = 320;
lpMMI->ptMaxTrackSize.y = 240;
lpMMI->ptMaxTrackSize.x = rcWnd.Width();
lpMMI->ptMaxTrackSize.y = rcWnd.Height();
lpMMI->ptMaxSize.x = rcWnd.Width();
lpMMI->ptMaxSize.y = rcWnd.Height();
}
//-----------------------------------------------------------------------------
// Purpose: (virtual imp)
// Input : pt -
// BOOL -
// Output : int
//-----------------------------------------------------------------------------
int Clipper3D::HitTest( CPoint pt, BOOL )
{
const int POINT_TOLERANCE = 4;
CRect r;
//
// check point point 0
//
r.SetRect( m_ClipPoints[0][axHorz],
m_ClipPoints[0][axVert],
m_ClipPoints[0][axHorz],
m_ClipPoints[0][axVert] );
RectToScreen( r );
r.InflateRect( POINT_TOLERANCE, POINT_TOLERANCE );
if( r.PtInRect( pt ) )
{
return 0;
}
//
// check clip point 1
//
r.SetRect( m_ClipPoints[1][axHorz],
m_ClipPoints[1][axVert],
m_ClipPoints[1][axHorz],
m_ClipPoints[1][axVert] );
RectToScreen( r );
r.InflateRect( POINT_TOLERANCE, POINT_TOLERANCE );
if( r.PtInRect( pt ) )
{
return 1;
}
// neither point hit
return -1;
}
void CMyExplorerCntrItem::OnGetItemPosition(CRect& rPosition)
{
ASSERT_VALID(this);
// During in-place activation, CMyExplorerCntrItem::OnGetItemPosition
// will be called to determine the location of this item. The default
// implementation created from AppWizard simply returns a hard-coded
// rectangle. Usually, this rectangle would reflect the current
// position of the item relative to the view used for activation.
// You can obtain the view by calling CMyExplorerCntrItem::GetActiveView.
// TODO: return correct rectangle (in pixels) in rPosition
rPosition.SetRect(10, 10, 210, 210);
}
void CControlBar::OnWindowPosChanging(LPWINDOWPOS lpWndPos)
{
// We call DefWindowProc here instead of CWnd::OnWindowPosChanging
// (which calls CWnd::Default, which calls through the super wndproc)
// because certain control bars that are system implemented (such as
// CToolBar with TBSTYLE_FLAT) do not implement WM_WINDOWPOSCHANGING
// correctly, causing repaint problems. This code bypasses that whole
// mess.
::DefWindowProc(m_hWnd, WM_WINDOWPOSCHANGING, 0, (LPARAM)lpWndPos);
if (lpWndPos->flags & SWP_NOSIZE)
return;
// invalidate borders on the right
CRect rect;
GetWindowRect(&rect);
CSize sizePrev = rect.Size();
int cx = lpWndPos->cx;
int cy = lpWndPos->cy;
if (cx != sizePrev.cx && (m_dwStyle & CBRS_BORDER_RIGHT))
{
rect.SetRect(cx-afxData.cxBorder2, 0, cx, cy);
InvalidateRect(&rect);
rect.SetRect(sizePrev.cx-afxData.cxBorder2, 0, sizePrev.cx, cy);
InvalidateRect(&rect);
}
// invalidate borders on the bottom
if (cy != sizePrev.cy && (m_dwStyle & CBRS_BORDER_BOTTOM))
{
rect.SetRect(0, cy-afxData.cyBorder2, cx, cy);
InvalidateRect(&rect);
rect.SetRect(0, sizePrev.cy-afxData.cyBorder2, cx, sizePrev.cy);
InvalidateRect(&rect);
}
}
void CDib::Create32BitFromPicture (CPictureHolder* pPicture, int iWidth, int iHeight)
{
CRect r;
CBitmap newBMP;
CWindowDC dc(NULL);
CDC tempDC;
tempDC.CreateCompatibleDC(&dc);
newBMP.CreateDiscardableBitmap(&dc,iWidth,iHeight);
CBitmap* pOldBitmap = tempDC.SelectObject(&newBMP);
r.SetRect(0,0,iWidth,iHeight);
pPicture->Render(&tempDC,r,r);
// Create a 32 bit bitmap
stdex::vector<DWORD> pBits(iWidth * iHeight);
BITMAPINFO bi;
bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bi.bmiHeader.biWidth = iWidth;
bi.bmiHeader.biHeight = iHeight;
bi.bmiHeader.biPlanes = 1;
bi.bmiHeader.biBitCount = 32;
bi.bmiHeader.biCompression = BI_RGB;
bi.bmiHeader.biSizeImage = 0;
bi.bmiHeader.biXPelsPerMeter = 0;
bi.bmiHeader.biYPelsPerMeter = 0;
bi.bmiHeader.biClrUsed = 0;
bi.bmiHeader.biClrImportant = 0;
SetBitmap(&bi, pBits);
DWORD* pAr = (DWORD*)GetDIBits();
// Copy data into the 32 bit dib..
for(int i=0;i<iHeight;i++)
{
for(int j=0;j<iWidth;j++)
{
pAr[(i*iWidth)+j] = FixColorRef(tempDC.GetPixel(j,i));
}
}
tempDC.SelectObject(pOldBitmap);
}
BOOL CInPlaceFrame::CanGetBorderSpace(
LPCRECT lpRectBorder, LPOLEINPLACEUIWINDOW lpUIWindow, BOOL bFrame)
{
ASSERT_VALID(this);
ASSERT(lpRectBorder == NULL ||
AfxIsValidAddress(lpRectBorder, sizeof(RECT), FALSE));
ASSERT(lpUIWindow != NULL);
// use IOleInPlaceUIWindow::GetBorder if no border given
CRect rectBorder;
if (lpRectBorder != NULL)
rectBorder.CopyRect(lpRectBorder);
else
lpUIWindow->GetBorder(&rectBorder);
// get CWnd* for the OLE window
HWND hwnd;
VERIFY(lpUIWindow->GetWindow(&hwnd) == NOERROR);
CWnd* pWnd = CWnd::FromHandle(hwnd);
ASSERT(pWnd != NULL);
// see how much space we need by calling reposition bars
CRect rectNeeded = rectBorder;
pWnd->RepositionBars(0, 0xFFFF, 0, CWnd::reposQuery, &rectNeeded, &rectBorder);
CRect rectRequest;
// request the border space from the container
rectRequest.SetRect(
rectNeeded.left - rectBorder.left,
rectNeeded.top - rectBorder.top,
rectBorder.right - rectNeeded.right,
rectBorder.bottom - rectNeeded.bottom);
CRect rectTemp;
rectTemp = rectRequest;
// if no border space, just call SetBorderSpace
if (rectRequest.IsRectNull())
goto RequestFailed;
if (lpUIWindow->RequestBorderSpace(&rectTemp) != NOERROR)
goto RequestFailed;
return TRUE;
RequestFailed:
return FALSE;
}
CRect CSgSelectionPreparationBar::GetCustomSelRect()
{
CRect rcCustom;
CString csText;
m_edtLeft.GetWindowText(csText);
int x = _ttoi(csText);
m_edtTop.GetWindowText(csText);
int y = _ttoi(csText);
m_edtWidth.GetWindowText(csText);
int x2 = x + _ttoi(csText);
m_edtHeight.GetWindowText(csText);
int y2 = y + _ttoi(csText);
rcCustom.SetRect(x, y , x2, y2);
return rcCustom;
}
BOOL CSgSelectionPreparationBar::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
{
CPoint ptCursor;
GetCursorPos(&ptCursor);
CRect rcClient;
GetClientRect(&rcClient);
CRect rcDrag;
rcDrag.SetRect(rcClient.left, rcClient.top, rcClient.right, rcClient.top + 15);
ScreenToClient(&ptCursor);
if(rcDrag.PtInRect(ptCursor))
SetCursor(LoadCursor(NULL, IDC_HAND));
return CWnd::OnSetCursor(pWnd, nHitTest, message);;
}
// return rectange of handle in device coords
CRect CDrawObject::GetHandleRect(int nHandleID)
{
// FTLTRACE(TEXT("CDrawObject(0x%p)::GetHandleRect,m_position=[%d,%d]x[%d,%d], nHandle=%d\n"), this,
//m_position.left, m_position.top, m_position.right, m_position.bottom,
//nHandleID);
CRect rect;
// get the center of the handle in device coords
CPoint point = GetHandle(nHandleID);
// convert to client/device coords
//m_pDrawCanvas->DocToClient(&point);
// return CRect of handle in device coords
rect.SetRect(point.x - TRACK_MARGIN, point.y - TRACK_MARGIN, point.x + TRACK_MARGIN, point.y + TRACK_MARGIN);
//m_pDrawCanvas->ClientToDoc(&rect);
return rect;
}
