/* 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, 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); }
/*********************************************************************** * RectVisible (GDI32.@) */ BOOL WINAPI RectVisible( HDC hdc, const RECT* rect ) { RECT tmpRect, visrect; BOOL ret; DC *dc = get_dc_ptr( hdc ); if (!dc) return FALSE; TRACE("%p %s\n", hdc, wine_dbgstr_rect( rect )); tmpRect = *rect; lp_to_dp( dc, (POINT *)&tmpRect, 2 ); order_rect( &tmpRect ); update_dc( dc ); ret = (!get_dc_device_rect( dc, &visrect ) || intersect_rect( &visrect, &visrect, &tmpRect )); if (ret && get_dc_region( dc )) ret = RectInRegion( get_dc_region( dc ), &tmpRect ); release_dc_ptr( dc ); return ret; }
static HRESULT WINAPI ddrawex_surface4_Lock(IDirectDrawSurface4 *iface, RECT *rect, DDSURFACEDESC2 *desc, DWORD flags, HANDLE h) { struct ddrawex_surface *surface = impl_from_IDirectDrawSurface4(iface); HRESULT hr; TRACE("iface %p, rect %s, desc %p, flags %#x, h %p.\n", iface, wine_dbgstr_rect(rect), desc, flags, h); if (SUCCEEDED(hr = IDirectDrawSurface4_Lock(surface->parent, rect, desc, flags, h)) && surface->permanent_dc) { desc->ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY; desc->ddsCaps.dwCaps &= ~DDSCAPS_OWNDC; } return hr; }
static void STATUSBAR_SetPartBounds (STATUS_INFO *infoPtr) { STATUSWINDOWPART *part; RECT rect, *r; UINT i; /* get our window size */ GetClientRect (infoPtr->Self, &rect); TRACE("client wnd size is %s\n", wine_dbgstr_rect(&rect)); rect.left += infoPtr->horizontalBorder; rect.top += infoPtr->verticalBorder; /* set bounds for simple rectangle */ infoPtr->part0.bound = rect; /* set bounds for non-simple rectangles */ for (i = 0; i < infoPtr->numParts; i++) { part = &infoPtr->parts[i]; r = &infoPtr->parts[i].bound; r->top = rect.top; r->bottom = rect.bottom; if (i == 0) r->left = 0; else r->left = infoPtr->parts[i-1].bound.right + infoPtr->horizontalGap; if (part->x == -1) r->right = rect.right; else r->right = part->x; if (infoPtr->hwndToolTip) { TTTOOLINFOW ti; ti.cbSize = sizeof(TTTOOLINFOW); ti.hwnd = infoPtr->Self; ti.uId = i; ti.rect = *r; SendMessageW (infoPtr->hwndToolTip, TTM_NEWTOOLRECTW, 0, (LPARAM)&ti); } } }
static HRESULT WINAPI d3d9_surface_LockRect(IDirect3DSurface9 *iface, D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) { struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface); struct wined3d_map_desc map_desc; HRESULT hr; TRACE("iface %p, locked_rect %p, rect %s, flags %#x.\n", iface, locked_rect, wine_dbgstr_rect(rect), flags); wined3d_mutex_lock(); hr = wined3d_surface_map(surface->wined3d_surface, &map_desc, rect, flags); wined3d_mutex_unlock(); locked_rect->Pitch = map_desc.row_pitch; locked_rect->pBits = map_desc.data; return hr; }
static HRESULT WINAPI IWineD3DTextureImpl_AddDirtyRect(IWineD3DTexture *iface, const RECT *dirty_rect) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; IWineD3DSurfaceImpl *surface; TRACE("iface %p, dirty_rect %s.\n", iface, wine_dbgstr_rect(dirty_rect)); if (!(surface = (IWineD3DSurfaceImpl *)basetexture_get_sub_resource(texture, 0))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; } texture->baseTexture.texture_rgb.dirty = TRUE; texture->baseTexture.texture_srgb.dirty = TRUE; surface_add_dirty_rect(surface, dirty_rect); return WINED3D_OK; }
/* 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); }
/*************************************************************************** * MCIAVI_mciPut [internal] */ DWORD MCIAVI_mciPut(UINT wDevID, DWORD dwFlags, LPMCI_DGV_PUT_PARMS lpParms) { WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID); RECT rc; TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK; if (wma == NULL) return MCIERR_INVALID_DEVICE_ID; EnterCriticalSection(&wma->cs); if (dwFlags & MCI_DGV_RECT) { rc = lpParms->rc; } else { GetClientRect(wma->hWndPaint, &rc); } if (dwFlags & MCI_DGV_PUT_CLIENT) { FIXME("PUT_CLIENT %s\n", wine_dbgstr_rect(&rc)); LeaveCriticalSection(&wma->cs); return MCIERR_UNRECOGNIZED_COMMAND; } if (dwFlags & MCI_DGV_PUT_DESTINATION) { TRACE("PUT_DESTINATION %s\n", wine_dbgstr_rect(&rc)); wma->dest = rc; } if (dwFlags & MCI_DGV_PUT_FRAME) { FIXME("PUT_FRAME %s\n", wine_dbgstr_rect(&rc)); LeaveCriticalSection(&wma->cs); return MCIERR_UNRECOGNIZED_COMMAND; } if (dwFlags & MCI_DGV_PUT_SOURCE) { TRACE("PUT_SOURCE %s\n", wine_dbgstr_rect(&rc)); wma->source = rc; } if (dwFlags & MCI_DGV_PUT_VIDEO) { FIXME("PUT_VIDEO %s\n", wine_dbgstr_rect(&rc)); LeaveCriticalSection(&wma->cs); return MCIERR_UNRECOGNIZED_COMMAND; } if (dwFlags & MCI_DGV_PUT_WINDOW) { FIXME("PUT_WINDOW %s\n", wine_dbgstr_rect(&rc)); LeaveCriticalSection(&wma->cs); return MCIERR_UNRECOGNIZED_COMMAND; } LeaveCriticalSection(&wma->cs); return 0; }
/*********************************************************************** * MonitorFromRect (USER32.@) */ HMONITOR WINAPI MonitorFromRect( LPRECT rect, DWORD flags ) { struct monitor_enum_info info; info.rect = *rect; info.max_area = 0; info.min_distance = ~0u; info.primary = 0; info.nearest = 0; info.ret = 0; if (!EnumDisplayMonitors( 0, NULL, monitor_enum, (LPARAM)&info )) return 0; if (!info.ret) { if (flags & MONITOR_DEFAULTTOPRIMARY) info.ret = info.primary; else if (flags & MONITOR_DEFAULTTONEAREST) info.ret = info.nearest; } TRACE( "%s flags %x returning %p\n", wine_dbgstr_rect(rect), flags, info.ret ); return info.ret; }
static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, struct tagMSG* lpmsg, LPOLECLIENTSITE pActiveSite, LONG lindex, HWND hwndParent, LPCRECT lprcPosRect) { WebBrowser *This = impl_from_IOleObject(iface); TRACE("(%p)->(%d %p %p %d %p %s)\n", This, iVerb, lpmsg, pActiveSite, lindex, hwndParent, wine_dbgstr_rect(lprcPosRect)); /* restore closed client site if we have one */ if(!This->client && This->client_closed) { IOleClientSite *client = This->client_closed; This->client_closed = NULL; IOleObject_SetClientSite(iface, client); IOleClientSite_Release(client); } switch (iVerb) { case OLEIVERB_SHOW: TRACE("OLEIVERB_SHOW\n"); return activate_ui(This, pActiveSite); case OLEIVERB_UIACTIVATE: TRACE("OLEIVERB_UIACTIVATE\n"); return activate_ui(This, pActiveSite); case OLEIVERB_INPLACEACTIVATE: TRACE("OLEIVERB_INPLACEACTIVATE\n"); return activate_inplace(This, pActiveSite); case OLEIVERB_HIDE: TRACE("OLEIVERB_HIDE\n"); if(This->inplace) IOleInPlaceSiteEx_OnInPlaceDeactivate(This->inplace); if(This->shell_embedding_hwnd) ShowWindow(This->shell_embedding_hwnd, SW_HIDE); return S_OK; default: FIXME("stub for %d\n", iVerb); break; } return E_NOTIMPL; }
static void dump_region( const char *p, HRGN hrgn) { DWORD i, size; RGNDATA *data = NULL; RECT *rect; if (!hrgn) { TRACE( "%s null region\n", p ); return; } if (!(size = GetRegionData( hrgn, 0, NULL ))) { return; } if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return; GetRegionData( hrgn, size, data ); TRACE("%s %d rects:", p, data->rdh.nCount ); for (i = 0, rect = (RECT *)data->Buffer; i<20 && i < data->rdh.nCount; i++, rect++) TRACE( " %s", wine_dbgstr_rect( rect)); TRACE("\n"); HeapFree( GetProcessHeap(), 0, data ); }
HRESULT CDECL wined3d_swapchain_get_front_buffer_data(const struct wined3d_swapchain *swapchain, struct wined3d_surface *dst_surface) { struct wined3d_surface *src_surface; RECT src_rect, dst_rect; TRACE("swapchain %p, dst_surface %p.\n", swapchain, dst_surface); src_surface = swapchain->front_buffer; SetRect(&src_rect, 0, 0, src_surface->resource.width, src_surface->resource.height); dst_rect = src_rect; if (swapchain->desc.windowed) { MapWindowPoints(swapchain->win_handle, NULL, (POINT *)&dst_rect, 2); FIXME("Using destination rect %s in windowed mode, this is likely wrong.\n", wine_dbgstr_rect(&dst_rect)); } return wined3d_surface_blt(dst_surface, &dst_rect, src_surface, &src_rect, 0, NULL, WINED3D_TEXF_POINT); }
static HRESULT WINAPI IDirect3DSurface8Impl_LockRect(IDirect3DSurface8 *iface, D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) { IDirect3DSurface8Impl *This = impl_from_IDirect3DSurface8(iface); struct wined3d_map_desc map_desc; HRESULT hr; TRACE("iface %p, locked_rect %p, rect %s, flags %#x.\n", iface, locked_rect, wine_dbgstr_rect(rect), flags); wined3d_mutex_lock(); if (rect) { D3DSURFACE_DESC desc; IDirect3DSurface8_GetDesc(iface, &desc); if ((rect->left < 0) || (rect->top < 0) || (rect->left >= rect->right) || (rect->top >= rect->bottom) || (rect->right > desc.Width) || (rect->bottom > desc.Height)) { WARN("Trying to lock an invalid rectangle, returning D3DERR_INVALIDCALL\n"); wined3d_mutex_unlock(); return D3DERR_INVALIDCALL; } } hr = wined3d_surface_map(This->wined3d_surface, &map_desc, rect, flags); wined3d_mutex_unlock(); locked_rect->Pitch = map_desc.row_pitch; locked_rect->pBits = map_desc.data; return hr; }
/*********************************************************************** * PatBlt (GDI32.@) */ BOOL WINAPI PatBlt( HDC hdc, INT left, INT top, INT width, INT height, DWORD rop) { DC * dc; BOOL ret = FALSE; if (rop_uses_src( rop )) return FALSE; if ((dc = get_dc_ptr( hdc ))) { struct bitblt_coords dst; update_dc( dc ); dst.log_x = left; dst.log_y = top; dst.log_width = width; dst.log_height = height; dst.layout = dc->layout; if (rop & NOMIRRORBITMAP) { dst.layout |= LAYOUT_BITMAPORIENTATIONPRESERVED; rop &= ~NOMIRRORBITMAP; } ret = !get_vis_rectangles( dc, &dst, NULL, NULL ); TRACE("dst %p log=%d,%d %dx%d phys=%d,%d %dx%d vis=%s rop=%06x\n", hdc, dst.log_x, dst.log_y, dst.log_width, dst.log_height, dst.x, dst.y, dst.width, dst.height, wine_dbgstr_rect(&dst.visrect), rop ); if (!ret) { PHYSDEV physdev = GET_DC_PHYSDEV( dc, pPatBlt ); ret = physdev->funcs->pPatBlt( physdev, &dst, rop ); } release_dc_ptr( dc ); } return ret; }
static void STATUSBAR_DrawSizeGrip (HTHEME theme, HDC hdc, LPRECT lpRect) { RECT rc = *lpRect; TRACE("draw size grip %s\n", wine_dbgstr_rect(lpRect)); if (theme) { SIZE gripperSize; if (SUCCEEDED (GetThemePartSize (theme, hdc, SP_GRIPPER, 0, lpRect, TS_DRAW, &gripperSize))) { rc.left = rc.right - gripperSize.cx; rc.top = rc.bottom - gripperSize.cy; if (SUCCEEDED (DrawThemeBackground(theme, hdc, SP_GRIPPER, 0, &rc, NULL))) return; } } rc.left = max( rc.left, rc.right - GetSystemMetrics(SM_CXVSCROLL) - 1 ); rc.top = max( rc.top, rc.bottom - GetSystemMetrics(SM_CYHSCROLL) - 1 ); DrawFrameControl( hdc, &rc, DFC_SCROLL, DFCS_SCROLLSIZEGRIP ); }
void update_plugin_window(PluginHost *host, HWND hwnd, const RECT *rect) { BOOL rect_changed = FALSE; if(!hwnd || (host->hwnd && host->hwnd != hwnd)) { FIXME("unhandled hwnd\n"); return; } TRACE("%p %s\n", hwnd, wine_dbgstr_rect(rect)); if(memcmp(rect, &host->rect, sizeof(RECT))) { host->rect = *rect; rect_changed = TRUE; } if(!host->hwnd) { host->hwnd = hwnd; activate_plugin(host); } if(rect_changed && host->ip_object) IOleInPlaceObject_SetObjectRects(host->ip_object, &host->rect, &host->rect); }
/* * @implemented * * Synced with wine 1.1.32 */ INT WINAPI DrawTextExW( HDC hdc, LPWSTR str, INT i_count, LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp ) { SIZE size; const WCHAR *strPtr; WCHAR *retstr, *p_retstr; size_t size_retstr; WCHAR line[MAX_BUFFER]; int len, lh, count=i_count; TEXTMETRICW tm; int lmargin = 0, rmargin = 0; int x = rect->left, y = rect->top; int width = rect->right - rect->left; int max_width = 0; int last_line; int tabwidth /* to keep gcc happy */ = 0; int prefix_offset; ellipsis_data ellip; int invert_y=0; TRACE("%s, %d, [%s] %08x\n", debugstr_wn (str, count), count, wine_dbgstr_rect(rect), flags); if (dtp) TRACE("Params: iTabLength=%d, iLeftMargin=%d, iRightMargin=%d\n", dtp->iTabLength, dtp->iLeftMargin, dtp->iRightMargin); if (!str) return 0; strPtr = str; if (flags & DT_SINGLELINE) flags &= ~DT_WORDBREAK; GetTextMetricsW(hdc, &tm); if (flags & DT_EXTERNALLEADING) lh = tm.tmHeight + tm.tmExternalLeading; else lh = tm.tmHeight; if (str[0] && count == 0) return lh; if (dtp && dtp->cbSize != sizeof(DRAWTEXTPARAMS)) return 0; if (count == -1) { count = strlenW(str); if (count == 0) { if( flags & DT_CALCRECT) { rect->right = rect->left; if( flags & DT_SINGLELINE) rect->bottom = rect->top + lh; else rect->bottom = rect->top; } return lh; } } if (GetGraphicsMode(hdc) == GM_COMPATIBLE) { SIZE window_ext, viewport_ext; GetWindowExtEx(hdc, &window_ext); GetViewportExtEx(hdc, &viewport_ext); if ((window_ext.cy > 0) != (viewport_ext.cy > 0)) invert_y = 1; } if (dtp) { lmargin = dtp->iLeftMargin; rmargin = dtp->iRightMargin; if (!(flags & (DT_CENTER | DT_RIGHT))) x += lmargin; dtp->uiLengthDrawn = 0; /* This param RECEIVES number of chars processed */ } if (flags & DT_EXPANDTABS) { int tabstop = ((flags & DT_TABSTOP) && dtp) ? dtp->iTabLength : 8; tabwidth = tm.tmAveCharWidth * tabstop; } if (flags & DT_CALCRECT) flags |= DT_NOCLIP; if (flags & DT_MODIFYSTRING) { size_retstr = (count + 4) * sizeof (WCHAR); retstr = HeapAlloc(GetProcessHeap(), 0, size_retstr); if (!retstr) return 0; memcpy (retstr, str, size_retstr); } else { size_retstr = 0; retstr = NULL; } p_retstr = retstr; do { len = sizeof(line)/sizeof(line[0]); if (invert_y) last_line = !(flags & DT_NOCLIP) && y - ((flags & DT_EDITCONTROL) ? 2*lh-1 : lh) < rect->bottom; else last_line = !(flags & DT_NOCLIP) && y + ((flags & DT_EDITCONTROL) ? 2*lh-1 : lh) > rect->bottom; strPtr = TEXT_NextLineW(hdc, strPtr, &count, line, &len, width, flags, &size, last_line, &p_retstr, tabwidth, &prefix_offset, &ellip); if (flags & DT_CENTER) x = (rect->left + rect->right - size.cx) / 2; else if (flags & DT_RIGHT) x = rect->right - size.cx; if (flags & DT_SINGLELINE) { if (flags & DT_VCENTER) y = rect->top + (rect->bottom - rect->top) / 2 - size.cy / 2; else if (flags & DT_BOTTOM) y = rect->bottom - size.cy; } if (!(flags & DT_CALCRECT)) { const WCHAR *str = line; int xseg = x; while (len) { int len_seg; SIZE size; if ((flags & DT_EXPANDTABS)) { const WCHAR *p; p = str; while (p < str+len && *p != TAB) p++; len_seg = p - str; if (len_seg != len && !GetTextExtentPointW(hdc, str, len_seg, &size)) return 0; } else len_seg = len; if (!ExtTextOutW( hdc, xseg, y, ((flags & DT_NOCLIP) ? 0 : ETO_CLIPPED) | ((flags & DT_RTLREADING) ? ETO_RTLREADING : 0), rect, str, len_seg, NULL )) return 0; if (prefix_offset != -1 && prefix_offset < len_seg) { TEXT_DrawUnderscore (hdc, xseg, y + tm.tmAscent + 1, str, prefix_offset, (flags & DT_NOCLIP) ? NULL : rect); } len -= len_seg; str += len_seg; if (len) { assert ((flags & DT_EXPANDTABS) && *str == TAB); len--; str++; xseg += ((size.cx/tabwidth)+1)*tabwidth; if (prefix_offset != -1) { if (prefix_offset < len_seg) { /* We have just drawn an underscore; we ought to * figure out where the next one is. I am going * to leave it for now until I have a better model * for the line, which will make reprefixing easier. * This is where ellip would be used. */ prefix_offset = -1; } else prefix_offset -= len_seg; } } } } else if (size.cx > max_width) max_width = size.cx; if (invert_y) y -= lh; else y += lh; if (dtp) dtp->uiLengthDrawn += len; } while (strPtr && !last_line); if (flags & DT_CALCRECT) { rect->right = rect->left + max_width; rect->bottom = y; if (dtp) rect->right += lmargin + rmargin; } if (retstr) { memcpy (str, retstr, size_retstr); HeapFree (GetProcessHeap(), 0, retstr); } return y - rect->top; }
/****************************************************************************** * MCIAVI_mciWhere [internal] */ DWORD MCIAVI_mciWhere(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms) { WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID); RECT rc; TRACE("(%04x, %08x, %p)\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK; if (wma == NULL) return MCIERR_INVALID_DEVICE_ID; /* Ignore MCI_TEST flag. */ EnterCriticalSection(&wma->cs); if (dwFlags & MCI_DGV_WHERE_DESTINATION) { if (dwFlags & MCI_DGV_WHERE_MAX) { GetClientRect(wma->hWndPaint, &rc); TRACE("WHERE_DESTINATION_MAX %s\n", wine_dbgstr_rect(&rc)); } else { TRACE("WHERE_DESTINATION %s\n", wine_dbgstr_rect(&wma->dest)); rc = wma->dest; } } if (dwFlags & MCI_DGV_WHERE_FRAME) { if (dwFlags & MCI_DGV_WHERE_MAX) FIXME("MCI_DGV_WHERE_FRAME_MAX\n"); else FIXME("MCI_DGV_WHERE_FRAME\n"); LeaveCriticalSection(&wma->cs); return MCIERR_UNRECOGNIZED_COMMAND; } if (dwFlags & MCI_DGV_WHERE_SOURCE) { if (dwFlags & MCI_DGV_WHERE_MAX) { rc.left = 0; rc.top = 0; rc.right = wma->inbih->biWidth; rc.bottom = wma->inbih->biHeight; TRACE("WHERE_SOURCE_MAX %s\n", wine_dbgstr_rect(&rc)); } else { TRACE("WHERE_SOURCE %s\n", wine_dbgstr_rect(&wma->source)); rc = wma->source; } } if (dwFlags & MCI_DGV_WHERE_VIDEO) { if (dwFlags & MCI_DGV_WHERE_MAX) FIXME("WHERE_VIDEO_MAX\n"); else FIXME("WHERE_VIDEO\n"); LeaveCriticalSection(&wma->cs); return MCIERR_UNRECOGNIZED_COMMAND; } if (dwFlags & MCI_DGV_WHERE_WINDOW) { if (dwFlags & MCI_DGV_WHERE_MAX) { GetWindowRect(GetDesktopWindow(), &rc); TRACE("WHERE_WINDOW_MAX %s\n", wine_dbgstr_rect(&rc)); } else { GetWindowRect(wma->hWndPaint, &rc); TRACE("WHERE_WINDOW %s\n", wine_dbgstr_rect(&rc)); } } /* In MCI, RECT structure is used differently: rc.right = width & rc.bottom = height * So convert the normal RECT into a MCI RECT before returning */ lpParms->rc.left = rc.left; lpParms->rc.top = rc.top; lpParms->rc.right = rc.right - rc.left; lpParms->rc.bottom = rc.bottom - rc.top; LeaveCriticalSection(&wma->cs); return 0; }
/********************************************************************** * EMFDRV_ExtTextOut */ BOOL EMFDRV_ExtTextOut( PHYSDEV dev, INT x, INT y, UINT flags, const RECT *lprect, LPCWSTR str, UINT count, const INT *lpDx ) { EMREXTTEXTOUTW *pemr; DWORD nSize; BOOL ret; EMFDRV_PDEVICE *physDev = (EMFDRV_PDEVICE*) dev; int textHeight = 0; int textWidth = 0; const UINT textAlign = GetTextAlign(physDev->hdc); nSize = sizeof(*pemr) + ((count+1) & ~1) * sizeof(WCHAR) + count * sizeof(INT); TRACE("%s %s count %d nSize = %ld\n", debugstr_wn(str, count), wine_dbgstr_rect(lprect), count, nSize); pemr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nSize); pemr->emr.iType = EMR_EXTTEXTOUTW; pemr->emr.nSize = nSize; pemr->iGraphicsMode = GetGraphicsMode(physDev->hdc); pemr->exScale = pemr->eyScale = 1.0; /* FIXME */ pemr->emrtext.ptlReference.x = x; pemr->emrtext.ptlReference.y = y; pemr->emrtext.nChars = count; pemr->emrtext.offString = sizeof(*pemr); memcpy((char*)pemr + pemr->emrtext.offString, str, count * sizeof(WCHAR)); pemr->emrtext.fOptions = flags; if(!lprect) { pemr->emrtext.rcl.left = pemr->emrtext.rcl.top = 0; pemr->emrtext.rcl.right = pemr->emrtext.rcl.bottom = -1; } else { pemr->emrtext.rcl.left = lprect->left; pemr->emrtext.rcl.top = lprect->top; pemr->emrtext.rcl.right = lprect->right; pemr->emrtext.rcl.bottom = lprect->bottom; } pemr->emrtext.offDx = pemr->emrtext.offString + ((count+1) & ~1) * sizeof(WCHAR); if(lpDx) { UINT i; SIZE strSize; memcpy((char*)pemr + pemr->emrtext.offDx, lpDx, count * sizeof(INT)); for (i = 0; i < count; i++) { textWidth += lpDx[i]; } GetTextExtentPoint32W(physDev->hdc, str, count, &strSize); textHeight = strSize.cy; } else { UINT i; INT *dx = (INT *)((char*)pemr + pemr->emrtext.offDx); SIZE charSize; for (i = 0; i < count; i++) { GetTextExtentPoint32W(physDev->hdc, str + i, 1, &charSize); dx[i] = charSize.cx; textWidth += charSize.cx; textHeight = max(textHeight, charSize.cy); } } switch (textAlign & (TA_LEFT | TA_RIGHT | TA_CENTER)) { case TA_CENTER: { pemr->rclBounds.left = x - (textWidth / 2) - 1; pemr->rclBounds.right = x + (textWidth / 2) + 1; break; } case TA_RIGHT: { pemr->rclBounds.left = x - textWidth - 1; pemr->rclBounds.right = x; break; } default: { /* TA_LEFT */ pemr->rclBounds.left = x; pemr->rclBounds.right = x + textWidth + 1; } } switch (textAlign & (TA_TOP | TA_BOTTOM | TA_BASELINE)) { case TA_BASELINE: { TEXTMETRICW tm; GetTextMetricsW(physDev->hdc, &tm); /* Play safe here... it's better to have a bounding box */ /* that is too big than too small. */ pemr->rclBounds.top = y - textHeight - 1; pemr->rclBounds.bottom = y + tm.tmDescent + 1; break; } case TA_BOTTOM: { pemr->rclBounds.top = y - textHeight - 1; pemr->rclBounds.bottom = y; break; } default: { /* TA_TOP */ pemr->rclBounds.top = y; pemr->rclBounds.bottom = y + textHeight + 1; } } ret = EMFDRV_WriteRecord( dev, &pemr->emr ); if(ret) EMFDRV_UpdateBBox( dev, &pemr->rclBounds ); HeapFree( GetProcessHeap(), 0, pemr ); return ret; }
/********************************************************************** * ExtEscape (X11DRV.@) */ static INT X11DRV_ExtEscape( PHYSDEV dev, INT escape, INT in_count, LPCVOID in_data, INT out_count, LPVOID out_data ) { X11DRV_PDEVICE *physDev = get_x11drv_dev( dev ); switch(escape) { case QUERYESCSUPPORT: if (in_data && in_count >= sizeof(DWORD)) { switch (*(const INT *)in_data) { case X11DRV_ESCAPE: return TRUE; } } break; case X11DRV_ESCAPE: if (in_data && in_count >= sizeof(enum x11drv_escape_codes)) { switch(*(const enum x11drv_escape_codes *)in_data) { case X11DRV_SET_DRAWABLE: if (in_count >= sizeof(struct x11drv_escape_set_drawable)) { const struct x11drv_escape_set_drawable *data = in_data; physDev->dc_rect = data->dc_rect; physDev->drawable = data->drawable; XFreeGC( gdi_display, physDev->gc ); physDev->gc = XCreateGC( gdi_display, physDev->drawable, 0, NULL ); XSetGraphicsExposures( gdi_display, physDev->gc, False ); XSetSubwindowMode( gdi_display, physDev->gc, data->mode ); TRACE( "SET_DRAWABLE hdc %p drawable %lx dc_rect %s\n", dev->hdc, physDev->drawable, wine_dbgstr_rect(&physDev->dc_rect) ); return TRUE; } break; case X11DRV_GET_DRAWABLE: if (out_count >= sizeof(struct x11drv_escape_get_drawable)) { struct x11drv_escape_get_drawable *data = out_data; data->drawable = physDev->drawable; data->dc_rect = physDev->dc_rect; return TRUE; } break; case X11DRV_FLUSH_GL_DRAWABLE: if (in_count >= sizeof(struct x11drv_escape_flush_gl_drawable)) { const struct x11drv_escape_flush_gl_drawable *data = in_data; RECT rect = physDev->dc_rect; OffsetRect( &rect, -physDev->dc_rect.left, -physDev->dc_rect.top ); /* The GL drawable may be lagged behind if we don't flush first, so * flush the display make sure we copy up-to-date data */ XFlush( gdi_display ); XSetFunction( gdi_display, physDev->gc, GXcopy ); XCopyArea( gdi_display, data->gl_drawable, physDev->drawable, physDev->gc, 0, 0, rect.right, rect.bottom, physDev->dc_rect.left, physDev->dc_rect.top ); add_device_bounds( physDev, &rect ); return TRUE; } break; case X11DRV_START_EXPOSURES: XSetGraphicsExposures( gdi_display, physDev->gc, True ); physDev->exposures = 0; return TRUE; case X11DRV_END_EXPOSURES: if (out_count >= sizeof(HRGN)) { HRGN hrgn = 0, tmp = 0; XSetGraphicsExposures( gdi_display, physDev->gc, False ); if (physDev->exposures) { for (;;) { XEvent event; XWindowEvent( gdi_display, physDev->drawable, ~0, &event ); if (event.type == NoExpose) break; if (event.type == GraphicsExpose) { RECT rect; rect.left = event.xgraphicsexpose.x - physDev->dc_rect.left; rect.top = event.xgraphicsexpose.y - physDev->dc_rect.top; rect.right = rect.left + event.xgraphicsexpose.width; rect.bottom = rect.top + event.xgraphicsexpose.height; if (GetLayout( dev->hdc ) & LAYOUT_RTL) mirror_rect( &physDev->dc_rect, &rect ); TRACE( "got %s count %d\n", wine_dbgstr_rect(&rect), event.xgraphicsexpose.count ); if (!tmp) tmp = CreateRectRgnIndirect( &rect ); else SetRectRgn( tmp, rect.left, rect.top, rect.right, rect.bottom ); if (hrgn) CombineRgn( hrgn, hrgn, tmp, RGN_OR ); else { hrgn = tmp; tmp = 0; } if (!event.xgraphicsexpose.count) break; } else { ERR( "got unexpected event %d\n", event.type ); break; } } if (tmp) DeleteObject( tmp ); } *(HRGN *)out_data = hrgn; return TRUE; } break; default: break; } } break; } return 0; }
/************************************************************************* * ScrollDC (X11DRV.@) */ BOOL X11DRV_ScrollDC( HDC hdc, INT dx, INT dy, const RECT *lprcScroll, const RECT *lprcClip, HRGN hrgnUpdate, LPRECT lprcUpdate ) { RECT rcSrc, rcClip, offset; INT dxdev, dydev, res; HRGN DstRgn, clipRgn, visrgn; INT code = X11DRV_START_EXPOSURES; TRACE("dx,dy %d,%d rcScroll %s rcClip %s hrgnUpdate %p lprcUpdate %p\n", dx, dy, wine_dbgstr_rect(lprcScroll), wine_dbgstr_rect(lprcClip), hrgnUpdate, lprcUpdate); /* enable X-exposure events */ if (hrgnUpdate || lprcUpdate) ExtEscape( hdc, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, 0, NULL ); /* get the visible region */ visrgn=CreateRectRgn( 0, 0, 0, 0); GetRandomRgn( hdc, visrgn, SYSRGN); if( !(GetVersion() & 0x80000000)) { /* Window NT/2k/XP */ POINT org; GetDCOrgEx(hdc, &org); OffsetRgn( visrgn, -org.x, -org.y); } /* intersect with the clipping Region if the DC has one */ clipRgn = CreateRectRgn( 0, 0, 0, 0); if (GetClipRgn( hdc, clipRgn) != 1) { DeleteObject(clipRgn); clipRgn=NULL; } else CombineRgn( visrgn, visrgn, clipRgn, RGN_AND); /* only those pixels in the scroll rectangle that remain in the clipping * rect are scrolled. */ if( lprcClip) rcClip = *lprcClip; else GetClipBox( hdc, &rcClip); rcSrc = rcClip; OffsetRect( &rcClip, -dx, -dy); IntersectRect( &rcSrc, &rcSrc, &rcClip); /* if an scroll rectangle is specified, only the pixels within that * rectangle are scrolled */ if( lprcScroll) IntersectRect( &rcSrc, &rcSrc, lprcScroll); /* now convert to device coordinates */ LPtoDP(hdc, (LPPOINT)&rcSrc, 2); TRACE("source rect: %s\n", wine_dbgstr_rect(&rcSrc)); /* also dx and dy */ SetRect(&offset, 0, 0, dx, dy); LPtoDP(hdc, (LPPOINT)&offset, 2); dxdev = offset.right - offset.left; dydev = offset.bottom - offset.top; /* now intersect with the visible region to get the pixels that will * actually scroll */ DstRgn = CreateRectRgnIndirect( &rcSrc); res = CombineRgn( DstRgn, DstRgn, visrgn, RGN_AND); /* and translate, giving the destination region */ OffsetRgn( DstRgn, dxdev, dydev); if( TRACE_ON( scroll)) dump_region( "Destination scroll region: ", DstRgn); /* if there are any, do it */ if( res > NULLREGION) { RECT rect ; /* clip to the destination region, so we can BitBlt with a simple * bounding rectangle */ if( clipRgn) ExtSelectClipRgn( hdc, DstRgn, RGN_AND); else SelectClipRgn( hdc, DstRgn); GetRgnBox( DstRgn, &rect); DPtoLP(hdc, (LPPOINT)&rect, 2); TRACE("destination rect: %s\n", wine_dbgstr_rect(&rect)); BitBlt( hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, hdc, rect.left - dx, rect.top - dy, SRCCOPY); } /* compute the update areas. This is the combined clip rectangle * minus the scrolled region, and intersected with the visible * region. */ if (hrgnUpdate || lprcUpdate) { HRGN hrgn = hrgnUpdate; HRGN ExpRgn = 0; /* collect all the exposures */ code = X11DRV_END_EXPOSURES; ExtEscape( hdc, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, sizeof(ExpRgn), (LPSTR)&ExpRgn ); /* Intersect clip and scroll rectangles, allowing NULL values */ if( lprcScroll) if( lprcClip) IntersectRect( &rcClip, lprcClip, lprcScroll); else rcClip = *lprcScroll; else if( lprcClip) rcClip = *lprcClip; else GetClipBox( hdc, &rcClip); /* Convert the combined clip rectangle to device coordinates */ LPtoDP(hdc, (LPPOINT)&rcClip, 2); if( hrgn ) SetRectRgn( hrgn, rcClip.left, rcClip.top, rcClip.right, rcClip.bottom); else hrgn = CreateRectRgnIndirect( &rcClip); CombineRgn( hrgn, hrgn, visrgn, RGN_AND); CombineRgn( hrgn, hrgn, DstRgn, RGN_DIFF); /* add the exposures to this */ if( ExpRgn) { if( TRACE_ON( scroll)) dump_region( "Expose region: ", ExpRgn); CombineRgn( hrgn, hrgn, ExpRgn, RGN_OR); DeleteObject( ExpRgn); } if( TRACE_ON( scroll)) dump_region( "Update region: ", hrgn); if( lprcUpdate) { GetRgnBox( hrgn, lprcUpdate ); /* Put the lprcUpdate in logical coordinates */ DPtoLP( hdc, (LPPOINT)lprcUpdate, 2 ); TRACE("returning lprcUpdate %s\n", wine_dbgstr_rect(lprcUpdate)); } if( !hrgnUpdate) DeleteObject( hrgn); } /* restore original clipping region */ SelectClipRgn( hdc, clipRgn); DeleteObject( visrgn); DeleteObject( DstRgn); if( clipRgn) DeleteObject( clipRgn); return TRUE; }
/*********************************************************************** * PSDRV_PutImage */ DWORD PSDRV_PutImage( PHYSDEV dev, HBITMAP hbitmap, HRGN clip, BITMAPINFO *info, const struct gdi_image_bits *bits, struct bitblt_coords *src, struct bitblt_coords *dst, DWORD rop ) { int src_stride, dst_stride, size, x, y, width, height, bit_offset; int dst_x, dst_y, dst_width, dst_height; unsigned char *src_ptr, *dst_ptr; struct gdi_image_bits dst_bits; if (hbitmap) return ERROR_NOT_SUPPORTED; if (info->bmiHeader.biPlanes != 1) goto update_format; if (info->bmiHeader.biCompression != BI_RGB) goto update_format; if (info->bmiHeader.biBitCount == 16 || info->bmiHeader.biBitCount == 32) goto update_format; if (!bits) return ERROR_SUCCESS; /* just querying the format */ TRACE( "bpp %u %s -> %s\n", info->bmiHeader.biBitCount, wine_dbgstr_rect(&src->visrect), wine_dbgstr_rect(&dst->visrect) ); width = src->visrect.right - src->visrect.left; height = src->visrect.bottom - src->visrect.top; src_stride = get_dib_width_bytes( info->bmiHeader.biWidth, info->bmiHeader.biBitCount ); dst_stride = (width * info->bmiHeader.biBitCount + 7) / 8; src_ptr = bits->ptr; if (info->bmiHeader.biHeight > 0) src_ptr += (info->bmiHeader.biHeight - src->visrect.bottom) * src_stride; else src_ptr += src->visrect.top * src_stride; bit_offset = src->visrect.left * info->bmiHeader.biBitCount; src_ptr += bit_offset / 8; bit_offset &= 7; if (bit_offset) FIXME( "pos %s not supported\n", wine_dbgstr_rect(&src->visrect) ); size = height * dst_stride; if (src_stride != dst_stride || (info->bmiHeader.biBitCount == 24 && !bits->is_copy)) { if (!(dst_bits.ptr = HeapAlloc( GetProcessHeap(), 0, size ))) return ERROR_OUTOFMEMORY; dst_bits.is_copy = TRUE; dst_bits.free = free_heap_bits; } else { dst_bits.ptr = src_ptr; dst_bits.is_copy = bits->is_copy; dst_bits.free = NULL; } dst_ptr = dst_bits.ptr; switch (info->bmiHeader.biBitCount) { case 1: case 4: case 8: if (src_stride != dst_stride) for (y = 0; y < height; y++, src_ptr += src_stride, dst_ptr += dst_stride) memcpy( dst_ptr, src_ptr, dst_stride ); break; case 24: if (dst_ptr != src_ptr) for (y = 0; y < height; y++, src_ptr += src_stride, dst_ptr += dst_stride) for (x = 0; x < width; x++) { dst_ptr[x * 3] = src_ptr[x * 3 + 2]; dst_ptr[x * 3 + 1] = src_ptr[x * 3 + 1]; dst_ptr[x * 3 + 2] = src_ptr[x * 3]; } else /* swap R and B in place */ for (y = 0; y < height; y++, src_ptr += src_stride, dst_ptr += dst_stride) for (x = 0; x < width; x++) { unsigned char tmp = dst_ptr[x * 3]; dst_ptr[x * 3] = dst_ptr[x * 3 + 2]; dst_ptr[x * 3 + 2] = tmp; } break; } dst_x = dst->visrect.left; dst_y = dst->visrect.top, dst_width = dst->visrect.right - dst->visrect.left; dst_height = dst->visrect.bottom - dst->visrect.top; if (src->width * dst->width < 0) { dst_x += dst_width; dst_width = -dst_width; } if (src->height * dst->height < 0) { dst_y += dst_height; dst_height = -dst_height; } PSDRV_SetClip(dev); PSDRV_WriteGSave(dev); if (clip) PSDRV_AddClip( dev, clip ); PSDRV_WriteImageBits( dev, info, dst_x, dst_y, dst_width, dst_height, width, height, dst_bits.ptr, size ); PSDRV_WriteGRestore(dev); PSDRV_ResetClip(dev); if (dst_bits.free) dst_bits.free( &dst_bits ); return ERROR_SUCCESS; update_format: info->bmiHeader.biPlanes = 1; if (info->bmiHeader.biBitCount > 8) info->bmiHeader.biBitCount = 24; info->bmiHeader.biCompression = BI_RGB; return ERROR_BAD_FORMAT; }
static HRESULT WINAPI d3d8_surface_LockRect(IDirect3DSurface8 *iface, D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) { struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface); struct wined3d_box box; struct wined3d_map_desc map_desc; HRESULT hr; D3DRESOURCETYPE type; TRACE("iface %p, locked_rect %p, rect %s, flags %#x.\n", iface, locked_rect, wine_dbgstr_rect(rect), flags); wined3d_mutex_lock(); if (surface->texture) type = IDirect3DBaseTexture8_GetType(&surface->texture->IDirect3DBaseTexture8_iface); else type = D3DRTYPE_SURFACE; if (rect) { D3DSURFACE_DESC desc; IDirect3DSurface8_GetDesc(iface, &desc); if (type != D3DRTYPE_TEXTURE && ((rect->left < 0) || (rect->top < 0) || (rect->left >= rect->right) || (rect->top >= rect->bottom) || (rect->right > desc.Width) || (rect->bottom > desc.Height))) { WARN("Trying to lock an invalid rectangle, returning D3DERR_INVALIDCALL\n"); wined3d_mutex_unlock(); locked_rect->Pitch = 0; locked_rect->pBits = NULL; return D3DERR_INVALIDCALL; } wined3d_box_set(&box, rect->left, rect->top, rect->right, rect->bottom, 0, 1); } hr = wined3d_resource_map(wined3d_texture_get_resource(surface->wined3d_texture), surface->sub_resource_idx, &map_desc, rect ? &box : NULL, wined3dmapflags_from_d3dmapflags(flags, 0)); wined3d_mutex_unlock(); if (SUCCEEDED(hr)) { locked_rect->Pitch = map_desc.row_pitch; locked_rect->pBits = map_desc.data; } else if (type != D3DRTYPE_TEXTURE) { locked_rect->Pitch = 0; locked_rect->pBits = NULL; } if (hr == E_INVALIDARG) return D3DERR_INVALIDCALL; return hr; }
/* A GL context is provided by the caller */ static void swapchain_blit(IWineD3DSwapChainImpl *This, struct wined3d_context *context, const RECT *src_rect, const RECT *dst_rect) { IWineD3DDeviceImpl *device = This->device; IWineD3DSurfaceImpl *backbuffer = ((IWineD3DSurfaceImpl *) This->backBuffer[0]); UINT src_w = src_rect->right - src_rect->left; UINT src_h = src_rect->bottom - src_rect->top; GLenum gl_filter; const struct wined3d_gl_info *gl_info = context->gl_info; TRACE("swapchain %p, context %p, src_rect %s, dst_rect %s.\n", This, context, wine_dbgstr_rect(src_rect), wine_dbgstr_rect(dst_rect)); if (src_w == dst_rect->right - dst_rect->left && src_h == dst_rect->bottom - dst_rect->top) gl_filter = GL_NEAREST; else gl_filter = GL_LINEAR; if (0 && gl_info->fbo_ops.glBlitFramebuffer && is_identity_fixup(backbuffer->resource.format_desc->color_fixup)) { ENTER_GL(); context_bind_fbo(context, GL_READ_FRAMEBUFFER, &context->src_fbo); context_attach_surface_fbo(context, GL_READ_FRAMEBUFFER, 0, backbuffer); context_attach_depth_stencil_fbo(context, GL_READ_FRAMEBUFFER, NULL, FALSE); context_bind_fbo(context, GL_DRAW_FRAMEBUFFER, NULL); context_set_draw_buffer(context, GL_BACK); glDisable(GL_SCISSOR_TEST); IWineD3DDeviceImpl_MarkStateDirty(This->device, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE)); /* Note that the texture is upside down */ gl_info->fbo_ops.glBlitFramebuffer(src_rect->left, src_rect->top, src_rect->right, src_rect->bottom, dst_rect->left, dst_rect->bottom, dst_rect->right, dst_rect->top, GL_COLOR_BUFFER_BIT, gl_filter); checkGLcall("Swapchain present blit(EXT_framebuffer_blit)\n"); LEAVE_GL(); } else { struct wined3d_context *context2; float tex_left = src_rect->left; float tex_top = src_rect->top; float tex_right = src_rect->right; float tex_bottom = src_rect->bottom; context2 = context_acquire(This->device, This->backBuffer[0], CTXUSAGE_BLIT); if(backbuffer->Flags & SFLAG_NORMCOORD) { tex_left /= src_w; tex_right /= src_w; tex_top /= src_h; tex_bottom /= src_h; } if (is_complex_fixup(backbuffer->resource.format_desc->color_fixup)) gl_filter = GL_NEAREST; ENTER_GL(); context_bind_fbo(context2, GL_DRAW_FRAMEBUFFER, NULL); /* Set up the texture. The surface is not in a IWineD3D*Texture container, * so there are no d3d texture settings to dirtify */ device->blitter->set_shader((IWineD3DDevice *) device, backbuffer); glTexParameteri(backbuffer->texture_target, GL_TEXTURE_MIN_FILTER, gl_filter); glTexParameteri(backbuffer->texture_target, GL_TEXTURE_MAG_FILTER, gl_filter); context_set_draw_buffer(context, GL_BACK); /* Set the viewport to the destination rectandle, disable any projection * transformation set up by CTXUSAGE_BLIT, and draw a (-1,-1)-(1,1) quad. * * Back up viewport and matrix to avoid breaking last_was_blit * * Note that CTXUSAGE_BLIT set up viewport and ortho to match the surface * size - we want the GL drawable(=window) size. */ glPushAttrib(GL_VIEWPORT_BIT); glViewport(dst_rect->left, dst_rect->top, dst_rect->right, dst_rect->bottom); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glBegin(GL_QUADS); /* bottom left */ glTexCoord2f(tex_left, tex_bottom); glVertex2i(-1, -1); /* top left */ glTexCoord2f(tex_left, tex_top); glVertex2i(-1, 1); /* top right */ glTexCoord2f(tex_right, tex_top); glVertex2i(1, 1); /* bottom right */ glTexCoord2f(tex_right, tex_bottom); glVertex2i(1, -1); glEnd(); glPopMatrix(); glPopAttrib(); device->blitter->unset_shader((IWineD3DDevice *) device); checkGLcall("Swapchain present blit(manual)\n"); LEAVE_GL(); context_release(context2); } }
/* A GL context is provided by the caller */ static void swapchain_blit(const struct wined3d_swapchain *swapchain, struct wined3d_context *context, const RECT *src_rect, const RECT *dst_rect) { struct wined3d_surface *backbuffer = swapchain->back_buffers[0]; UINT src_w = src_rect->right - src_rect->left; UINT src_h = src_rect->bottom - src_rect->top; GLenum gl_filter; const struct wined3d_gl_info *gl_info = context->gl_info; RECT win_rect; UINT win_h; TRACE("swapchain %p, context %p, src_rect %s, dst_rect %s.\n", swapchain, context, wine_dbgstr_rect(src_rect), wine_dbgstr_rect(dst_rect)); if (src_w == dst_rect->right - dst_rect->left && src_h == dst_rect->bottom - dst_rect->top) gl_filter = GL_NEAREST; else gl_filter = GL_LINEAR; GetClientRect(swapchain->win_handle, &win_rect); win_h = win_rect.bottom - win_rect.top; if (gl_info->fbo_ops.glBlitFramebuffer && is_identity_fixup(backbuffer->resource.format->color_fixup)) { DWORD location = SFLAG_INTEXTURE; if (backbuffer->resource.multisample_type) { location = SFLAG_INRB_RESOLVED; surface_load_location(backbuffer, location, NULL); } ENTER_GL(); context_apply_fbo_state_blit(context, GL_READ_FRAMEBUFFER, backbuffer, NULL, location); glReadBuffer(GL_COLOR_ATTACHMENT0); context_check_fbo_status(context, GL_READ_FRAMEBUFFER); context_apply_fbo_state_blit(context, GL_DRAW_FRAMEBUFFER, swapchain->front_buffer, NULL, SFLAG_INDRAWABLE); context_set_draw_buffer(context, GL_BACK); context_invalidate_state(context, STATE_FRAMEBUFFER); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE)); context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1)); context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2)); context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3)); glDisable(GL_SCISSOR_TEST); context_invalidate_state(context, STATE_RENDER(WINED3D_RS_SCISSORTESTENABLE)); /* Note that the texture is upside down */ gl_info->fbo_ops.glBlitFramebuffer(src_rect->left, src_rect->top, src_rect->right, src_rect->bottom, dst_rect->left, win_h - dst_rect->top, dst_rect->right, win_h - dst_rect->bottom, GL_COLOR_BUFFER_BIT, gl_filter); checkGLcall("Swapchain present blit(EXT_framebuffer_blit)\n"); LEAVE_GL(); } else { struct wined3d_device *device = swapchain->device; struct wined3d_context *context2; float tex_left = src_rect->left; float tex_top = src_rect->top; float tex_right = src_rect->right; float tex_bottom = src_rect->bottom; context2 = context_acquire(device, swapchain->back_buffers[0]); context_apply_blit_state(context2, device); if (backbuffer->flags & SFLAG_NORMCOORD) { tex_left /= src_w; tex_right /= src_w; tex_top /= src_h; tex_bottom /= src_h; } if (is_complex_fixup(backbuffer->resource.format->color_fixup)) gl_filter = GL_NEAREST; ENTER_GL(); context_apply_fbo_state_blit(context2, GL_FRAMEBUFFER, swapchain->front_buffer, NULL, SFLAG_INDRAWABLE); /* Set up the texture. The surface is not in a wined3d_texture * container, so there are no D3D texture settings to dirtify. */ device->blitter->set_shader(device->blit_priv, context2, backbuffer); glTexParameteri(backbuffer->texture_target, GL_TEXTURE_MIN_FILTER, gl_filter); glTexParameteri(backbuffer->texture_target, GL_TEXTURE_MAG_FILTER, gl_filter); context_set_draw_buffer(context, GL_BACK); /* Set the viewport to the destination rectandle, disable any projection * transformation set up by context_apply_blit_state(), and draw a * (-1,-1)-(1,1) quad. * * Back up viewport and matrix to avoid breaking last_was_blit * * Note that context_apply_blit_state() set up viewport and ortho to * match the surface size - we want the GL drawable(=window) size. */ glPushAttrib(GL_VIEWPORT_BIT); glViewport(dst_rect->left, win_h - dst_rect->bottom, dst_rect->right, win_h - dst_rect->top); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glBegin(GL_QUADS); /* bottom left */ glTexCoord2f(tex_left, tex_bottom); glVertex2i(-1, -1); /* top left */ glTexCoord2f(tex_left, tex_top); glVertex2i(-1, 1); /* top right */ glTexCoord2f(tex_right, tex_top); glVertex2i(1, 1); /* bottom right */ glTexCoord2f(tex_right, tex_bottom); glVertex2i(1, -1); glEnd(); glPopMatrix(); glPopAttrib(); device->blitter->unset_shader(context->gl_info); checkGLcall("Swapchain present blit(manual)\n"); LEAVE_GL(); context_release(context2); } }
/****************************************************************************** * Acquire : gets exclusive control of the mouse */ static HRESULT WINAPI SysMouseAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface) { SysMouseImpl *This = (SysMouseImpl *)iface; RECT rect; POINT point; HRESULT res; TRACE("(this=%p)\n",This); if ((res = IDirectInputDevice2AImpl_Acquire(iface)) != DI_OK) return res; /* Init the mouse state */ GetCursorPos( &point ); if (This->base.data_format.user_df->dwFlags & DIDF_ABSAXIS) { This->m_state.lX = point.x; This->m_state.lY = point.y; } else { This->m_state.lX = 0; This->m_state.lY = 0; This->org_coords = point; } This->m_state.lZ = 0; This->m_state.rgbButtons[0] = GetKeyState(VK_LBUTTON) & 0x80; This->m_state.rgbButtons[1] = GetKeyState(VK_RBUTTON) & 0x80; This->m_state.rgbButtons[2] = GetKeyState(VK_MBUTTON) & 0x80; /* Install our mouse hook */ if (This->base.dwCoopLevel & DISCL_EXCLUSIVE) { RECT rc; ShowCursor(FALSE); /* hide cursor */ if (GetWindowRect(This->base.win, &rc)) { FIXME("Clipping cursor to %s\n", wine_dbgstr_rect( &rc )); ClipCursor(&rc); } else ERR("Failed to get RECT: %d\n", GetLastError()); } /* Get the window dimension and find the center */ GetWindowRect(This->base.win, &rect); This->win_centerX = (rect.right - rect.left) / 2; This->win_centerY = (rect.bottom - rect.top ) / 2; /* Warp the mouse to the center of the window */ if (This->base.dwCoopLevel & DISCL_EXCLUSIVE) { This->mapped_center.x = This->win_centerX; This->mapped_center.y = This->win_centerY; MapWindowPoints(This->base.win, HWND_DESKTOP, &This->mapped_center, 1); TRACE("Warping mouse to %d - %d\n", This->mapped_center.x, This->mapped_center.y); SetCursorPos( This->mapped_center.x, This->mapped_center.y ); This->last_warped = GetCurrentTime(); This->need_warp = FALSE; } return DI_OK; }
/***************************************************************************** * IDirectDrawClipper::GetClipList * * Retrieve a copy of the clip list * * Arguments: * rect: Rectangle to be used to clip the clip list or NULL for the * entire clip list. * clip_list: structure for the resulting copy of the clip list. * If NULL, fills Size up to the number of bytes necessary to hold * the entire clip. * clip_list_size: Size of resulting clip list; size of the buffer at clip_list * or, if clip_list is NULL, receives the required size of the buffer * in bytes. * * RETURNS * Either DD_OK or DDERR_* ************************************************************************/ static HRESULT WINAPI ddraw_clipper_GetClipList(IDirectDrawClipper *iface, RECT *rect, RGNDATA *clip_list, DWORD *clip_list_size) { struct ddraw_clipper *clipper = impl_from_IDirectDrawClipper(iface); HRGN region; TRACE("iface %p, rect %s, clip_list %p, clip_list_size %p.\n", iface, wine_dbgstr_rect(rect), clip_list, clip_list_size); wined3d_mutex_lock(); if (clipper->window) { if (!(region = get_window_region(clipper->window))) { wined3d_mutex_unlock(); WARN("Failed to get window region.\n"); return E_FAIL; } } else { if (!(region = clipper->region)) { wined3d_mutex_unlock(); WARN("No clip list set.\n"); return DDERR_NOCLIPLIST; } } if (rect) { HRGN clip_region; if (!(clip_region = CreateRectRgnIndirect(rect))) { wined3d_mutex_unlock(); ERR("Failed to create region.\n"); if (clipper->window) DeleteObject(region); return E_FAIL; } if (CombineRgn(clip_region, region, clip_region, RGN_AND) == ERROR) { wined3d_mutex_unlock(); ERR("Failed to combine regions.\n"); DeleteObject(clip_region); if (clipper->window) DeleteObject(region); return E_FAIL; } if (clipper->window) DeleteObject(region); region = clip_region; } *clip_list_size = GetRegionData(region, *clip_list_size, clip_list); if (rect || clipper->window) DeleteObject(region); wined3d_mutex_unlock(); return DD_OK; }
/*********************************************************************** * BeginBufferedPaint (UXTHEME.@) */ HPAINTBUFFER WINAPI BeginBufferedPaint(HDC targetdc, const RECT *rect, BP_BUFFERFORMAT format, BP_PAINTPARAMS *params, HDC *retdc) { char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors[256])]; BITMAPINFO *bmi = (BITMAPINFO *)bmibuf; struct paintbuffer *buffer; TRACE("(%p %s %d %p %p)\n", targetdc, wine_dbgstr_rect(rect), format, params, retdc); if (retdc) *retdc = NULL; if (!targetdc || IsRectEmpty(rect)) return NULL; if (params) FIXME("painting parameters are ignored\n"); buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(*buffer)); buffer->targetdc = targetdc; buffer->rect = *rect; buffer->memorydc = CreateCompatibleDC(targetdc); switch (format) { case BPBF_COMPATIBLEBITMAP: buffer->bitmap = CreateCompatibleBitmap(targetdc, rect->right - rect->left, rect->bottom - rect->top); buffer->bits = NULL; break; case BPBF_DIB: case BPBF_TOPDOWNDIB: case BPBF_TOPDOWNMONODIB: /* create DIB section */ memset(bmi, 0, sizeof(bmibuf)); bmi->bmiHeader.biSize = sizeof(bmi->bmiHeader); bmi->bmiHeader.biHeight = format == BPBF_DIB ? rect->bottom - rect->top : -(rect->bottom - rect->top); bmi->bmiHeader.biWidth = rect->right - rect->left; bmi->bmiHeader.biBitCount = format == BPBF_TOPDOWNMONODIB ? 1 : 32; bmi->bmiHeader.biPlanes = 1; bmi->bmiHeader.biCompression = BI_RGB; buffer->bitmap = CreateDIBSection(buffer->memorydc, bmi, DIB_RGB_COLORS, &buffer->bits, NULL, 0); break; default: WARN("Unknown buffer format %d\n", format); buffer->bitmap = NULL; free_paintbuffer(buffer); return NULL; } if (!buffer->bitmap) { WARN("Failed to create buffer bitmap\n"); free_paintbuffer(buffer); return NULL; } SetWindowOrgEx(buffer->memorydc, rect->left, rect->top, NULL); IntersectClipRect(buffer->memorydc, rect->left, rect->top, rect->right, rect->bottom); DeleteObject(SelectObject(buffer->memorydc, buffer->bitmap)); *retdc = buffer->memorydc; return (HPAINTBUFFER)buffer; }
static LRESULT PAGER_MouseMove (PAGER_INFO* infoPtr, INT keys, INT x, INT y) { POINT clpt, pt; RECT wnrect, *btnrect = NULL; BOOL topLeft = FALSE; INT btnstate = 0; INT hit; HDC hdc; pt.x = x; pt.y = y; TRACE("[%p] to (%d,%d)\n", infoPtr->hwndSelf, x, y); ClientToScreen(infoPtr->hwndSelf, &pt); GetWindowRect(infoPtr->hwndSelf, &wnrect); if (PtInRect(&wnrect, pt)) { RECT TLbtnrect, BRbtnrect; PAGER_GetButtonRects(infoPtr, &TLbtnrect, &BRbtnrect, FALSE); clpt = pt; MapWindowPoints(0, infoPtr->hwndSelf, &clpt, 1); hit = PAGER_HitTest(infoPtr, &clpt); if ((hit == PGB_TOPORLEFT) && (infoPtr->TLbtnState == PGF_NORMAL)) { topLeft = TRUE; btnrect = &TLbtnrect; infoPtr->TLbtnState = PGF_HOT; btnstate = infoPtr->TLbtnState; } else if ((hit == PGB_BOTTOMORRIGHT) && (infoPtr->BRbtnState == PGF_NORMAL)) { topLeft = FALSE; btnrect = &BRbtnrect; infoPtr->BRbtnState = PGF_HOT; btnstate = infoPtr->BRbtnState; } /* If in one of the buttons the capture and draw buttons */ if (btnrect) { TRACE("[%p] draw btn (%s), Capture %s, style %08x\n", infoPtr->hwndSelf, wine_dbgstr_rect(btnrect), (infoPtr->bCapture) ? "TRUE" : "FALSE", infoPtr->dwStyle); if (!infoPtr->bCapture) { TRACE("[%p] SetCapture\n", infoPtr->hwndSelf); SetCapture(infoPtr->hwndSelf); infoPtr->bCapture = TRUE; } if (infoPtr->dwStyle & PGS_AUTOSCROLL) SetTimer(infoPtr->hwndSelf, TIMERID1, 0x3e, 0); hdc = GetWindowDC(infoPtr->hwndSelf); /* OffsetRect(wnrect, 0 | 1, 0 | 1) */ PAGER_DrawButton(hdc, infoPtr->clrBk, *btnrect, infoPtr->dwStyle & PGS_HORZ, topLeft, btnstate); ReleaseDC(infoPtr->hwndSelf, hdc); return 0; } } /* If we think we are captured, then do release */ if (infoPtr->bCapture && (WindowFromPoint(pt) != infoPtr->hwndSelf)) { NMHDR nmhdr; infoPtr->bCapture = FALSE; if (GetCapture() == infoPtr->hwndSelf) { ReleaseCapture(); if (infoPtr->TLbtnState == PGF_GRAYED) { infoPtr->TLbtnState = PGF_INVISIBLE; SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE); } else if (infoPtr->TLbtnState == PGF_HOT) { infoPtr->TLbtnState = PGF_NORMAL; /* FIXME: just invalidate button rect */ RedrawWindow(infoPtr->hwndSelf, NULL, NULL, RDW_FRAME | RDW_INVALIDATE); } if (infoPtr->BRbtnState == PGF_GRAYED) { infoPtr->BRbtnState = PGF_INVISIBLE; SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE); } else if (infoPtr->BRbtnState == PGF_HOT) { infoPtr->BRbtnState = PGF_NORMAL; /* FIXME: just invalidate button rect */ RedrawWindow(infoPtr->hwndSelf, NULL, NULL, RDW_FRAME | RDW_INVALIDATE); } /* Notify parent of released mouse capture */ memset(&nmhdr, 0, sizeof(NMHDR)); nmhdr.hwndFrom = infoPtr->hwndSelf; nmhdr.idFrom = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID); nmhdr.code = NM_RELEASEDCAPTURE; SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, nmhdr.idFrom, (LPARAM)&nmhdr); } if (IsWindow(infoPtr->hwndSelf)) KillTimer(infoPtr->hwndSelf, TIMERID1); } return 0; }
static void PAGER_DrawButton(HDC hdc, COLORREF clrBk, RECT arrowRect, BOOL horz, BOOL topLeft, INT btnState) { HBRUSH hBrush, hOldBrush; RECT rc = arrowRect; TRACE("arrowRect = %s, btnState = %d\n", wine_dbgstr_rect(&arrowRect), btnState); if (btnState == PGF_INVISIBLE) return; if ((rc.right - rc.left <= 0) || (rc.bottom - rc.top <= 0)) return; hBrush = CreateSolidBrush(clrBk); hOldBrush = (HBRUSH)SelectObject(hdc, hBrush); FillRect(hdc, &rc, hBrush); if (btnState == PGF_HOT) { DrawEdge( hdc, &rc, BDR_RAISEDINNER, BF_RECT); if (horz) PAGER_DrawHorzArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft); else PAGER_DrawVertArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft); } else if (btnState == PGF_NORMAL) { DrawEdge (hdc, &rc, BDR_OUTER, BF_FLAT); if (horz) PAGER_DrawHorzArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft); else PAGER_DrawVertArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft); } else if (btnState == PGF_DEPRESSED) { DrawEdge( hdc, &rc, BDR_SUNKENOUTER, BF_RECT); if (horz) PAGER_DrawHorzArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft); else PAGER_DrawVertArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft); } else if (btnState == PGF_GRAYED) { DrawEdge (hdc, &rc, BDR_OUTER, BF_FLAT); if (horz) { PAGER_DrawHorzArrow(hdc, rc, COLOR_3DHIGHLIGHT, topLeft); rc.left++, rc.top++; rc.right++, rc.bottom++; PAGER_DrawHorzArrow(hdc, rc, COLOR_3DSHADOW, topLeft); } else { PAGER_DrawVertArrow(hdc, rc, COLOR_3DHIGHLIGHT, topLeft); rc.left++, rc.top++; rc.right++, rc.bottom++; PAGER_DrawVertArrow(hdc, rc, COLOR_3DSHADOW, topLeft); } } SelectObject( hdc, hOldBrush ); DeleteObject(hBrush); }