main.c

Mrxvt是一个小巧

/* xterm sequences - title, iconName, color (exptl) */
/* EXTPROTO */
void
rxvt_set_win_title (rxvt_t* r, Window win, const char* str)
{
	XChangeProperty (r->Xdisplay, win, XA_WM_NAME,
		XA_STRING, 8, PropModeReplace,
		(unsigned char*) str, STRLEN (str));
#ifdef X_HAVE_UTF8_STRING
	rxvt_set_utf8_property (r, r->h->xa[XA_NET_WM_NAME],
		r->TermWin.parent, str);
#endif
}


/* EXTPROTO */
void
rxvt_set_term_title (rxvt_t* r, const unsigned char *str)
{
#ifdef SMART_WINDOW_TITLE
	XTextProperty	prop;

	if (XGetWMName (r->Xdisplay, r->TermWin.parent, &prop) == 0)
		prop.value = NULL;
	if (NULL == prop.value || STRCMP(prop.value, str))
#endif
	{
		rxvt_set_win_title (r, r->TermWin.parent, (char*) str);
	}
}


/* EXTPROTO */
void
rxvt_set_icon_name (rxvt_t* r, const unsigned char *str)
{
	XTextProperty	prop;

#ifdef SMART_WINDOW_TITLE
	if (XGetWMIconName(r->Xdisplay, r->TermWin.parent, &prop) == 0)
		prop.value = NULL;
	if (NULL == prop.value || STRCMP(prop.value, str))
#endif
	{
		XChangeProperty (r->Xdisplay, r->TermWin.parent,
			XA_WM_ICON_NAME, XA_STRING, 8, PropModeReplace,
			(unsigned char*) str, STRLEN (str));
#ifdef X_HAVE_UTF8_STRING
		rxvt_set_utf8_property (r, r->h->xa[XA_NET_WM_ICON_NAME],
			r->TermWin.parent, (char*) str);
#endif
	}
}


