static void fxDodgeProcessSubject (CompWindow *wCur, Region wRegion, Region dodgeRegion, Bool alwaysInclude) { XRectangle rect; rect.x = WIN_X(wCur); rect.y = WIN_Y(wCur); rect.width = WIN_W(wCur); rect.height = WIN_H(wCur); Region wCurRegion = XCreateRegion(); if (!wCurRegion) return; XUnionRectWithRegion(&rect, &emptyRegion, wCurRegion); if (!alwaysInclude) { Region intersectionRegion = XCreateRegion(); if (intersectionRegion) { XIntersectRegion(wRegion, wCurRegion, intersectionRegion); if (!XEmptyRegion(intersectionRegion)) XUnionRegion(dodgeRegion, wCurRegion, dodgeRegion); XDestroyRegion (intersectionRegion); } } else XUnionRegion(dodgeRegion, wCurRegion, dodgeRegion); XDestroyRegion (wCurRegion); }
/* Generates a region containing free space (here the * active window counts as free space). The region argument * is the start-region (ie: the output dev). */ static Region smartputEmptyRegion (CompWindow *window, Region region) { CompScreen *s = window->screen; CompWindow *w; Region newRegion, tmpRegion; XRectangle tmpRect; newRegion = XCreateRegion (); if (!newRegion) return NULL; tmpRegion = XCreateRegion (); if (!tmpRegion) { XDestroyRegion (newRegion); return NULL; } XUnionRegion (region, newRegion, newRegion); for (w = s->windows; w; w = w->next) { EMPTY_REGION (tmpRegion); if (w->id == window->id) continue; if (w->invisible || w->hidden || w->minimized) continue; if (w->wmType & CompWindowTypeDesktopMask) continue; if (w->wmType & CompWindowTypeDockMask) { if (w->struts) { XUnionRectWithRegion (&w->struts->left, tmpRegion, tmpRegion); XUnionRectWithRegion (&w->struts->right, tmpRegion, tmpRegion); XUnionRectWithRegion (&w->struts->top, tmpRegion, tmpRegion); XUnionRectWithRegion (&w->struts->bottom, tmpRegion, tmpRegion); XSubtractRegion (newRegion, tmpRegion, newRegion); } continue; } tmpRect.x = w->serverX - w->input.left; tmpRect.y = w->serverY - w->input.top; tmpRect.width = w->serverWidth + w->input.right + w->input.left; tmpRect.height = w->serverHeight + w->input.top + w->input.bottom; XUnionRectWithRegion (&tmpRect, tmpRegion, tmpRegion); XSubtractRegion (newRegion, tmpRegion, newRegion); } XDestroyRegion (tmpRegion); return newRegion; }
void X11Factory::getMonitorInfo( const GenericWindow &rWindow, int* p_x, int* p_y, int* p_width, int* p_height ) const { // initialize to default geometry *p_x = 0; *p_y = 0; *p_width = getScreenWidth(); *p_height = getScreenHeight(); // Use Xinerama to determine the monitor where the video // mostly resides (biggest surface) Display *pDisplay = m_pDisplay->getDisplay(); Window wnd = (Window)rWindow.getOSHandle(); Window root = DefaultRootWindow( pDisplay ); Window child_wnd; int x, y; unsigned int w, h, border, depth; XGetGeometry( pDisplay, wnd, &root, &x, &y, &w, &h, &border, &depth ); XTranslateCoordinates( pDisplay, wnd, root, 0, 0, &x, &y, &child_wnd ); int num; XineramaScreenInfo* info = XineramaQueryScreens( pDisplay, &num ); if( info ) { Region reg1 = XCreateRegion(); XRectangle rect1 = { (short)x, (short)y, (unsigned short)w, (unsigned short)h }; XUnionRectWithRegion( &rect1, reg1, reg1 ); unsigned int surface = 0; for( int i = 0; i < num; i++ ) { Region reg2 = XCreateRegion(); XRectangle rect2 = { info[i].x_org, info[i].y_org, (unsigned short)info[i].width, (unsigned short)info[i].height }; XUnionRectWithRegion( &rect2, reg2, reg2 ); Region reg = XCreateRegion(); XIntersectRegion( reg1, reg2, reg ); XRectangle rect; XClipBox( reg, &rect ); unsigned int surf = rect.width * rect.height; if( surf > surface ) { surface = surf; *p_x = info[i].x_org; *p_y = info[i].y_org; *p_width = info[i].width; *p_height = info[i].height; } XDestroyRegion( reg ); XDestroyRegion( reg2 ); } XDestroyRegion( reg1 ); XFree( info ); } }
Bool XftDrawSetClip (XftDraw *draw, Region r) { Region n = 0; if (!r && !draw->clip) return True; if (r) { n = XCreateRegion (); if (n) { if (!XUnionRegion (n, r, n)) { XDestroyRegion (n); return False; } } } if (draw->clip) { XDestroyRegion (draw->clip); } draw->clip = n; if (draw->render_able) { XRenderPictureAttributes pa; if (n) { XRenderSetPictureClipRegion (draw->dpy, draw->render.pict, n); } else { pa.clip_mask = None; XRenderChangePicture (draw->dpy, draw->render.pict, CPClipMask, &pa); } } if (draw->core_set) { XGCValues gv; if (n) XSetRegion (draw->dpy, draw->core.draw_gc, n); else { gv.clip_mask = None; XChangeGC (draw->dpy, draw->core.draw_gc, GCClipMask, &gv); } } return True; }
void X11Graphics::drawGraphics( const OSGraphics &rGraphics, int xSrc, int ySrc, int xDest, int yDest, int width, int height ) { const X11Graphics& rGraph = (X11Graphics&)rGraphics; // check and adapt to source if needed if( !checkBoundaries( 0, 0, rGraph.getWidth(), rGraph.getHeight(), xSrc, ySrc, width, height ) ) { msg_Err( getIntf(), "nothing to draw from graphics source" ); return; } // check destination if( !checkBoundaries( 0, 0, m_width, m_height, xDest, yDest, width, height ) ) { msg_Err( getIntf(), "out of reach destination! pls, debug your skin" ); return; } // Source drawable Drawable src = rGraph.getDrawable(); // Create the mask for transparency Region voidMask = XCreateRegion(); XRectangle rect; rect.x = xSrc; rect.y = ySrc; rect.width = width; rect.height = height; Region clipMask = XCreateRegion(); XUnionRectWithRegion( &rect, voidMask, clipMask ); Region mask = XCreateRegion(); XIntersectRegion( rGraph.getMask(), clipMask, mask ); XDestroyRegion( clipMask ); XDestroyRegion( voidMask ); XOffsetRegion( mask, xDest - xSrc, yDest - ySrc ); // Copy the pixmap XSetRegion( XDISPLAY, m_gc, mask ); XCopyArea( XDISPLAY, src, m_pixmap, m_gc, xSrc, ySrc, width, height, xDest, yDest ); // Add the source mask to the mask of the graphics Region newMask = XCreateRegion(); XUnionRegion( m_mask, mask, newMask ); XDestroyRegion( mask ); XDestroyRegion( m_mask ); m_mask = newMask; }
static void update_wireframe_window (MetaDisplay *display, Window xwindow, const MetaRectangle *rect) { XMoveResizeWindow (display->xdisplay, xwindow, rect->x, rect->y, rect->width, rect->height); #define OUTLINE_WIDTH 3 if (rect->width > OUTLINE_WIDTH * 2 && rect->height > OUTLINE_WIDTH * 2) { XRectangle xrect; Region inner_xregion; Region outer_xregion; inner_xregion = XCreateRegion (); outer_xregion = XCreateRegion (); xrect.x = 0; xrect.y = 0; xrect.width = rect->width; xrect.height = rect->height; XUnionRectWithRegion (&xrect, outer_xregion, outer_xregion); xrect.x += OUTLINE_WIDTH; xrect.y += OUTLINE_WIDTH; xrect.width -= OUTLINE_WIDTH * 2; xrect.height -= OUTLINE_WIDTH * 2; XUnionRectWithRegion (&xrect, inner_xregion, inner_xregion); XSubtractRegion (outer_xregion, inner_xregion, outer_xregion); XShapeCombineRegion (display->xdisplay, xwindow, ShapeBounding, 0, 0, outer_xregion, ShapeSet); XDestroyRegion (outer_xregion); XDestroyRegion (inner_xregion); } else { /* Unset the shape */ XShapeCombineMask (display->xdisplay, xwindow, ShapeBounding, 0, 0, None, ShapeSet); } }
virtual bool destroy_detached(XRegion detached) const { if ((detached)) { XDestroyRegion(detached); return true; } return false; }
// Intersect & push a new clip rectangle: void Fl_Device::push_clip(int x, int y, int w, int h) { Region r; if (w > 0 && h > 0) { fl_transform(x,y); r = XRectangleRegion(x, y, w, h); Region current = rstack[rstackptr]; if (current) { #ifndef _WIN32 Region temp = XCreateRegion(); XIntersectRegion(current, r, temp); XDestroyRegion(r); r = temp; #else CombineRgn(r,r,current,RGN_AND); #endif } } // make empty clip region: else { #ifndef _WIN32 r = XCreateRegion(); #else r = CreateRectRgn(0,0,0,0); #endif } if (rstackptr < STACK_MAX) rstack[++rstackptr] = r; fl_restore_clip(); }
// Replace the top of the clip stack: void fl_clip_region(Region r) { Region oldr = rstack[rstackptr]; if(oldr) XDestroyRegion(oldr); rstack[rstackptr] = r; fl_restore_clip(); }
void x_gram_expose(Display *dpy, Window w, x_gram *gram, XExposeEvent *event) { static Region region; static int partregion; XRectangle rect; rect.x = (short) event->x; rect.y = (short) event->y; rect.width = (unsigned short) event->width; rect.height = (unsigned short) event->height; #ifdef MARK_DEBUG printf("----- xeventExpose:\nx=%d y=%d w=%d h=%d\n-----", event->x,event->y,event->width,event->height); #endif if (! partregion) { region=XCreateRegion(); partregion = 1; } if (rect.width && rect.height) XUnionRectWithRegion(&rect,region,region); if (event->count == 0) { x_gram_draw(dpy,w,gram,region); partregion = 0; XDestroyRegion(region); } }
void XmRedisplayWidget(Widget widget) { XExposeEvent xev ; Region region ; xev.type = Expose ; /* is this better than 0 ? shouldn't make much difference unless the expose method is very tricky... */ xev.serial = LastKnownRequestProcessed(XtDisplay(widget)) ; xev.send_event = False ; xev.display = XtDisplay(widget); xev.window = XtWindowOfObject(widget); /* work with gadget too */ xev.x = 0 ; xev.y = 0 ; xev.width = widget->core.width ; xev.height = widget->core.height ; xev.count = 0 ; region = XCreateRegion(); XtAddExposureToRegion((XEvent*)&xev, region); if (widget->core.widget_class->core_class.expose) (*(widget->core.widget_class->core_class.expose)) (widget, (XEvent*)&xev, region); XDestroyRegion(region); }
// Destroy region FXRegion::~FXRegion(){ #ifdef WIN32 DeleteObject((HRGN)region); #else XDestroyRegion((Region)region); #endif }
void finiCore (void) { CompPlugin *p; while (core.displays) removeDisplay (core.displays); if (core.watchPollFds) free (core.watchPollFds); while ((p = popPlugin ())) unloadPlugin (p); XDestroyRegion (core.outputRegion); XDestroyRegion (core.tmpRegion); }
void sClipExclude(const sRect &r) { sVERIFY(ClipIndex != 0); Region temp = sRectToRegion(r); XSubtractRegion(ClipStack[ClipIndex],temp,ClipStack[ClipIndex]); XDestroyRegion(temp); sChangedRegions(); }
void sClipRect(const sRect &r) { sVERIFY(ClipIndex != 0); Region temp = sRectToRegion(r); XIntersectRegion(ClipStack[ClipIndex],temp,ClipStack[ClipIndex]); XDestroyRegion(temp); sChangedRegions(); }
Bool apc_gp_set_region( Handle self, Handle rgn) { DEFXX; Region region; PRegionSysData r; if ( PObject( self)-> options. optInDrawInfo) return false; if ( !XF_IN_PAINT(XX)) return false; if (rgn == nilHandle) { Rect r; r. left = 0; r. bottom = 0; r. right = XX-> size. x - 1; r. top = XX-> size. y - 1; return apc_gp_set_clip_rect( self, r); } r = GET_REGION(rgn); XClipBox( r-> region, &XX-> clip_rect); XX-> clip_rect. y += XX-> size. y - r-> height; XX-> clip_mask_extent. x = XX-> clip_rect. width; XX-> clip_mask_extent. y = XX-> clip_rect. height; if ( XX-> clip_rect. width == 0 || XX-> clip_rect. height == 0) { Rect r; r. left = -1; r. bottom = -1; r. right = -1; r. top = -1; return apc_gp_set_clip_rect( self, r); } region = XCreateRegion(); XUnionRegion( region, r-> region, region); /* offset region if drawable is buffered */ XOffsetRegion( region, XX-> btransform. x, XX-> size.y - r-> height - XX-> btransform. y); /* otherwise ( and only otherwise ), and if there's a X11 clipping, intersect the region with it. X11 clipping must not mix with the buffer clipping */ if (( !XX-> udrawable || XX-> udrawable == XX-> gdrawable) && XX-> paint_region) XIntersectRegion( region, XX-> paint_region, region); XSetRegion( DISP, XX-> gc, region); if ( XX-> flags. kill_current_region) XDestroyRegion( XX-> current_region); XX-> flags. kill_current_region = 1; XX-> current_region = region; XX-> flags. xft_clip = 0; #ifdef USE_XFT if ( XX-> xft_drawable) prima_xft_update_region( self); #endif #ifdef HAVE_X11_EXTENSIONS_XRENDER_H if ( XX-> argb_picture ) XRenderSetPictureClipRegion(DISP, XX->argb_picture, region); #endif return true; }
EAPI void ecore_x_xregion_free(Ecore_X_XRegion *region) { LOGFN(__FILE__, __LINE__, __FUNCTION__); if (!region) return; XDestroyRegion((Region)region); } /* ecore_x_xregion_free */
Bool apc_region_destroy( Handle self) { if ( REGION ) { XDestroyRegion(REGION); REGION = NULL; } return true; }
// Reset region to empty void FXRegion::reset(){ #ifdef WIN32 DeleteObject((HRGN)region); region=(void*)CreateRectRgn(0,0,0,0); #else XDestroyRegion((Region)region); region=XCreateRegion(); #endif }
// pop back to previous clip: void Fl_Device::pop_clip() { if (rstackptr > 0) { Region oldr = rstack[rstackptr--]; if (oldr) XDestroyRegion(oldr); fl_restore_clip(); } }
XftTextRenderer::~XftTextRenderer() { if (xclip) XDestroyRegion(xclip); font->release(); if (owner) owner->rendererDeleted(this); }
static void PaxWidgetDestroy(char * data) { PaxWidget *paxwidget = (PaxWidget *) data; Tk_FreeOptions(configSpecs, (char *) paxwidget, paxwidget->display, 0); Py_XDECREF(paxwidget->obj); XDestroyRegion(paxwidget->exposed_region); ckfree((char *) paxwidget); }
static void ExitXLib() { if(sGetSystemFlags() & sISF_2D) { XRenderFreePicture(sXDisplay(),XPict); XftDrawDestroy(XDraw); for(sInt i=0;i<MAX_COLORS;i++) XftColorFree(sXDisplay(),sXVisual,sXColMap,&ColorXFT[i]); for(sInt i=0;i<MAX_CLIPS;i++) XDestroyRegion(ClipStack[i]); XDestroyRegion(EmptyRegion); for(sInt i=0;i<sMP_MAX;i++) XFreeCursor(sXDisplay(),Cursors[i]); } }
void X11Graphics::drawGraphics( const OSGraphics &rGraphics, int xSrc, int ySrc, int xDest, int yDest, int width, int height ) { if( width == -1 ) { width = rGraphics.getWidth(); } if( height == -1 ) { height = rGraphics.getHeight(); } // Source drawable Drawable src = ((X11Graphics&)rGraphics).getDrawable(); // Create the mask for transparency Region voidMask = XCreateRegion(); XRectangle rect; rect.x = xSrc; rect.y = ySrc; rect.width = width; rect.height = height; Region clipMask = XCreateRegion(); XUnionRectWithRegion( &rect, voidMask, clipMask ); Region mask = XCreateRegion(); XIntersectRegion( ((X11Graphics&)rGraphics).getMask(), clipMask, mask ); XDestroyRegion( clipMask ); XDestroyRegion( voidMask ); XOffsetRegion( mask, xDest - xSrc, yDest - ySrc ); // Copy the pixmap XSetRegion( XDISPLAY, m_gc, mask ); XCopyArea( XDISPLAY, src, m_pixmap, m_gc, xSrc, ySrc, width, height, xDest, yDest ); // Add the source mask to the mask of the graphics Region newMask = XCreateRegion(); XUnionRegion( m_mask, mask, newMask ); XDestroyRegion( mask ); XDestroyRegion( m_mask ); m_mask = newMask; }
int _zbar_window_end (zbar_window_t *w) { window_state_t *x = w->state; XSetClipMask(w->display, x->gc, None); if(x->exposed) { XDestroyRegion(x->exposed); x->exposed = NULL; } XFlush(w->display); return(0); }
// Xor region r with this one FXRegion& FXRegion::operator^=(const FXRegion& r){ #ifdef WIN32 CombineRgn((HRGN)region,(HRGN)region,(HRGN)r.region,RGN_XOR); #else Region res=XCreateRegion(); XXorRegion((Region)region,(Region)r.region,res); XDestroyRegion((Region)region); region=res; #endif return *this; }
// Substract region r from this one FXRegion& FXRegion::operator-=(const FXRegion& r){ #ifndef WIN32 Region res=XCreateRegion(); XSubtractRegion((Region)region,(Region)r.region,res); XDestroyRegion((Region)region); region=res; #else CombineRgn((HRGN)region,(HRGN)region,(HRGN)r.region,RGN_DIFF); #endif return *this; }
// Assign region r to this one FXRegion& FXRegion::operator=(const FXRegion& r){ #ifdef WIN32 CombineRgn((HRGN)region,(HRGN)r.region,(HRGN)r.region,RGN_COPY); #else if(region!=r.region){ XDestroyRegion((Region)region); region=XCreateRegion(); XUnionRegion((Region)r.region,(Region)region,(Region)region); } #endif return *this; }
// Replace top of stack with top of stack minus this rectangle: void Fl_Device::clip_out(int x, int y, int w, int h) { if (w <= 0 || h <= 0) return; Region current = rstack[rstackptr]; // current must not be zero, you must push a rectangle first. I // return without doing anything because that makes some old fltk code work: if (!current) return; fl_transform(x,y); Region r = XRectangleRegion(x, y, w, h); #ifndef _WIN32 Region temp = XCreateRegion(); XSubtractRegion(current, r, temp); XDestroyRegion(r); XDestroyRegion(current); rstack[rstackptr] = temp; #else CombineRgn(current,current,r,RGN_DIFF); DeleteObject(r); #endif fl_restore_clip(); }
inline void X11Graphics::addVSegmentInRegion( Region &rMask, int yStart, int yEnd, int x ) { XRectangle rect; rect.x = x; rect.y = yStart; rect.width = 1; rect.height = yEnd - yStart; Region newMask = XCreateRegion(); XUnionRectWithRegion( &rect, rMask, newMask ); XDestroyRegion( rMask ); rMask = newMask; }