Example #1
0
int DumpX(bufferdevice * dev, palette * pal) {
  	Display 			  * display;
  	XImage                * ximage;
  	Window                window;
  	XEvent                an_event;
  	GC                    gc;
  	Visual                * visual;
  	XGCValues             values;
  	int                   m, n, screen, dplanes;
  	int                   width, height, ret = 1;
  	ColorValues           * cor;
  
  	width = dev->MaxX;
  	height = dev->MaxY; 

  	if ((display = XOpenDisplay(NULL)) == NULL)
		ret = 0;
  	else {  
    	screen = DefaultScreen(display);
    	dplanes = DisplayPlanes(display,screen);   
    	visual = XDefaultVisual(display,screen);
  
    	if (!(window=XCreateSimpleWindow(display,RootWindow(display,screen),0,0,width,height,1,BlackPixel(display,screen),WhitePixel(display,screen))))
			ret = 0;
    	else {
      		XSelectInput(display, window, EventMask);
      		gc = XCreateGC(display, window, 0, &values);
      		XMapWindow(display,window);
      		XSync(display,False);
  			ximage = XCreateImage(display,visual,dplanes,ZPixmap,0,malloc(width*height*sizeof(int)),width,height,8,0);

      		for(m=0;m<height;m++) {
        		for(n=0;n<width;n++) {
          			cor = GetColor(dev->buffer[m*width+n],pal);
          			ximage -> data[(m*4)*width+n*4] = (char) round((cor->blue)*255);
          			ximage -> data[(m*4)*width+n*4+1] = (char) round((cor->green)*255);
          			ximage -> data[(m*4)*width+n*4+2] = (char) round((cor->red)*255);
          			ximage -> data[(m*4)*width+n*4+3] = (char) 0;
          		}
        	}

      		XPutImage(display,window,gc,ximage,0,0,0,0,width,height);

      		sleep(30);
      	}
	}
 
  	return ret;
}
Example #2
0
void MpImageWindow::MapXImage (void) // virtual
{
  // draw the XImage to the window (if there is one)
  if (theXImage) {  

    int f = GetFrameTotalWidth(),
        w = MpMin( Width()-2*f,image->GetWidth() ),
        h = MpMin( Height()-2*f,image->GetLength() );

    XPutImage(Mp.theDisplay,Win(),Mp.theDrawGC,theXImage, 
	      0,0,  // offset in source image
	      f,f,  // offset in destination
	      w,h); // effective size to draw
  }
}
Example #3
0
static void vo_x11_display (AVPicture * pic)
{
    vo_lock ();

    vo_x11_vfmt2rgb (my_pic, pic);

    Ximg->data = my_pic->data[0];
    XPutImage (Xdisplay, Xvowin, Xvogc, Ximg, 0, 0, 0, 0, dw, dh);

    if (vo_draw_string)
        x11_draw_string (&osd);

    XFlush (Xdisplay);
    vo_unlock ();
}
void QXlibWindowSurface::flush(QWidget *widget, const QRegion &region, const QPoint &offset)
{
    Q_UNUSED(widget);
    Q_UNUSED(region);
    Q_UNUSED(offset);

    if (!painted)
        return;

    QXlibScreen *screen = QXlibScreen::testLiteScreenForWidget(widget);
    GC gc = xw->graphicsContext();
    Window window = xw->xWindow();
#ifdef DONT_USE_MIT_SHM
    // just convert the image every time...
    if (!shm_img.isNull()) {
        QXlibWindow *win = static_cast<QXlibWindow*>(window()->platformWindow());

        QImage image = shm_img;
        //img.convertToFormat(
        XImage *xi = XCreateImage(screen->display(), win->visual(), win->depth(), ZPixmap,
                                  0, (char *) image.scanLine(0), image.width(), image.height(),
                                  32, image.bytesPerLine());

        int x = 0;
        int y = 0;

        /*int r =*/  XPutImage(screen->display(), window, gc, xi, 0, 0, x, y, image.width(), image.height());

        xi->data = 0; // QImage owns these bits
        XDestroyImage(xi);
    }
#else
    // Use MIT_SHM
    if (image_info && image_info->image) {
        //qDebug() << "Here we go" << image_info->image->width << image_info->image->height;
        int x = 0;
        int y = 0;

        // We could set send_event to true, and then use the ShmCompletion to synchronize,
        // but let's do like Qt/11 and just use XSync
        XShmPutImage (screen->display()->nativeDisplay(), window, gc, image_info->image, 0, 0,
                      x, y, image_info->image->width, image_info->image->height,
                      /*send_event*/ False);

        screen->display()->sync();
    }
#endif
}
Example #5
0
static void
roll_up				(vbi_page *		pg,
				 int			first_row,
				 int			last_row)
{
	ushort scol, *canvas = ximgdata + 45 * DISP_WIDTH;
	vbi_rgba col;
	int i, j;

#if 1 /* soft */

	sh_first = first_row;
	sh_last = last_row;
	shift = 26;
	bump(step, FALSE);

	canvas += 48 + (((last_row * CELL_HEIGHT) + CELL_HEIGHT - step)
			* DISP_WIDTH);
	col = pg->color_map[pg->text[last_row * pg->columns].background];
	scol = RGB565 (col);

	for (j = 0; j < step; ++j) {
		if (pg->text[last_row * pg->columns].opacity
		    == VBI_TRANSPARENT_SPACE) {
			for (i = 0; i < CELL_WIDTH * pg->columns; ++i)
				canvas[i] = RGB565 (COLORKEY);
		} else {
			for (i = 0; i < CELL_WIDTH * pg->columns; ++i)
				canvas[i] = scol;
		}

		canvas += DISP_WIDTH;
	}

#else /* at once */

	memmove (canvas + first_row * CELL_HEIGHT * DISP_WIDTH,
		 canvas + (first_row + 1) * CELL_HEIGHT * DISP_WIDTH,
		 (last_row - first_row) * CELL_HEIGHT * DISP_WIDTH * 2);

	draw_video (48, 45 + last_row * CELL_HEIGHT,
		    DISP_WIDTH - 48, CELL_HEIGHT);

#endif

	XPutImage (display, window, gc, ximage,
		   0, 0, 0, 0, DISP_WIDTH, DISP_HEIGHT);
}
Example #6
0
File: brush.c Project: aragaer/wine
/***********************************************************************
 *           BRUSH_DitherColor
 */
