Ejemplo n.º 1
0
void x11_expose(struct x11bitmap *xb, Region r) {
  if (xb->frontbuffer) {
    /* Double-buffered expose update */
    XSetRegion(x11_display,x11_gctab[PG_LGOP_NONE],r);
    XCopyArea(x11_display,xb->d,xb->frontbuffer->d,
	      x11_gctab[PG_LGOP_NONE],0,0,xb->sb.w,xb->sb.h,0,0);
    XSetRegion(x11_display,x11_gctab[PG_LGOP_NONE],x11_display_region);
  }
  else {
    /* Ugly non-double-buffered expose update */

    struct divtree *p;
    int i;
    
    for (i=0;i<=PG_LGOPMAX;i++)
      if (x11_gctab[i])
	XSetRegion(x11_display,x11_gctab[i],r);
    x11_current_region = r;

    for (p=dts->top;p;p=p->next)
      if (p->display == (hwrbitmap)xb)
	p->flags |= DIVTREE_ALL_REDRAW;
    update(NULL,1);

    for (i=0;i<=PG_LGOPMAX;i++)
      if (x11_gctab[i])
	XSetRegion(x11_display,x11_gctab[i],x11_display_region);
    x11_current_region = x11_display_region;
  }
}
Ejemplo n.º 2
0
void rebcmp_blit_region(REBCMP_CTX* ctx, Region reg)
{
	//RL_Print("rebcmp_blit_region, ctx: %x\n", ctx);
	XSetRegion(global_x_info->display, ctx->x_gc, reg);
	/*
	XRectangle rect;
	XClipBox(ctx->Win_Region, &rect);
	RL_Print("Setting window region at: %dx%d, size:%dx%d\n",
			 rect.x, rect.y, rect.width, rect.height);
			 */

#ifdef USE_XSHM
	if (global_x_info->has_xshm) {
		//RL_Print("XshmPutImage\n");
		XShmPutImage(global_x_info->display, 
				ctx->host_window->x_id, 
				ctx->x_gc, 
				ctx->x_image,
				0, 0, 	//src x, y
				0, 0, 	//dest x, y
				ctx->x_image->width, ctx->x_image->height,
				False);
		XFlush(global_x_info->display); //x_image could change if we don't flush here
	} else {
#endif
		Drawable dest = global_x_info->has_double_buffer ? 
			ctx->host_window->x_back_buffer :
			ctx->host_window->x_id;

		if (global_x_info->sys_pixmap_format == pix_format_bgra32){
			XPutImage (global_x_info->display,
					dest,
					ctx->x_gc,
					ctx->x_image,
					0, 0,	//src x, y
					0, 0,	//dest x, y
					ctx->x_image->width, ctx->x_image->height);
		} else {
			put_image(global_x_info->display,
					dest,
					ctx->x_gc,
					ctx->x_image,
					ctx->x_image->width, ctx->x_image->height,
					global_x_info->sys_pixmap_format);
		}

		if (global_x_info->has_double_buffer) {
			//RL_Print("Swapping...\n");
			XdbeSwapInfo swapInfo;
			swapInfo.swap_window = ctx->host_window->x_id;
			swapInfo.swap_action = XdbeUndefined;
			XdbeSwapBuffers(global_x_info->display, &swapInfo, 1);
		}
#ifdef USE_XSHM
	}
#endif

	//RL_Print("rebcmp_blit done\n");
}
Ejemplo n.º 3
0
int _zbar_window_begin (zbar_window_t *w)
{
    window_state_t *xs = w->state;
    if(xs->exposed)
        XSetRegion(w->display, xs->gc, xs->exposed);

    return(0);
}
Ejemplo n.º 4
0
static void sSetGCRegion()
{
  if(UpdateRegionGC)
  {
    XSetRegion(sXDisplay(),sXGC,ClipStack[ClipIndex]);
    UpdateRegionGC = sFALSE;
  }
}
Ejemplo n.º 5
0
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;
}
Ejemplo n.º 6
0
Archivo: xftdraw.c Proyecto: aosm/X11
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;
}
Ejemplo n.º 7
0
// Make the system's clip match the top of the clip stack.  This can
// be used after changing the stack, or to undo any clobbering of clip
// done by your program:
void fl_restore_clip()
{
    Region r = rstack[rstackptr];
    fl_clip_state_number++;
#ifdef _WIN32
    SelectClipRgn(fl_gc, r);     //if r is NULL, clip is automatically cleared
#else
    if (r) XSetRegion(fl_display, fl_gc, r);
    else XSetClipMask(fl_display, fl_gc, 0);
#endif
}
Ejemplo n.º 8
0
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;
}
Ejemplo n.º 9
0
int _zbar_window_draw_logo (zbar_window_t *w)
{
    window_state_t *x = w->state;
    int screen = DefaultScreen(w->display);

    /* clear to white */
    XSetForeground(w->display, x->gc, WhitePixel(w->display, screen));
    XFillRectangle(w->display, w->xwin, x->gc, 0, 0, w->width, w->height);

    if(!x->logo_scale || !x->logo_zbars)
        return(0);

    XSetForeground(w->display, x->gc, BlackPixel(w->display, screen));
    XFillRectangles(w->display, w->xwin, x->gc, x->logo_bars, 5);

    XSetLineAttributes(w->display, x->gc, 2 * x->logo_scale,
                       LineSolid, CapRound, JoinRound);

    XSetForeground(w->display, x->gc, x->logo_colors[0]);
    XDrawLines(w->display, w->xwin, x->gc, x->logo_z, 4, CoordModeOrigin);

    if(x->exposed) {
        XIntersectRegion(x->logo_zbars, x->exposed, x->exposed);
        XSetRegion(w->display, x->gc, x->exposed);
    }
    else
        XSetRegion(w->display, x->gc, x->logo_zbars);

    XSetForeground(w->display, x->gc, x->logo_colors[1]);
    XDrawLines(w->display, w->xwin, x->gc, x->logo_z, 4, CoordModeOrigin);

    /* reset GC */
    XSetLineAttributes(w->display, x->gc, 0,
                       LineSolid, CapButt, JoinMiter);
    return(0);
}
Ejemplo n.º 10
0
void X11Graphics::drawRect( int left, int top, int width, int height,
                            uint32_t color )
{
    // Update the mask with the rectangle
    addHSegmentInRegion( m_mask, left, left + width, top );
    addHSegmentInRegion( m_mask, left, left + width, top + height );
    addVSegmentInRegion( m_mask, top, top + height, left );
    addVSegmentInRegion( m_mask, top, top + height, left + width );

    // Draw the rectangle
    XGCValues gcVal;
    gcVal.foreground = m_rDisplay.getPixelValue( color >> 16, color >> 8, color );
    XChangeGC( XDISPLAY, m_gc, GCForeground,  &gcVal );
    XSetRegion( XDISPLAY, m_gc, m_mask );
    XDrawRectangle( XDISPLAY, m_pixmap, m_gc, left, top, width - 1, height - 1 );
}
Ejemplo n.º 11
0
void
x_drawable_rep::set_clipping (SI x1, SI y1, SI x2, SI y2, bool restore) {
  (void) restore;
  outer_round (x1, y1, x2, y2);
  renderer_rep::set_clipping (x1, y1, x2, y2);
  Region region= XCreateRegion ();
  decode (x1, y1);
  decode (x2, y2);
  XRectangle r;
  r.x     = x1;
  r.y     = y2;
  r.width = x2-x1;
  r.height= y1-y2;
  XUnionRectWithRegion (&r, region, region);
  XSetRegion (dpy, gc, region);
  XDestroyRegion (region);
}
Ejemplo n.º 12
0
void
JXGC::SetClipRegion
	(
	const Region clipRegion
	)
{
	ClearPrivateClipping();

	itsClipRegion = JXCopyRegion(clipRegion);
	itsClipOffset = JPoint(0,0);
	XSetRegion(*itsDisplay, itsXGC, clipRegion);

	const unsigned long valueMask = GCClipXOrigin | GCClipYOrigin;
	XGCValues values;
	values.clip_x_origin = 0;
	values.clip_y_origin = 0;
	XChangeGC(*itsDisplay, itsXGC, valueMask, &values);
}
Ejemplo n.º 13
0
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;
}
Ejemplo n.º 14
0
static PyObject *
PaxGC_SetRegion(PaxGCObject *self, PyObject*args)
{
	PyObject *arg1;
	if (self->shared) {
		PyErr_SetString(PyExc_TypeError, "can't modify shared GC");
		return NULL;
	}
	if (!PyArg_ParseTuple(args, "O",
			&arg1))
		return NULL;
	if (!PaxRegion_Check(arg1)) {
		if (!PyErr_Occurred())
			PyErr_SetString(PyExc_TypeError, "arg1 should be Region");
		return NULL;
	}
XSetRegion(self->display, self->gc,
			PaxRegion_AsRegion(arg1));
	Py_INCREF(Py_None);
	return Py_None;
}
Ejemplo n.º 15
0
void X11Graphics::fillRect( int left, int top, int width, int height,
                            uint32_t color )
{
    // Update the mask with the rectangle area
    Region newMask = XCreateRegion();
    XRectangle rect;
    rect.x = left;
    rect.y = top;
    rect.width = width;
    rect.height = height;
    XUnionRectWithRegion( &rect, m_mask, newMask );
    XDestroyRegion( m_mask );
    m_mask = newMask;

    // Draw the rectangle
    XGCValues gcVal;
    gcVal.foreground = m_rDisplay.getPixelValue( color >> 16, color >> 8, color );
    XChangeGC( XDISPLAY, m_gc, GCForeground,  &gcVal );
    XSetRegion( XDISPLAY, m_gc, m_mask );
    XFillRectangle( XDISPLAY, m_pixmap, m_gc, left, top, width, height );
}
Ejemplo n.º 16
0
Bool
apc_gp_set_clip_rect( Handle self, Rect clipRect)
{
	DEFXX;
	Region region;
	XRectangle r;

	if ( !XF_IN_PAINT(XX))
		return false;

	SORT( clipRect. left, clipRect. right);
	SORT( clipRect. bottom, clipRect. top);
	r. x = clipRect. left;
	r. y = REVERT( clipRect. top);
	r. width = clipRect. right - clipRect. left+1;
	r. height = clipRect. top - clipRect. bottom+1;
	XX-> clip_rect = r;
	XX-> clip_mask_extent. x = r. width;
	XX-> clip_mask_extent. y = r. height;
	region = XCreateRegion();
	XUnionRectWithRegion( &r, region, region);
	if ( XX-> paint_region)
		XIntersectRegion( region, XX-> paint_region, region);
	if ( XX-> btransform. x != 0 || XX-> btransform. y != 0) {
		XOffsetRegion( region, XX-> btransform. x, -XX-> btransform. y);
	}
	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;
}
Ejemplo n.º 17
0
/*
 * Kreslení
 */
