xlib.c

rxvt经典的linux下的终端.小巧实用

	"-gb2312", GB2312_CHARSET,
	"-big5", CHINESEBIG5_CHARSET,
	"-jis", SHIFTJIS_CHARSET,
	NULL, DEFAULT_CHARSET
    };
    int i;
    char *p;
    if (!name)
    {
	if (lang) *lang=NULL;
	return DEFAULT_CHARSET;
    }
    else if (lang) *lang=(char *)name+strlen((char *)name);
    for (i=0; charset[i].label; i++)
	if (NULL!=(p=strstr(name, charset[i].label)))
	{
	    if (lang) *lang=p;
	    break;
	}
    return charset[i].id;
}

/* attempts to translate the font name into
** something win32 understands.
** 
*/
Font
NT_loadfont(name)
char *name;
{
    LOGFONT lf;
    HFONT hfont;
    char *p,*q,*lang;
    int size = 0;
    char buff[33];
	
    memset(&lf,0,sizeof(lf));
    lf.lfHeight = -13;
	
    lf.lfWeight = FW_NORMAL;
    lf.lfFaceName[0]='\0';
	
    lf.lfCharSet = getCharSetFromName(name,&lang);
    
    if (name && strstr(name,"-bold"))
    {
	lf.lfWeight = FW_BOLD;
    }
    for(p=name, q=buff; p&&p<=lang; p++)
    {
	if (((!*p || *p=='-') && q!=buff) || (q-buff>31))
	{
	    *q++='\0';
	    if (lf.lfFaceName[0]=='\0')
	    {
		if (isalpha(buff[0]) || IsDBCSLeadByte(buff[0]))
		    strcpy(lf.lfFaceName, buff);
		else if (isdigit(buff[0]) && ((q=strchr(buff,'x')) || (q=strchr(buff,'X'))))
		{
		    strcpy(lf.lfFaceName, "Courier New");
		    size = -atoi(q+1);
		}
		else if (size == 0 && isdigit(buff[0]))
		    size = -atoi(buff);
	    }
	    else if (size == 0 && isdigit(buff[0]))
	    {				
		size = -atoi(buff);
	    }
	    q = buff;
	}
	else
	    *q++ = *p;
	if (!*p) break;
    }
	
    if (size > 99)
	lf.lfHeight = - (size/10);
    else if (size)
	lf.lfHeight = - size;
    
    if (!strcmp(lf.lfFaceName,"lucidatypewriter"))
	strcpy(lf.lfFaceName,"Lucida Console");
    else if (lf.lfFaceName[0]=='\0'&&lf.lfCharSet==DEFAULT_CHARSET)
	strcpy(lf.lfFaceName,"Courier New");
    hfont = CreateFontIndirect(&lf);
    return (Font)hfont;
}