#ifdef XTERM_COLOR_CHANGE
/* EXTPROTO */
void
rxvt_set_window_color(rxvt_t* r, int page, int idx, const char *color)
{
	XColor			xcol;
	int				ufbg_switched;
#ifdef OFF_FOCUS_FADING
	int				color_switched;
#endif
	int				color_set;
	register int	i;


	DBG_MSG( 2, ( stderr, "rxvt_set_window_color( r, %d, %d, %s), ATAB=%d\n",
				page, idx, color, ATAB(r) ) );

	if (color == NULL || *color == '\0')
		return;

	color_set = ISSET_PIXCOLOR(r->h, idx);
	/*
	** Restore colors now. Remember to restore ufbg color before
	** PixColors
	*/
	ufbg_switched = rxvt_restore_ufbg_color (r);
#ifdef OFF_FOCUS_FADING
	color_switched = rxvt_restore_pix_color (r);
#endif

	/* handle color aliases */
	if( isdigit((int) *color) )
	{
		i = atoi(color);
		if (i >= 8 && i <= 15)			/* bright colors */
		{
			i -= 8;
# ifndef NO_BRIGHTCOLOR
			r->PixColors[idx] = r->PixColors[minBrightCOLOR + i];
			SET_PIXCOLOR(r->h, idx);
			goto Done;
# endif
		}
		if (i >= 0 && i <= 7)			/* normal colors */
		{
			r->PixColors[idx] = r->PixColors[minCOLOR + i];
			SET_PIXCOLOR(r->h, idx);
			goto Done;
		}
	}
	if (!rxvt_parse_alloc_color(r, &xcol, color))
	{
		/* restore to original state and return */
#ifdef OFF_FOCUS_FADING
		if (color_switched)
			rxvt_switch_pix_color (r);
#endif
		if (ufbg_switched)
			rxvt_switch_ufbg_color (r);
		return;
	}

	/* XStoreColor (r->Xdisplay, XCMAP, XColor*); */

	/*
	 * FIXME: should free colors here, but no idea how to do it so instead,
	 * so just keep gobbling up the colormap
	 */
# if 0
	for (i = Color_Black; i <= Color_White; i++)
		if (r->PixColors[idx] == r->PixColors[i])
			break;

	if (i > Color_White)
	{
		fprintf (stderr, "XFreeColors: r->PixColors [%d] = %lu\n",
				idx, r->PixColors [idx]);
		XFreeColors(r->Xdisplay, XCMAP, (r->PixColors + idx), 1,
				DisplayPlanes(r->Xdisplay, XSCREEN));
	}
# endif

	r->PixColors[idx] = xcol.pixel;

#ifdef OFF_FOCUS_FADING
	if (r->h->rs[Rs_fade])
		r->PixColorsUnfocus[idx] = rxvt_fade_color (r, xcol.pixel);
#endif
#ifdef XFT_SUPPORT
	if (color_set)
	{
		XftColorFree (r->Xdisplay, XVISUAL, XCMAP, &(r->XftColors[idx]));
	}
	rxvt_alloc_xft_color (r, r->PixColors[idx], &(r->XftColors[idx]));
#endif
	SET_PIXCOLOR(r->h, idx);

Done:
	/*
	 * Ok, now return to original state before restoring colors. Remember to
	 * change PixColors before ufbg color
	 */
#ifdef OFF_FOCUS_FADING
	if (color_switched)
		rxvt_switch_pix_color (r);
#endif
	if (ufbg_switched)
		rxvt_restore_ufbg_color (r);

	/* XXX Need to save the fg / bg colors of each tab here. */
	if ( idx == Color_bg )
	{
		PVTS( r, page )->p_bg	= r->PixColors[idx];
#ifdef XFT_SUPPORT
		PVTS( r, page )->p_xftbg = r->XftColors[idx];
#endif
	}
	else if ( idx == Color_fg )
	{
		PVTS( r, page )->p_fg	= r->PixColors[idx];
#ifdef XFT_SUPPORT
		PVTS( r, page )->p_xftfg = r->XftColors[idx];
#endif
	}

	/* background color has changed */
	if (
		  (idx == Color_bg && !ufbg_switched)
		  || (idx == Color_ufbg && ufbg_switched)
	   )
	{
#ifdef TRANSPARENT
		if (!(r->Options & Opt_transparent))
#endif
		{
#ifdef BACKGROUND_IMAGE
			if (None == PVTS(r, page)->pixmap)
#endif
			{
				DBG_MSG( 3, ( stderr, "Changing background of page %d\n",
							page ) );
				XSetWindowBackground(r->Xdisplay, PVTS(r, page)->vt,
					r->PixColors[Color_bg]);
			}
		}
	}

	/* handle Color_BD, scrollbar background, etc. */
	/*
	 * XXX gi1242: Still needs work. Won't handle different tab bg's properly.
	 */
	rxvt_set_colorfgbg(r);
	rxvt_recolour_cursor(r);

#if defined(TRANSPARENT) || defined(BACKGROUND_IMAGE)
# ifdef TINTING_SUPPORT
	if (idx == Color_tint)
	{
#  ifdef TRANSPARENT
		if (r->Options & Opt_transparent)
			/* reset background */
			rxvt_check_our_parents (r);
		else
#  endif
#  ifdef BACKGROUND_IMAGE
		{	/* reset background */
			for (i = 0; i <= LTAB(r); i ++)
				rxvt_resize_pixmap (r, i);
		}
#  endif
		{	/* empty body to suppress compile error */	}
	}
# endif	/* TINTING_SUPPORT */
#endif	/* TRANSPARENT || BACKGROUND_IMAGE */

	/*
	 *  Just clear the window and generate expose events. The screen refresh
	 *  will get put on our queue of X events :)
	 */
	XClearArea( r->Xdisplay, AVTS(r)->vt, 0, 0, 0, 0, True );
}

#else
# define rxvt_set_window_color(r, idx,color)	((void)0)
#endif		/* XTERM_COLOR_CHANGE */


/* EXTPROTO */
void
rxvt_recolour_cursor(rxvt_t *r)
{
	XColor			xcol[2];

	xcol[0].pixel = r->PixColors[Color_pointer];
	xcol[1].pixel = r->PixColors[Color_bg];
	XQueryColors(r->Xdisplay, XCMAP, xcol, 2);
	XRecolorCursor(r->Xdisplay, r->term_pointer, &(xcol[0]), &(xcol[1]));
}


/*----------------------------------------------------------------------*/
/*
 * find if fg/bg matches any of the normal (low-intensity) colors
 */
