void CTyHMProxy::DrawDC_Vecter(CDC *pDC, CElecMapView *pView)
{
float minx,miny,maxx,maxy;
pView->GetFloatRect(&minx,&miny,&maxx,&maxy);
if (!IntersectRect(minx,miny,maxx,maxy)) return;
GetRect(&minx,&miny,&maxx,&maxy);
CPoint pt1,pt2;
pt1=pView->UPtoLP(minx,miny);
pt2=pView->UPtoLP(maxx,maxy);
CRect rt;
rt.SetRect(pt1,pt2);
rt.NormalizeRect();
//DrawVector(LPCSTR vectorname,CDC* pDC,CRect viewRect,CRect clipRect,COLORREF color,BOOL blReplace)
DrawVector(m_str1,pDC,rt,rt,m_color1,m_bTranslate1);
}
static int query_screens(void)
{
int i, count, event_base, error_base;
XineramaScreenInfo *screens;
RECT rc_work = {0, 0, 0, 0};
if (!monitors) /* first time around */
load_xinerama();
query_work_area( &rc_work );
if (!pXineramaQueryExtension || !pXineramaQueryScreens ||
!pXineramaQueryExtension( gdi_display, &event_base, &error_base ) ||
!(screens = pXineramaQueryScreens( gdi_display, &count ))) return 0;
if (monitors != &default_monitor) HeapFree( GetProcessHeap(), 0, monitors );
if ((monitors = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*monitors) )))
{
int device = 2; /* 1 is reserved for primary */
nb_monitors = count;
for (i = 0; i < nb_monitors; i++)
{
monitors[i].cbSize = sizeof( monitors[i] );
monitors[i].rcMonitor.left = screens[i].x_org;
monitors[i].rcMonitor.top = screens[i].y_org;
monitors[i].rcMonitor.right = screens[i].x_org + screens[i].width;
monitors[i].rcMonitor.bottom = screens[i].y_org + screens[i].height;
monitors[i].dwFlags = 0;
if (!IntersectRect( &monitors[i].rcWork, &rc_work, &monitors[i].rcMonitor ))
monitors[i].rcWork = monitors[i].rcMonitor;
}
get_primary()->dwFlags |= MONITORINFOF_PRIMARY;
for (i = 0; i < nb_monitors; i++)
{
snprintfW( monitors[i].szDevice, sizeof(monitors[i].szDevice) / sizeof(WCHAR),
monitor_deviceW, (monitors[i].dwFlags & MONITORINFOF_PRIMARY) ? 1 : device++ );
}
}
else count = 0;
XFree( screens );
return count;
}
bool CBoulder::CheckCollision(IBaseInterface* pObject)
{
RECT rectCollisionResult = { 0, 0, 0, 0 };
CBaseObject* pBaseObject = (CBaseObject*)pObject;
if(IntersectRect(&rectCollisionResult, &GetCollisionRect().GetWindowsRECT(), &pBaseObject->GetCollisionRect().GetWindowsRECT()))
{
if(pObject->GetType() == TYPE_CHAR_ENEMY)
// ((CEnemy*)pObject)->SufferDamage(CPlayer::GetInstance()->GetAttackDamage());
//if(pObject->GetType() != TYPE_CHAR_PLAYER && pObject->GetType() != TYPE_WEAPON_ARROW)
//{
// CMessageSystem::GetInstance()->SendMsg(new CDestroyObjectMessage(this));
//}
return true;
}
return false;
}
BOOL CGdiAlpha::AlphaBackup(HDC hdc,LPCRECT pRect,ALPHAINFO &alphaInfo)
{
HBITMAP hBmp=(HBITMAP)GetCurrentObject(hdc,OBJ_BITMAP);
DUIASSERT(hBmp);
BITMAP bm;
GetObject(hBmp,sizeof(BITMAP),&bm);
if(bm.bmBitsPixel!=32) return FALSE;
alphaInfo.rc=*pRect;
POINT pt;
GetViewportOrgEx(hdc,&pt);
RECT rcImg= {0,0,bm.bmWidth,bm.bmHeight};
OffsetRect(&alphaInfo.rc,pt.x,pt.y);
IntersectRect(&alphaInfo.rc,&alphaInfo.rc,&rcImg);
alphaInfo.lpBuf=ALPHABACKUP(&bm,alphaInfo.rc.left,alphaInfo.rc.top,alphaInfo.rc.right - alphaInfo.rc.left, alphaInfo.rc.bottom - alphaInfo.rc.top);
return TRUE;
}
/*********************** Generl drawing support ******************************/
void GUIAPI SetPixel(HDC hdc, int x, int y, gal_pixel c)
{
PDC pdc;
PCLIPRECT pClipRect;
RECT rcOutput;
pdc = dc_HDC2PDC (hdc);
if (dc_IsGeneralHDC(hdc)) {
pthread_mutex_lock (&pdc->pGCRInfo->lock);
if (!dc_GenerateECRgn (pdc, FALSE)) {
pthread_mutex_unlock (&pdc->pGCRInfo->lock);
return;
}
}
coor_LP2SP (pdc, &x, &y);
rcOutput.left = x - 1;
rcOutput.top = y - 1;
rcOutput.right = x + 1;
rcOutput.bottom = y + 1;
pthread_mutex_lock (&__mg_gdilock);
IntersectRect (&rcOutput, &rcOutput, &pdc->ecrgn.rcBound);
if (!dc_IsMemHDC(hdc)) ShowCursorForGDI (FALSE, &rcOutput);
// set graphics context.
GAL_SetGC (pdc->gc);
GAL_SetFgColor (pdc->gc, c);
pClipRect = pdc->ecrgn.head;
while(pClipRect)
{
if(PtInRect(&(pClipRect->rc), x, y)) {
GAL_DrawPixel (pdc->gc, x, y, c);
break;
}
pClipRect = pClipRect->next;
}
if( !dc_IsMemHDC(hdc) ) ShowCursorForGDI(TRUE, &rcOutput);
pthread_mutex_unlock(&__mg_gdilock);
if (dc_IsGeneralHDC(hdc)) pthread_mutex_unlock (&pdc->pGCRInfo->lock);
}
bool Collision::ammoMonsterCollision(Physical* ammo, MonsterManager* mm, int damage)
{
vUnit* mons = mm->getMonsters();
RECT r;
viUnit iter = mons->begin();
for (; iter != mons->end(); iter++)
{
if (IntersectRect(&r, &ammo->getRect(), &(*iter)->getRect()))
{
(*iter)->hit((ammo->getSpeedX() < 0) ? LEFT : RIGHT, damage);
return true;
}
}
return false;
}
static int HWAccelBlit (GAL_Surface *src, GAL_Rect *srcrect,
GAL_Surface *dst, GAL_Rect *dstrect)
{
RECT rc_src = {srcrect->x, srcrect->y, srcrect->x + srcrect->w, srcrect->y + srcrect->h};
RECT rc_dst = {dstrect->x, dstrect->y, dstrect->x + dstrect->w, dstrect->y + dstrect->h};
RECT rc_inter, rc_sub [4];
if (rc_src.top < rc_dst.top && IntersectRect (&rc_inter, &rc_src, &rc_dst)) {
int i, sub_count, inter_h;
Sint32 off_x = dstrect->x - srcrect->x;
Sint32 off_y = dstrect->y - srcrect->y;
GAL_Rect tmp_src, tmp_dst;
inter_h = rc_inter.bottom - rc_inter.top;
for (i = 0; i < inter_h; i++) {
rc_inter.top = rc_inter.bottom - 1;
make_rects (&tmp_src, &tmp_dst, &rc_inter, off_x, off_y);
HWAccelBlit_helper (src, &tmp_src, dst, &tmp_dst);
rc_inter.bottom --;
}
sub_count = SubtractRect (rc_sub, &rc_src, &rc_dst);
for (i = 0; i < sub_count; i++) {
make_rects (&tmp_src, &tmp_dst, rc_sub + i, off_x, off_y);
HWAccelBlit_helper (src, &tmp_src, dst, &tmp_dst);
}
}
else if (rc_src.top == rc_dst.top && rc_src.left < rc_dst.left) {
int i;
GAL_Rect tmp_src, tmp_dst;
Sint32 off_x = dstrect->x - srcrect->x;
RECT rc = rc_src;
for (i = 0; i < rc_src.right - rc_src.left; i++) {
rc.left = rc.right - 1;
make_rects (&tmp_src, &tmp_dst, &rc, off_x, 0);
HWAccelBlit_helper (src, &tmp_src, dst, &tmp_dst);
rc.right --;
}
}
else
HWAccelBlit_helper (src, srcrect, dst, dstrect);
return(0);
}
/* Helper function that blits the front buffer contents to the target window. */
void x11_copy_to_screen(const struct wined3d_swapchain *swapchain, const RECT *rect)
{
struct wined3d_surface *front;
POINT offset = {0, 0};
HDC src_dc, dst_dc;
RECT draw_rect;
HWND window;
TRACE("swapchain %p, rect %s.\n", swapchain, wine_dbgstr_rect(rect));
front = surface_from_resource(wined3d_texture_get_sub_resource(swapchain->front_buffer, 0));
if (swapchain->palette)
wined3d_palette_apply_to_dc(swapchain->palette, front->hDC);
if (front->resource.map_count)
ERR("Trying to blit a mapped surface.\n");
TRACE("Copying surface %p to screen.\n", front);
surface_load_location(front, NULL, WINED3D_LOCATION_DIB);
src_dc = front->hDC;
window = swapchain->win_handle;
dst_dc = GetDCEx(window, 0, DCX_CLIPSIBLINGS | DCX_CACHE);
/* Front buffer coordinates are screen coordinates. Map them to the
* destination window if not fullscreened. */
if (swapchain->desc.windowed)
ClientToScreen(window, &offset);
TRACE("offset %s.\n", wine_dbgstr_point(&offset));
draw_rect.left = 0;
draw_rect.right = front->resource.width;
draw_rect.top = 0;
draw_rect.bottom = front->resource.height;
if (rect)
IntersectRect(&draw_rect, &draw_rect, rect);
BitBlt(dst_dc, draw_rect.left - offset.x, draw_rect.top - offset.y,
draw_rect.right - draw_rect.left, draw_rect.bottom - draw_rect.top,
src_dc, draw_rect.left, draw_rect.top, SRCCOPY);
ReleaseDC(window, dst_dc);
}
void GUIAPI PutSavedBoxOnDC (HDC hdc, int x, int y, int w, int h, void* vbuf)
{
PCLIPRECT pClipRect;
PDC pdc;
RECT rcOutput;
pdc = dc_HDC2PDC(hdc);
if (dc_IsGeneralHDC(hdc)) {
if (!dc_GenerateECRgn (pdc, FALSE)) {
return;
}
}
// Transfer logical to device to screen here.
w += x; h += y;
coor_LP2SP(pdc, &x, &y);
coor_LP2SP(pdc, &w, &h);
rcOutput.left = x;
rcOutput.top = y;
rcOutput.right = w;
rcOutput.bottom = h;
NormalizeRect (&rcOutput);
w = RECTW (rcOutput); h = RECTH (rcOutput);
IntersectRect (&rcOutput, &rcOutput, &pdc->ecrgn.rcBound);
if( !dc_IsMemHDC(hdc) ) ShowCursorForGDI(FALSE, &rcOutput);
GAL_SetGC (pdc->gc);
pClipRect = pdc->ecrgn.head;
while(pClipRect)
{
if (DoesIntersect (&rcOutput, &pClipRect->rc)) {
GAL_SetClipping(pdc->gc, pClipRect->rc.left, pClipRect->rc.top,
pClipRect->rc.right - 1, pClipRect->rc.bottom - 1);
GAL_PutBox (pdc->gc, x, y, w, h, vbuf);
}
pClipRect = pClipRect->next;
}
if( !dc_IsMemHDC(hdc) ) ShowCursorForGDI(TRUE, &rcOutput);
}
bool CScreenBuffer::Create(HDC hDev,const RECT & rc,LPCTSTR szName )
{
TrackDebugOut;
Destroy();
m_hMemDC = CreateCompatibleDC(hDev);
if(m_hMemDC == NULL){
DebugOutF(filelog::log_error,("CreateCompatibleDC failed with %d"),GetLastError() );
return false;
}
RECT rcscreen = GetDCRect(hDev);
RECT rcdest;
IntersectRect(&rcdest,&rcscreen,&rc);
LONG lWidth = rcdest.right - rcdest.left;
LONG lHeight = rcdest.bottom - rcdest.top;
LONG lBitsPPix = 32;//GetDeviceCaps(hDev,BITSPIXEL);
LONG dwImageSize = lHeight*CalculatePitch(CalculateLine(lWidth,lBitsPPix));
// save [bmp file header] + [bmp info header] + [bmp data] to the file mapping object
//DWORD filesize = 0;
LONG biClrUsed = 0;
RGBQUAD rgbquad[256];
if (lBitsPPix < 16)
{
TrackDebugOut;
biClrUsed = GetDIBColorTable(hDev,0,256,rgbquad);
}
if(!CFileMappingBitmap::Create(lWidth,lHeight,lBitsPPix,biClrUsed,rgbquad,szName))
{
return false;
}
m_hBmp = CreateDIBSection(m_hMemDC,(BITMAPINFO*)InfoHeader(),DIB_RGB_COLORS, (void**)&m_pBuff, GetHandle(), FileHeader()->bfOffBits);
if(m_hBmp == NULL){
DebugOutF(filelog::log_error,("CreateDIBSection failed %d"),GetLastError() );
return false;
}
SelectObject(m_hMemDC,m_hBmp);
//HDC hdc = GetDC(0);
BitBlt(m_hMemDC,0,0,rcdest.right-rcdest.left,rcdest.bottom-rcdest.top,hDev,rcdest.left,rcdest.top,SRCCOPY|CAPTUREBLT);
//ReleaseDC(0,hdc);
return true;
}
// ----------------------------------------------------------------------------
//
// RemoveOverlaps()
// This is called from CleanupDesktopRectangles make sure the monitor array
// is non-overlapping.
//
// ----------------------------------------------------------------------------
void NEAR PASCAL RemoveOverlaps(LPRECT arc, UINT count)
{
LPRECT lprc1, lprc2, lprcL;
//
// Center the rectangles around a common origin. We will move them outward
// when there are conflicts so centering (a) reduces running time and
// hence (b) reduces the chances of totally mangling the positions.
//
CenterRectangles(arc, count);
//
// Now loop through the array fixing any overlaps.
//
lprcL = arc + count;
lprc2 = arc + 1;
ReScan:
while (lprc2 < lprcL)
{
//
// Scan all rectangles before this one looking for intersections.
//
for (lprc1 = arc; lprc1 < lprc2; lprc1++)
{
RECT rcI;
//
// Move one of the rectanges if there is an intersection.
//
if (IntersectRect(&rcI, lprc1, lprc2))
{
//
// Move one of the rectangles out of the way and then restart
// the scan for overlaps with that rectangle (since moving it
// may have created new overlaps).
//
lprc2 = RemoveOverlap(lprc1, lprc2, &rcI);
goto ReScan;
}
}
lprc2++;
}
}
// ChildWindowFromPoint() messes up with group boxes
static BOOL CALLBACK FindChildAtPointEnumProc(HWND hwnd, LPARAM lParam)
{
if (IsWindowVisible(hwnd)) {
struct FindChildAtPointData *fcap = (struct FindChildAtPointData*)lParam;
RECT rcVisible, rc, rcParent;
GetWindowRect(hwnd, &rc);
GetWindowRect(GetParent(hwnd), &rcParent);
IntersectRect(&rcVisible, &rcParent, &rc);
if (PtInRect(&rcVisible, fcap->pt)) {
int thisArea = (rc.bottom - rc.top)*(rc.right - rc.left);
if (thisArea && (thisArea<fcap->bestArea || fcap->bestArea == 0)) {
fcap->bestArea = thisArea;
fcap->hwnd = hwnd;
}
}
}
return TRUE;
}
bool WdeFindObjectsInRect( RECT *r, LIST **obj_list, LIST *olist )
{
OBJPTR child;
RECT child_rect;
RECT irect;
*obj_list = NULL;
for( ; olist != NULL; olist = ListNext( olist ) ) {
child = ListElement( olist );
Location( child, &child_rect );
if( IntersectRect( &irect, &child_rect, r ) ) {
WdeInsertObject( obj_list, child );
}
}
return( *obj_list != NULL );
}
HRESULT IE_IOleInSiteWindowless::InvalidateRect(LPCRECT pRect, BOOL fErase)
{
//DEBUG("************IOleInPlaceSiteWindowless::InvalidateRect");
// Clip the rectangle against the object's size and invalidate it
RECT rcI = { 0, 0, 0, 0 };
RECT posRect=m_fs->m_IEWindow->SetBounds();
if (pRect == NULL)
{
rcI = posRect;
}
else
{
IntersectRect(&rcI, &posRect, pRect);
}
::InvalidateRect(m_fs->m_hWndParent, &rcI, fErase);
return S_OK;
}
void CTyHMProxy::DrawDC_Bmp(CDC *pDC, CElecMapView *pView)
{
float minx,miny,maxx,maxy;
pView->GetFloatRect(&minx,&miny,&maxx,&maxy);
if (!IntersectRect(minx,miny,maxx,maxy)) return;
GetRect(&minx,&miny,&maxx,&maxy);
CPoint pt1,pt2;
pt1=pView->UPtoLP(minx,miny);
pt2=pView->UPtoLP(maxx,maxy);
CRect rt;
rt.SetRect(pt1,pt2);
rt.NormalizeRect();
DrawImage(m_str1,pDC,pt1.x,pt1.y,rt.Width(),rt.Height(),m_bTranslate1,m_color1);
}
bool Collision::playerMonsterCollision(Player* player, MonsterManager* mm)
{
vUnit* mons = mm->getMonsters();
RECT r;
viUnit iter = mons->begin();
for (; iter != mons->end(); iter++)
{
if (IntersectRect(&r, &player->getRect(), &(*iter)->getRect()) &&
!player->isUnbeatable())
{
player->hit((player->getX() < (*iter)->getX()) ? LEFT : RIGHT, (*iter)->getAtk());
return true;
}
}
return false;
}
BOOL Protocol::ItemInRect
(
OpWndItemD* wi,
LPRECT lprc,
BOOL fReqFullEnclosure
)
{
BOOL fRet;
RECT rcItem;
if(m_fFrames)
{
if(fReqFullEnclosure)
{
MakeRealRect(&rcItem, &wi->m_rcItem);
fRet = (lprc->left <= rcItem.left)
&&
(lprc->top <= rcItem.top)
&&
(lprc->right >= rcItem.right)
&&
(lprc->bottom >= rcItem.bottom);
}
else
{
RECT rcIntr;
RECT rcTemp;
MakeRealRect(&rcItem, &wi->m_rcItem);
CopyRect(&rcTemp, lprc);
if (rcTemp.left == rcTemp.right) rcTemp.right++;
if (rcTemp.top == rcTemp.bottom) rcTemp.bottom++;
fRet = IntersectRect(&rcIntr, &rcTemp, &rcItem);
}
}
else
fRet = wi->ItemInRect(lprc, fReqFullEnclosure);
return fRet;
}
STDMETHODIMP CGfxFB::SetDstRect(const RECT *pRect)
{
if(EqualRect(pRect,&m_rectDst))
return S_OK;
m_rectDst = *pRect;
IntersectRect(&m_rectDst,&m_rectScn,&m_rectDst);
#ifdef PXA_LINUX
DP("FB Setdest(%d,%d,%d,%d) \n",m_rectDst.left, m_rectDst.top, m_rectDst.right, m_rectDst.bottom);
return E_UNEXPECTED;
m_fbvinfo.xres = (m_rectDst.right - m_rectDst.left)&(~(DST_ALIGN-1));
m_fbvinfo.yres = (m_rectDst.bottom - m_rectDst.top)&(~(DST_ALIGN -1));
m_fbvinfo.bits_per_pixel = 19;
m_fbvinfo.nonstd = (FORMAT_PLANAR_420<< 20) | (m_rectDst.top << 10) | m_rectDst.left;
if (m_pBuff != NULL)
{
munmap(m_pBuff, m_iBufSize);
m_pBuff = NULL;
}
DP("Update info: left = %d, top = %d, xres = %d, yres = %d\n", m_fbvinfo.nonstd&0x3ff, (m_fbvinfo.nonstd>>10)&0x3ff, m_fbvinfo.xres, m_fbvinfo.yres);
int ret = ioctl(m_iHndFB, FBIOPUT_VSCREENINFO, &m_fbvinfo);
DP("Update()::FBIOPUT_VSCREENINFO :%d \n", ret);
ioctl(m_iHndFB, FBIOGET_FSCREENINFO, &m_fbfinfo);
m_iBufSize = m_fbfinfo.smem_len;
DP("Update()::m_iBufSize :%d \n", m_iBufSize );
m_pBuff = (unsigned char *)mmap(0, m_iBufSize, PROT_READ | PROT_WRITE, MAP_SHARED, m_iHndFB, 0);
if(m_pBuff ==NULL)
{
DP("Update()::set dest failed \n");
return E_FAIL;
}
#endif
Update();
return S_OK;
}
HWND __createWindow0( MHND hmMonitor,LPCTSTR lpClassName,LPCTSTR lpWindowName,
DWORD dwStyle,int x,int y,int nWidth,
int nHeight,HWND hWndParent,HMENU hMenu,
HANDLE hInstance,LPVOID lpParam )
{
HWND retCode = NULL;
if( (NULL != hmMonitor) && (NULL != lpClassName) &&
(NULL != lpWindowName) && (NULL != hInstance) )
{
RECT rRW = {0,0,0,0};
RECT rRM = {0,0,0,0};
RECT rSect = {0,0,0,0};
SetRect(&rRW,x,y,x+nWidth,y+nHeight);
if( TRUE == _monitorBounds(hmMonitor,&rRM) )
{
__normaRectPos(&rRW,rRW,rRM);
IntersectRect(&rSect,&rRM,&rRW);
if( TRUE == EqualRect(&rSect,&rRW) )
{
x = rSect.left;
y = rSect.top;
nWidth = rSect.right - rSect.left;
nHeight = rSect.bottom - rSect.top;
retCode = CreateWindow(
lpClassName,lpWindowName,
dwStyle,x,y,nWidth,
nHeight,hWndParent,hMenu,
(HINSTANCE)hInstance,lpParam
);
} else {
// A coisa indefinida. Nao tenho sabdoria o que
// fazer aqui mesmo
// E necessario perguntar Jeannette
}
}
}
return retCode;
}
/*
====================
Flush
====================
*/
VOID BrushCircle::Flush(const Map* map, const Vector3& pt)
{
GUARD(BrushCircle::Flush);
CHECK(map);
// compute the view
F32 radius = this->Radius();
Vector4 rect(pt[0]-radius, pt[1]-radius, pt[0]+radius, pt[1]+radius);
Rect src, dst, clip;
/*
src.left = U2P(rect[0])/U2P(CHUNK_STRIDE);
src.top = U2P(rect[1])/U2P(CHUNK_STRIDE);
src.right = (U2P(rect[2])%U2P(CHUNK_STRIDE)) ? (U2P(rect[2])/U2P(CHUNK_STRIDE)+1) : U2P(rect[2])/U2P(CHUNK_STRIDE);
src.bottom = (U2P(rect[3])%U2P(CHUNK_STRIDE)) ? (U2P(rect[3])/U2P(CHUNK_STRIDE)+1) : U2P(rect[3])/U2P(CHUNK_STRIDE);
*/
src.left = (U2P(rect[0])%U2P(CHUNK_STRIDE)) ? (U2P(rect[0])/U2P(CHUNK_STRIDE)-1) : U2P(rect[0])/U2P(CHUNK_STRIDE);
src.top = (U2P(rect[1])%U2P(CHUNK_STRIDE)) ? (U2P(rect[1])/U2P(CHUNK_STRIDE)-1) : U2P(rect[1])/U2P(CHUNK_STRIDE);
src.right = (U2P(rect[2])%U2P(CHUNK_STRIDE)) ? (U2P(rect[2])/U2P(CHUNK_STRIDE)+1) : U2P(rect[2])/U2P(CHUNK_STRIDE);
src.bottom = (U2P(rect[3])%U2P(CHUNK_STRIDE)) ? (U2P(rect[3])/U2P(CHUNK_STRIDE)+1) : U2P(rect[3])/U2P(CHUNK_STRIDE);
dst.left = -map->mWidth/2;
dst.top = 0;
dst.right = map->mWidth/2;
dst.bottom = map->mHeight;
IntersectRect(&clip, &dst, &src);
for(I32 j = clip.top; j < clip.bottom; j++)
{
for(I32 i = clip.left; i < clip.right; i++)
{
std::pair<I32,I32> coord(i,j);
std::map< std::pair<I32,I32>, ChunkPtr >::const_iterator it = map->mChunks.find(coord);
if(it == map->mChunks.end()) continue;
EChunkPtr chunk = dynamic_ptr_cast<EChunk>(it->second);
Matrix world = Matrix::makeTranslate(i*CHUNK_STRIDE,j*CHUNK_STRIDE,0);
Matrix world_inv; world_inv.invert(world);
Vector3 point = pt * world_inv;
this->Flush(chunk.Ptr(), point);
}
}
UNGUARD;
}
BOOL GUIAPI SaveMainWindowContent (HWND hWnd, const char* filename)
{
RECT rcScreen;
RECT rcWin;
BITMAP bitmap;
int save_ret;
SetRect (&rcScreen, 0, 0, WIDTHOFPHYGC, HEIGHTOFPHYGC);
if (hWnd) {
GetWindowRect (hWnd, &rcWin);
if (!IntersectRect (&rcWin, &rcWin, &rcScreen))
return FALSE;
}
else
rcWin = rcScreen;
bitmap.bmType = BMP_TYPE_NORMAL;
bitmap.bmBitsPerPixel = BITSPERPHYPIXEL;
bitmap.bmBytesPerPixel = BYTESPERPHYPIXEL;
bitmap.bmWidth = RECTW (rcWin);
bitmap.bmHeight = RECTH (rcWin);
bitmap.bmPitch = bitmap.bmWidth * bitmap.bmBytesPerPixel;
if (bitmap.bmWidth == 0 || bitmap.bmHeight == 0) {
#ifdef _DEBUG
fprintf (stderr, "SaveContent: Empty Rect.\n");
#endif
return FALSE;
}
bitmap.bmBits = SaveCoveredScreenBox (rcWin.left, rcWin.top,
RECTW (rcWin), RECTH (rcWin));
if (!bitmap.bmBits) {
#ifdef _DEBUG
fprintf (stderr, "SaveContent: SaveBox error.\n");
#endif
return FALSE;
}
save_ret = SaveBitmap (HDC_SCREEN, &bitmap, filename);
free (bitmap.bmBits);
return (save_ret == 0);
}
int CardRegion::GetOverlapRatio(int x, int y, int w, int h)
{
RECT me, him;
RECT inter;
SetRect(&him, x, y, x+w, y+h);
SetRect(&me, xpos, ypos, xpos+width, ypos+height);
//see if the specified rectangle overlaps us
if(IntersectRect(&inter, &me, &him))
{
int wi = inter.right - inter.left;
int hi = inter.bottom - inter.top;
int overlap = wi * hi;
int total = width * height;
int percent = (overlap << 16) / total;
return (percent * 100) >> 16;
}
/* Helper function that blits the front buffer contents to the target window. */
void x11_copy_to_screen(const struct wined3d_swapchain *swapchain, const RECT *rect)
{
const struct wined3d_surface *front;
POINT offset = {0, 0};
HDC src_dc, dst_dc;
RECT draw_rect;
HWND window;
TRACE("swapchain %p, rect %s.\n", swapchain, wine_dbgstr_rect(rect));
front = swapchain->front_buffer;
if (!(front->resource.usage & WINED3DUSAGE_RENDERTARGET))
return;
if (front->flags & SFLAG_LOCKED)
ERR("Trying to blit a mapped surface.\n");
TRACE("Copying surface %p to screen.\n", front);
src_dc = front->hDC;
window = swapchain->win_handle;
dst_dc = GetDCEx(window, 0, DCX_CLIPSIBLINGS | DCX_CACHE);
/* Front buffer coordinates are screen coordinates. Map them to the
* destination window if not fullscreened. */
if (swapchain->desc.windowed)
ClientToScreen(window, &offset);
TRACE("offset %s.\n", wine_dbgstr_point(&offset));
draw_rect.left = 0;
draw_rect.right = front->resource.width;
draw_rect.top = 0;
draw_rect.bottom = front->resource.height;
if (rect)
IntersectRect(&draw_rect, &draw_rect, rect);
BitBlt(dst_dc, draw_rect.left - offset.x, draw_rect.top - offset.y,
draw_rect.right - draw_rect.left, draw_rect.bottom - draw_rect.top,
src_dc, draw_rect.left, draw_rect.top, SRCCOPY);
ReleaseDC(window, dst_dc);
}
/* helper callback for MonitorFromRect */
static BOOL CALLBACK monitor_enum( HMONITOR monitor, HDC hdc, LPRECT rect, LPARAM lp )
{
struct monitor_enum_info *info = (struct monitor_enum_info *)lp;
RECT intersect;
if (IntersectRect( &intersect, rect, &info->rect ))
{
/* check for larger intersecting area */
UINT area = (intersect.right - intersect.left) * (intersect.bottom - intersect.top);
if (area > info->max_area)
{
info->max_area = area;
info->ret = monitor;
}
}
else if (!info->max_area) /* if not intersecting, check for min distance */
{
UINT distance;
UINT x, y;
if (info->rect.right <= rect->left) x = rect->left - info->rect.right;
else if (rect->right <= info->rect.left) x = info->rect.left - rect->right;
else x = 0;
if (info->rect.bottom <= rect->top) y = rect->top - info->rect.bottom;
else if (rect->bottom <= info->rect.top) y = info->rect.top - rect->bottom;
else y = 0;
distance = x * x + y * y;
if (distance < info->min_distance)
{
info->min_distance = distance;
info->nearest = monitor;
}
}
if (!info->primary)
{
MONITORINFO mon_info;
mon_info.cbSize = sizeof(mon_info);
GetMonitorInfoW( monitor, &mon_info );
if (mon_info.dwFlags & MONITORINFOF_PRIMARY) info->primary = monitor;
}
return TRUE;
}
BYTE SquareBox::BoxIsCollide(BoundaryBox* other, const bool& back)
{
if (other == NULL) return 10;
if (other->type() == BBOX_SQUARE)
{
Rect oBox = dynamic_cast<SquareBox*>(other)->getBox();
/*return !(rcBox.left > oBox.right ||
rcBox.right < oBox.left ||
rcBox.top > oBox.bottom ||
rcBox.bottom < oBox.top);*/
Rect tmp;
if(IntersectRect(&tmp, &rcBox, &oBox))
{
if(rcBox.left < oBox.right && rcBox.right > oBox.right && back)
{
return 1;
}
else if(rcBox.right > oBox.left && rcBox.left < oBox.left && !back)
{
return 2;
}
else if(rcBox.bottom > oBox.top && rcBox.top < oBox.top)
{
return 0;
}
else if(rcBox.top < oBox.bottom)
{
return 3;
}
}
else
return 4;
}
else if (other->type() == BBOX_CIRCLE)
{
/*return other->IsCollide(this);*/
return 0;
}
return 4;
}
/*
* @implemented
*/
BOOL
WINAPI
SubtractRect(LPRECT lprcDst,
CONST RECT *lprcSrc1,
CONST RECT *lprcSrc2)
{
RECT tempRect;
if(lprcDst == NULL || lprcSrc1 == NULL || lprcSrc2 == NULL)
return(FALSE);
if(!IntersectRect(&tempRect, lprcSrc1, lprcSrc2))
{
*lprcDst = *lprcSrc1;
return(TRUE);
}
if (EqualRect(&tempRect, lprcSrc1))
{
SetRectEmpty(lprcDst);
return FALSE;
}
*lprcDst = *lprcSrc1;
if(lprcDst->top == tempRect.top && lprcDst->bottom == tempRect.bottom)
{
if(lprcDst->left == tempRect.left)
lprcDst->left = tempRect.right;
else if(lprcDst->right == tempRect.right)
lprcDst->right = tempRect.left;
}
else if(lprcDst->left == tempRect.left && lprcDst->right == tempRect.right)
{
if(lprcDst->top == tempRect.top)
lprcDst->top = tempRect.bottom;
else if(lprcDst->bottom == tempRect.bottom)
lprcDst->bottom = tempRect.top;
}
return(TRUE);
}
void PaintAlternatingRows (HWND hWnd)
// re-draw rows with the appropriate background colour
{
int i;
RECT rectUpd, // rectangle to update
rectDestin, // temporary storage
rect; // row rectangle
POINT pt;
int iItems,
iTop;
COLORREF c; // temporary storage
// get the rectangle to be updated
GetUpdateRect (hWnd, &rectUpd, FALSE);
// allow default processing first
CallWindowProc (old_lv_proc, hWnd, WM_PAINT, 0, 0);
// set the row horizontal dimensions
SetRect (&rect, rectUpd.left, 0, rectUpd.right, 0);
// number of displayed rows
iItems = ListView_GetCountPerPage (hWnd);
// first visible row
iTop = ListView_GetTopIndex (hWnd);
ListView_GetItemPosition (hWnd, iTop, &pt);
for (i=iTop ; i<=iTop+iItems ; i++) {
// set row vertical dimensions
rect.top = pt.y;
ListView_GetItemPosition (hWnd, i+1, &pt);
rect.bottom = pt.y;
// if row rectangle intersects update rectangle then it requires
// re-drawing
if (IntersectRect (&rectDestin, &rectUpd, &rect)) {
// change text background colour accordingly
c = get_row_color(hWnd, i);
ListView_SetTextBkColor (hWnd, c);
// invalidate the row rectangle then...
InvalidateRect (hWnd, &rect, FALSE);
// ...force default processing
CallWindowProc (old_lv_proc, hWnd, WM_PAINT, 0, 0);
}
}
}
STDMETHODIMP CDrawTxt::Intersects(RECT rect, BOOL* pbIntersects)
{
RECT fixed;
fixed.left = ROUND(m_rcPosition.left);
fixed.top = ROUND(m_rcPosition.top);
fixed.right = ROUND(m_rcPosition.right);
fixed.bottom = ROUND(m_rcPosition.bottom);
fixed.right++;
fixed.bottom++;
RECT temp;
IntersectRect(&temp, &fixed, &rect);
if (IsRectEmpty(&temp))
*pbIntersects = FALSE;
else
*pbIntersects = TRUE;
return S_OK;
}
void AFXAPI _GetClippingCoordinates(LPCRECT pPosRect, LPCRECT pClipRect,
LPRECT pIntersectRect, LPPOINT pOffsetPoint)
{
int clipLeft = 0;
int clipTop = 0;
if ((pClipRect == NULL) || IsRectEmpty(pClipRect))
{
CopyRect(pIntersectRect, pPosRect);
}
else
{
IntersectRect(pIntersectRect, pPosRect, pClipRect);
clipLeft = pClipRect->left;
clipTop = pClipRect->top;
}
pOffsetPoint->x = min(0, pPosRect->left - clipLeft);
pOffsetPoint->y = min(0, pPosRect->top - clipTop);
}
BOOL GUIAPI ClipRgnIntersect (PCLIPRGN pRstRgn,
const CLIPRGN* pRgn1, const CLIPRGN* pRgn2)
{
RECT rc;
PCLIPRECT pnewcr;
PCLIPRECT pcr1, pcr2;
if (pRstRgn->head) return FALSE;
if (!(pcr1 = pRgn1->head)) return TRUE;
if (!(pcr2 = pRgn2->head)) return TRUE;
pnewcr = ClipRectAlloc (pRstRgn->heap);
pnewcr->next = NULL;
pRstRgn->head = pnewcr;
while (pcr1) {
while (pcr2) {
if (IntersectRect (&rc, &pcr1->rc, &pcr2->rc)) {
pnewcr->rc = rc;
pnewcr->next = ClipRectAlloc (pRstRgn->heap);
}
pcr2 = pcr2->next;
}
pcr2 = pRgn2->head;
pcr1 = pcr1->next;
}
pRstRgn->tail = pnewcr;
if (pnewcr->next)
{
FreeClipRect(pRstRgn->heap, pnewcr->next);
pnewcr->next = NULL;
}
EvaluateBoundRect(pRstRgn);
return TRUE;
}