XFontStruct *
XLoadQueryFont(Display *display, const char *name)
{
    XFontStruct *fs;
    TEXTMETRIC tm;
    HDC hdc;
    HWND root;
    HFONT old;
    int i;
	
    xtrace("XLoadQueryFont\n");
    fs = allocateMemory(sizeof(XFontStruct));
    fs->fid = NT_loadfont(name);

    root=GetDesktopWindow();
    hdc=GetDC(root);
    old = SelectObject(hdc, (HFONT)fs->fid);
    GetTextMetrics(hdc, &tm);
    fs->min_bounds.width = tm.tmAveCharWidth;
    fs->max_bounds.width = tm.tmMaxCharWidth;
    fs->n_properties = 0;
    fs->properties = NULL;
    fs->min_char_or_byte2 =tm.tmFirstChar;
    fs->max_char_or_byte2 =tm.tmLastChar;
    fs->per_char = (XCharStruct*)allocateMemory(sizeof(XCharStruct)*(tm.tmLastChar+1));
    ZeroMemory(fs->per_char, sizeof(XCharStruct)*(tm.tmLastChar+1));

    if (!(tm.tmPitchAndFamily & TMPF_FIXED_PITCH)) {
	for (i=tm.tmFirstChar; i<=tm.tmLastChar; i++) {
	    fs->per_char[i].width = tm.tmAveCharWidth;
	    fs->per_char[i].rbearing = tm.tmAveCharWidth;
 	}
    } else if (tm.tmPitchAndFamily & TMPF_TRUETYPE) {
	for (i=tm.tmFirstChar; i<=tm.tmLastChar; i++)
	{
	    ABC abc;
	    if (!GetCharABCWidths(hdc,i,i,&abc))
	    {
		abc.abcA = 0;
		abc.abcB = tm.tmAveCharWidth;
		abc.abcC = 0;
	    }
	    fs->per_char[i].lbearing = abc.abcA;
	    fs->per_char[i].width = abc.abcB;
	    fs->per_char[i].rbearing = abc.abcB+abc.abcC;		    
	}
    } else {
	for (i=tm.tmFirstChar; i<=tm.tmLastChar; i++)
	{
	    INT fw;
	    if (!GetCharWidth(hdc,i,i,&fw))
	    {
		fw = tm.tmAveCharWidth;
	    }
	    fs->per_char[i].lbearing = 0;
	    fs->per_char[i].width = fw;
	    fs->per_char[i].rbearing = fw;
	}
    }
    if (getCharSetFromName(name,NULL) == DEFAULT_CHARSET)
    {
	int last = tm.tmLastChar;

	switch(tm.tmCharSet) {
	    case CHINESEBIG5_CHARSET:
	    case GB2312_CHARSET:
	    case SHIFTJIS_CHARSET:
		if (tm.tmLastChar > 127) last = 127;
		break;
	}

	if (last >= tm.tmFirstChar)
	{
	    fs->max_bounds = fs->per_char[last];
	    fs->min_bounds = fs->per_char[last];
	    for (i=tm.tmFirstChar; i<last; i++)
	    {
		if (fs->per_char[i].lbearing > fs->max_bounds.lbearing)
		    fs->max_bounds.lbearing = fs->per_char[i].lbearing;
		else if(fs->per_char[i].lbearing < fs->min_bounds.lbearing)
		    fs->min_bounds.lbearing = fs->per_char[i].lbearing;

		if (fs->per_char[i].width > fs->max_bounds.width)
		    fs->max_bounds.width = fs->per_char[i].width;
		else if(fs->per_char[i].width < fs->min_bounds.width)
		    fs->min_bounds.width = fs->per_char[i].width;

		if (fs->per_char[i].rbearing > fs->max_bounds.rbearing)
		    fs->max_bounds.rbearing = fs->per_char[i].rbearing;
		else if(fs->per_char[i].rbearing < fs->min_bounds.rbearing)
		    fs->min_bounds.rbearing = fs->per_char[i].rbearing;
	    }
	}
    }
    fs->ascent = tm.tmAscent;
    fs->descent= tm.tmDescent;
    SelectObject(hdc,old);
    ReleaseDC(root,hdc);
    return(fs);
}

XFontStruct *
XQueryFont(display, font_id)
Display *display;
XID     font_id;
{
	static XFontStruct fs;

	xtrace("XQueryFont\n");
	return(&fs);
}

KeySym
XKeycodeToKeysym(display, keycode, index)
Display *display;
unsigned int keycode;
int     index;
{
	xtrace("XKeycodeToKeysym\n");
	if (keycode == 254) return XK_Alt_L;
	else if (keycode == 255) return XK_Num_Lock;
	return(NoSymbol);
}
KeyCode
XKeysymToKeycode(display, keysym)
Display *display;
KeySym keysym;
{
	xtrace("XKeycodeToKeysym\n");
	if (keysym == XK_Alt_L) return 254;
	else if (keysym == XK_Num_Lock) return 255;
	return(0);
}
KeySym
XStringToKeysym(const char *str)
{
	xtrace("XStringToKeysym\n");
	return(NoSymbol);
}

