/*
 * -- $Header: /cec/src/nestor/servers/R3/shXlib/XFont.c,v 1.1.1.1 90/04/23 09:57:20 spanachi Exp $
 */

#include "copyright.h"

/* $XConsortium: XFont.c,v 11.26 88/09/06 16:05:50 jim Exp $ */
/* Copyright    Massachusetts Institute of Technology    1986	*/

/* -- MULTIPLEX Extension -- */

#define NEED_REPLIES
#include "Xlibint.h"

/* additional includes -- */
#include "resources.h"
#include "utils.h"
#include "map.h"

XFontStruct *_XQueryFont();

XFontStruct *XLoadQueryFont(calling_dpy, name)
   /* -- must rename or else macro GetReq will fail -- */
   register Display *calling_dpy;
   char *name;
{
    XFontStruct *font_result, *def_result ;
    register long nbytes;
    Font fid;
    xOpenFontReq *req;

    /* -- additional vars -- */
    register Display *dpy ;
    register int      i , ok ;

    /* -- Flush the queue to keep buffers aligned -- */
    XmuXFlushDefault( calling_dpy ) ;

    /* 
     * -- XLoadQueryFont creates a new resource; 
     * -- we loop here to detect an error
     */
    ok = True ;
    for( i = 0 ; 
	 ( dpy = XmuXGetDisplay( calling_dpy , i ) ) != NULL && ok ; i++ )
    {
	LockDisplay(dpy);
	GetReq(OpenFont, req);
	nbytes = req->nbytes  = name ? strlen(name) : 0;
	req->fid = fid = XAllocID(dpy);
	req->length += (nbytes+3)>>2;
	Data (dpy, name, nbytes);
	dpy->request--;
	font_result = (_XQueryFont(dpy, fid));
	dpy->request++;
	if (!font_result) 
	{
	    /* if _XQueryFont returned NULL, then the OpenFont request got
	       a BadName error.  This means that the following QueryFont
	       request is guaranteed to get a BadFont error, since the id
	       passed to QueryFont wasn't really a valid font id.  To read
	       and discard this second error, we call _XReply again. */
	    xReply reply;
	    (void) _XReply (dpy, &reply, 0, xFalse);
	    ok = False ;
	}
	else
	    /* 
	     * -- On success : store the new resource if it necessary 
	     */
	    if( XmuXStoreResources( dpy ) )
		XmuXInsertFontInfo( dpy , fid , name ) ;
	if( dpy == calling_dpy )
	    def_result = font_result ;
	UnlockDisplay(dpy);
	SyncHandle();
    }
    
    return(  ok ? def_result : ( XFontStruct * ) NULL ) ;
}

XFreeFont(dpy, fs)
    register Display *dpy;
    XFontStruct *fs;
{ 
    register xResourceReq *req;
    register _XExtension *ext = dpy->ext_procs;

    LockDisplay(dpy);
    while (ext) {		/* call out to any extensions interested */
	if (ext->free_Font != NULL) (*ext->free_Font)(dpy, fs, &ext->codes);
	ext = ext->next;
	}    
    GetResReq (CloseFont, fs->fid, req);
    _XFreeExtData(fs->ext_data);
    if (fs->per_char)
       Xfree ((char *) fs->per_char);
    if (fs->properties)
       Xfree ((char *) fs->properties);
    ext = dpy->ext_procs;
    /* 
     * -- remove the resource info 
     */
    if( XmuXStoreResources( dpy ) )
	XmuXRemoveFontInfo( dpy , fs->fid ) ;
    Xfree ((char *) fs);
    UnlockDisplay(dpy);
    SyncHandle();
}


XFontStruct *_XQueryFont (dpy, fid)	/* Internal-only entry point */
    register Display *dpy;
    Font fid;

{
    register XFontStruct *fs;
    register long nbytes;
    xQueryFontReply reply;
    register xResourceReq *req;
    register _XExtension *ext;

    GetResReq(QueryFont, fid, req);
    if (!_XReply (dpy, (xReply *) &reply,
       ((SIZEOF(xQueryFontReply) - SIZEOF(xReply)) >> 2), xFalse))
	   return (NULL);
    fs = (XFontStruct *) Xmalloc (sizeof (XFontStruct));
    fs->ext_data 		= NULL;
    fs->fid 			= fid;
    fs->direction 		= reply.drawDirection;
    fs->min_char_or_byte2	= reply.minCharOrByte2;
    fs->max_char_or_byte2 	= reply.maxCharOrByte2;
    fs->min_byte1 		= reply.minByte1;
    fs->max_byte1 		= reply.maxByte1;
    fs->default_char 		= reply.defaultChar;
    fs->all_chars_exist 	= reply.allCharsExist;
    fs->ascent 			= cvtINT16toInt (reply.fontAscent);
    fs->descent 		= cvtINT16toInt (reply.fontDescent);
    
#ifdef MUSTCOPY
    {
	xCharInfo *xcip;

	xcip = (xCharInfo *) &reply.minBounds;
	fs->min_bounds.lbearing = xcip->leftSideBearing;
	fs->min_bounds.rbearing = xcip->rightSideBearing;
	fs->min_bounds.width = xcip->characterWidth;
	fs->min_bounds.ascent = xcip->ascent;
	fs->min_bounds.descent = xcip->descent;
	fs->min_bounds.attributes = xcip->attributes;

	xcip = (xCharInfo *) &reply.maxBounds;
	fs->max_bounds.lbearing = xcip->leftSideBearing;
	fs->max_bounds.rbearing = xcip->rightSideBearing;
	fs->max_bounds.width = xcip->characterWidth;
	fs->max_bounds.ascent = xcip->ascent;
	fs->max_bounds.descent = xcip->descent;
	fs->max_bounds.attributes = xcip->attributes;
    }
#else
    /* XXX the next two statements won't work if short isn't 16 bits */
    fs->min_bounds = * (XCharStruct *) &reply.minBounds;
    fs->max_bounds = * (XCharStruct *) &reply.maxBounds;
#endif /* MUSTCOPY */

    fs->n_properties = reply.nFontProps;
    /* 
     * if no properties defined for the font, then it is bad
     * font, but shouldn't try to read nothing.
     */
    fs->properties = NULL;
    if (fs->n_properties > 0) {
	    nbytes = reply.nFontProps * sizeof(XFontProp);
	    fs->properties = (XFontProp *) Xmalloc (nbytes);
	    nbytes = reply.nFontProps * SIZEOF(xFontProp);
	    _XRead32 (dpy, (char *)fs->properties, nbytes);
    }
    /*
     * If no characters in font, then it is a bad font, but
     * shouldn't try to read nothing.
     */
    /* have to unpack charinfos on some machines (CRAY) */
    fs->per_char = NULL;
    if (reply.nCharInfos > 0){
	    nbytes = reply.nCharInfos * sizeof(XCharStruct);
	    fs->per_char = (XCharStruct *) Xmalloc (nbytes);
	    nbytes = reply.nCharInfos * SIZEOF(xCharInfo);
	    _XRead16 (dpy, (char *)fs->per_char, nbytes);
    }

    ext = dpy->ext_procs;
    while (ext) {		/* call out to any extensions interested */
	if (ext->create_Font != NULL) 
		(*ext->create_Font)(dpy, fs, &ext->codes);
	ext = ext->next;
	}    
    return (fs);
}


XFontStruct *XQueryFont (dpy, fid)
    register Display *dpy;
    Font fid;
{
    XFontStruct *font_result;

    LockDisplay(dpy);
    font_result = _XQueryFont(dpy, fid );
    UnlockDisplay(dpy);
    SyncHandle();
    return font_result;
}