/* INTPROTO */
void
rxvt_set_colorfgbg(rxvt_t *r)
{
	unsigned int	i;
	const char	 *xpmb = "\0";
	char			fstr[sizeof("default") + 1], bstr[sizeof("default") + 1];

	r->h->env_colorfgbg = rxvt_malloc(sizeof("COLORFGBG=default;default;bg")
						+ 1);
	STRCPY(fstr, "default");
	STRCPY(bstr, "default");
	for (i = Color_Black; i <= Color_White; i++)
		if (r->PixColors[Color_fg] == r->PixColors[i])
		{
			sprintf(fstr, "%d", (i - Color_Black));
			break;
		}
	for (i = Color_Black; i <= Color_White; i++)
		if (r->PixColors[Color_bg] == r->PixColors[i])
		{
			sprintf(bstr, "%d", (i - Color_Black));
#ifdef BACKGROUND_IMAGE
			xpmb = "default;";
#endif
			break;
		}
	sprintf(r->h->env_colorfgbg, "COLORFGBG=%s;%s%s", fstr, xpmb, bstr);
	putenv(r->h->env_colorfgbg);

#ifndef NO_BRIGHTCOLOR
	r->h->colorfgbg = DEFAULT_RSTYLE;
	for (i = minCOLOR; i <= maxCOLOR; i++)
	{
		if (
				r->PixColors[Color_fg] == r->PixColors[i]
# ifndef NO_BOLD_UNDERLINE_REVERSE
				&& r->PixColors[Color_fg] == r->PixColors[Color_BD]
# endif
				/* if we wanted boldFont to have precedence */
# if 0	/* was ifndef NO_BOLDFONT */
				&& r->TermWin.bfont == NULL
# endif	
		   )
			r->h->colorfgbg = SET_FGCOLOR(r->h->colorfgbg, i);
		if (r->PixColors[Color_bg] == r->PixColors[i])
			r->h->colorfgbg = SET_BGCOLOR(r->h->colorfgbg, i);
	}
#endif	/* NO_BRIGHTCOLOR */
}

/*----------------------------------------------------------------------*/
/*
 * Colour determination for low colour displays, routine from
 *	 Hans de Goede <[e-mail]>
 */


#ifdef XFT_SUPPORT
/* EXTPROTO */
int
rxvt_alloc_xft_color (rxvt_t* r, unsigned long pixel, XftColor* xftcolor)      
{
	XColor          xcol;
	XRenderColor    render; 

	assert (xftcolor);

	xcol.pixel = pixel;
	if (!XQueryColor (r->Xdisplay, XCMAP, &xcol))
		return 0;

	render.red   = xcol.red;
	render.green = xcol.green;
	render.blue  = xcol.blue;
	render.alpha = 0xFFFF; 
	return (XftColorAllocValue (r->Xdisplay, XVISUAL, XCMAP, &render, xftcolor));
}
#endif  /* XFT_SUPPORT */


/* EXTPROTO */
int
rxvt_parse_alloc_color(rxvt_t* r, XColor *screen_in_out, const char *colour)
{
	int				res = 0;

	if (!XParseColor(r->Xdisplay, XCMAP, colour, screen_in_out))
		rxvt_print_error("can't determine colour: %s", colour);
	else
		res = rxvt_alloc_color(r, screen_in_out, colour);
	return res;
}


/* EXTPROTO */
int
rxvt_alloc_color( rxvt_t* r, XColor *screen_in_out, const char *colour )
{
	return XAllocColor( r->Xdisplay, XCMAP, screen_in_out );

#if 0 /* 2006-05-27 gi1242: Really bad code. */
	int				res;

	if( (res = XAllocColor(r->Xdisplay, XCMAP, screen_in_out)) )
		return res;

	/* try again with closest match */
	/*
	 * XXX 2006-05-25 gi1242: This is really inefficient. There must be a better
	 * way!
	 */
	if (XDEPTH >= 4 && XDEPTH <= 8)
	{
		int				i, numcol;
		int				best_pixel = 0;
		unsigned long   best_diff, diff;
		XColor			*colors;

#define rSQR(x)		((x)*(x))

		best_diff = 0;
		numcol = 0x01 << XDEPTH;
		if( (colors = rxvt_malloc(numcol * sizeof(XColor))) )
		{
			for (i = 0; i < numcol; i++)
			colors[i].pixel = i;

			XQueryColors(r->Xdisplay, XCMAP, colors, numcol);
			for (i = 0; i < numcol; i++)
			{
				diff = rSQR(screen_in_out->red - colors[i].red)
					+ rSQR(screen_in_out->green - colors[i].green)
					+ rSQR(screen_in_out->blue - colors[i].blue);
				if (i == 0 || diff < best_diff)
				{
					best_pixel = colors[i].pixel;
					best_diff = diff;
				}
			}
			*screen_in_out = colors[best_pixel];
			free(colors);

			res = XAllocColor(r->Xdisplay, XCMAP, screen_in_out);
		}
	}

	if (res == 0)
		rxvt_print_error("can't allocate color: %s", colour);

	return res;
#endif
}



