/***********************************************************************
* macdrv_surface_flush
*/
static void macdrv_surface_flush(struct window_surface *window_surface)
{
struct macdrv_window_surface *surface = get_mac_surface(window_surface);
CGRect rect;
HRGN region;
window_surface->funcs->lock(window_surface);
TRACE("flushing %p %s bounds %s bits %p\n", surface, wine_dbgstr_rect(&surface->header.rect),
wine_dbgstr_rect(&surface->bounds), surface->bits);
rect = cgrect_from_rect(surface->bounds);
rect = CGRectOffset(rect, surface->header.rect.left, surface->header.rect.top);
if (!IsRectEmpty(&surface->bounds) && (region = CreateRectRgnIndirect(&surface->bounds)))
{
if (surface->drawn)
{
CombineRgn(surface->drawn, surface->drawn, region, RGN_OR);
DeleteObject(region);
}
else
surface->drawn = region;
}
update_blit_data(surface);
reset_bounds(&surface->bounds);
window_surface->funcs->unlock(window_surface);
if (!CGRectIsEmpty(rect))
macdrv_window_needs_display(surface->window, rect);
}
wxBitmap wxScreenDCImpl::DoGetAsBitmap(const wxRect *subrect) const
{
wxRect rect = subrect ? *subrect : wxRect(0, 0, m_width, m_height);
wxBitmap bmp(rect.GetSize(), 32);
#if !wxOSX_USE_IPHONE
CGRect srcRect = CGRectMake(rect.x, rect.y, rect.width, rect.height);
CGContextRef context = (CGContextRef)bmp.GetHBITMAP();
CGContextSaveGState(context);
CGContextTranslateCTM( context, 0, m_height );
CGContextScaleCTM( context, 1, -1 );
if ( subrect )
srcRect = CGRectOffset( srcRect, -subrect->x, -subrect->y ) ;
CGImageRef image = grabViaOpenGL(kCGNullDirectDisplay, srcRect);
wxASSERT_MSG(image, wxT("wxScreenDC::GetAsBitmap - unable to get screenshot."));
CGContextDrawImage(context, srcRect, image);
CGImageRelease(image);
CGContextRestoreGState(context);
#else
// TODO implement using UIGetScreenImage, CGImageCreateWithImageInRect, CGContextDrawImage
#endif
return bmp;
}
wxBitmap wxScreenDCImpl::DoGetAsBitmap(const wxRect *subrect) const
{
CGRect srcRect = CGRectMake(0, 0, m_width, m_height);
if (subrect)
{
srcRect.origin.x = subrect->GetX();
srcRect.origin.y = subrect->GetY();
srcRect.size.width = subrect->GetWidth();
srcRect.size.height = subrect->GetHeight();
}
wxBitmap bmp = wxBitmap(srcRect.size.width, srcRect.size.height, 32);
#if wxOSX_USE_IPHONE
#else
CGContextRef context = (CGContextRef)bmp.GetHBITMAP();
CGContextSaveGState(context);
CGContextTranslateCTM( context, 0, m_height );
CGContextScaleCTM( context, 1, -1 );
if ( subrect )
srcRect = CGRectOffset( srcRect, -subrect->x, -subrect->y ) ;
CGImageRef image = grabViaOpenGL(kCGNullDirectDisplay, srcRect);
wxASSERT_MSG(image, wxT("wxScreenDC::GetAsBitmap - unable to get screenshot."));
CGContextDrawImage(context, srcRect, image);
CGContextRestoreGState(context);
#endif
return bmp;
}
// ---------------------------------------------------------------------------
//
// -----------
void bToolMove::update(bool global){
if(!global){
clearTempPathContext(false);
}
if(get_on_drag()){
CGPoint v1,v2;
get_clic(&v1);
get_cur(&v2);
CGFloat dx=v2.x-v1.x;
CGFloat dy=v2.y-v1.y;
bGenericGeoElement* o;
bArray sel(*_gapp->selMgr()->elements());
ivx_rect vr;
for(long i=1;i<=sel.count();i++){
sel.get(i,&o);
o->getVertices(&_vxs);
ivs_bounds(_vxs,&vr);
hilite_rect(getTempPathContext(),CGRectOffset(CGRectInset(ivr2cgr(_gapp,vr),-2,-2),dx,dy),true,true);
}
}
if(!global){
validTempPathContext();
}
}
/***********************************************************************
* create_surface_image
*
* Caller must hold the surface lock. On input, *rect is the requested
* image rect, relative to the window whole_rect, a.k.a. visible_rect.
* On output, it's been intersected with that part backed by the surface
* and is the actual size of the returned image. copy_data indicates if
* the caller will keep the returned image beyond the point where the
* surface bits can be guaranteed to remain valid and unchanged. If so,
* the bits are copied instead of merely referenced by the image.
*
* IMPORTANT: This function is called from non-Wine threads, so it
* must not use Win32 or Wine functions, including debug
* logging.
*/
CGImageRef create_surface_image(void *window_surface, CGRect *rect, int copy_data)
{
CGImageRef cgimage = NULL;
struct macdrv_window_surface *surface = get_mac_surface(window_surface);
int width, height;
width = surface->header.rect.right - surface->header.rect.left;
height = surface->header.rect.bottom - surface->header.rect.top;
*rect = CGRectIntersection(cgrect_from_rect(surface->header.rect), *rect);
if (!CGRectIsEmpty(*rect))
{
CGRect visrect;
CGColorSpaceRef colorspace;
CGDataProviderRef provider;
int bytes_per_row, offset, size;
CGImageAlphaInfo alphaInfo;
visrect = CGRectOffset(*rect, -surface->header.rect.left, -surface->header.rect.top);
colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
bytes_per_row = get_dib_stride(width, 32);
offset = CGRectGetMinX(visrect) * 4 + (height - CGRectGetMaxY(visrect)) * bytes_per_row;
size = min(CGRectGetHeight(visrect) * bytes_per_row,
surface->info.bmiHeader.biSizeImage - offset);
if (copy_data)
{
CFDataRef data = CFDataCreate(NULL, (UInt8*)surface->bits + offset, size);
provider = CGDataProviderCreateWithCFData(data);
CFRelease(data);
}
else
provider = CGDataProviderCreateWithData(NULL, surface->bits + offset, size, NULL);
alphaInfo = surface->use_alpha ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaNoneSkipFirst;
cgimage = CGImageCreate(CGRectGetWidth(visrect), CGRectGetHeight(visrect),
8, 32, bytes_per_row, colorspace,
alphaInfo | kCGBitmapByteOrder32Little,
provider, NULL, FALSE, kCGRenderingIntentDefault);
CGDataProviderRelease(provider);
CGColorSpaceRelease(colorspace);
}
return cgimage;
}
unsigned TileController::blankPixelCountForTiles(const PlatformLayerList& tiles, const FloatRect& visibleRect, const IntPoint& tileTranslation)
{
Region paintedVisibleTiles;
for (PlatformLayerList::const_iterator it = tiles.begin(), end = tiles.end(); it != end; ++it) {
const PlatformLayer* tileLayer = it->get();
FloatRect visiblePart(CGRectOffset(PlatformCALayer::frameForLayer(tileLayer), tileTranslation.x(), tileTranslation.y()));
visiblePart.intersect(visibleRect);
if (!visiblePart.isEmpty())
paintedVisibleTiles.unite(enclosingIntRect(visiblePart));
}
Region uncoveredRegion(enclosingIntRect(visibleRect));
uncoveredRegion.subtract(paintedVisibleTiles);
return uncoveredRegion.totalArea();
}
static wxBitmap DoGetAsBitmap(const wxRect *subrect)
{
CGRect cgbounds = CGDisplayBounds(CGMainDisplayID());
wxRect rect = subrect ? *subrect : wxRect(0, 0, cgbounds.size.width, cgbounds.size.height);
wxBitmap bmp(rect.GetSize().GetWidth(), rect.GetSize().GetHeight(), 32);
CGDisplayCreateImageFunc createImage =
(CGDisplayCreateImageFunc) dlsym(RTLD_NEXT, "CGDisplayCreateImage");
if (createImage == NULL)
{
return bmp;
}
CGRect srcRect = CGRectMake(rect.x, rect.y, rect.width, rect.height);
CGContextRef context = (CGContextRef)bmp.GetHBITMAP();
CGContextSaveGState(context);
CGContextTranslateCTM( context, 0, cgbounds.size.height );
CGContextScaleCTM( context, 1, -1 );
if ( subrect )
srcRect = CGRectOffset( srcRect, -subrect->x, -subrect->y ) ;
CGImageRef image = NULL;
image = createImage(kCGDirectMainDisplay);
wxASSERT_MSG(image, wxT("wxScreenDC::GetAsBitmap - unable to get screenshot."));
CGContextDrawImage(context, srcRect, image);
CGImageRelease(image);
CGContextRestoreGState(context);
return bmp;
}
wxBitmap wxWindowDCImpl::DoGetAsBitmap(const wxRect *subrect) const
{
// wxScreenDC is derived from wxWindowDC, so a screen dc will
// call this method when a Blit is performed with it as a source.
if (!m_window)
return wxNullBitmap;
ControlRef handle = (ControlRef) m_window->GetHandle();
if ( !handle )
return wxNullBitmap;
HIRect rect;
CGImageRef image;
CGContextRef context;
HIViewCreateOffscreenImage( handle, 0, &rect, &image);
int width = subrect != NULL ? subrect->width : (int)rect.size.width;
int height = subrect != NULL ? subrect->height : (int)rect.size.height ;
wxBitmap bmp = wxBitmap(width, height, 32);
context = (CGContextRef)bmp.GetHBITMAP();
CGContextSaveGState(context);
CGContextTranslateCTM( context, 0, height );
CGContextScaleCTM( context, 1, -1 );
if ( subrect )
rect = CGRectOffset( rect, -subrect->x, -subrect->y ) ;
CGContextDrawImage( context, rect, image );
CGContextRestoreGState(context);
return bmp;
}
void
TkMacOSXUpdateClipRgn(
TkWindow *winPtr)
{
MacDrawable *macWin;
if (winPtr == NULL) {
return;
}
macWin = winPtr->privatePtr;
if (macWin && macWin->flags & TK_CLIP_INVALID) {
TkWindow *win2Ptr;
if (Tk_IsMapped(winPtr)) {
int rgnChanged = 0;
CGRect bounds;
HIMutableShapeRef rgn;
/*
* Start with a region defined by the window bounds.
*/
TkMacOSXWinCGBounds(winPtr, &bounds);
rgn = TkMacOSXHIShapeCreateMutableWithRect(&bounds);
/*
* Clip away the area of any windows that may obscure this window.
* For a non-toplevel window, first, clip to the parents visible
* clip region. Second, clip away any siblings that are higher in
* the stacking order. For an embedded toplevel, just clip to the
* container's visible clip region. Remember, we only allow one
* contained window in a frame, and don't support any other widgets
* in the frame either. This is not currently enforced, however.
*/
if (!Tk_IsTopLevel(winPtr)) {
TkMacOSXUpdateClipRgn(winPtr->parentPtr);
if (winPtr->parentPtr) {
ChkErr(HIShapeIntersect,
winPtr->parentPtr->privatePtr->aboveVisRgn,
rgn, rgn);
}
win2Ptr = winPtr;
while ((win2Ptr = win2Ptr->nextPtr)) {
if (Tk_IsTopLevel(win2Ptr) || !Tk_IsMapped(win2Ptr)) {
continue;
}
TkMacOSXWinCGBounds(win2Ptr, &bounds);
ChkErr(TkMacOSHIShapeDifferenceWithRect, rgn, &bounds);
}
} else if (Tk_IsEmbedded(winPtr)) {
win2Ptr = TkpGetOtherWindow(winPtr);
if (win2Ptr) {
TkMacOSXUpdateClipRgn(win2Ptr);
ChkErr(HIShapeIntersect,
win2Ptr->privatePtr->aboveVisRgn, rgn, rgn);
} else if (tkMacOSXEmbedHandler != NULL) {
HIShapeRef visRgn;
TkMacOSXCheckTmpQdRgnEmpty();
tkMacOSXEmbedHandler->getClipProc((Tk_Window) winPtr,
tkMacOSXtmpQdRgn);
visRgn = HIShapeCreateWithQDRgn(tkMacOSXtmpQdRgn);
SetEmptyRgn(tkMacOSXtmpQdRgn);
ChkErr(HIShapeIntersect, visRgn, rgn, rgn);
}
/*
* TODO: Here we should handle out of process embedding.
*/
} else if (winPtr->wmInfoPtr->attributes &
kWindowResizableAttribute) {
HIViewRef growBoxView;
OSErr err = HIViewFindByID(HIViewGetRoot(
TkMacOSXDrawableWindow(winPtr->window)),
kHIViewWindowGrowBoxID, &growBoxView);
if (err == noErr) {
ChkErr(HIViewGetFrame, growBoxView, &bounds);
bounds = CGRectOffset(bounds,
-winPtr->wmInfoPtr->xInParent,
-winPtr->wmInfoPtr->yInParent);
ChkErr(TkMacOSHIShapeDifferenceWithRect, rgn, &bounds);
}
}
macWin->aboveVisRgn = HIShapeCreateCopy(rgn);
/*
* The final clip region is the aboveVis region (or visible region)
* minus all the children of this window. If the window is a
* container, we must also subtract the region of the embedded
* window.
*/
win2Ptr = winPtr->childList;
while (win2Ptr) {
if (Tk_IsTopLevel(win2Ptr) || !Tk_IsMapped(win2Ptr)) {
win2Ptr = win2Ptr->nextPtr;
continue;
}
TkMacOSXWinCGBounds(win2Ptr, &bounds);
ChkErr(TkMacOSHIShapeDifferenceWithRect, rgn, &bounds);
rgnChanged = 1;
win2Ptr = win2Ptr->nextPtr;
}
if (Tk_IsContainer(winPtr)) {
win2Ptr = TkpGetOtherWindow(winPtr);
if (win2Ptr) {
if (Tk_IsMapped(win2Ptr)) {
TkMacOSXWinCGBounds(win2Ptr, &bounds);
ChkErr(TkMacOSHIShapeDifferenceWithRect, rgn, &bounds);
rgnChanged = 1;
}
}
/*
* TODO: Here we should handle out of process embedding.
*/
}
if (rgnChanged) {
HIShapeRef diffRgn = HIShapeCreateDifference(
macWin->aboveVisRgn, rgn);
if (!HIShapeIsEmpty(diffRgn)) {
macWin->visRgn = HIShapeCreateCopy(rgn);
}
CFRelease(diffRgn);
}
CFRelease(rgn);
} else {
/*
* An unmapped window has empty clip regions to prevent any
* (erroneous) drawing into it or its children from becoming
* visible. [Bug 940117]
*/
if (!Tk_IsTopLevel(winPtr)) {
TkMacOSXUpdateClipRgn(winPtr->parentPtr);
} else if (Tk_IsEmbedded(winPtr)) {
win2Ptr = TkpGetOtherWindow(winPtr);
if (win2Ptr) {
TkMacOSXUpdateClipRgn(win2Ptr);
}
}
macWin->aboveVisRgn = TkMacOSXHIShapeCreateEmpty();
}
if (!macWin->visRgn) {
macWin->visRgn = HIShapeCreateCopy(macWin->aboveVisRgn);
}
macWin->flags &= ~TK_CLIP_INVALID;
#ifdef TK_MAC_DEBUG_CLIP_REGIONS
TkMacOSXDebugFlashRegion((Drawable) macWin, macWin->visRgn);
#endif /* TK_MAC_DEBUG_CLIP_REGIONS */
}
}
FX_BOOL CFX_QuartzDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
FX_ARGB argb,
const FX_RECT* srcRect,
int dest_left,
int dest_top,
int blendType,
int alphaFlag ,
void* iccTransform )
{
SaveState();
CGFloat src_left, src_top, src_width, src_height;
if (srcRect) {
src_left = srcRect->left;
src_top = srcRect->top;
src_width = srcRect->Width();
src_height = srcRect->Height();
} else {
src_left = src_top = 0;
src_width = pBitmap->GetWidth();
src_height = pBitmap->GetHeight();
}
CGAffineTransform ctm = CGContextGetCTM(_context);
CGFloat scale_x = FXSYS_fabs(ctm.a);
CGFloat scale_y = FXSYS_fabs(ctm.d);
src_left /= scale_x;
src_top /= scale_y;
src_width /= scale_x;
src_height /= scale_y;
CGRect rect_fx = CGRectMake(dest_left, dest_top, src_width, src_height);
CGRect rect_usr = CGRectApplyAffineTransform(rect_fx, _foxitDevice2User);
CGContextBeginPath(_context);
CGContextAddRect(_context, rect_usr);
CGContextClip(_context);
rect_usr.size = CGSizeMake(pBitmap->GetWidth() / scale_x, pBitmap->GetHeight() / scale_y);
rect_usr = CGRectOffset(rect_usr, -src_left, -src_top);
CG_SetImageTransform(dest_left, dest_top, src_width, src_height, &rect_usr);
CFX_DIBitmap* pBitmap1 = NULL;
if (pBitmap->IsAlphaMask()) {
if (pBitmap->GetBuffer()) {
pBitmap1 = (CFX_DIBitmap*)pBitmap;
} else {
pBitmap1 = pBitmap->Clone();
}
if (NULL == pBitmap1) {
RestoreState(FALSE);
return FALSE;
}
CGDataProviderRef pBitmapProvider = CGDataProviderCreateWithData(NULL,
pBitmap1->GetBuffer(),
pBitmap1->GetPitch() * pBitmap1->GetHeight(),
NULL);
CGColorSpaceRef pColorSpace = CGColorSpaceCreateDeviceGray();
CGBitmapInfo bitmapInfo = kCGImageAlphaNone | kCGBitmapByteOrderDefault;
CGImageRef pImage = CGImageCreate(pBitmap1->GetWidth(),
pBitmap1->GetHeight(),
pBitmap1->GetBPP(),
pBitmap1->GetBPP(),
pBitmap1->GetPitch(),
pColorSpace,
bitmapInfo,
pBitmapProvider, NULL, true,
kCGRenderingIntentDefault);
CGContextClipToMask(_context, rect_usr, pImage);
CGContextSetRGBFillColor(_context,
FXARGB_R(argb) / 255.f,
FXARGB_G(argb) / 255.f,
FXARGB_B(argb) / 255.f,
FXARGB_A(argb) / 255.f);
CGContextFillRect(_context, rect_usr);
CGImageRelease(pImage);
CGColorSpaceRelease(pColorSpace);
CGDataProviderRelease(pBitmapProvider);
if (pBitmap1 != pBitmap) {
delete pBitmap1;
}
RestoreState(FALSE);
return TRUE;
}
if (pBitmap->GetBPP() < 32) {
pBitmap1 = pBitmap->CloneConvert(FXDIB_Rgb32);
} else {
if (pBitmap->GetBuffer()) {
pBitmap1 = (CFX_DIBitmap*)pBitmap;
} else {
pBitmap1 = pBitmap->Clone();
}
}
if (NULL == pBitmap1) {
RestoreState(FALSE);
return FALSE;
}
if (pBitmap1->HasAlpha()) {
if (pBitmap1 == pBitmap) {
pBitmap1 = pBitmap->Clone();
if (!pBitmap1) {
RestoreState(FALSE);
return FALSE;
}
}
for (int row = 0; row < pBitmap1->GetHeight(); row ++) {
FX_LPBYTE pScanline = (FX_LPBYTE)pBitmap1->GetScanline(row);
for (int col = 0; col < pBitmap1->GetWidth(); col ++) {
pScanline[0] = (FX_BYTE)(pScanline[0] * pScanline[3] / 255.f + .5f);
pScanline[1] = (FX_BYTE)(pScanline[1] * pScanline[3] / 255.f + .5f);
pScanline[2] = (FX_BYTE)(pScanline[2] * pScanline[3] / 255.f + .5f);
pScanline += 4;
}
}
}
CGContextRef ctx = createContextWithBitmap(pBitmap1);
CGImageRef image = CGBitmapContextCreateImage(ctx);
int blend_mode = blendType;
if (FXDIB_BLEND_HARDLIGHT == blendType) {
blend_mode = kCGBlendModeSoftLight;
} else if (FXDIB_BLEND_SOFTLIGHT == blendType) {
blend_mode = kCGBlendModeHardLight;
} else if (blendType >= FXDIB_BLEND_NONSEPARABLE && blendType <= FXDIB_BLEND_LUMINOSITY) {
blend_mode = blendType - 9;
} else if (blendType > FXDIB_BLEND_LUMINOSITY || blendType < 0) {
blend_mode = kCGBlendModeNormal;
}
CGContextSetBlendMode(_context, (CGBlendMode)blend_mode);
CGContextDrawImage(_context, rect_usr, image);
CGImageRelease(image);
CGContextRelease(ctx);
if (pBitmap1 != pBitmap) {
delete pBitmap1;
}
RestoreState(FALSE);
return TRUE;
}
void MacWidgetPainter::DrawFocusRect(const OpRect &drawrect)
{
OpRect opBounds = drawrect;
float scale = ((float)vd->GetScale()) / 100.0f;
#ifdef VIEWPORTS_SUPPORT
opBounds.x += vd->GetTranslationX() - vd->GetRenderingViewX() + vd->ScaleToDoc(vd->GetOffsetX());
opBounds.y += vd->GetTranslationY() - vd->GetRenderingViewY() + vd->ScaleToDoc(vd->GetOffsetY());
#else
opBounds.x += vd->GetTranslationX() - vd->GetViewX() + vd->ScaleToDoc(vd->GetOffsetX());
opBounds.y += vd->GetTranslationY() - vd->GetViewY() + vd->ScaleToDoc(vd->GetOffsetY());
#endif
CGRect scaledBounds = {{opBounds.x*scale, opBounds.y*scale}, {opBounds.width*scale, opBounds.height*scale}};
OpRect vd_clip = vd->GetClipping(); // Get current cliprect, we need to sync QDclip with that
vd_clip = vd->ScaleToScreen(vd_clip);
vd_clip.x += vd->GetOffsetX();
vd_clip.y += vd->GetOffsetY();
CGRect clipBounds = {{vd_clip.x, vd_clip.y}, {vd_clip.width, vd_clip.height}};
clipBounds = CGRectInset(clipBounds, -3, -3); // don't quite know why...
scaledBounds = CGRectInset(scaledBounds, 4, 4);
VEGAOpPainter* painter = (VEGAOpPainter*)m_painter;
VEGARenderTarget* target = painter->GetRenderTarget();
CocoaVEGAWindow* window = (CocoaVEGAWindow*)target->getTargetWindow();
if(!window)
{
return;
}
int win_height = CGImageGetHeight(window->getImage());
#ifdef PIXEL_SCALE_RENDERING_SUPPORT
const PixelScaler& scaler = vd->GetVPScale();
win_height = FROM_DEVICE_PIXEL(scaler, win_height);
#endif // PIXEL_SCALE_RENDERING_SUPPORT
CGContextRef context = window->getPainter();
if (context)
{
MacOpView *macview = (MacOpView *)vd->GetOpView();
OpPoint pt;
pt = macview->ConvertToScreen(pt);
OpWindow* root = macview->GetRootWindow();
INT32 xpos,ypos;
root->GetInnerPos(&xpos, &ypos);
scaledBounds = CGRectOffset(scaledBounds, pt.x - xpos, pt.y - ypos);
clipBounds = CGRectOffset(clipBounds, pt.x - xpos, pt.y - ypos);
CGContextSaveGState(context);
float scale = 1.0f;
#ifdef PIXEL_SCALE_RENDERING_SUPPORT
scale = TO_DEVICE_PIXEL(scaler, scale);
#endif // PIXEL_SCALE_RENDERING_SUPPORT
CGContextScaleCTM(context, scale, -scale);
CGContextTranslateCTM(context, 0.0f, -win_height);
CGContextClipToRect(context, clipBounds);
HIThemeDrawFocusRect(&scaledBounds, true, context, kHIThemeOrientationNormal);
CGContextRestoreGState(context);
}
}