static Pixmap BRUSH_DitherColor( COLORREF color, int depth)
{
    /* X image for building dithered pixmap */
    static XImage *ditherImage = NULL;
    static COLORREF prevColor = 0xffffffff;
    unsigned int x, y;
    Pixmap pixmap;
    GC gc = get_bitmap_gc(depth);

    if (!ditherImage)
    {
        ditherImage = X11DRV_DIB_CreateXImage( MATRIX_SIZE, MATRIX_SIZE, depth );
        if (!ditherImage) 
        {
            ERR("Could not create dither image\n");
            return 0;
        }
    }

    wine_tsx11_lock();
    if (color != prevColor)
    {
	int r = GetRValue( color ) * DITHER_LEVELS;
	int g = GetGValue( color ) * DITHER_LEVELS;
	int b = GetBValue( color ) * DITHER_LEVELS;
	const int *pmatrix = dither_matrix;

	for (y = 0; y < MATRIX_SIZE; y++)
	{
	    for (x = 0; x < MATRIX_SIZE; x++)
	    {
		int d  = *pmatrix++ * 256;
		int dr = ((r + d) / MATRIX_SIZE_2) / 256;
		int dg = ((g + d) / MATRIX_SIZE_2) / 256;
		int db = ((b + d) / MATRIX_SIZE_2) / 256;
		XPutPixel( ditherImage, x, y, PIXEL_VALUE(dr,dg,db) );
	    }
	}
	prevColor = color;
    }

    pixmap = XCreatePixmap( gdi_display, root_window, MATRIX_SIZE, MATRIX_SIZE, depth );
    XPutImage( gdi_display, pixmap, gc, ditherImage, 0, 0,
    	       0, 0, MATRIX_SIZE, MATRIX_SIZE );
    wine_tsx11_unlock();

    return pixmap;
}
Example #7
0
/***************************************************************************
  Converts an image to a pixmap...
***************************************************************************/
static Pixmap image2pixmap(XImage *xi)
{
  Pixmap ret;
  XGCValues values;
  GC gc;
  
  ret = XCreatePixmap(display, root_window, xi->width, xi->height, xi->depth);

  values.foreground = 1;
  values.background = 0;
  gc = XCreateGC(display, ret, GCForeground | GCBackground, &values);

  XPutImage(display, ret, gc, xi, 0, 0, 0, 0, xi->width, xi->height);
  XFreeGC(display, gc);
  return ret;
}
void Draw(Image imagem, int positionX,int positionY){
  int m,n;  
  for(m=positionY;m<imagem.sizeY+positionY;m++) {
    for(n=positionX;n<imagem.sizeX+positionX;n++) {
      int x = n-positionX;
      int y = m-positionY;
      if(imagem.pixel[x][y].printable){
        WindowProperties.ximage -> data[(m*4)*WindowProperties.width+n*4] = (char)(int)(imagem.pixel[x][y].color.blue);
        WindowProperties.ximage -> data[(m*4)*WindowProperties.width+n*4+1] = (char)(int)(imagem.pixel[x][y].color.green);
        WindowProperties.ximage -> data[(m*4)*WindowProperties.width+n*4+2] = (char)(int)(imagem.pixel[x][y].color.red);
        WindowProperties.ximage -> data[(m*4)*WindowProperties.width+n*4+3] = (char) 0;
      }
    }
  }
  XPutImage(WindowProperties.display,WindowProperties.window,WindowProperties.gc,WindowProperties.ximage,0,0,0,0,WindowProperties.width,WindowProperties.height);
}
Example #9
0
int camera_shoot(struct IplImage *img, XImage *ximg, GC theGC, Window theWindow, int x1, int y1)
{
	int x, y;
	
	for (y = 0; y < img->height; y++)
		for (x = 0; x < img->width; x++) {
			unsigned char r, g, b;
			r = img->data[img->nchans * (y * img->width + x) + 0];
			g = img->data[img->nchans * (y * img->width + x) + 1];
			b = img->data[img->nchans * (y * img->width + x) + 2];
			XPutPixel(ximg, x, y, ((r << 16) | (g << 8) | b));
		}
	XPutImage(theDisplay, theWindow, theGC, ximg, 0, 0, x1, y1, 640, 480);

	return 0;	
}
Example #10
0
int
TkPutImage(
    unsigned long *colors,	/* Array of pixel values used by this image.
				 * May be NULL. */
    int ncolors,		/* Number of colors used, or 0. */
    Display *display,
    Drawable d,			/* Destination drawable. */
    GC gc,
    XImage *image,		/* Source image. */
    int src_x, int src_y,	/* Offset of subimage. */
    int dest_x, int dest_y,	/* Position of subimage origin in drawable. */
    unsigned int width, unsigned int height)
				/* Dimensions of subimage. */
{
    return XPutImage(display, d, gc, image, src_x, src_y, dest_x, dest_y, width, height);
}
void DrawImage(Display * dpy, Window win, XImage * image)
{
    static GC gc;
    if(win!=0)
    {
        if(gc==0)
        {
            XGCValues gc_val;
            gc = XCreateGC (dpy, win, GCForeground|GCBackground, &gc_val);
        }
        /*for(i=0;i<100;i++)
        {
            image->data*/
        XPutImage (dpy, win, gc, image, 0, 0, 0, 0, 1024, 768);
    }
}
Example #12
0
void Xvars::put_image(int dpyNum,Drawable dest,XImage* src,const Size& size) {
  // Create temp GC to set foreground and background in case we are
  // dealing with a mask.
  GC gc;
  XGCValues values;
  values.foreground = 1;
  values.background = 0;
  gc = XCreateGC(dpy[dpyNum],dest,
                 GCForeground | GCBackground,&values);  

  XPutImage(dpy[dpyNum],dest,gc,src,
            0,0,0,0,size.width,size.height);
  
  // Kill temp GC.
  XFreeGC(dpy[dpyNum],gc);  
}
Example #13
0
void up_x11update(void)
{
#ifndef CONFIG_SIM_X11NOSHM
  if (b_useshm)
    {
      XShmPutImage(g_display, g_window, g_gc, g_image, 0, 0, 0, 0,
                   g_fbpixelwidth, g_fbpixelheight, 0);
    }
  else
#endif
    {
      XPutImage(g_display, g_window, g_gc, g_image, 0, 0, 0, 0,
                g_fbpixelwidth, g_fbpixelheight);
    }
  XSync(g_display, 0);
}
void display_image (int xsize, int ysize,
		    Pixel *R,
		    Pixel *G,
		    Pixel *B)
{
   static char    data[(int) (MAXCOLS * MAXROWS)];
   int            i;
   static XImage        *ximage;
   static int frame_count=-1;

   frame_count++;
   if ((frame_count % (NSAMPLESECS * MAXFPS)) == 0) {
      gettimeofday(&tp2, NULL); 
      time_elapsed = (int) (((tp2.tv_sec - tp1.tv_sec) * 1000)        
			    + ((tp2.tv_usec - tp1.tv_usec) / 1000));  
      printf ("caught %d frames in %.1f sec\n", 
	      (frame_count) / NSAMPLESECS,
	      ((float) time_elapsed) / (NSAMPLESECS * 1000.0));
      tp1 = tp2;
      frame_count = 0;
      translate_setup (xsize, ysize, R, G, B);
      redo_cmap(rmap,gmap,bmap);

      return;
   }
   
   translate_box (R, G, B, xsize, ysize, data);
   for (i = 0; i < xsize * ysize; i++)
     data[i] = pixels[data[i]];
   ximage = XCreateImage(display_,
			 DefaultVisual(display_, DefaultScreen(display_)),
			 8, ZPixmap,
			 0, 
			 (char*) data,
			 MAXCOLS, MAXROWS,
			 8, MAXCOLS);
   ximage->byte_order = XImageByteOrder(display_);

   XPutImage(display_, wtwin_, gc_, ximage, 
	     0, 0, 
	     0, 0,
	     MAXCOLS, MAXROWS);
    
   ximage->data = NULL; 
   XDestroyImage(ximage);
   XFlush(display_);
}  
Example #15
0
result CMuli3DPresentTargetLinuxX11::Present( const float32 *i_pSource, uint32 i_iFloats )
{
	m3ddeviceparameters DeviceParameters = m_pParent->GetDeviceParameters();

	// Copy pixels to the ximage-buffer ---------------------------------------

	fpuTruncate();

	if( m_iPixelBytes == 2 )
	{
		// 16-bit
		uint16 *pDestination = (uint16 *)m_pXImage->data;
		uint32 iPixels = DeviceParameters.iBackbufferWidth * DeviceParameters.iBackbufferHeight;
		while( iPixels-- )
		{
			const int32 iR = iClamp( ftol( i_pSource[0] * m_i16bitMaxVal[0] ), 0, m_i16bitMaxVal[0] );
			const int32 iG = iClamp( ftol( i_pSource[1] * m_i16bitMaxVal[1] ), 0, m_i16bitMaxVal[1] );
			const int32 iB = iClamp( ftol( i_pSource[2] * m_i16bitMaxVal[2] ), 0, m_i16bitMaxVal[2] );
			i_pSource += i_iFloats;

			*pDestination++ = ( iR << m_i16bitShift[0] ) | ( iG << m_i16bitShift[1] ) | ( iB << m_i16bitShift[2] );
		}
	}
	else
	{
		// 24- or 32-bit
		uint8 *pDestination = (uint8 *)m_pXImage->data;
		uint32 iPixels = DeviceParameters.iBackbufferWidth * DeviceParameters.iBackbufferHeight;
		while( iPixels-- )
		{
			pDestination[0] = iClamp( ftol( i_pSource[2] * 255.0f ), 0, 255 ); // b
			pDestination[1] = iClamp( ftol( i_pSource[1] * 255.0f ), 0, 255 ); // g
			pDestination[2] = iClamp( ftol( i_pSource[0] * 255.0f ), 0, 255 ); // r

			i_pSource += i_iFloats;
			pDestination += m_iPixelBytes;
		}
	}

	fpuReset();

	// Present to window/screen
	XPutImage( m_pDisplay, DeviceParameters.hDeviceWindow, m_WindowGC, m_pXImage, 0, 0,
		0, 0, DeviceParameters.iBackbufferWidth, DeviceParameters.iBackbufferHeight );

	return s_ok;
}
Example #16
0
File: filters.c Project: yhsesq/yhs
/* Taking differences between the values of horizontally adjacent pixels */
void differencex_filter(){
  float mask[2]={1,-1};
  float rmax, rmin, rng;
  int i,j;
  matrix m,dx;

  /* Fill in the image with background color */
  for(i=0; i<IMAGE_WIDTH; i++)
    for(j=0; j<IMAGE_HEIGHT; j++)
      XPutPixel(theXImage_2,i,j,bg);

  /* Clear the drawing window so the image is displayed again */
  XClearArea(XtDisplay(draw_1),XtWindow(draw_2),0,0,0,0,True);

  /* Associate the watch cursor with the main window */ 
  XDefineCursor(XtDisplay(draw_1), XtWindow(main_window), theCursor);

  /* Flush the request buffer and wait for all events */
  /* and errors to be processed by the server.        */
  XSync(XtDisplay(draw_1), False);

  for(i=0;i<IMAGE_WIDTH;i++)
    for(j=0;j<IMAGE_HEIGHT;j++)
       m[i][j]= XGetPixel(theXImage_1,i,j);

  convo_vectorx(m, mask, 1, &rmax, &rmin, dx);

  rng = (rmax-rmin);

  for(i=0;i<512;i++)
    for(j=0;j<511;j++){
	XPutPixel(theXImage_2,i,j,(unsigned long)
		(((float)(dx[i][j]-rmin)/rng)*255.0));
  }

  /* Copy image into pixmap */
  XPutImage(XtDisplay(draw_2), thePixmap_2, image_gc_2, theXImage_2,
		 0, 0, 0, 0, theXImage_2->width, theXImage_2->height);

  /* Disassociate the watch cursor from the main window */
  XUndefineCursor(XtDisplay(draw_1), XtWindow(main_window));

  /* Clear the drawing window so the image is displayed again */
  XClearArea(XtDisplay(draw_2),XtWindow(draw_2),0,0,0,0,True);

}
Example #17
0
void wsPutImage( wsTWindow * win )
{
 if ( wsUseXShm )
  {
   XShmPutImage( wsDisplay,win->WindowID,win->wGC,win->xImage,
    0,0,
    ( win->Width - win->xImage->width ) / 2,( win->Height - win->xImage->height ) / 2,
    win->xImage->width,win->xImage->height,0 );
  }
  else
   {
    XPutImage( wsDisplay,win->WindowID,win->wGC,win->xImage,
    0,0,
    ( win->Width - win->xImage->width ) / 2,( win->Height - win->xImage->height ) / 2,
    win->xImage->width,win->xImage->height );
   }
}
Example #18
0
int draw_image (ClientData cd, Tcl_Interp *interp, int argc, char **argv) {
    Tk_Window tkwin;
    Display *display;
    Window window;
    GC gc;
    Tk_Window interpWin;

    interpWin=(Tk_Window) cd;
    tkwin=Tk_NameToWindow (interp,".c",interpWin);
    display=Tk_Display (tkwin);
    window=Tk_WindowId (tkwin);
    gc=Tk_GetGC (tkwin,0,NULL);
    if (ximage!=NULL) {
        XPutImage (display,window,gc,ximage,0,0,0,0,RESX,RESY);
    }
    return 0;
}
Example #19
0
static void
swrastXPutImage(__DRIdrawable * draw, int op,
                int srcx, int srcy, int x, int y,
                int w, int h, int stride,
                int shmid, char *data, void *loaderPrivate)
{
   struct drisw_drawable *pdp = loaderPrivate;
   __GLXDRIdrawable *pdraw = &(pdp->base);
   Display *dpy = pdraw->psc->dpy;
   Drawable drawable;
   XImage *ximage;
   GC gc;

   if (!pdp->ximage || shmid != pdp->shminfo.shmid) {
      if (!XCreateDrawable(pdp, shmid, dpy))
         return;
   }

   switch (op) {
   case __DRI_SWRAST_IMAGE_OP_DRAW:
      gc = pdp->gc;
      break;
   case __DRI_SWRAST_IMAGE_OP_SWAP:
      gc = pdp->swapgc;
      break;
   default:
      return;
   }

   drawable = pdraw->xDrawable;
   ximage = pdp->ximage;
   ximage->bytes_per_line = stride ? stride : bytes_per_line(w * ximage->bits_per_pixel, 32);
   ximage->data = data;

   if (pdp->shminfo.shmid >= 0) {
      ximage->width = ximage->bytes_per_line / ((ximage->bits_per_pixel + 7)/ 8);
      ximage->height = h;
      XShmPutImage(dpy, drawable, gc, ximage, srcx, srcy, x, y, w, h, False);
      XSync(dpy, False);
   } else {
      ximage->width = w;
      ximage->height = h;
      XPutImage(dpy, drawable, gc, ximage, srcx, srcy, x, y, w, h);
   }
   ximage->data = NULL;
}
void
JXGC::CopyImage
	(
	const XImage*		source,
	const JCoordinate	src_x,
	const JCoordinate	src_y,
	const JCoordinate	width,
	const JCoordinate	height,
	const Drawable		dest,
	const JCoordinate	dest_x,
	const JCoordinate	dest_y
	)
	const
{
	XPutImage(*itsDisplay, dest, itsXGC, const_cast<XImage*>(source),
			  src_x, src_y, dest_x, dest_y, width, height);
}
Example #21
0
static Pixmap xf_mono_bitmap_new(xfContext* xfc, int width, int height,
                                 const BYTE* data)
{
	int scanline;
	XImage* image;
	Pixmap bitmap;
	scanline = (width + 7) / 8;
	bitmap = XCreatePixmap(xfc->display, xfc->drawable, width, height, 1);
	image = XCreateImage(xfc->display, xfc->visual, 1,
	                     ZPixmap, 0, (char*) data, width, height, 8, scanline);
	image->byte_order = LSBFirst;
	image->bitmap_bit_order = LSBFirst;
	XPutImage(xfc->display, bitmap, xfc->gc_mono, image, 0, 0, 0, 0, width, height);
	image->data = NULL;
	XDestroyImage(image);
	return bitmap;
}
Example #22
0
void DrawImage(char *data, int x, int y, int width, int height)
{
  XImage *xi;

  if (lsx_curwin->toplevel == NULL || data == NULL)
    return;

  xi = XCreateImage(display, DefaultVisual(display, DefaultScreen(display)),
                    8, ZPixmap, 0, data, width, height,
                    XBitmapPad(display),  width);
  if (xi == NULL)
    return;

  XPutImage(display, window, drawgc, xi, 0,0, x,y,  xi->width,xi->height);

  XFree((char *)xi);
}
Example #23
0
Pixmap xf_glyph_new(xfInfo* xfi, int width, int height, uint8* data)
{
	int scanline;
	Pixmap bitmap;
	XImage* image;

	scanline = (width + 7) / 8;
	bitmap = XCreatePixmap(xfi->display, xfi->drawable, width, height, 1);
	image = XCreateImage(xfi->display, xfi->visual, 1,
			ZPixmap, 0, (char*) data, width, height, 8, scanline);
	image->byte_order = MSBFirst;
	image->bitmap_bit_order = MSBFirst;
	XInitImage(image);
	XPutImage(xfi->display, bitmap, xfi->gc_mono, image, 0, 0, 0, 0, width, height);
	XFree(image);
	return bitmap;
}
Example #24
0
void window_display_framebuffer(window *wnd)
{
	struct timespec tim;
	struct timespec tim2;

	/* copy framebuffer data */
	wnd->img->data = (char*)wnd->fb.color;
	XPutImage(wnd->dpy, wnd->wnd, wnd->gc, wnd->img,
		0, 0, 0, 0, wnd->fb.width, wnd->fb.height);

	wnd->img->data = NULL;

	/* wait for ~16.666 ms -> ~60 fps */
	tim.tv_sec = 0;
	tim.tv_nsec = 16666666L;
	nanosleep(&tim, &tim2);
}
Example #25
0
void wsImageDraw(wsWindow *win)
{
#ifdef HAVE_SHM
    if (wsUseXShm) {
        XShmPutImage(wsDisplay, win->WindowID, win->wGC, win->xImage,
                     0, 0,
                     (win->Width - win->xImage->width) / 2, (win->Height - win->xImage->height) / 2,
                     win->xImage->width, win->xImage->height, 0);
    } else
#endif
    {
        XPutImage(wsDisplay, win->WindowID, win->wGC, win->xImage,
                  0, 0,
                  (win->Width - win->xImage->width) / 2, (win->Height - win->xImage->height) / 2,
                  win->xImage->width, win->xImage->height);
    }
}
Example #26
0
/**
 * Display a surface that's in a tiled configuration.  That is, all the
 * pixels for a TILE_SIZExTILE_SIZE block are contiguous in memory.
 */