static void expose(XExposeEvent *event)
{
    Region region, region1, region2;
    XRectangle rect;
    
    if(event->count > 0)
	return; /* Kreslit jen po poslední události v øadì */
  
    XDrawArc(display, topwin, my_gc, 20, 20, topwin_w - 40, topwin_h - 40,
	     0, 360 * 64);
    
    region = XCreateRegion();
    region1 = XCreateRegion();
    region2 = XCreateRegion();
    rect.x = rect.y = 0;
    rect.width = 100;
    rect.height = topwin_w - 60;
    XUnionRectWithRegion(&rect, region, region1);
    rect.width = 20;
    rect.height = 10;
    XUnionRectWithRegion(&rect, region2, region);
    XOffsetRegion(region, 50, 100);
    XSubtractRegion(region1, region, region2);
    XDestroyRegion(region);
    region = XCreateRegion();
    rect.width = 100;
    rect.height = 30;
    XUnionRectWithRegion(&rect, region, region1);
    XOffsetRegion(region1, (int)topwin_w - 120, -30 + ((int)topwin_h - 40) / 2);
    XUnionRegion(region1, region2, region);
    XSetRegion(display, my_gc, region);
    XDestroyRegion(region);
    XDestroyRegion(region1);
    XDestroyRegion(region2);
    XSetClipOrigin(display, my_gc, 20, 20);
    XFillArc(display, topwin, my_gc, 20, 20, topwin_w - 40, topwin_h - 40,
	     0, 360 * 64);
    XSetClipMask(display, my_gc, None); /* Zru¹it oøezávání */
}
Ejemplo n.º 18
0
void handleExpose(void (*expose)())
/* this function handles the expose event */
{
/* set rectangle to be exposed area */
   rectangle.x = (short) report.xexpose.x;
   rectangle.y = (short) report.xexpose.y;
   rectangle.width = (unsigned short) report.xexpose.width;
   rectangle.height = (unsigned short) report.xexpose.height;

/* union this rect into a region */
   XUnionRectWithRegion(&rectangle, region, region);

/* if this is the last contiguous expose in a group, set
     the clip region, clear region for next time, and draw.*/
   if (report.xexpose.count == 0)
   {
      XSetRegion(display, drawgc, region);
      XDestroyRegion(region);
      region = XCreateRegion();
      if (expose != NULL) (*expose)();
   }
}
Ejemplo n.º 19
0
Archivo: xftdraw.c Proyecto: aosm/X11
Bool
XftDrawCorePrepare (XftDraw	*draw,
		    XftColor	*color,
		    XftFont	*font)
{

    if (!draw->core_set)
    {
	XGCValues	    gcv;
	unsigned long	    mask;
	draw->core_set = True;

	draw->core.fg = color->pixel;
	gcv.foreground = draw->core.fg;
	mask = GCForeground;
	if (font)
	{
	    draw->core.font = font->u.core.font->fid;
	    gcv.font = draw->core.font;
	    mask |= GCFont;
	}
	draw->core.draw_gc = XCreateGC (draw->dpy, draw->drawable, 
					mask, &gcv);
	if (draw->clip)
	    XSetRegion (draw->dpy, draw->core.draw_gc, draw->clip);
    }
    if (draw->core.fg != color->pixel)
    {
	draw->core.fg = color->pixel;
	XSetForeground (draw->dpy, draw->core.draw_gc, draw->core.fg);
    }
    if (font && draw->core.font != font->u.core.font->fid)
    {
	draw->core.font = font->u.core.font->fid;
	XSetFont (draw->dpy, draw->core.draw_gc, draw->core.font);
    }
    return True;
}
Ejemplo n.º 20
0
/*
 *
 *  Procedure:
 *      menuitem_paint - draws a single entry in a popped up menu
 *
 *      mr - the menu instance that holds the menu item
 *      mi - the menu item to redraw
 *      fw - the FvwmWindow structure to check against allowed functions
 *
 */
void menuitem_paint(
	struct MenuItem *mi, struct MenuPaintItemParameters *mpip)
{
	struct MenuStyle *ms = mpip->ms;
	struct MenuDimensions *dim = mpip->dim;

	static FlocaleWinString *fws = NULL;
	int y_offset;
	int text_y;
	int y_height;
	int x;
	int y;
	int lit_x_start;
	int lit_x_end;
	gc_quad_t gcs;
	gc_quad_t off_gcs;
	int cs = -1;
	int off_cs;
	FvwmRenderAttributes fra;
	/*Pixel fg, fgsh;*/
	int relief_thickness = ST_RELIEF_THICKNESS(ms);
	Bool is_item_selected;
	Bool item_cleared = False;
	Bool xft_clear = False;
	Bool empty_inter = False;
	XRectangle b;
	Region region = None;
	int i;
	int sx1;
	int sx2;
	FlocaleFont* font;

	if (!mi)
	{
		return;
	}
	is_item_selected = (mi == mpip->selected_item);

	if (MI_IS_TITLE(mi))
	{
		font = ST_PTITLEFONT(ms);
	}
	else
	{
		font = ST_PSTDFONT(ms);
	}

	y_offset = MI_Y_OFFSET(mi);
	y_height = MI_HEIGHT(mi);
	if (MI_IS_SELECTABLE(mi))
	{
		text_y = y_offset + MDIM_ITEM_TEXT_Y_OFFSET(*dim);
	}
	else
	{
		text_y = y_offset + font->ascent +
			ST_TITLE_GAP_ABOVE(ms);
	}
	/* center text vertically if the pixmap is taller */
	if (MI_PICTURE(mi))
	{
		text_y += MI_PICTURE(mi)->height;
	}
	for (i = 0; i < mpip->used_mini_icons; i++)
	{
		y = 0;
		if (MI_MINI_ICON(mi)[i])
		{
			if (MI_MINI_ICON(mi)[i]->height > y)
			{
				y = MI_MINI_ICON(mi)[i]->height;
			}
		}
		y -= font->height;
		if (y > 1)
		{
			text_y += y / 2;
		}
	}