XModifierKeymap *
XGetModifierMapping(display)
Display *display;
{
	XModifierKeymap *map = NULL;
	xtrace("XGetModifierMapping\n");
	map = (XModifierKeymap *)allocateMemory(sizeof(XModifierKeymap));
	map->max_keypermod = 1;
	map->modifiermap = (KeyCode *)allocateMemory(sizeof(KeyCode)*8);
	map->modifiermap[0]=0;
	map->modifiermap[1]=0;
	map->modifiermap[2]=0;
	map->modifiermap[3]=XKeysymToKeycode(display,XK_Alt_L);
	map->modifiermap[4]=0;
	map->modifiermap[5]=0;
	map->modifiermap[6]=0;
	map->modifiermap[7]=XKeysymToKeycode(display,XK_Num_Lock);
	return(map);
}
int
XFreeModifiermap(XModifierKeymap *modmap)
{
	xtrace("XFreeModifiermap\n");
	freeMemory(modmap->modifiermap);
	freeMemory(modmap);
	return 0;
}


int
XSetFont(display,gc,font)
Display *display;
GC gc;
Font font;
{
	xtrace("XSetFont\n");
	gc->values.font = font;
	return 0;
}


int
XSetFontPath(display,dirs,nd)
Display *display;
char **dirs;
int nd;
{
	xtrace("XSetFontPath\n");
	return 0;
}


/*****************************************************************\

	Function: XTextExtents
	Inputs:   font structure, string, string length.
	Returned: writing direction, max ascent, max descent, font overall
		  characteristics.

	Comments: The design of windows fonts is similar to X, as far as
		  ascent and descent are concerned.  However, they are
		  positioned differently on the screen (see XDrawText).

\*****************************************************************/

static HDC desktopHDC;
static int firstTE = TRUE;
int
XTextExtents(fstruct,str,nc,dir,ascent,descent,overall)
XFontStruct *fstruct;
const char *str;
int nc;
int *dir,*ascent,*descent;
XCharStruct *overall;
{
	TEXTMETRIC tmet;
	HDC hdc;
	SIZE tsize;
	HWND desktop;
	HFONT old;
	
	xtrace("XTextExtents\n");
	if (firstTE)
	{
		firstTE = FALSE;
		desktop=GetDesktopWindow();
		desktopHDC=GetDC(desktop);
	}
	hdc = desktopHDC;
	old = SelectObject(hdc, (HFONT)fstruct->fid);
	GetTextMetrics(hdc,&tmet);
	GetTextExtentPoint(hdc,str,nc,&tsize);
	*dir=FontLeftToRight;
	*ascent=tmet.tmAscent + 1;
	*descent=tmet.tmDescent;
	overall->ascent=(short)(tmet.tmAscent + 1);
	overall->descent=(short)tmet.tmDescent;
	overall->width=(short)tsize.cx;
	overall->lbearing=0;
	overall->rbearing=(short)tsize.cx;
	/* cjh_rel_dc(desktop,hdc);*/
	SelectObject(hdc,old);
	return 0;
}


int
XTextExtents16(fstruct,str,nc,dir,ascent,descent,overall)
XFontStruct *fstruct;
const XChar2b *str;
int nc;
int *dir,*ascent,*descent;
XCharStruct *overall;
{
	xtrace("XTextExtents16\n");
	return 0;
}


/*****************************************************************\


	Function: XTextWidth
	Inputs:   font structure, string, length of string.
	Returned: String width in pixels.

	Comments:

\*****************************************************************/

int
XTextWidth(fstruct,str,co)
XFontStruct *fstruct;
const char *str;
int co;
{
	HDC hdc;
	SIZE tsize;
	HWND root;
	HFONT old;
	xtrace("XTextWidth\n");

	if(firstTE)
	{
		firstTE = FALSE;
		root=GetDesktopWindow();
		hdc=GetDC(root);
	}
	old = SelectObject(hdc, (HFONT)fstruct->fid);
	GetTextExtentPoint(hdc,str,co,&tsize);
	SelectObject(hdc,old);
	/*cjh_rel_dc(root,hdc);*/
	return (tsize.cx);
}


int
XTextWidth16(fstruct,str,co)
XFontStruct *fstruct;
const XChar2b *str;
int co;
{
	xtrace("XTextWidth16\n");
	return 0;
}


