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; }