示例#1
0
unsigned long XtcwpGetLastPixel (Display *dpy)
/*****************************************************************************
return last pixel in range of contiguous pixels in XA_RGB_DEFAULT_MAP
******************************************************************************
Input:
dpy		display
******************************************************************************
Notes:
If it does not already exist, XA_RGB_DEFAULT_MAP will be created.
If XA_RGB_DEFAULT_MAP does not exist and cannot be created, then
this function returns 0.
******************************************************************************
Author:  Dave Hale, Colorado School of Mines, 09/29/90
*****************************************************************************/
{
	Screen *scr=XDefaultScreenOfDisplay(dpy);
	Window root=XRootWindowOfScreen(scr);
	XStandardColormap scmap;
	
	/* if XA_RGB_DEFAULT_MAP does not exist, create it */
	if (!XGetStandardColormap(dpy,root,&scmap,XA_RGB_DEFAULT_MAP))
		if (!XtcwpCreateRGBDefaultMap(dpy,&scmap))
			return 0;
	
	/* return last pixel in range of contiguous pixels */
	return scmap.base_pixel+
		scmap.red_max*scmap.red_mult+
		scmap.green_max*scmap.green_mult+
		scmap.blue_max*scmap.blue_mult;
}
示例#2
0
/*
 ****************************************************************
 *	Programa principal					*
 ****************************************************************
 */
