예제 #1
0
void glDispyWidget::paintGL() {


    //http://stackoverflow.com/questions/6512543/obtaining-full-desktop-screenshot-from-the-gpu
    //http://forum.openframeworks.cc/index.php?topic=3017.0
    if(useShm) {
        XShmGetImage(xDisplay, rootWindow, img, 0, 0, AllPlanes);
    }
    else {
        //XImage *img = XGetImage(display,root,0,0,400,400,XAllPlanes(),ZPixmap);
        img = XGetImage(xDisplay,rootWindow,0,0,xDisplayWidth,xDisplayHeight,XAllPlanes(),ZPixmap);
    }
    if (img == NULL) {
       qDebug() << "error getting display data";
       return;
    }
    qDebug() << img->width;
    /*glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(1,0,0);
    glBegin(GL_POLYGON);
    glVertex2f(0,0);
    glVertex2f(100,500);
    glVertex2f(500,100);
    glEnd();
    */
    //see http://www.opengl.org/wiki/Programming_OpenGL_in_Linux:_Creating_a_texture_from_a_Pixmap
    //generate a texture from the Ximage
    glBindTexture(GL_TEXTURE_2D, texture);
    /*GL_EXT extension test
    glXBindTexImageEXT (display, glxpixmap, GLX_FRONT_LEFT_EXT, NULL);
     */



    /*working code
    */
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, xDisplayWidth,xDisplayHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, (void*)(&(img->data[0])));
    glEnable(GL_TEXTURE_2D);
    //glEnable(GL_MULTISAMPLE);
    //glEnable(GL_CULL_FACE);

    glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
    glBegin(GL_QUADS);
    glTexCoord2f(0.0f, 0.0f); glVertex3f(0.f, 0.f, 0.f);
    glTexCoord2f(1.0f, 0.0f); glVertex3f(width(), 0.f, 0.f);
    glTexCoord2f(1.0f, 1.0f); glVertex3f(width(), height()-2, 0);
    glTexCoord2f(0.0f, 1.0f); glVertex3f(0.f, height(), 0.f);
    glEnd();
    //render_fbo->toImage().save("test.png");
}
예제 #2
0
void FindPixel (char *windowName, int x, int y, Display *display, Window rootWindow)
{
	Window parent;
	Window *children;
	Window *child;
	XImage *image;
	XWindowAttributes winAttr;
	XColor color;
	XTextProperty wmName;

	unsigned int noOfChildren;
	unsigned long pixel;
	int status;
	int i, red, green, blue;
	char **list;

	status = XGetWMName (display, rootWindow, &wmName);

	if ((status) && (wmName.value) && (wmName.nitems)) {
		if (strcmp(windowName, wmName.value) == 0) {
			XGetWindowAttributes(display, rootWindow, &winAttr);
			image = XGetImage(display, rootWindow, 0, 0, winAttr.width, winAttr.height, XAllPlanes(), ZPixmap);
			color.pixel = XGetPixel(image, x, y);
			XQueryColor(display, XDefaultColormap(display, XDefaultScreen(display)), &color);
			red = floor(color.red * 0.003891051);
			green = floor(color.green * 0.003891051);
			blue = floor(color.blue * 0.003891051);

			printf("%i %i %i\n", red, green, blue);
		}
	}
	
	
	status = XQueryTree (display, rootWindow, &rootWindow, &parent, &children, &noOfChildren);
	
	for (i=0; i < noOfChildren; i++) {
		FindPixel (windowName, x, y, display, children[i]);
	}
	
	XFree ((char*) children);
}
예제 #3
0
void
ga_xwin_capture(char *buf, int buflen, struct gaRect *rect) {
	if(XShmGetImage(display, rootWindow, image, 0, 0, XAllPlanes()) == 0) {
		ga_error("FATAL: XShmGetImage failed.\n");
		exit(-1);
	}
	if(rect == NULL) {
		bcopy(image->data, buf, buflen);
	} else {
		int i;
		char *src, *dst;
		src = ((char *) image->data);
		src += image->bytes_per_line * rect->top;
		src += RGBA_SIZE * rect->left;
		dst = (char*) buf;
		//
		for(i = 0; i < rect->height; i++) {
			bcopy(src, dst, rect->linesize);
			src += image->bytes_per_line;
			dst += rect->linesize;
		}
	}
	return;
}
예제 #4
0
int save_image (FILE *file)
{
	int 		x_loc,y_loc;
#ifdef X11WM
	Window    	canvas_root_win, child_win;
        XImage		*ximage;
#else
	void *ximage = NULL;
#endif
	char		r[MAX_COLORS],g[MAX_COLORS],b[MAX_COLORS];
	unsigned int	x_width,y_height,border_width,depth;
	int		width, height;
#ifdef X11WM
	int		screen = DefaultScreen(connect_id.display);
	int		scrn_width=DisplayWidth(connect_id.display,screen);
        int		scrn_height=DisplayHeight(connect_id.display,screen);
#else
	int		screen;
	int		scrn_width;
        int		scrn_height;
#endif
	int		x1,y1;

	/* 
 	 * Get allocated memory for the XImage structure and copy the
 	 * canvas window to it.
	 */
	/* Get the application window's position */

#ifdef X11WM
	XRaiseWindow(connect_id.display,connect_id.drawable);
	if (	XGetGeometry(
		connect_id.display,connect_id.drawable, &canvas_root_win,
	   	&x_loc, &y_loc, &x_width, &y_height, &border_width, &depth) == 0
				||
		XTranslateCoordinates(connect_id.display,connect_id.drawable,
		canvas_root_win,0,0,&x1,&y1,&child_win) == False)
	  {
	   err_warn(1,fperr,"Error - getting raster image.\n");
	   return 0;
	  }

	width = x_width;
	height = y_height;

	/* Find the new x location and the width, if necessary. */

	if ((-x1 > width) || (x1 > scrn_width)) {
	   err_warn(1,fperr,"Error - X for getting raster image.\n");
	   return 0;
	  }
	if (x1 < 0)
	  {
	   width=width+x1;
	   x1=0;
	  }
	else if (x1+width > scrn_width)
	  {
	   width=scrn_width-x1;
	  }

	if ((-y1 > height) || (y1 > scrn_height)) {
	   err_warn(1,fperr,"Error - Y for getting raster image.\n");
	   return 0;
	  }
	if (y1 < 0)
	  {
	   height=height+y1;
	   y1=0;
	  }
	else if (y1+height > scrn_height)
	  {
	   height=scrn_height-y1;
	  }

        /* This way is good because the root window will create partially obscure windows.
	 * But this method doesn't work for the Mac which has a rootless window.
         * ximage = XGetImage(cptr->connect_id.display,
                RootWindowOfScreen(DefaultScreenOfDisplay(cptr->connect_id.display)),
                   x1, y1, width, height, XAllPlanes(), ZPixmap);
         */
	ximage = XGetImage(connect_id.display,
		           connect_id.drawable,
                           0, 0, width, height, XAllPlanes(), ZPixmap);
#elif defined QTWM
	vcs_legacy_Qt_window_get_image_by_id(connect_id.wkst_id,&ximage);
#else
	fprintf(stderr,"insert here your WM to get image\n");
#endif
        if (ximage == NULL)
	  {
	   err_warn(1,fperr,"Error - getting raster image.\n");
	   return 0;
	  }
	/* If display has 8 bit color */
#ifdef X11WM
        if (ximage->depth == 8) {
           /* Convert X colors to u_char arrays */
           convert_gks_color(r, g, b);

           /* Save the image and its colormap in a Sun Raster file */
           ras_write_ximage(file,  ximage, r, g, b, MAX_COLORS);
        } else {
           /* Save the image with no colormap in a Sun Raster file */
           ras_write_ximage(file, ximage, NULL, NULL, NULL, 0);
	}
#elif defined QTWM
	ras_write_ximage(file, ximage, NULL, NULL, NULL, 0);
#else
	fprintf(stderr,"insert here your write to ras func\n");
#endif

	/* Print out image information
        print_image_info(x_loc, y_loc, ximage, MAX_COLORS);
	*/

	/* Remove the image from memory */
#ifdef X11WM
        XDestroyImage(ximage);
#elif defined QTWM
	free(ximage);
#else
	fprintf(stderr,"insert here your destroy ximage func\n");
#endif
	return 1;
}
예제 #5
0
int main(int argc, char *argv[]) {
  Display *disp;
  int scr, prepare, tmp;
  Window selector, rootwin;
  XEvent event;
  cairo_surface_t *canvas;
  Atom setfull[2];
  XWindowAttributes scrattr;
  XSetWindowAttributes winattr;
  XVisualInfo vis;
  ScreenshotLoc initloc, endloc;
  pngstream pngstr;
  XImage *ximg;
  
  // Get the user's display
  if (!(disp = XOpenDisplay(NULL))) {
    printf("Could not get display!\n");
  }

  // Get screen, root
  scr = DefaultScreen(disp);
  rootwin = RootWindow(disp, scr);
		   
  XMatchVisualInfo(disp, scr, 32, TrueColor, &vis);
  
  // Get screen stats for width/height
  XGetWindowAttributes(disp, rootwin, &scrattr);

  // Set window attributes
  winattr.colormap = XCreateColormap(disp, rootwin, vis.visual, AllocNone);
  winattr.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | Button1MotionMask;
  winattr.background_pixmap = None;
  winattr.border_pixel = 0;
  // Make the selector window
  selector = XCreateWindow(disp,
			   rootwin,
			   0, 0,
			   scrattr.width, scrattr.height,
			   0,
			   vis.depth,
			   InputOutput,
			   vis.visual,
			   CWColormap | CWEventMask | CWBackPixmap | CWBorderPixel,
			   &winattr); 
  XStoreName(disp, selector, "cloudselect");
  // We need key release (any key == cancel), and button for hold/release
  //XSelectInput(disp, selector, ExposureMask|ButtonPressMask|ButtonReleaseMask|KeyReleaseMask);
  XMapWindow(disp, selector);

  // set our window to fullscreen
  setfull[0] = XInternAtom(disp, "_NET_WM_STATE_FULLSCREEN", False);
  setfull[1] = None;
  
  XChangeProperty(disp,
		  selector,
		  XInternAtom(disp, "_NET_WM_STATE", False),
		  XA_ATOM,
		  32,
		  PropModeReplace,
		  (unsigned char *)setfull,
		  1);

  RemoveDecorations(disp, selector);  
  
  // make a cairo surface to paint on
  canvas = cairo_xlib_surface_create(disp, selector, vis.visual, scrattr.width, scrattr.height);

  initloc.x = initloc.y = -1;

  prepare = 0;
  
  while (get_xevents(disp, &event)) {
    if (event.type == Expose) {
      paint(canvas, scrattr.width, scrattr.height);
    } else if (event.type == ButtonPress) {
      if (event.xbutton.button == Button1) {
	initloc.x = event.xbutton.x;
	initloc.y = event.xbutton.y;
      } else {
	printf("[INFO] Operation cancelled.\n");
	break;
      }
    } else if (event.type == ButtonRelease) { // We have completed selecting!
      if (event.xbutton.button == Button1) {
	endloc.x = event.xbutton.x;
	endloc.y = event.xbutton.y;

	// Negative resolutions are bad and make no sense anyway
	if (endloc.x < initloc.x) {
	  tmp = endloc.x;
	  endloc.x = initloc.x;
	  initloc.x = tmp;
	}
	if (endloc.y < initloc.y) {
	  tmp = endloc.y;
	  endloc.y = initloc.y;
	  initloc.y = tmp;
	}

	// Debug printf()s
	printf("Initial co-ordinates: (%d, %d)\n", initloc.x, initloc.y);
	printf("Final co-ordinates:   (%d, %d)\n", endloc.x, endloc.y);
	printf("Dimensions:           %dx%d\n", endloc.y-initloc.y, endloc.x-initloc.x);

	// Get selection as XImage
	ximg = XGetImage(disp, rootwin, initloc.x, initloc.y, (endloc.x-initloc.x), (endloc.y-initloc.y), XAllPlanes(), ZPixmap);

	// Pass XImage to mkpngstream
	pngstr = mkpngstream(disp, DefaultScreen(disp), vis.visual, ximg, initloc, endloc); // Make PNG stream to send to CloudApp
	if (!pngstr.data) {
	  printf("Making PNG stream failed...\n");
	  if (ximg) {
	    XFree(ximg); // XFree doesn't like NULL pointers
	  }
	} else {
	  test_write_file(pngstr, "test.png");
	}
	break;
      } else { // ... Wrong button!
	printf("[INFO Operation cancelled.\n");
	break;
      }
    } else if (event.type == MotionNotify) { // We only track Button1Motion, so...
      endloc.x = event.xmotion.x;
      endloc.y = event.xmotion.y;
      printf("[INFO] endloc.x: %d\nendloc.y: %d\n", endloc.x, endloc.y);
      printf("[INFO] initloc.x: %d\ninitloc.y: %d\n", initloc.x, initloc.y);
      paint(canvas, scrattr.width, scrattr.height);
      setrect(canvas, initloc, endloc);
    } else if (event.type == KeyRelease) {
      if (prepare == 1) break;
    }
    else if (event.type == KeyPress) {
      prepare = 1;
    }
  }

  cairo_surface_destroy(canvas);

  XCloseDisplay(disp);
  return 0;
}