int
XGetErrorDatabaseText(display,name,msg,defstr,buf,len)
Display *display;
const char *name,*msg;
const char *defstr;
char *buf;
int len;
{
	static char def_err[]="Errors not implemented";
	int n;

	xtrace("XGetErrorDatabaseText\n");
	while (n<len && def_err[n] != 0)
		*(buf+n)=def_err[n++];
	*(buf+n)=0;
	return 0;
}


int
XGetErrorText(display,code,buf,len)
Display *display;
int code;
char *buf;
int len;
{
	xtrace("XGetErrorText\n");
	return 0;
}


XErrorHandler
XSetErrorHandler(handler)
XErrorHandler handler;
{
	xtrace("XSetErrorHandler\n");
	return 0;
}


/*****************************************************************\


	Function: XDefaultScreen
	Inputs:   display
	Returned: default screen number

	Comments:

\*****************************************************************/

int
XDefaultScreen(display)
Display *display;
{
	xtrace("XDefaultScreen\n");
	return (display->default_screen);
}

Visual *
XDefaultVisual(display, screen)
Display *display;
int screen;
{
	xtrace("XDefaultVisual\n");
	return DefaultVisual(display, screen);
}
int
XDefaultDepth(display, screen)
Display *display;
int screen;
{
	xtrace("XDefaultDepth\n");
	return DefaultDepth(display, screen);
}
Colormap
XDefaultColormap(display, screen)
Display *display;
int screen;
{
	xtrace("XDefaultColormap\n");
	return DefaultColormap(display, screen);
}


/*****************************************************************\


	Function: XScreenOfDisplay
	Inputs:   display,screen number
	Returned: screen list.

	Comments:

\*****************************************************************/

Screen *
XScreenOfDisplay(display,scr)
Display *display;
int scr;
{
	xtrace("XScreenOfDisplay\n");
	return (display->screens);
}


Cursor
XCreateFontCursor(display,shape)
Display *display;
unsigned int shape;
{
	xtrace("XCreateFontCursor\n");
	return 0;
}


int
XRecolorCursor(display,cursor,fg,bg)
Display *display;
Cursor cursor;
XColor *fg,*bg;
{
	xtrace("XRecolorCursor\n");
	return 0;
}


/*****************************************************************\


	Function: XWarpPointer
	Inputs:   display, source window, destination window, source window
		  geometry, destination x, y.

	Comments: Not knowingly tested.

\*****************************************************************/

int
XWarpPointer(display,sw,dw,sx,sy,swidth,sheight,dx,dy)
Display *display;
Window sw,dw;
int sx,sy;
unsigned int swidth,sheight;
int dx,dy;
{
	NT_window *ntsw=(NT_window *)sw;
	NT_window *ntdw=(NT_window *)dw;

	POINT cpt,tmp;
	RECT srct;
	HDC hDC;

	xtrace("XWarpPointer\n");
	GetCursorPos(&cpt);
	if (ntsw==None)
	{
		if (ntdw==None)
			SetCursorPos(dx,dy);
		else
		{
			tmp.x=dx;
			tmp.y=dy;
			ClientToScreen(ntdw->w,&tmp);
			SetCursorPos(tmp.x,tmp.y);
		}
	}
	else
	{
		GetWindowRect(ntsw->w,&srct);
		tmp.x=sx;
		tmp.y=sy;
		ClientToScreen(ntsw->w,&tmp);
		if (swidth==0)
			swidth=srct.right-sx;
		if (sheight==0)
			sheight=srct.bottom-sy;
		hDC = cjh_get_dc(ntdw);
		if (cpt.x>=tmp.x && cpt.x<tmp.x+(int)swidth &&
		    cpt.y>=tmp.y && cpt.y<tmp.y+(int)sheight &&
		    PtVisible(hDC,cpt.x,cpt.y))
		{
			if (ntdw==None)
				SetCursorPos(cpt.x+dx,cpt.y+dy);
			else
			{
				tmp.x=dx;
				tmp.y=dy;
				ClientToScreen(ntdw->w,&tmp);
				SetCursorPos(tmp.x,tmp.y);
			}
		}
		cjh_rel_dc(ntdw,hDC);
	}
	return 0;
}


/*****************************************************************\


	Function: XBell
	Inputs:   display, percent loudness.

	Comments: Don't throw awa