static void
xlib_cell_display_surface(struct xmesa_buffer *b, struct pipe_surface *surf)
{
   XImage *ximage;
   struct xm_buffer *xm_buf = xm_buffer(
      cell_texture(surf->texture)->buffer);
   const uint tilesPerRow = (surf->width + TILE_SIZE - 1) / TILE_SIZE;
   uint x, y;

   ximage = b->tempImage;

   /* check that the XImage has been previously initialized */
   assert(ximage->format);
   assert(ximage->bitmap_unit);

   /* update XImage's fields */
   ximage->width = TILE_SIZE;
   ximage->height = TILE_SIZE;
   ximage->bytes_per_line = TILE_SIZE * 4;

   for (y = 0; y < surf->height; y += TILE_SIZE) {
      for (x = 0; x < surf->width; x += TILE_SIZE) {
         uint tmpTile[TILE_SIZE * TILE_SIZE];
         int tx = x / TILE_SIZE;
         int ty = y / TILE_SIZE;
         int offset = ty * tilesPerRow + tx;
         int w = TILE_SIZE;
         int h = TILE_SIZE;

         if (y + h > surf->height)
            h = surf->height - y;
         if (x + w > surf->width)
            w = surf->width - x;

         /* offset in pixels */
         offset *= TILE_SIZE * TILE_SIZE;

         /* twiddle from ximage buffer to temp tile */
         twiddle_tile((uint *) xm_buf->data + offset, tmpTile);
         /* display temp tile data */
         ximage->data = (char *) tmpTile;
         XPutImage(b->xm_visual->display, b->drawable, b->gc,
                   ximage, 0, 0, x, y, w, h);
      }
   }
}
Example #27
0
void DisplayPixRegion(int ilo, int ihi, int jlo, int jhi)
{
  int count, x, y, height, width;

  y = ilo * scale;
  x = jlo * scale;
  height = (ihi - ilo + 1) * scale;
  width = (jhi - jlo + 1) * scale;
  
  XPutImage(display, window, gc, image, x, y, x, y, width, height);
  XFlush(display);

/*
  for(count = 0; count < rows; count++)
  {
    XDrawLine(display, XtWindow(canvas_widget), gc, 0, 
             (overlay_row[count] - 1 - top_edge) * scale,
              pict_width * scale - 1, 
             (overlay_row[count] - 1 - top_edge) * scale);
  }
  for(count = 0; count < cols; count++)
  {
    XDrawLine(display, XtWindow(canvas_widget), gc, 
             (overlay_col[count] - 1 - left_edge) * scale, 0, 
             (overlay_col[count] - 1 - left_edge) * scale, 
              pict_height * scale - 1);
  }
*/

  for(count = 0; count < rows; count++)
  {
    XDrawLine(display, XtWindow(canvas_widget), gc, 0,
             (overlay_row[count]  - top_edge + .5) * scale,
              pict_width * scale - 1,
             (overlay_row[count] - top_edge + .5) * scale);
  }
  for(count = 0; count < cols; count++)
  {
    XDrawLine(display, XtWindow(canvas_widget), gc,
             (overlay_col[count]  - left_edge + .5) * scale, 0,
             (overlay_col[count]  - left_edge + .5) * scale,
              pict_height * scale - 1);
  }


}
Example #28
0
int main (int argc, char *argv[])
{
	int imageWidth;
	int imageHeight;
	XImage *img;		
	Window mainWin;
	unsigned long windowMask;
	XSetWindowAttributes winAttrib;
	int screen;
	Display *dis;
	GC copyGC;
	dis = XOpenDisplay (NULL);
	screen = DefaultScreen (dis);
	img = create_image_from_buffer (dis, screen, &imageWidth, &imageHeight);
	windowMask = CWBackPixel | CWBorderPixel;
	winAttrib.border_pixel = BlackPixel (dis, screen);
	winAttrib.background_pixel = BlackPixel (dis, screen);
	winAttrib.override_redirect = 0;
	mainWin = XCreateWindow (dis, DefaultRootWindow (dis),20, 20,imageWidth,imageHeight,0, DefaultDepth (dis, screen),InputOutput, CopyFromParent,CWBackPixel | CWBorderPixel, &winAttrib);
	copyGC = XCreateGC (dis, mainWin, 0, NULL);
	XMapWindow (dis, mainWin);
	XSelectInput(dis, mainWin, ExposureMask | KeyPressMask);
	Atom WM_DELETE_WINDOW = XInternAtom(dis, "WM_DELETE_WINDOW", False);
	XSetWMProtocols(dis, mainWin, &WM_DELETE_WINDOW, 1);

	while (1) {
		XEvent event;
		XNextEvent (dis, &event);
		switch  (event.type) {
			case Expose:
				XPutImage (dis, mainWin, copyGC, img, 0, 0, 0, 0, imageWidth, imageHeight);
				XFlush (dis);
			break;            
			case KeyPress:
				if (XK_q == XLookupKeysym (&event.xkey, 0)) {
					exit (EXIT_SUCCESS);
				}
			break;
			case ClientMessage:
				XCloseDisplay(dis);
				exit (EXIT_SUCCESS);
			break;
		}			
	}
	return EXIT_FAILURE;
} 
Example #29
0
/* For each point, evaluate its colour */
static void display_double(int size, double xmin, double xmax, double ymin, double ymax, int yofs, int ylim)
{
    int x, y;

    double cr, ci;

    double xscal = (xmax - xmin) / size;
    double yscal = (ymax - ymin) / size;

    unsigned counts;

#if (OPTIMIZED)
    cr = xmin;
    ci = ymin;
#endif

    for (y = yofs ; y < ylim; y++)
        {
            for (x = 0; x < size; x++)
                {
#if (!OPTIMIZED)
                    cr = xmin + x * xscal;
                    ci = ymin + y * yscal;
#endif

                    counts = mandel_double(cr, ci);

                    ((unsigned *) g_x11.bitmap->data)[x + y*size] = cols[counts];

#if (OPTIMIZED)
                    cr += xscal;
#endif
                }

            /* Display it line-by-line for speed */
            XPutImage(g_x11.dpy, g_x11.win, g_x11.gc, g_x11.bitmap,
                      0, y, 0, y,
                      size, 1);
#if (OPTIMIZED)
            ci += yscal;
#endif
        }

    XFlush(g_x11.dpy);
}
Example #30
0
/* For each point, evaluate its colour */
static void display_float(int width, int height,
                          float xmin, float xmax,
                          float ymin, float ymax, int yofs, int ylim)
{
    int size = width * height;
    int x;
    int y;

    float cr, ci;

    float xscal = (xmax - xmin) / size;
    float yscal = (ymax - ymin) / size;

    unsigned counts;

#if (OPTIMIZED)
    cr = xmin;
    ci = ymin;
#endif
    for (y = yofs; y < ylim; y++)
        {
            for (x = 0; x < width; x++)
                {
#if (!OPTIMIZED)
                    cr = xmin + x * xscal;
                    ci = ymin + y * yscal;
#endif
                    counts = mandel_float(cr, ci);
                    ((unsigned *) g_x11.bitmap->data)[x + y*width] = cols[counts];
#if (OPTIMIZED)
                    cr += xscal;
#endif
                }

            /* Display it line-by-line for speed */
            XPutImage(g_x11.dpy, g_x11.win, g_x11.gc, g_x11.bitmap,
                      0, y, 0, y,
                      width, 1);
#if (OPTIMIZED)
            ci += yscal;
#endif
        }

    XFlush(g_x11.dpy);
}