/* -------------------------------------------------------------------- *
 * -						X INPUT METHOD ROUTINES						- *
 * -------------------------------------------------------------------- */
#ifdef USE_XIM
/* INTPROTO */
void
rxvt_IM_set_size(rxvt_t* r, XRectangle *size)
{
	XWindowAttributes	xwa;

	XGetWindowAttributes(r->Xdisplay, AVTS(r)->vt, &xwa);
	size->x = xwa.x + r->TermWin.int_bwidth;
	size->y = xwa.y + r->TermWin.int_bwidth;
	size->width = Width2Pixel(r->TermWin.ncol);
	size->height = Row2Pixel(r->TermWin.nrow);
}

/* INTPROTO */
void
rxvt_IM_set_position(rxvt_t* r, XPoint *pos)
{
	XWindowAttributes	xwa;

	XGetWindowAttributes(r->Xdisplay, AVTS(r)->vt, &xwa);
	pos->x = xwa.x + Col2Pixel(ASCR(r).cur.col);
	pos->y = xwa.y + Row2Pixel(ASCR(r).cur.row) + r->TermWin.font->ascent;
}

/* INTPROTO */
void
rxvt_IM_set_color(rxvt_t* r, unsigned long *fg, unsigned long *bg)
{
	*fg = r->PixColors[Color_fg];
	*bg = r->PixColors[Color_bg];
}

/* Checking whether input method is running. */
/* INTPROTO */
Bool
rxvt_IM_is_running(rxvt_t *r)
{
	char				*p;
	Atom			atom;
	Window			win;
	char			server[IMBUFSIZ];

	/* get current locale modifier */
	DBG_MSG(2, (stderr, "rxvt_IM_is_running ()\n"));
	if ((p = XSetLocaleModifiers(NULL)) != NULL)
	{
		STRCPY(server, "@server=");
		STRNCAT(server, &(p[4]), IMBUFSIZ - 9);	/* skip "@im=" */
		if ((p = STRCHR(server + 1, '@')) != NULL)	/* first one only */
			*p = '\0';

		atom = XInternAtom(r->Xdisplay, server, False);
		win = XGetSelectionOwner (r->Xdisplay, atom);
		if (win != None)
			return True;
	}
	return False;
}


/* EXTPROTO */
void
rxvt_IM_send_spot (rxvt_t *r)
{
	XPoint			spot;
	XVaNestedList   preedit_attr;

	if (r->h->Input_Context == NULL ||
		!r->TermWin.focus ||
		!(r->h->input_style & XIMPreeditPosition) ||
		!(r->h->event_type == KeyPress ||
		r->h->event_type == Expose ||
		r->h->event_type == NoExpose ||
		r->h->event_type == SelectionNotify ||
		r->h->event_type == ButtonRelease ||
		r->h->event_type == FocusIn) ||
		!rxvt_IM_is_running(r))
		return;

	rxvt_IM_set_position(r, &spot);

	preedit_attr = XVaCreateNestedList(0, XNSpotLocation, &spot, NULL);
	XSetICValues(r->h->Input_Context, XNPreeditAttributes, preedit_attr, NULL);
	XFree(preedit_attr);
}


/* EXTPROTO */
void
rxvt_IM_set_fontset (rxvt_t* r, int idx)
{
	char				*string;
	long			length;
	XFontSet		prev_fontset;
	int				success = 0;

	if (idx < 0 || idx >= MAX_NFONTS)
		return;
	DBG_MSG(1,(stderr, "rxvt_setTermFontSet()\n"));
	prev_fontset = r->TermWin.fontset;
	r->TermWin.fontset = NULL;

	length = 0;
	if (r->h->rs[Rs_font + idx])
		length += STRLEN(r->h->rs[Rs_font + idx]) + 1;
# ifdef MULTICHAR_SET
	if (r->h->rs[Rs_mfont + idx])
		length += STRLEN(r->h->rs[Rs_mfont + idx]) + 1;
# endif
	/* possible integer overflow? */
	assert (length >= 0 && length+1 > 0);
	if (len