	off_cs = ST_HAS_MENU_CSET(ms) ? ST_CSET_MENU(ms) : -1;
	/* Note: it's ok to pass a NULL label to is_function_allowed. */
	if (
		!IS_EWMH_DESKTOP_FW(mpip->fw) &&
		!is_function_allowed(
			MI_FUNC_TYPE(mi), MI_LABEL(mi)[0], mpip->fw,
			RQORIG_PROGRAM_US, False))
	{
		gcs = ST_MENU_STIPPLE_GCS(ms);
		off_gcs = gcs;
		off_cs = ST_HAS_GREYED_CSET(ms) ? ST_CSET_GREYED(ms) : -1;
	}
	else if (is_item_selected)
	{
		gcs = ST_MENU_ACTIVE_GCS(ms);
		off_gcs = ST_MENU_INACTIVE_GCS(ms);
	}
	else if (MI_IS_TITLE(mi))
	{
		gcs = ST_MENU_TITLE_GCS(ms);
		off_gcs = ST_MENU_INACTIVE_GCS(ms);
	}
	else
	{
		gcs = ST_MENU_INACTIVE_GCS(ms);
		off_gcs = ST_MENU_INACTIVE_GCS(ms);
	}
	if (is_item_selected)
	{
		cs = (ST_HAS_ACTIVE_CSET(ms)) ? ST_CSET_ACTIVE(ms) : -1;
	}
	else if (MI_IS_TITLE(mi))
	{
		cs = (ST_HAS_TITLE_CSET(ms)) ? ST_CSET_TITLE(ms) : off_cs;
	}
	else
	{
		cs = off_cs;
	}

	/*
	 * Hilight the item.
	 */
	if (FftSupport && ST_PSTDFONT(ms)->fftf.fftfont != NULL)
	{
		xft_clear = True;
	}

	/* Hilight or clear the background. */
	lit_x_start = -1;
	lit_x_end = -1;
	if (is_item_selected &&
	    (ST_DO_HILIGHT_BACK(ms) || ST_DO_HILIGHT_FORE(ms)))
	{
		/* Hilight the background. */
		if (MDIM_HILIGHT_WIDTH(*dim) - 2 * relief_thickness > 0)
		{
			lit_x_start = MDIM_HILIGHT_X_OFFSET(*dim) +
				relief_thickness;
			lit_x_end = lit_x_start + MDIM_HILIGHT_WIDTH(*dim) -
				2 * relief_thickness;
			if (ST_DO_HILIGHT_BACK(ms))
			{
				draw_highlight_background(
					mpip, lit_x_start,
					y_offset + relief_thickness,
					lit_x_end - lit_x_start,
					y_height - relief_thickness,
					(cs >= 0 ? &Colorset[cs] : NULL),
					gcs.back_gc);
				item_cleared = True;
			}
		}
	}
	else if ((MI_WAS_DESELECTED(mi) &&
		  (relief_thickness > 0 ||
		   ST_DO_HILIGHT_BACK(ms) || ST_DO_HILIGHT_FORE(ms)) &&
		  (ST_FACE(ms).type != GradientMenu || ST_HAS_MENU_CSET(ms))))
	{
		int x1;
		int x2;
		/* we clear if xft_clear and !ST_HAS_MENU_CSET(ms) as the
		 * non colorset code is too complicate ... olicha */
		int d = 0;

		if (MI_PREV_ITEM(mi) &&
		    mpip->selected_item == MI_PREV_ITEM(mi))
		{
			/* Don't paint over the hilight relief. */
			d = relief_thickness;
		}
		/* Undo the hilighting. */
		x1 = min(
			MDIM_HILIGHT_X_OFFSET(*dim), MDIM_ITEM_X_OFFSET(*dim));
		x2 = max(
			MDIM_HILIGHT_X_OFFSET(*dim) + MDIM_HILIGHT_WIDTH(*dim),
			MDIM_ITEM_X_OFFSET(*dim) + MDIM_ITEM_WIDTH(*dim));
		clear_menu_item_background(
			mpip, x1, y_offset + d, x2 - x1,
			y_height + relief_thickness - d);
		item_cleared = True;
	}
	else if (MI_IS_TITLE(mi))
	{
		lit_x_start = MDIM_ITEM_X_OFFSET(*dim);
		lit_x_end = lit_x_start + MDIM_ITEM_WIDTH(*dim);
		/* Hilight the background. */
		if (
			MDIM_HILIGHT_WIDTH(*dim) > 0 &&
			ST_DO_HILIGHT_TITLE_BACK(ms))
		{
			draw_highlight_background(
				mpip, lit_x_start,
				y_offset + relief_thickness,
				lit_x_end - lit_x_start,
				y_height - relief_thickness,
				(cs >= 0 ? &Colorset[cs] : NULL),
				gcs.back_gc);
			item_cleared = True;
		}
	}

	MI_WAS_DESELECTED(mi) = False;
	memset(&fra, 0, sizeof(fra));
	fra.mask = 0;

	/* Hilight 3D */
	if (is_item_selected && relief_thickness > 0)
	{
		GC rgc;
		GC sgc;

		rgc = gcs.hilight_gc;
		sgc = gcs.shadow_gc;
		if (ST_IS_ITEM_RELIEF_REVERSED(ms))
		{
			GC tgc = rgc;

			/* swap gcs for reversed relief */
			rgc = sgc;
			sgc = tgc;
		}
		if (MDIM_HILIGHT_WIDTH(*dim) - 2 * relief_thickness > 0)
		{
			/* The relief reaches down into the next item, hence
			 * the value for the second y coordinate:
			 * MI_HEIGHT(mi) + 1 */
			RelieveRectangle(
				dpy, mpip->w,  MDIM_HILIGHT_X_OFFSET(*dim),
				y_offset, MDIM_HILIGHT_WIDTH(*dim) - 1,
				MI_HEIGHT(mi) - 1 + relief_thickness, rgc, sgc,
				relief_thickness);
		}
	}


	/*
	 * Draw the item itself.
	 */

	/* Calculate the separator offsets. */
	if (ST_HAS_LONG_SEPARATORS(ms))
	{
		sx1 = MDIM_ITEM_X_OFFSET(*dim) + relief_thickness;
		sx2 = MDIM_ITEM_X_OFFSET(*dim) + MDIM_ITEM_WIDTH(*dim) - 1 -
			relief_thickness;
	}
	else
	{
		sx1 = MDIM_ITEM_X_OFFSET(*dim) + relief_thickness +
			MENU_SEPARATOR_SHORT_X_OFFSET;
		sx2 = MDIM_ITEM_X_OFFSET(*dim) + MDIM_ITEM_WIDTH(*dim) - 1 -
			relief_thickness - MENU_SEPARATOR_SHORT_X_OFFSET;
	}
	if (MI_IS_SEPARATOR(mi))
	{
		if (sx1 < sx2)
		{
			/* It's a separator. */
			draw_separator(
				mpip->w, gcs.shadow_gc, gcs.hilight_gc, sx1,
				y_offset + y_height - MENU_SEPARATOR_HEIGHT,
				sx2);
			/* Nothing else to do. */
		}
		return;
	}
	else if (MI_IS_TEAR_OFF_BAR(mi))
	{
		int tx1;
		int tx2;

		tx1 = MDIM_ITEM_X_OFFSET(*dim) + relief_thickness +
			MENU_TEAR_OFF_BAR_X_OFFSET;
		tx2 = MDIM_ITEM_X_OFFSET(*dim) + MDIM_ITEM_WIDTH(*dim) - 1 -
			relief_thickness -
			MENU_TEAR_OFF_BAR_X_OFFSET;
		if (tx1 < tx2)
		{

			/* It's a tear off bar. */
			draw_tear_off_bar(
				mpip->w, gcs.shadow_gc, gcs.hilight_gc, tx1,
				y_offset + relief_thickness +
				MENU_TEAR_OFF_BAR_Y_OFFSET, tx2);
		}
		/* Nothing else to do. */
		return;
	}
	else if (MI_IS_TITLE(mi))
	{
		/* Separate the title. */
		if (ST_TITLE_UNDERLINES(ms) > 0 && !mpip->flags.is_first_item)
		{
			int add = (MI_IS_SELECTABLE(MI_PREV_ITEM(mi))) ?
				relief_thickness : 0;

			text_y += MENU_SEPARATOR_HEIGHT + add;
			y = y_offset + add;
			if (sx1 < sx2)
			{
				draw_separator(
					mpip->w, gcs.shadow_gc, gcs.hilight_gc,
					sx1, y, sx2);
			}
		}
		/* Underline the title. */
		switch (ST_TITLE_UNDERLINES(ms))
		{
		case 0:
			break;
		case 1:
			if (MI_NEXT_ITEM(mi) != NULL)
			{
				y = y_offset + y_height - MENU_SEPARATOR_HEIGHT;
				draw_separator(
					mpip->w, gcs.shadow_gc, gcs.hilight_gc,
					sx1, y, sx2);
			}
			break;
		default:
			for (i = ST_TITLE_UNDERLINES(ms); i-- > 0; )
			{
				y = y_offset + y_height - 1 -
					i * MENU_UNDERLINE_HEIGHT;
				XDrawLine(
					dpy, mpip->w, gcs.shadow_gc, sx1, y,
					sx2, y);
			}
			break;
		}
	}