int
main (int argc, const char *argv[])
{
	XStandardColormap stdcmap, *cmp;
	Display		*dpy = NULL;
	Window		root, win;
	XGCValues	gcv;
	int		depth;

	FILE		*fp;
	XImage		*ximage = NULL;
	IMAGE		*last_image, *ip, *old_ip;
	int		nimages, times;

	const char	*display = NOSTR;
	int		time_interval = 0;
	int		opt, exit_val = 0;
	int		Nflag = 0;

	Atom		map;
	KeySym		key;

	save_argc = argc;	save_argv = argv;

	/*
	 *	Analisa as opções de execução.
	 */
	while ((opt = getopt (argc, argv, "d:f:HMNRs:v")) != EOF)
	{
		switch (opt)
		{
		    case 'd':
			display = optarg;
			break;

		    case 'f':
			if (strchr (optarg, '/') != NOSTR)
			{
				int	num, den;

				sscanf (optarg, "%d/%d", &num, &den);

				if (num != 1 || den <= 0 || den > 8)
					msg ("$Fator redutivo inválido");

				default_factor = -den + 1;
			}
			else
			{
				sscanf (optarg, "%d", &default_factor);

				if (default_factor <= 0 || default_factor > 8)
					msg ("$Fator de ampliação inválido");

				default_factor--;
			}
			break;

		    case 'H':
			help (0);
			break;

		    case 'M':
			return (0);

		    case 'N':
			Nflag++;
			break;

		    case 'R':
			Rflag++;
			break;

		    case 's':
			time_interval = atol (optarg);

			if (time_interval < 1 || time_interval > 60)
			{
				msg ("Argumento inválido para opção '-s'");
				help (1);
			}

			break;

		    case 'v':
			vflag++;
			break;

		    default:
			putc ('\n', stderr);
			help (2);

		}	/* end switch (opt) */

	}	/* end while (analisando opções) */

	argv += optind;
	argc -= optind;

	/*
	 *	Consistência final das Opções.
	 */
	if (Nflag)
	{
		if (argc > 0 || *argv != NOSTR)
			msg ("$Com a opção '-N' NÃO podem ser dados nomes de arquivos");

		argv = read_args_from_stdin (&argc);
	}

	if (Rflag && time_interval > 0)
		msg ("$As opções '-R' e '-s' são incompatíveis");

	/*
	 *	Constrói a Tabela de Imagens.
	 */
	for (/* acima */; *argv != NULL; argv++)
	{
		if (ftw (*argv, add_image_to_table) < 0)
			msg ("$*Erro em \"ftw (%s)\"", *argv);
	}

	if ((nimages = next_image - images) <= 0)
		msg ("$Não foram encontrados arquivos contendo imagens");

	last_image = next_image - 1;

	if (Rflag && nimages > 1)
	{
		/* Escolhe aleatoriamente uma imagem */

		images += (time (NULL) % nimages); last_image = images;

		msg ("Imagem a a janela-mãe: \"%s\"", images->i_name);
	}

	/*
	 *	Abre a conexão com o servidor.
	 */
	if ((dpy = XOpenDisplay (display)) == NULL)
	{
		msg
		(	"$Não consegui conectar-me ao servidor \"%s\"",
			XDisplayName (display)
		);
	}

	screen = DefaultScreen (dpy);
	depth  = DefaultDepth (dpy, screen);
	root   = RootWindow (dpy, screen);

	/*
	 *	Obtém o mapa de cores de acordo com a profundidade.
	 */
	cmp = &stdcmap;

	map = (depth <= 8) ? XA_RGB_DEFAULT_MAP : XA_RGB_BEST_MAP;

	if (!XGetStandardColormap (dpy, root, cmp, map))
	{
		cmp = NULL;
		msg ("Mapa de cores padrão para profundidade %d não disponível", depth);
	}

	/*
	 *	Decide se cria ou não uma janela para exibir as imagens.
	 */
	win = Rflag ? root : create_window (dpy);

	gcv.foreground = WhitePixel (dpy, screen);
	gcv.background = BlackPixel (dpy, screen);

	gc = XCreateGC (dpy, win, GCForeground|GCBackground, &gcv);

	/*
	 *	Mostra as imagens.
	 */
	for (times = 0, old_ip = NOIMAGE, ip = images; ip != NOIMAGE; times++)
	{
		if (vflag && (times & 15) == 0 && nimages > 0)
		{
			printf ("\n NUM  FMT   LARG x  ALT   FATOR   CORES   TAMANHO  ARQUIVO\n");
			printf ("--------------------------------------------------------------\n");
		}

		if (old_ip != ip)
		{
			/* Abre o arquivo que contém a imagem */

			if ((fp = fdopen (inopen (ip->i_dev, ip->i_ino), "r")) == NOFILE)
			{
				msg ("*Não consegui abrir o arquivo \"%s\"", ip->i_name);
				exit_val++; break;
			}

			/* Lê a imagem para a memória */

			if ((ximage = (*ip->i_format->f_load) (fp, 1, dpy, cmp, ip)) == NULL)
			{
				msg ("Não consegui ler imagens do arquivo \"%s\"", ip->i_name);
				fclose (fp); exit_val++; break;
			}

			fclose (fp);

			/* Imprime, se necessário, algumas informações sobre a imagem */

			if (vflag)
			{
				char	factor[8];

				if (ip->i_factor >= 0)
					snprintf (factor, sizeof (factor), "%d",    ip->i_factor + 1);
				else
					snprintf (factor, sizeof (factor), "1/%d", -ip->i_factor + 1);

				printf
				(	"%4d  %s   %4d x %4d   %4s %8d  %8d  %s\n",
					ip - images + 1, ip->i_format->f_extension,
					ip->i_width,	 ip->i_height,  factor,
					ip->i_ncolors,	 ip->i_file_sz, ip->i_name
				);
			}

			/* Mostra a imagem como fundo da janela */

			if (draw_window (dpy, win, ximage, ip) < 0)
				break;

		}	/* end if (nova imagem) */

		/* Aguarda eventos e analisa o retorno */

		key = wait_for_events (dpy, win, time_interval);

		old_ip = ip;

		switch (key)
		{
		    case 'q':
		    case 'Q':
		    case XK_Escape:
			ip = NOIMAGE;		/* Fim do programa */
			break;

		    case XK_Up:
		    case XK_KP_Up:
			if (ip > images)
				ip--;		/* Retrocede uma imagem */
			break;

		    case XK_Down:
		    case XK_KP_Down:
			if (ip < last_image)
				ip++;		/* Avança uma imagem */
			elif (time_interval > 0)
				ip = images;	/* Volta ao início */
			break;

		    case XK_Home:
		    case XK_KP_Home:
			ip = images;		/* Volta ao início */
			break;

		    case XK_End:
		    case XK_KP_End:
			ip = last_image;	/* Vai para a última imagem */
			break;

		    case XK_Right:
		    case XK_KP_Right:
			ip->i_factor++;		/* Aumenta o fator */
			old_ip = NOIMAGE;
			break;

		    case XK_Left:		/* Diminui o fator */
		    case XK_KP_Left:
			ip->i_factor--;
			old_ip = NOIMAGE;
			break;

		    default:
			break;

		}	/* end switch (tecla retornada) */

		if (ip != old_ip)
			XDestroyImage (ximage);

	}	/* end for (percorrendo imagens) */

	XFreeGC (dpy, gc);

	XCloseDisplay (dpy);

	return (exit_val);

}	/* end main */
示例#3
0
Colormap XtcwpCreateRGBColormap (Display *dpy, Window win)
/*****************************************************************************
create a colormap with an RGB color scale in contiguous cells
******************************************************************************
Input:
dpy		display
win		window
******************************************************************************
Notes:
The returned colormap is only created; the window's colormap attribute
is not changed, and the colormap is not installed by this function.
The returned colormap is a copy of the window's current colormap, but 
with an RGB color scale allocated in the range of contiguous cells
determined by XA_RGB_DEFAULT_MAP.  If it does not already exist,
XA_RGB_DEFAULT_MAP will be created.
******************************************************************************
Author:  Dave Hale, Colorado School of Mines, 09/29/90
*****************************************************************************/
{
	Screen *scr=XDefaultScreenOfDisplay(dpy);
	Window root=XRootWindowOfScreen(scr);
	Colormap cmap,wcmap;
	XStandardColormap scmap;
	XColor color;
	XWindowAttributes wa;
	unsigned long i,ncells,npixels;
	unsigned long bpixel,epixel,pixel[4096];
	
	/* determine beginning and ending pixels in contiguous range */
	bpixel = XtcwpGetFirstPixel(dpy);
	epixel = XtcwpGetLastPixel(dpy);
	if (epixel<=bpixel) return None;
	
	/* get standard colormap XA_RGB_DEFAULT_MAP */
	if (!XGetStandardColormap(dpy,root,&scmap,XA_RGB_DEFAULT_MAP))
		if (!XtcwpCreateRGBDefaultMap(dpy,&scmap))
			return None;
	
	/* determine window's current colormap */
	XGetWindowAttributes(dpy,win,&wa);
	wcmap = wa.colormap;
	
	/* create new colormap and allocate all cells read/write */
	cmap = XCreateColormap(dpy,win,DefaultVisualOfScreen(scr),AllocNone);
	ncells = CellsOfScreen(scr);
	XAllocColorCells(dpy,cmap,True,NULL,0,pixel,(unsigned int)ncells);
	
	/* copy color cells from window's colormap to new colormap */
	for (i=0; i<ncells; ++i) {
		if (i<bpixel || i>epixel) {
			color.pixel = i;
			XQueryColor(dpy,wcmap,&color);
			XFreeColors(dpy,cmap,&i,1,0);
			XAllocColor(dpy,cmap,&color);
		}
	}
	
	/* copy RGB color scale from XA_RGB_DEFAULT_MAP to new colormap */
	npixels = epixel-bpixel+1;
	for (i=0; i<npixels; ++i) {
		color.pixel = bpixel+i;
		XQueryColor(dpy,scmap.colormap,&color);
		XStoreColor(dpy,cmap,&color);
	}
	
	/* return colormap */
	return cmap;
}
示例#4
0
Status XtcwpCreateRGBDefaultMap (Display *dpy, XStandardColormap *scmap)
/*****************************************************************************
create XA_RGB_DEFAULT_MAP property of root window if it does not already exist
******************************************************************************
Input:
dpy		display

Output:
scmap		the standard colormap structure
******************************************************************************
Notes:
This function returns 0 if the XA_RGB_DEFAULT_MAP property does not exist
and cannot be created.  At least 8 contiguous color cells must be free
in the default colormap to create the XA_RGB_DEFAULT_MAP.  If created, the
red_max, green_max, and blue_max values returned in scmap will be equal.
******************************************************************************
Author:  Dave Hale, Colorado School of Mines, 09/29/90
*****************************************************************************/
{
	Screen *scr=XDefaultScreenOfDisplay(dpy);
	Window root=XRootWindowOfScreen(scr);
	Colormap cmap;
	XColor color;
	int i,ncells;
	unsigned long npixels;
	unsigned long bpixel,epixel,pixel1,pixel2,imax,rmult,gmult,bmult;
	unsigned long pixel[4096];

	/* grab the server */
	XGrabServer(dpy);

	/* if XA_RGB_DEFAULT_MAP does not exist, then */
	if (!XGetStandardColormap(dpy,root,scmap,XA_RGB_DEFAULT_MAP)) {
		
		/* use default colormap */
		cmap = DefaultColormapOfScreen(scr);

		/* determine largest number of contiguous free color cells */
		ncells = CellsOfScreen(scr);
		while(ncells && 
			!XAllocColorCells(dpy,cmap,True,NULL,0,pixel,ncells))
			ncells--;
		
		/* determine beginning and ending pixel of contiguous cells */
		for (i=1,bpixel=epixel=pixel1=pixel2=pixel[0]; i<ncells; i++) {
			if (pixel[i]==pixel[i-1]+1)
				pixel2 = pixel[i];
			else
				pixel1 = pixel2 = pixel[i];
			if (pixel2-pixel1>=epixel-bpixel) {
				bpixel = pixel1;
				epixel = pixel2;
			}
		}
		
		/* number of pixels must be at least 8 */
		npixels = epixel-bpixel+1;
		if (npixels<8) {
			XUngrabServer(dpy);
			return 0;
		}
		
		/* force number of contiguous cells to be an integer cubed */
		for (i=2,imax=0; i*i*i<=npixels; i++,imax++);
		npixels = (imax+1)*(imax+1)*(imax+1);
		bpixel = epixel-npixels+1;
		
		/* free cells not in contiguous range */
		for (i=0; i<ncells; i++)
			if (pixel[i]<bpixel || pixel[i]>epixel)
				XFreeColors(dpy,cmap,&pixel[i],1,0);

		/* store colors in contiguous range of allocated cells */
		rmult = (imax+1)*(imax+1);
		gmult = imax+1;
		bmult = 1;
		for (i=0; i<npixels; i++) {
			color.pixel = bpixel+i;
			color.red = (unsigned short) (i/rmult);
			color.green = (unsigned short) ((i-color.red*rmult)/gmult);
			color.blue = (unsigned short) (i-color.red*rmult-color.green*gmult);
			color.red *= 65535/imax;
			color.green *= 65535/imax;
			color.blue *= 65535/imax;
			color.flags = DoRed|DoGreen|DoBlue;
			XStoreColor(dpy,cmap,&color);
		}
		
		/* set standard colormap */
		scmap->colormap = cmap;
		scmap->red_max = imax;
		scmap->green_max = imax;
		scmap->blue_max = imax;
		scmap->red_mult = rmult;
		scmap->green_mult = gmult;
		scmap->blue_mult = bmult;
		scmap->base_pixel = bpixel;
		XSetStandardColormap(dpy,root,scmap,XA_RGB_DEFAULT_MAP);
	}

	/* ungrab the server before returning */
	XUngrabServer(dpy);
	return 1;
}