	/*
	 * Draw the labels.
	 */
	if (fws == NULL)
	{
		FlocaleAllocateWinString(&fws);
	}
	fws->win = mpip->w;
	fws->y = text_y;
	fws->flags.has_colorset = 0;
	b.y = text_y - font->ascent;
	b.height = font->height + 1; /* ? */
	if (!item_cleared && mpip->ev)
	{
		int u,v;
		if (!frect_get_seg_intersection(
			    mpip->ev->xexpose.y, mpip->ev->xexpose.height,
			    b.y, b.height, &u, &v))
		{
			/* empty intersection */
			empty_inter = True;
		}
		b.y = u;
		b.height = v;
	}

	for (i = MAX_MENU_ITEM_LABELS; i-- > 0; )
	{
		if (!empty_inter && MI_LABEL(mi)[i] && *(MI_LABEL(mi)[i]))
		{
			Bool draw_string = True;
			int text_width;
			int tmp_cs;

			if (MI_LABEL_OFFSET(mi)[i] >= lit_x_start &&
			    MI_LABEL_OFFSET(mi)[i] < lit_x_end)
			{
				/* label is in hilighted area */
				fws->gc = gcs.fore_gc;
				tmp_cs = cs;
			}
			else
			{
				/* label is in unhilighted area */
				fws->gc = off_gcs.fore_gc;
				tmp_cs = off_cs;
			}
			if (tmp_cs >= 0)
			{
				fws->colorset = &Colorset[tmp_cs];
				fws->flags.has_colorset = 1;
			}
			fws->str = MI_LABEL(mi)[i];
			b.x = fws->x = MI_LABEL_OFFSET(mi)[i];
			b.width = text_width = FlocaleTextWidth(
				font, fws->str, strlen(fws->str));

			if (!item_cleared && mpip->ev)
			{
				int s_x,s_w;
				if (frect_get_seg_intersection(
					    mpip->ev->xexpose.x,
					    mpip->ev->xexpose.width,
					    fws->x, text_width,
					    &s_x, &s_w))
				{
					b.x = s_x;
					b.width = s_w;
					region = XCreateRegion();
					XUnionRectWithRegion(
						&b, region, region);
					fws->flags.has_clip_region = True;
					fws->clip_region = region;
					draw_string = True;
					XSetRegion(dpy, fws->gc, region);
				}
				else
				{
					/* empty intersection */
					draw_string = False;
				}
			}
			if (draw_string)
			{
				if (!item_cleared && xft_clear)
				{
					clear_menu_item_background(
						mpip, b.x, b.y, b.width,
						b.height);
				}
				FlocaleDrawString(dpy, font, fws, 0);

				/* hot key */
				if (MI_HAS_HOTKEY(mi) && !MI_IS_TITLE(mi) &&
				    (!MI_IS_HOTKEY_AUTOMATIC(mi) ||
				     ST_USE_AUTOMATIC_HOTKEYS(ms)) &&
				    MI_HOTKEY_COLUMN(mi) == i)
				{
					FlocaleDrawUnderline(
						dpy, ST_PSTDFONT(ms), fws,
						MI_HOTKEY_COFFSET(mi));
				}
			}
		}
		if (region)
		{
			XDestroyRegion(region);
			region = None;
			fws->flags.has_clip_region = False;
			fws->clip_region = None;
			XSetClipMask(dpy, fws->gc, None);
		}
	}

	/*
	 * Draw the submenu triangle.
	 */

	if (MI_IS_POPUP(mi))
	{
		GC tmp_gc;

		if (MDIM_TRIANGLE_X_OFFSET(*dim) >= lit_x_start &&
		    MDIM_TRIANGLE_X_OFFSET(*dim) < lit_x_end &&
		    is_item_selected)
		{
			/* triangle is in hilighted area */
			if (ST_TRIANGLES_USE_FORE(ms))
			{
				tmp_gc = gcs.fore_gc;
			}
			else
			{
				tmp_gc = gcs.hilight_gc;
			}
		}
		else
		{
			/* triangle is in unhilighted area */
			if (ST_TRIANGLES_USE_FORE(ms))
			{
				tmp_gc = off_gcs.fore_gc;
			}
			else
			{
				tmp_gc = off_gcs.hilight_gc;
			}
		}
		y = y_offset + (y_height - MENU_TRIANGLE_HEIGHT +
				relief_thickness) / 2;

		if (ST_TRIANGLES_USE_FORE(ms))
		{
			DrawTrianglePattern(
				dpy, mpip->w, tmp_gc, tmp_gc, tmp_gc,
				MDIM_TRIANGLE_X_OFFSET(*dim), y,
				MENU_TRIANGLE_WIDTH, MENU_TRIANGLE_HEIGHT, 0,
				(mpip->flags.is_left_triangle) ? 'l' : 'r',
				ST_HAS_TRIANGLE_RELIEF(ms),
				!ST_HAS_TRIANGLE_RELIEF(ms), is_item_selected);

		}
		else
		{
			DrawTrianglePattern(
				dpy, mpip->w, gcs.hilight_gc, gcs.shadow_gc,
				tmp_gc,	MDIM_TRIANGLE_X_OFFSET(*dim), y,
				MENU_TRIANGLE_WIDTH, MENU_TRIANGLE_HEIGHT, 0,
				(mpip->flags.is_left_triangle) ? 'l' : 'r',
				ST_HAS_TRIANGLE_RELIEF(ms),
				!ST_HAS_TRIANGLE_RELIEF(ms), is_item_selected);
		}
	}

	/*
	 * Draw the item picture.
	 */

	if (MI_PICTURE(mi))
	{
		GC tmp_gc;
		int tmp_cs;
		Bool draw_picture = True;

		x = menudim_middle_x_offset(mpip->dim) -
			MI_PICTURE(mi)->width / 2;
		y = y_offset + ((MI_IS_SELECTABLE(mi)) ? relief_thickness : 0);
		if (x >= lit_x_start && x < lit_x_end)
		{
			tmp_gc = gcs.fore_gc;
			tmp_cs = cs;
		}
		else
		{
			tmp_gc = off_gcs.fore_gc;
			tmp_cs = off_cs;
		}
		fra.mask = FRAM_DEST_IS_A_WINDOW;
		if (tmp_cs >= 0)
		{
			fra.mask |= FRAM_HAVE_ICON_CSET;
			fra.colorset = &Colorset[tmp_cs];
		}
		b.x = x;
		b.y = y;
		b.width = MI_PICTURE(mi)->width;
		b.height = MI_PICTURE(mi)->height;
		if (!item_cleared && mpip->ev)
		{
			if (!frect_get_intersection(
				    mpip->ev->xexpose.x, mpip->ev->xexpose.y,
				    mpip->ev->xexpose.width,
				    mpip->ev->xexpose.height,
				    b.x, b.y, b.width, b.height, &b))
			{
				draw_picture = False;
			}
		}
		if (draw_picture)
		{
			if (
				!item_cleared &&
				(MI_PICTURE(mi)->alpha != None ||
				 (tmp_cs >=0 &&
				  Colorset[tmp_cs].icon_alpha_percent < 100)))
			{
				clear_menu_item_background(
					mpip, b.x, b.y, b.width, b.height);
			}
			PGraphicsRenderPicture(
				dpy, mpip->w, MI_PICTURE(mi), &fra,
				mpip->w, tmp_gc, Scr.MonoGC, Scr.AlphaGC,
				b.x - x, b.y - y, b.width, b.height,
				b.x, b.y, b.width, b.height, False);
		}
	}

	/*
	 * Draw the mini icons.
	 */

	for (i = 0; i < mpip->used_mini_icons; i++)
	{
		int k;
		Bool draw_picture = True;

		/* We need to reverse the mini icon order for left submenu
		 * style. */
		k = (ST_USE_LEFT_SUBMENUS(ms)) ?
			mpip->used_mini_icons - 1 - i : i;

		if (MI_MINI_ICON(mi)[i])
		{
			GC tmp_gc;
			int tmp_cs;

			if (MI_PICTURE(mi))
			{
				y = y_offset + MI_HEIGHT(mi) -
					MI_MINI_ICON(mi)[i]->height;
			}
			else
			{
				y = y_offset +
					(MI_HEIGHT(mi) +
					 ((MI_IS_SELECTABLE(mi)) ?
					  relief_thickness : 0) -
					 MI_MINI_ICON(mi)[i]->height) / 2;
			}
			if (MDIM_ICON_X_OFFSET(*dim)[k] >= lit_x_start &&
			    MDIM_ICON_X_OFFSET(*dim)[k] < lit_x_end)
			{
				/* icon is in hilighted area */
				tmp_gc = gcs.fore_gc;
				tmp_cs = cs;
			}
			else
			{
				/* icon is in unhilighted area */
				tmp_gc = off_gcs.fore_gc;
				tmp_cs = off_cs;
			}
			fra.mask = FRAM_DEST_IS_A_WINDOW;
			if (tmp_cs >= 0)
			{
				fra.mask |= FRAM_HAVE_ICON_CSET;
				fra.colorset = &Colorset[tmp_cs];
			}
			b.x = MDIM_ICON_X_OFFSET(*dim)[k];
			b.y = y;
			b.width = MI_MINI_ICON(mi)[i]->width;
			b.height = MI_MINI_ICON(mi)[i]->height;
			if (!item_cleared && mpip->ev)
			{
				if (!frect_get_intersection(
					    mpip->ev->xexpose.x,
					    mpip->ev->xexpose.y,
					    mpip->ev->xexpose.width,
					    mpip->ev->xexpose.height,
					    b.x, b.y, b.width, b.height, &b))
				{
					draw_picture = False;
				}
			}
			if (draw_picture)
			{
				if (!item_cleared &&
				    (MI_MINI_ICON(mi)[i]->alpha != None
				     || (tmp_cs >=0 &&
					 Colorset[tmp_cs].icon_alpha_percent <
					 100)))
				{
					clear_menu_item_background(
						mpip,
						b.x, b.y, b.width, b.height);
				}
				PGraphicsRenderPicture(
					dpy, mpip->w, MI_MINI_ICON(mi)[i],
					&fra, mpip->w, tmp_gc, Scr.MonoGC,
					Scr.AlphaGC,
					b.x - MDIM_ICON_X_OFFSET(*dim)[k],
					b.y - y, b.width, b.height,
					b.x, b.y, b.width, b.height, False);
			}
		}
	}

	return;
}
Ejemplo n.º 21
0
/*ARGSUSED*/
static void
XawLabelRedisplay(Widget gw, XEvent *event, Region region)
{
    LabelWidget w = (LabelWidget)gw;
    GC gc;

    if (*Superclass->core_class.expose != NULL)
	(*Superclass->core_class.expose)(gw, event, region);

    gc = XtIsSensitive(gw) ? w->label.normal_GC : w->label.gray_GC;
#ifdef notdef
    if (region != NULL)
	XSetRegion(XtDisplay(gw), gc, region);
#endif /*notdef*/

    if (w->label.pixmap == None) {
	int len = w->label.label_len;
	char *label = w->label.label;
	Position y = w->label.label_y + w->label.font->max_bounds.ascent;
	Position ksy = w->label.label_y;

	/* display left bitmap */
	if (w->label.left_bitmap && w->label.lbm_width != 0)
	    XCopyPlane (XtDisplay(gw), w->label.left_bitmap, XtWindow(gw), gc,
			0, 0, w->label.lbm_width, w->label.lbm_height,
			w->label.internal_width,
			w->label.internal_height + w->label.lbm_y, 1L);

	if (w->simple.international == True) {
	    XFontSetExtents *ext = XExtentsOfFontSet(w->label.fontset);

	    ksy += XawAbs(ext->max_ink_extent.y);

	    if (len == MULTI_LINE_LABEL) {
		char *nl;

		while ((nl = index(label, '\n')) != NULL) {
		    XmbDrawString(XtDisplay(w), XtWindow(w), w->label.fontset,
				  gc, w->label.label_x, ksy, label,
				  (int)(nl - label));
		    ksy += ext->max_ink_extent.height;
		    label = nl + 1;
		}
		len = strlen(label);
	    }
	    if (len)
		XmbDrawString(XtDisplay(w), XtWindow(w), w->label.fontset, gc,
			      w->label.label_x, ksy, label, len);
	}
	else {
	    if (len == MULTI_LINE_LABEL) {
		char *nl;

		while ((nl = index(label, '\n')) != NULL) {
		    if (w->label.encoding)
			XDrawString16(XtDisplay(gw), XtWindow(gw), gc,
				      w->label.label_x, y,
				      (XChar2b *)label, (int)(nl - label) / 2);
		    else
			XDrawString(XtDisplay(gw), XtWindow(gw), gc,
				    w->label.label_x, y, label, (int)(nl - label));
		    y += w->label.font->max_bounds.ascent +
			 w->label.font->max_bounds.descent;
		    label = nl + 1;
		}
		len = strlen(label);
	    }
	    if (len) {
		if (w->label.encoding)
		    XDrawString16(XtDisplay(gw), XtWindow(gw), gc,
				  w->label.label_x, y, (XChar2b *)label, len / 2);
		else
		    XDrawString(XtDisplay(gw), XtWindow(gw), gc,
				w->label.label_x, y, label, len);
	    }
	}
    }
    else if (w->label.label_len == 1)
	XCopyPlane(XtDisplay(gw), w->label.pixmap, XtWindow(gw), gc,
		   0, 0, w->label.label_width, w->label.label_height,
		   w->label.label_x, w->label.label_y, 1L);
    else
	XCopyArea(XtDisplay(gw), w->label.pixmap, XtWindow(gw), gc,
		  0, 0, w->label.label_width, w->label.label_height,
		  w->label.label_x, w->label.label_y);

#ifdef notdef
    if (region != NULL)
	XSetClipMask(XtDisplay(gw), gc, (Pixmap)None);
#endif /* notdef */
}
Ejemplo n.º 22
0
void X11Graphics::drawBitmap( const GenericBitmap &rBitmap, int xSrc,
                              int ySrc, int xDest, int yDest, int width,
                              int height, bool blend )
{
    // Get the bitmap size if necessary
    if( width == -1 )
    {
        width = rBitmap.getWidth();
    }
    else if( width > rBitmap.getWidth() )
    {
        msg_Dbg( getIntf(), "bitmap width too small (%i)", rBitmap.getWidth() );
        width = rBitmap.getWidth();
    }
    if( height == -1 )
    {
        height = rBitmap.getHeight();
    }
    else if( height > rBitmap.getHeight() )
    {
        msg_Dbg( getIntf(), "bitmap height too small (%i)", rBitmap.getHeight()
                                 );
        height = rBitmap.getHeight();
    }

    // Nothing to draw if width or height is null
    if( width == 0 || height == 0 )
    {
        return;
    }

    // Safety check for debugging purpose
    if( xDest + width > m_width || yDest + height > m_height )
    {
        msg_Dbg( getIntf(), "bitmap too large" );
        return;
    }

    // Get a buffer on the image data
    uint8_t *pBmpData = rBitmap.getData();
    if( pBmpData == NULL )
    {
        // Nothing to draw
        return;
    }

    // Get the image from the pixmap
    XImage *pImage = XGetImage( XDISPLAY, m_pixmap, xDest, yDest, width,
                                height, AllPlanes, ZPixmap );
    if( pImage == NULL )
    {
        msg_Dbg( getIntf(), "XGetImage returned NULL" );
        return;
    }
    char *pData = pImage->data;

    // Get the padding of this image
    int pad = pImage->bitmap_pad >> 3;
    int shift = ( pad - ( (width * XPIXELSIZE) % pad ) ) % pad;

    // Mask for transparency
    Region mask = XCreateRegion();

    // Get a pointer on the right X11Display::makePixel method
    X11Display::MakePixelFunc_t makePixelFunc = ( blend ?
        m_rDisplay.getBlendPixel() : m_rDisplay.getPutPixel() );

    // Skip the first lines of the image
    pBmpData += 4 * ySrc * rBitmap.getWidth();

    // Copy the bitmap on the image and compute the mask
    for( int y = 0; y < height; y++ )
    {
        // Skip uninteresting bytes at the beginning of the line
        pBmpData += 4 * xSrc;
        // Flag to say whether the previous pixel on the line was visible
        bool wasVisible = false;
        // Beginning of the current visible segment on the line
        int visibleSegmentStart = 0;
        for( int x = 0; x < width; x++ )
        {
            uint8_t b = *(pBmpData++);
            uint8_t g = *(pBmpData++);
            uint8_t r = *(pBmpData++);
            uint8_t a = *(pBmpData++);
            // Draw the pixel
            (m_rDisplay.*makePixelFunc)( (uint8_t*)pData, r, g, b, a );
            pData += XPIXELSIZE;
            if( a > 0 )
            {
                // Pixel is visible
                if( ! wasVisible )
                {
                    // Beginning of a visible segment
                    visibleSegmentStart = x;
                }
                wasVisible = true;
            }
            else
            {
                // Pixel is transparent
                if( wasVisible )
                {
                    // End of a visible segment: add it to the mask
                    addHSegmentInRegion( mask, visibleSegmentStart, x, y );
                }
                wasVisible = false;
            }
        }
        if( wasVisible )
        {
            // End of a visible segment: add it to the mask
            addHSegmentInRegion( mask, visibleSegmentStart, width, y );
        }
        pData += shift;
        // Skip uninteresting bytes at the end of the line
        pBmpData += 4 * (rBitmap.getWidth() - width - xSrc);
    }

    // Apply the mask to the graphics context
    XOffsetRegion( mask, xDest, yDest );
    XSetRegion( XDISPLAY, m_gc, mask );
    // Copy the image on the pixmap
    XPutImage( XDISPLAY, m_pixmap, m_gc, pImage, 0, 0, xDest, yDest, width,
               height);
    XDestroyImage( pImage );

    // Add the bitmap mask to the global graphics mask
    Region newMask = XCreateRegion();
    XUnionRegion( mask, m_mask, newMask );
    XDestroyRegion( m_mask );
    m_mask = newMask;

    XDestroyRegion( mask );
}
Ejemplo n.º 23
0
static void
x_gram_draw(Display *dpy, Window w, x_gram *gram, Region region)
{
   int i;
   GC gc;
   XGCValues gcvals;
   xblock *xb;
#ifdef X_HAVE_UTF8_STRING
   XmbTextItem text;
#else
   XwcTextItem text;
#endif
   int startblock, endblock, startpixel = 0, endpixel = 0;
   
   gc = XCreateGC(dpy, w, 0, &gcvals);
   XSetRegion(dpy, gc, region);
 
   if ((markgram == gram) && (STARTBLOCK != -1) && (ENDBLOCK != -1)) {
      if (xmarkSecond() == XMARK_END_BOUND) {
         startblock = STARTBLOCK;
         endblock = ENDBLOCK;
         startpixel = STARTPIXEL;
         endpixel = ENDPIXEL;
      } else {
         startblock = ENDBLOCK;
         endblock = STARTBLOCK;
         startpixel = ENDPIXEL;
         endpixel = STARTPIXEL;
      }
   } else {
      startblock = -1;
      endblock = -1;
   }

   for (i=0, xb = gram->blocks; i < gram->numblocks; i++, xb++) {
      if (XRectInRegion(region, xb->x1, xb->y1, xb->x2 - xb->x1,
                        xb->y2 - xb->y1) != RectangleOut) {
         if (i == startblock) {
            if (i == endblock) {
                SetFG(dpy, gc, gram->bgcolor);
                XFillRectangle(dpy, w, gc, xb->x1, xb->y1, startpixel,
                               xb->y2 - xb->y1);
                SetFG(dpy, gc, xb->fgcolor);
                XFillRectangle(dpy, w, gc, xb->x1 + startpixel, xb->y1,
                               endpixel - startpixel, xb->y2 - xb->y1);
                SetFG(dpy, gc, gram->bgcolor);
                XFillRectangle(dpy, w, gc, xb->x1 + endpixel, xb->y1,
                               xb->x2 - xb->x1 - endpixel, xb->y2 - xb->y1);
            } else {
                SetFG(dpy, gc, gram->bgcolor);
                XFillRectangle(dpy, w, gc, xb->x1, xb->y1, startpixel,
                              xb->y2 - xb->y1);
                SetFG(dpy, gc, xb->fgcolor);
                XFillRectangle(dpy, w, gc, xb->x1 + startpixel, xb->y1,
                               xb->x2 - xb->x1 - startpixel,xb->y2 - xb->y1);
            }
         } else if (i == endblock) {
             SetFG(dpy, gc, xb->fgcolor);
             XFillRectangle(dpy, w, gc, xb->x1, xb->y1, endpixel,
                            xb->y2 - xb->y1);
             SetFG(dpy, gc, gram->bgcolor);
             XFillRectangle(dpy, w, gc, xb->x1 + endpixel, xb->y1,
                            xb->x2 - xb->x1 - endpixel, xb->y2 - xb->y1);
         } else {
             if (startblock < i && i < endblock) {
                 SetFG(dpy, gc, xb->fgcolor);
             } else {
                 SetFG(dpy, gc, gram->bgcolor);
             }
             XFillRectangle(dpy, w, gc, xb->x1, xb->y1, xb->x2 - xb->x1,
                            xb->y2 - xb->y1);
         }
      }
   }

   gcvals.function = GXxor;
   XChangeGC(dpy, gc, GCFunction, &gcvals);

   for (i=0, xb = gram->blocks; i < gram->numblocks; i++, xb++) {
      if (XRectInRegion(region, xb->x1, xb->y1, xb->x2 - xb->x1,
                        xb->y2 - xb->y1) != RectangleOut) {
          SetFG(dpy, gc, gram->bgcolor ^ xb->fgcolor);
#ifdef X_HAVE_UTF8_STRING
          text.chars = xb->wstr;
#else
          text.chars = (wchar_t *)xb->wstr;
#endif
          text.nchars = xb->wlen;
          text.delta = 0;
          text.font_set = xb->font;
#ifdef X_HAVE_UTF8_STRING
          Xutf8DrawText(dpy, w, gc, xb->x, xb->y, &text, 1);
#else
          XwcDrawText(dpy, w, gc, xb->x, xb->y, &text, 1);
#endif
     }
   }

   XFreeGC(dpy, gc);
}
Ejemplo n.º 24
0
EAPI Eina_Bool
ecore_x_xregion_set(Ecore_X_XRegion *region, Ecore_X_GC gc)
{
   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   return XSetRegion(_ecore_x_disp, gc, (Region)region) ? EINA_TRUE : EINA_FALSE;
} /* ecore_x_xregion_set */
Ejemplo n.º 25
0
void X11Graphics::drawBitmap( const GenericBitmap &rBitmap, int xSrc,
                              int ySrc, int xDest, int yDest, int width,
                              int height, bool blend )
{
    // check and adapt to source if needed
    if( !checkBoundaries( 0, 0, rBitmap.getWidth(), rBitmap.getHeight(),
                          xSrc, ySrc, width, height ) )
    {
        msg_Err( getIntf(), "empty source! pls, debug your skin" );
        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;
    }

    // Get a buffer on the image data
    uint8_t *pBmpData = rBitmap.getData();
    if( pBmpData == NULL )
    {
        // Nothing to draw
        return;
    }

    // Force pending XCopyArea to be sent to the X Server
    // before issuing an XGetImage.
    XSync( XDISPLAY, False );

    // Get the image from the pixmap
    XImage *pImage = XGetImage( XDISPLAY, m_pixmap, xDest, yDest, width,
                                height, AllPlanes, ZPixmap );
    if( pImage == NULL )
    {
        msg_Dbg( getIntf(), "XGetImage returned NULL" );
        return;
    }
    char *pData = pImage->data;

    // Get the padding of this image
    int pad = pImage->bitmap_pad >> 3;
    int shift = ( pad - ( (width * XPIXELSIZE) % pad ) ) % pad;

    // Mask for transparency
    Region mask = XCreateRegion();

    // Get a pointer on the right X11Display::makePixel method
    X11Display::MakePixelFunc_t makePixelFunc = ( blend ?
        m_rDisplay.getBlendPixel() : m_rDisplay.getPutPixel() );

    // Skip the first lines of the image
    pBmpData += 4 * ySrc * rBitmap.getWidth();

    // Copy the bitmap on the image and compute the mask
    for( int y = 0; y < height; y++ )
    {
        // Skip uninteresting bytes at the beginning of the line
        pBmpData += 4 * xSrc;
        // Flag to say whether the previous pixel on the line was visible
        bool wasVisible = false;
        // Beginning of the current visible segment on the line
        int visibleSegmentStart = 0;
        for( int x = 0; x < width; x++ )
        {
            uint8_t b = *(pBmpData++);
            uint8_t g = *(pBmpData++);
            uint8_t r = *(pBmpData++);
            uint8_t a = *(pBmpData++);
            // Draw the pixel
            (m_rDisplay.*makePixelFunc)( (uint8_t*)pData, r, g, b, a );
            pData += XPIXELSIZE;
            if( a > 0 )
            {
                // Pixel is visible
                if( ! wasVisible )
                {
                    // Beginning of a visible segment
                    visibleSegmentStart = x;
                }
                wasVisible = true;
            }
            else
            {
                // Pixel is transparent
                if( wasVisible )
                {
                    // End of a visible segment: add it to the mask
                    addHSegmentInRegion( mask, visibleSegmentStart, x, y );
                }
                wasVisible = false;
            }
        }
        if( wasVisible )
        {
            // End of a visible segment: add it to the mask
            addHSegmentInRegion( mask, visibleSegmentStart, width, y );
        }
        pData += shift;
        // Skip uninteresting bytes at the end of the line
        pBmpData += 4 * (rBitmap.getWidth() - width - xSrc);
    }

    // Apply the mask to the graphics context
    XOffsetRegion( mask, xDest, yDest );
    XSetRegion( XDISPLAY, m_gc, mask );
    // Copy the image on the pixmap
    XPutImage( XDISPLAY, m_pixmap, m_gc, pImage, 0, 0, xDest, yDest, width,
               height);
    XDestroyImage( pImage );

    // Add the bitmap mask to the global graphics mask
    Region newMask = XCreateRegion();
    XUnionRegion( mask, m_mask, newMask );
    XDestroyRegion( m_mask );
    m_mask = newMask;

    XDestroyRegion( mask );
}
Ejemplo n.º 26
0
void exposeCB (Widget w, 
	ExposeCD *cd,
	XtcwpAxesCallbackStruct *ca)
{
	Model *model=cd->model;
	char *edgecolor=cd->edgecolor;
	char *tricolor=cd->tricolor;
	float bclip=cd->bclip;
	float wclip=cd->wclip;
	Region region=ca->region;
	Position x=ca->x,y=ca->y;
	Dimension width=ca->width,height=ca->height;
	float x1beg=ca->x1beg,x1end=ca->x1end,
		x2beg=ca->x2beg,x2end=ca->x2end;
	int style=ca->style;
	Display *dpy=NULL;
	Window win;
	Region drawregion,tempregion;
	XWindowAttributes wa;
	Colormap cmap;
	XColor scolor,ecolor;
	XRectangle rect;
	long black=0;
	long white=0;
	GC gcedge,gctri;
	FGC fgcedge,fgctri,fgc;
	float x1,y1,x2,y2,x3,y3;
	Face *f;
	
	/* JG */
	dpy=XtDisplay(w);
	win=XtWindow(w);
	black=(long) BlackPixelOfScreen(XtScreen(w));
	white=(long) WhitePixelOfScreen(XtScreen(w));
	/* .. JG */

	/* determine current colormap */
	XGetWindowAttributes(dpy,win,&wa);
	cmap = wa.colormap;

	/* create GCs */
	gcedge = XCreateGC(dpy,win,0L,NULL);
	gctri = XCreateGC(dpy,win,0L,NULL);


	/* set line colors */
	if (XAllocNamedColor(dpy,cmap,edgecolor,&scolor,&ecolor))
		XSetForeground(dpy,gcedge,ecolor.pixel);
	else
		XSetForeground(dpy,gcedge,black);
	if (XAllocNamedColor(dpy,cmap,tricolor,&scolor,&ecolor))
		XSetForeground(dpy,gctri,ecolor.pixel);
	else
		XSetForeground(dpy,gctri,white);
	
	/* clip to intersection of axes rectangle and expose region */
	rect.x = x;  rect.y = y;  rect.width = width;  rect.height = height;
	tempregion = XCreateRegion();
	XUnionRectWithRegion(&rect,tempregion,tempregion);
	drawregion = XCreateRegion();
	XIntersectRegion(region,tempregion,drawregion);
	XSetRegion(dpy,gcedge,drawregion);
	XSetRegion(dpy,gctri,drawregion);
	
	/* create FGCs with clipping */
	if (style==XtcwpNORMAL) {
		fgcedge = FXCreateFGC(gcedge,x,y,width,height,
			x1beg,x2end,x1end-x1beg,x2beg-x2end);
		FSetClipRectangle(fgcedge,x1beg,x2end,x1end,x2beg);
		fgctri = FXCreateFGC(gctri,x,y,width,height,
			x1beg,x2end,x1end-x1beg,x2beg-x2end);
		FSetClipRectangle(fgctri,x1beg,x2end,x1end,x2beg);
	} else {
		fgcedge = FXCreateFGC(gcedge,x,y,width,height,
			x2beg,x1beg,x2end-x2beg,x1end-x1beg);
		FSetClipRectangle(fgcedge,x2beg,x1beg,x2end,x1end);
		fgctri = FXCreateFGC(gctri,x,y,width,height,
			x2beg,x1beg,x2end-x2beg,x1end-x1beg);
		FSetClipRectangle(fgctri,x2beg,x1beg,x2end,x1end);
	}
	
	/* draw image */
	drawimage(dpy,win,drawregion,fgctri,model,bclip,wclip,style);
	
	/* loop over triangles */
	f = model->f;
	do {
		/* get float coordinates of vertices */
		if (style==XtcwpNORMAL) {
			x1 = f->eu->vu->v->x;
			y1 = f->eu->vu->v->y;
			x2 = f->eu->euCW->vu->v->x;
			y2 = f->eu->euCW->vu->v->y;
			x3 = f->eu->euCCW->vu->v->x;
			y3 = f->eu->euCCW->vu->v->y;
		} else {
			x1 = f->eu->vu->v->y;
			y1 = f->eu->vu->v->x;
			x2 = f->eu->euCW->vu->v->y;
			y2 = f->eu->euCW->vu->v->x;
			x3 = f->eu->euCCW->vu->v->y;
			y3 = f->eu->euCCW->vu->v->x;
		}
		
		/* draw edges of triangle */
		fgc = f->eu->e->fixed ? fgcedge : fgctri;
		if (((fgc==fgcedge && !STREQ(edgecolor,"none")) ||
		     (fgc==fgctri && !STREQ(tricolor,"none"))))
			FXDrawLine(dpy,win,fgc,x1,y1,x2,y2);
		fgc = f->eu->euCW->e->fixed ? fgcedge : fgctri;
		if (((fgc==fgcedge && !STREQ(edgecolor,"none")) ||
		     (fgc==fgctri && !STREQ(tricolor,"none"))))
			FXDrawLine(dpy,win,fgc,x2,y2,x3,y3);
		fgc = f->eu->euCCW->e->fixed ? fgcedge : fgctri;
		if (((fgc==fgcedge && !STREQ(edgecolor,"none")) ||
		     (fgc==fgctri && !STREQ(tricolor,"none"))))
			FXDrawLine(dpy,win,fgc,x3,y3,x1,y1);
		f = f->fNext;
	} while (f!=model->f);

	/* free everything */
	FXFreeFGC(fgcedge);
	FXFreeFGC(fgctri);
	XFreeGC(dpy,gcedge);
	XFreeGC(dpy,gctri);
	XDestroyRegion(drawregion);
	XDestroyRegion(tempregion);
}
Ejemplo n.º 27
0
void drawBox (KinoWidget w, Element *box, int x, int y, LargeRegion r)
{
  Node *p;
  Region regExpose, regBox, empty, intersect;
  XRectangle re, rb;

  if (box != NULL && box->display != DISPLAY_NONE &&
    (box->display == DISPLAY_INLINE ||
    !(x + box->x + box->width < r.x || x + box->x > r.x + r.width ||
      y + box->y + box->height < r.y || y + box->y > r.y + r.height)))
  {
    x = x + box->x;
    y = y + box->y;

    if (box->display == DISPLAY_BLOCK)
    {
      if (box->background_color.alpha == 0)
      {
	changeGC (w, ((XFontStruct *) box->font)->fid,
	  box->background_color, box->background_color, 0);

	rb.x = x + ElementTotalLeft (box);
	rb.y = y + ElementTotalTop (box);
	rb.width = box->width -
	  ElementTotalLeft (box) - ElementTotalRight (box);
	rb.height = box->height -
	  ElementTotalTop (box) - ElementTotalBottom (box);

	re.x = r.x; re.y = r.y; re.width = r.width; re.height = r.height;

	empty = XCreateRegion ();
	regBox = XCreateRegion ();
	XUnionRectWithRegion (&rb, empty, regBox);
	regExpose = XCreateRegion ();
	XUnionRectWithRegion (&re, empty, regExpose);
	intersect = XCreateRegion ();
	XIntersectRegion (regBox, regExpose, intersect);

	XSetRegion (XtDisplay (w), w->kino.painter->gc, intersect);
	XFillRectangle (XtDisplay (w), XtWindow (w), w->kino.painter->gc,
	  r.x, r.y, r.width, r.height); 
	
	XDestroyRegion (regBox);
	XDestroyRegion (regExpose);
	XDestroyRegion (empty);
	XDestroyRegion (intersect);
      }

      if (box->border_top_color.alpha == 0 &&
	box->border_top_width.effective > 0)
      {
	changeGC (w, ((XFontStruct *) box->font)->fid,
	  box->border_top_color, box->background_color,
	  box->border_top_width.effective);
	XDrawLine (XtDisplay (w), XtWindow (w), w->kino.painter->gc,
	  x + box->margin_left.effective, 
	  y + box->margin_top.effective,
	  x + box->width - box->margin_right.effective,
	  y + box->margin_top.effective);
      }

      if (box->border_bottom_color.alpha == 0 &&
	box->border_bottom_width.effective > 0)
      {
	changeGC (w, ((XFontStruct *) box->font)->fid,
	  box->border_bottom_color, box->background_color,
	  box->border_bottom_width.effective);
	XDrawLine (XtDisplay (w), XtWindow (w), w->kino.painter->gc,
	  x + box->margin_left.effective, 
	  y + box->height - box->margin_bottom.effective,
	  x + box->width - box->margin_right.effective,
	  y + box->height - box->margin_bottom.effective);
      }

      if (box->border_left_color.alpha == 0 &&
	box->border_left_width.effective > 0)
      {
	changeGC (w, ((XFontStruct *) box->font)->fid,
	  box->border_left_color, box->background_color,
	  box->border_left_width.effective);
	XDrawLine (XtDisplay (w), XtWindow (w), w->kino.painter->gc,
	  x + box->margin_left.effective, 
	  y + box->margin_top.effective,
	  x + box->margin_left.effective, 
	  y + box->height - box->margin_bottom.effective);
      }

      if (box->border_right_color.alpha == 0 &&
	box->border_right_width.effective > 0)
      {
	changeGC (w, ((XFontStruct *) box->font)->fid,
	  box->border_right_color, box->background_color,
	  box->border_right_width.effective);
	XDrawLine (XtDisplay (w), XtWindow (w), w->kino.painter->gc,
	  x + box->width - box->margin_right.effective, 
	  y + box->margin_top.effective,
	  x + box->width - box->margin_right.effective, 
	  y + box->height - box->margin_bottom.effective);
      }
    }

    changeGC (w, ((XFontStruct *) box->font)->fid,
      box->color, box->background_color, 1);

    p = box->contents;
    while (p != NULL)
    {
      switch (p->type)
      {
	case TEXT_NODE:
	  drawWord (w, box, (Text *) p, x, y, r);
	  break;
	case ELEMENT_NODE:
	  drawBox (w, (Element *) p, x, y, r);
	  changeGC (w, ((XFontStruct *) box->font)->fid,
	    box->color, box->background_color, 1);
	  break;
	default: 
	  break;
      }
      p = p->next;
    }
  }
}
Ejemplo n.º 28
0
static PyObject *
pixmap_Intersected(PaxPixmapObject * self, PyObject * args)
{
    PyObject * other;
    XGCValues values;
    GC gc;
    Pixmap bitmap;
    Window root;
    int x, y;
    unsigned int width, height, border_width, depth;

    if (!PyArg_ParseTuple(args, "O", &other))
	return NULL;

    if (!XGetGeometry(self->display, self->pixmap,
		      &root, &x, &y, &width, &height,
		      &border_width, &depth))
    {
	PyErr_SetString(PyExc_RuntimeError, "Cannot get pixmap geometry");
	return NULL;
    }
    if (depth != 1)
    {
	PyErr_SetString(PyExc_TypeError, "pixmap must have depth 1");
	return NULL;
    }

    bitmap = XCreatePixmap(self->display, self->pixmap, width, height, 1);

    values.foreground = 0;
    values.background = 0;
    gc = XCreateGC(self->display, bitmap, GCForeground | GCBackground,
		   &values);
    XFillRectangle(self->display, bitmap, gc, 0, 0, width, height);
    XSetForeground(self->display, gc, 1);

    if (PaxRegion_Check(other))
    {
	XSetRegion(self->display, gc, PaxRegion_AsRegion(other));
	XCopyPlane(self->display, self->pixmap, bitmap, gc,
		   0, 0, width, height, 0, 0, 1);
    }
    else if (PaxPixmap_Check(other))
    {
	XCopyPlane(self->display, self->pixmap, bitmap, gc,
		   0, 0, width, height, 0, 0, 1);
	XSetFunction(self->display, gc, GXand);
	XCopyPlane(self->display, PaxPixmap_AsPixmap(other), bitmap, gc,
		   0, 0, width, height, 0, 0, 1);
    }
    else
    {
	XFreeGC(self->display, gc);
	XFreePixmap(self->display, bitmap);
	PyErr_SetString(PyExc_TypeError,
			"argument must be either pixmap or region");
	return NULL;
    }

    XFreeGC(self->display, gc);

    return PaxPixmap_FromPixmap(self->display, bitmap, 1);
}
Ejemplo n.º 29
0
static void xf_draw_screen_scaled(xfContext* xfc, int x, int y, int w, int h)
{
	XTransform transform;
	Picture windowPicture;
	Picture primaryPicture;
	XRenderPictureAttributes pa;
	XRenderPictFormat* picFormat;
	double xScalingFactor;
	double yScalingFactor;
	int x2;
	int y2;

	if (xfc->scaledWidth <= 0 || xfc->scaledHeight <= 0)
	{
		WLog_ERR(TAG, "the current window dimensions are invalid");
		return;
	}

	if (xfc->sessionWidth <= 0 || xfc->sessionHeight <= 0)
	{
		WLog_ERR(TAG, "the window dimensions are invalid");
		return;
	}

	xScalingFactor = xfc->sessionWidth / (double)xfc->scaledWidth;
	yScalingFactor = xfc->sessionHeight / (double)xfc->scaledHeight;

	XSetFillStyle(xfc->display, xfc->gc, FillSolid);
	XSetForeground(xfc->display, xfc->gc, 0);

	/* Black out possible space between desktop and window borders */
	{
		XRectangle box1 = { 0, 0, xfc->window->width, xfc->window->height };
		XRectangle box2 = { xfc->offset_x, xfc->offset_y, xfc->scaledWidth, xfc->scaledHeight };
		Region reg1 = XCreateRegion();
		Region reg2 = XCreateRegion();
		XUnionRectWithRegion(&box1, reg1, reg1);
		XUnionRectWithRegion(&box2, reg2, reg2);

		if (XSubtractRegion(reg1, reg2, reg1) && !XEmptyRegion(reg1))
		{
			XSetRegion(xfc->display, xfc->gc, reg1);
			XFillRectangle(xfc->display, xfc->window->handle, xfc->gc, 0, 0, xfc->window->width, xfc->window->height);
			XSetClipMask(xfc->display, xfc->gc, None);
		}

		XDestroyRegion(reg1);
		XDestroyRegion(reg2);
	}

	picFormat = XRenderFindVisualFormat(xfc->display, xfc->visual);

	pa.subwindow_mode = IncludeInferiors;
	primaryPicture = XRenderCreatePicture(xfc->display, xfc->primary, picFormat, CPSubwindowMode, &pa);
	windowPicture = XRenderCreatePicture(xfc->display, xfc->window->handle, picFormat, CPSubwindowMode, &pa);

	XRenderSetPictureFilter(xfc->display, primaryPicture, FilterBilinear, 0, 0);

	transform.matrix[0][0] = XDoubleToFixed(xScalingFactor);
	transform.matrix[0][1] = XDoubleToFixed(0.0);
	transform.matrix[0][2] = XDoubleToFixed(0.0);
	transform.matrix[1][0] = XDoubleToFixed(0.0);
	transform.matrix[1][1] = XDoubleToFixed(yScalingFactor);
	transform.matrix[1][2] = XDoubleToFixed(0.0);
	transform.matrix[2][0] = XDoubleToFixed(0.0);
	transform.matrix[2][1] = XDoubleToFixed(0.0);
	transform.matrix[2][2] = XDoubleToFixed(1.0);

	/* calculate and fix up scaled coordinates */
	x2 = x + w;
	y2 = y + h;
	x = floor(x / xScalingFactor) - 1;
	y = floor(y / yScalingFactor) - 1;
	w = ceil(x2 / xScalingFactor) + 1 - x;
	h = ceil(y2 / yScalingFactor) + 1 - y;

	XRenderSetPictureTransform(xfc->display, primaryPicture, &transform);
	XRenderComposite(xfc->display, PictOpSrc, primaryPicture, 0, windowPicture, x, y, 0, 0, xfc->offset_x + x, xfc->offset_y + y, w, h);
	XRenderFreePicture(xfc->display, primaryPicture);
	XRenderFreePicture(xfc->display, windowPicture);
}
Ejemplo n.º 30
0
void TkSetRegion(Display *d, GC g, TkRegion r)
{
    XSetRegion(d, g, (Region)r);
}