#define MIN(a,b) ((a)<(b)?(a):(b))
#endif
#define TimeCmp(a,c,b) ((int) ((a) - (b)) c 0)
-
+
#define NONZEROMETRICS(pci) ((pci)->leftSideBearing || \
(pci)->rightSideBearing || \
(pci)->ascent || \
static int fs_read_glyphs ( FontPathElementPtr fpe, FSBlockDataPtr blockrec );
static int fs_read_list ( FontPathElementPtr fpe, FSBlockDataPtr blockrec );
-static int fs_read_list_info ( FontPathElementPtr fpe,
+static int fs_read_list_info ( FontPathElementPtr fpe,
FSBlockDataPtr blockrec );
extern fd_set _fs_fd_mask;
-static void fs_block_handler ( pointer data, OSTimePtr wt,
+static void fs_block_handler ( pointer data, OSTimePtr wt,
pointer LastSelectMask );
static int fs_wakeup ( FontPathElementPtr fpe, unsigned long *mask );
/*
- * List of all FPEs
+ * List of all FPEs
*/
static FSFpePtr fs_fpes;
/*
static CARD32 fs_blockState;
static int _fs_restart_connection ( FSFpePtr conn );
-static void fs_send_query_bitmaps ( FontPathElementPtr fpe,
+static void fs_send_query_bitmaps ( FontPathElementPtr fpe,
FSBlockDataPtr blockrec );
static int fs_send_close_font ( FontPathElementPtr fpe, Font id );
static void fs_client_died ( pointer client, FontPathElementPtr fpe );
}
}
-/*
+/*
* close font server and remove any state associated with
* this connection - this includes any client records.
*/
FSClientPtr client, nclient;
_fs_close_server (conn);
-
- for (client = conn->clients; client; client = nclient)
+
+ for (client = conn->clients; client; client = nclient)
{
nclient = client->next;
free (client);
err = Successful;
}
}
-
+
if (err == Successful)
{
#ifdef NCD
fs_free_fpe(FontPathElementPtr fpe)
{
FSFpePtr conn = (FSFpePtr) fpe->private, *prev;
-
+
/* unhook from chain of all font servers */
for (prev = &fs_fpes; *prev; prev = &(*prev)->next)
{
blockrec->type = type;
blockrec->depending = 0;
blockrec->next = (FSBlockDataPtr) 0;
-
+
/* stick it on the end of the list (since its expected last) */
for (prev = &conn->blockedRequests; *prev; prev = &(*prev)->next)
;
_fs_set_pending_reply (FSFpePtr conn)
{
FSBlockDataPtr blockrec;
-
+
for (blockrec = conn->blockedRequests; blockrec; blockrec = blockrec->next)
if (blockrec->errcode == StillWorking)
break;
FSBlockDataPtr *prev;
for (prev = &conn->blockedRequests; *prev; prev = &(*prev)->next)
- if (*prev == blockrec)
+ if (*prev == blockrec)
{
*prev = blockrec->next;
break;
_fs_signal_clients_depending(FSClientsDependingPtr *clients_depending)
{
FSClientsDependingPtr p;
-
+
while ((p = *clients_depending))
{
*clients_depending = p->next;
_fs_add_clients_depending(FSClientsDependingPtr *clients_depending, pointer client)
{
FSClientsDependingPtr new, cd;
-
- for (; (cd = *clients_depending);
+
+ for (; (cd = *clients_depending);
clients_depending = &(*clients_depending)->next)
{
- if (cd->client == client)
+ if (cd->client == client)
return Suspended;
}
-
+
new = malloc (sizeof (FSClientsDependingRec));
if (!new)
return BadAlloc;
switch(blockrec->type) {
case FS_OPEN_FONT: {
FSBlockedFontPtr bfont = (FSBlockedFontPtr)blockrec->data;
-
+
fs_cleanup_bfont (bfont);
_fs_signal_clients_depending(&bfont->clients_depending);
break;
}
case FS_LOAD_GLYPHS: {
FSBlockedGlyphPtr bglyph = (FSBlockedGlyphPtr)blockrec->data;
-
+
_fs_clean_aborted_loadglyphs(bglyph->pfont,
bglyph->num_expected_ranges,
- bglyph->expected_ranges);
+ bglyph->expected_ranges);
_fs_signal_clients_depending(&bglyph->clients_depending);
break;
}
if (bfont->pfont)
{
fsd = (FSFontDataRec *) bfont->pfont->fpePrivate;
-
+
/* make sure the FS knows we choked on it */
fs_send_close_font(bfont->pfont->fpe, bfont->fontid);
-
+
/*
- * Either unload the font if it's being opened for
+ * Either unload the font if it's being opened for
* the first time, or smash the generation field to
* mark this font as an orphan
*/
*error = FSIO_BLOCK;
return 0;
}
-
+
ret = _fs_start_read (conn, sizeof (fsGenericReply), &buf);
if (ret != FSIO_READY)
{
*error = FSIO_BLOCK;
return 0;
}
-
+
rep = (fsGenericReply *) buf;
ret = _fs_start_read (conn, rep->length << 2, &buf);
}
*error = FSIO_READY;
-
+
return (fsGenericReply *) buf;
}
fs_reply_ready (FSFpePtr conn)
{
fsGenericReply *rep;
-
+
if (conn->fs_fd == -1 || !FD_ISSET (conn->fs_fd, &_fs_fd_mask))
return FALSE;
if (fs_data_read (conn) < sizeof (fsGenericReply))
fs_await_reply (FSFpePtr conn)
{
int ret;
-
+
if (conn->blockState & FS_COMPLETE_REPLY)
return FSIO_READY;
-
+
while (!fs_get_reply (conn, &ret))
{
if (ret != FSIO_BLOCK)
fs_cleanup_bfont (bfont);
return BadFontName;
}
-
+
/* If we're not reopening a font and FS detected a duplicate font
open request, replace our reference to the new font with a
reference to an existing font (possibly one not finished
if we we decide (in fs_read_query_info()) that we don't like what
we got. */
- if (rep->otherid && !(bfont->flags & FontReopen))
+ if (rep->otherid && !(bfont->flags & FontReopen))
{
fs_cleanup_bfont (bfont);
-
+
/* Find old font if we're completely done getting it from server. */
bfont->pfont = find_old_font(rep->otherid);
bfont->freeFont = FALSE;
*/
for (blockOrig = conn->blockedRequests;
blockOrig;
- blockOrig = blockOrig->next)
+ blockOrig = blockOrig->next)
{
- if (blockOrig != blockrec && blockOrig->type == FS_OPEN_FONT)
+ if (blockOrig != blockrec && blockOrig->type == FS_OPEN_FONT)
{
origBfont = (FSBlockedFontPtr) blockOrig->data;
- if (origBfont->fontid == rep->otherid)
+ if (origBfont->fontid == rep->otherid)
{
blockrec->depending = blockOrig->depending;
blockOrig->depending = blockrec;
fs_fonts_match (FontInfoPtr pInfo1, FontInfoPtr pInfo2)
{
int i;
-
+
if (pInfo1->firstCol != pInfo2->firstCol ||
pInfo1->lastCol != pInfo2->lastCol ||
pInfo1->firstRow != pInfo2->firstRow ||
fs_cleanup_bfont (bfont);
return BadFontName;
}
-
+
/* If this is a reopen, accumulate the query info into a dummy
font and compare to our original data. */
if (bfont->flags & FontReopen)
buf = (char *) rep;
buf += SIZEOF(fsQueryXInfoReply);
-
+
/* move the data over */
fsUnpack_XFontInfoHeader(rep, pInfo);
-
+
/* compute accelerators */
_fs_init_fontinfo(conn, pInfo);
/* Compute offsets into the reply */
pi = (fsPropInfo *) buf;
buf += SIZEOF (fsPropInfo);
-
+
po = (fsPropOffset *) buf;
buf += pi->num_offsets * SIZEOF(fsPropOffset);
pd = (pointer) buf;
buf += pi->data_len;
-
+
/* convert the properties and step over the reply */
ret = _fs_convert_props(pi, po, pd, pInfo);
_fs_done_read (conn, rep->length << 2);
-
+
if (ret == -1)
{
fs_cleanup_bfont (bfont);
err = BadFontName;
}
_fs_free_props (pInfo);
-
+
return err;
}
* Figure out if the whole font should get loaded right now.
*/
if (glyphCachingMode == CACHING_OFF ||
- (glyphCachingMode == CACHE_16_BIT_GLYPHS
+ (glyphCachingMode == CACHE_16_BIT_GLYPHS
&& !bfont->pfont->info.lastRow))
{
bfont->flags |= FontLoadAll;
}
-
+
/*
- * Ready to send the query bitmaps; the terminal font bit has
+ * Ready to send the query bitmaps; the terminal font bit has
* been computed and glyphCaching has been considered
*/
if (bfont->flags & FontLoadBitmaps)
*/
blockrec->sequenceNumber = bfont->queryExtentsSequence;
conn->blockedReplyTime = GetTimeInMillis () + FontServerRequestTimeout;
-
+
return StillWorking;
}
fs_cleanup_bfont (bfont);
return BadFontName;
}
-
+
/* move the data over */
/* need separate inkMetrics for fixed font server protocol version */
numExtents = rep->num_extents;
}
ci = pCI = malloc(sizeof(CharInfoRec) * numInfos);
- if (!pCI)
+ if (!pCI)
{
_fs_done_read (conn, rep->length << 2);
fs_cleanup_bfont(bfont);
buf = (char *) rep;
buf += SIZEOF (fsQueryXExtents16Reply);
fsci = buf;
-
+
fsd->glyphs_to_get = 0;
ci = fsfont->inkMetrics;
- for (i = 0; i < numExtents; i++)
+ for (i = 0; i < numExtents; i++)
{
memcpy(&fscilocal, fsci, SIZEOF(fsXCharInfo)); /* align it */
_fs_convert_char_info(&fscilocal, &ci->metrics);
/* Done with reply */
_fs_done_read (conn, rep->length << 2);
-
+
/* build bitmap metrics, ImageRectMax style */
if (haveInk)
{
}
bfont->state = FS_GLYPHS_REPLY;
- if (bfont->flags & FontLoadBitmaps)
+ if (bfont->flags & FontLoadBitmaps)
{
/*
* Reset the blockrec for the next reply
#ifdef DEBUG
fprintf (stderr, "fs_do_open_font state %s %s\n",
- fs_open_states[bfont->state],
+ fs_open_states[bfont->state],
((FSFontDataPtr) (bfont->pfont->fpePrivate))->name);
#endif
err = BadFontName;
#ifdef DEBUG
fprintf (stderr, "fs_do_open_font err %d\n", err);
#endif
- if (err != StillWorking)
+ if (err != StillWorking)
{
bfont->state = FS_DONE_REPLY; /* for _fs_load_glyphs() */
- while ((blockrec = blockrec->depending))
+ while ((blockrec = blockrec->depending))
{
bfont = (FSBlockedFontPtr) blockrec->data;
bfont->state = FS_DONE_REPLY; /* for _fs_load_glyphs() */
_fs_unmark_block (FSFpePtr conn, CARD32 mask)
{
FSFpePtr c;
-
+
if (conn->blockState & mask)
{
conn->blockState &= ~mask;
int soonest;
FSFpePtr conn;
- XFD_ORSET((fd_set *)LastSelectMask, (fd_set *)LastSelectMask,
+ XFD_ORSET((fd_set *)LastSelectMask, (fd_set *)LastSelectMask,
&_fs_fd_mask);
/*
* Flush all pending output
static void
fs_handle_unexpected(FSFpePtr conn, fsGenericReply *rep)
{
- if (rep->type == FS_Event && rep->data1 == KeepAlive)
+ if (rep->type == FS_Event && rep->data1 == KeepAlive)
{
fsNoopReq req;
int ret;
int err;
fsGenericReply *rep;
-
+
if ((rep = fs_get_reply (conn, &ret)))
{
_fs_add_rep_log (conn, rep);
- for (blockrec = conn->blockedRequests;
- blockrec;
- blockrec = blockrec->next)
+ for (blockrec = conn->blockedRequests;
+ blockrec;
+ blockrec = blockrec->next)
{
if (blockrec->sequenceNumber == rep->sequenceNumber)
break;
}
err = Successful;
- if (!blockrec)
+ if (!blockrec)
{
fs_handle_unexpected(conn, rep);
}
else
{
- /*
- * go read it, and if we're done,
- * wake up the appropriate client
+ /*
+ * go read it, and if we're done,
+ * wake up the appropriate client
*/
switch (blockrec->type) {
case FS_OPEN_FONT:
err = blockrec->errcode;
if (err != StillWorking)
{
- while (blockrec)
+ while (blockrec)
{
blockrec->errcode = err;
if (client != blockrec->client)
fd_set *LastSelectMask = (fd_set *) mask;
FSFpePtr conn = (FSFpePtr) fpe->private;
- /*
+ /*
* Don't continue if the fd is -1 (which will be true when the
* font server terminates
*/
blockrec->errcode,
blockrec->sequenceNumber,
fs_open_states[bfont->state],
- bfont->pfont ?
+ bfont->pfont ?
((FSFontDataPtr) (bfont->pfont->fpePrivate))->name :
"<freed>");
break;
}
}
}
-#endif
+#endif
return FALSE;
}
FSBlockDataPtr block;
_fs_unmark_block (conn, FS_GIVE_UP);
- while ((block = (FSBlockDataPtr) conn->blockedRequests))
+ while ((block = (FSBlockDataPtr) conn->blockedRequests))
{
if (block->errcode == StillWorking)
{
fprintf (stderr, "give up on FS \"%s\"\n", conn->servername);
#endif
_fs_mark_block (conn, FS_GIVE_UP);
- while ((block = (FSBlockDataPtr) conn->blockedRequests))
+ while ((block = (FSBlockDataPtr) conn->blockedRequests))
{
if (block->errcode == StillWorking)
{
{
_fs_giveup (conn);
}
- else
+ else
{
if (conn->blockState & FS_BROKEN_CONNECTION)
{
*/
/* ARGSUSED */
static int
-fs_send_open_font(pointer client, FontPathElementPtr fpe, Mask flags,
- char *name, int namelen,
- fsBitmapFormat format, fsBitmapFormatMask fmask,
+fs_send_open_font(pointer client, FontPathElementPtr fpe, Mask flags,
+ char *name, int namelen,
+ fsBitmapFormat format, fsBitmapFormatMask fmask,
XID id, FontPtr *ppfont)
{
FSFpePtr conn = (FSFpePtr) fpe->private;
if (conn->blockState & FS_GIVE_UP)
return BadFontName;
-
+
if (namelen <= 0 || namelen > sizeof (buf) - 1)
return BadFontName;
-
+
/*
* Get the font structure put together, either by reusing
* the existing one or creating a new one
font = fs_create_font (fpe, name, namelen, format, fmask);
if (!font)
return AllocError;
-
+
fsd = (FSFontDataPtr)font->fpePrivate;
}
-
+
/* make a new block record, and add it to the end of the list */
blockrec = fs_new_block_rec(font->fpe, client, FS_OPEN_FONT);
if (!blockrec)
(*font->unload_font) (font);
return AllocError;
}
-
+
/*
* Must check this before generating any protocol, otherwise we'll
* mess up a reconnect in progress
_fs_pending_reply (conn);
return Suspended;
}
-
+
fsd->generation = conn->generation;
bfont = (FSBlockedFontPtr) blockrec->data;
_fs_write_pad(conn, (char *) buf, namelen + 1);
blockrec->sequenceNumber = conn->current_seq;
-
+
inforeq.reqType = FS_QueryXInfo;
inforeq.pad = 0;
inforeq.id = fsd->fontid;
inforeq.length = SIZEOF(fsQueryXInfoReq) >> 2;
bfont->queryInfoSequence = conn->current_seq + 1;
-
+
_fs_add_req_log(conn, FS_QueryXInfo);
_fs_write(conn, (char *) &inforeq, SIZEOF(fsQueryXInfoReq));
-
+
if (!(bfont->flags & FontReopen))
{
extreq.reqType = FS_QueryXExtents16;
extreq.fid = fsd->fontid;
extreq.num_ranges = 0;
extreq.length = SIZEOF(fsQueryXExtents16Req) >> 2;
-
+
bfont->queryExtentsSequence = conn->current_seq + 1;
-
+
_fs_add_req_log(conn, FS_QueryXExtents16);
_fs_write(conn, (char *) &extreq, SIZEOF(fsQueryXExtents16Req));
}
-
+
#ifdef NCD
- if (configData.ExtendedFontDiags)
+ if (configData.ExtendedFontDiags)
{
memcpy(buf, name, MIN(256, namelen));
buf[MIN(256, namelen)] = '\0';
}
#endif
_fs_prepare_for_reply (conn);
-
+
err = blockrec->errcode;
if (bfont->flags & FontOpenSync)
{
bitreq.num_ranges = 0;
bfont->queryBitmapsSequence = conn->current_seq + 1;
-
+
_fs_add_req_log(conn, FS_QueryXBitmaps16);
_fs_write(conn, (char *) &bitreq, SIZEOF(fsQueryXBitmaps16Req));
}
/* ARGSUSED */
static int
-fs_open_font(pointer client, FontPathElementPtr fpe, Mask flags,
- char *name, int namelen,
- fsBitmapFormat format, fsBitmapFormatMask fmask,
+fs_open_font(pointer client, FontPathElementPtr fpe, Mask flags,
+ char *name, int namelen,
+ fsBitmapFormat format, fsBitmapFormatMask fmask,
XID id, FontPtr *ppfont,
char **alias, FontPtr non_cachable_font)
{
*alias = (char *) 0;
for (blockrec = conn->blockedRequests; blockrec; blockrec = blockrec->next)
{
- if (blockrec->type == FS_OPEN_FONT && blockrec->client == client)
+ if (blockrec->type == FS_OPEN_FONT && blockrec->client == client)
{
err = blockrec->errcode;
if (err == StillWorking)
return Suspended;
-
+
bfont = (FSBlockedFontPtr) blockrec->data;
if (err == Successful)
*ppfont = bfont->pfont;
}
off_adr = (char *)ppbits;
-
+
allbits = fs_alloc_glyphs (pfont, rep->nbytes);
-
+
if (!allbits)
{
err = AllocError;
goto bail;
}
-
+
#ifdef DEBUG
origallbits = allbits;
fprintf (stderr, "Reading %d glyphs in %d bytes for %s\n",
(int) rep->num_chars, (int) rep->nbytes, fsd->name);
#endif
-
+
for (i = 0; i < rep->num_chars; i++)
{
memcpy(&local_off, off_adr, SIZEOF(fsOffset32)); /* align it */
}
static int
-fs_send_load_glyphs(pointer client, FontPtr pfont,
+fs_send_load_glyphs(pointer client, FontPtr pfont,
int nranges, fsRange *ranges)
{
FontPathElementPtr fpe = pfont->fpe;
if (conn->blockState & FS_GIVE_UP)
return BadCharRange;
-
+
/* make a new block record, and add it to the end of the list */
blockrec = fs_new_block_rec(fpe, client, FS_LOAD_GLYPHS);
if (!blockrec)
_fs_pending_reply (conn);
return Suspended;
}
-
+
/* send the request */
req.reqType = FS_QueryXBitmaps16;
req.fid = ((FSFontDataPtr) pfont->fpePrivate)->fontid;
_fs_write(conn, (char *) &req, SIZEOF(fsQueryXBitmaps16Req));
blockrec->sequenceNumber = conn->current_seq;
-
+
/* Send ranges to the server... pack into a char array by hand
to avoid structure-packing portability problems and to
handle swapping for version1 protocol */
client values. */
static int
-_fs_load_glyphs(pointer client, FontPtr pfont, Bool range_flag,
+_fs_load_glyphs(pointer client, FontPtr pfont, Bool range_flag,
unsigned int nchars, int item_size, unsigned char *data)
{
FSFpePtr conn = (FSFpePtr) pfont->fpe->private;
err = blockrec->errcode;
if (err == StillWorking)
return Suspended;
-
+
_fs_signal_clients_depending(&bfont->clients_depending);
_fs_remove_block_rec(conn, blockrec);
if (err != Successful)
err = Successful;
/* copy data into FontPathRecord */
- for (i = 0; i < rep->nFonts; i++)
+ for (i = 0; i < rep->nFonts; i++)
{
length = *(unsigned char *)data++;
err = AddFontNamesName(blist->names, data, length);
}
static int
-fs_send_list_fonts(pointer client, FontPathElementPtr fpe, char *pattern,
+fs_send_list_fonts(pointer client, FontPathElementPtr fpe, char *pattern,
int patlen, int maxnames, FontNamesPtr newnames)
{
FSFpePtr conn = (FSFpePtr) fpe->private;
if (conn->blockState & FS_GIVE_UP)
return BadFontName;
-
+
/* make a new block record, and add it to the end of the list */
blockrec = fs_new_block_rec(fpe, client, FS_LIST_FONTS);
if (!blockrec)
_fs_pending_reply (conn);
return Suspended;
}
-
+
_fs_client_access (conn, client, FALSE);
_fs_client_resolution(conn);
_fs_write_pad(conn, (char *) pattern, patlen);
blockrec->sequenceNumber = conn->current_seq;
-
+
#ifdef NCD
if (configData.ExtendedFontDiags) {
char buf[256];
}
static int
-fs_list_fonts(pointer client, FontPathElementPtr fpe,
+fs_list_fonts(pointer client, FontPathElementPtr fpe,
char *pattern, int patlen, int maxnames, FontNamesPtr newnames)
{
FSFpePtr conn = (FSFpePtr) fpe->private;
/* see if the result is already there */
for (blockrec = conn->blockedRequests; blockrec; blockrec = blockrec->next)
{
- if (blockrec->type == FS_LIST_FONTS && blockrec->client == client)
+ if (blockrec->type == FS_LIST_FONTS && blockrec->client == client)
{
err = blockrec->errcode;
if (err == StillWorking)
}
buf = (char *) rep + SIZEOF (fsListFontsWithXInfoReply);
-
+
/*
* The original FS implementation didn't match
* the spec, version 1 was respecified to match the FS.
binfo->remaining = rep->nReplies;
binfo->status = FS_LFWI_REPLY;
-
+
/* disable this font server until we've processed this response */
_fs_unmark_block (conn, FS_COMPLETE_REPLY);
FD_CLR(conn->fs_fd, &_fs_fd_mask);
-done:
+done:
_fs_done_read (conn, rep->length << 2);
return err;
}
/* ARGSUSED */
static int
-fs_start_list_with_info(pointer client, FontPathElementPtr fpe,
+fs_start_list_with_info(pointer client, FontPathElementPtr fpe,
char *pattern, int len, int maxnames, pointer *pdata)
{
FSFpePtr conn = (FSFpePtr) fpe->private;
blockrec = fs_new_block_rec(fpe, client, FS_LIST_WITH_INFO);
if (!blockrec)
return AllocError;
-
+
binfo = (FSBlockedListInfoPtr) blockrec->data;
bzero((char *) binfo, sizeof(FSBlockedListInfoRec));
binfo->status = FS_LFWI_WAITING;
_fs_pending_reply (conn);
return Suspended;
}
-
+
_fs_client_access (conn, client, FALSE);
_fs_client_resolution(conn);
(void) _fs_write_pad(conn, pattern, len);
blockrec->sequenceNumber = conn->current_seq;
-
+
#ifdef NCD
if (configData.ExtendedFontDiags) {
char buf[256];
/* ARGSUSED */
static int
-fs_next_list_with_info(pointer client, FontPathElementPtr fpe,
- char **namep, int *namelenp,
+fs_next_list_with_info(pointer client, FontPathElementPtr fpe,
+ char **namep, int *namelenp,
FontInfoPtr *pFontInfo, int *numFonts,
pointer private)
{
/* see if the result is already there */
for (blockrec = conn->blockedRequests; blockrec; blockrec = blockrec->next)
- if (blockrec->type == FS_LIST_WITH_INFO && blockrec->client == client)
+ if (blockrec->type == FS_LIST_WITH_INFO && blockrec->client == client)
break;
if (!blockrec)
}
binfo = (FSBlockedListInfoPtr) blockrec->data;
-
+
if (binfo->status == FS_LFWI_WAITING)
return Suspended;
*namelenp = binfo->namelen;
*pFontInfo = &binfo->info;
*numFonts = binfo->remaining;
-
+
/* Restart reply processing from this font server */
FD_SET(conn->fs_fd, &_fs_fd_mask);
if (fs_reply_ready (conn))
_fs_mark_block (conn, FS_COMPLETE_REPLY);
-
+
err = blockrec->errcode;
switch (binfo->status) {
case FS_LFWI_FINISHED:
_fs_mark_block (conn, FS_PENDING_REPLY);
break;
}
-
+
return err;
}
for (blockrec = conn->blockedRequests; blockrec; blockrec = blockrec->next)
if (blockrec->client == client)
break;
-
+
if (!blockrec)
return;
-
+
/* replace the client pointers in this block rec with the chained one */
- if ((depending = blockrec->depending))
+ if ((depending = blockrec->depending))
{
blockrec->client = depending->client;
blockrec->depending = depending->depending;
_fs_check_connect (FSFpePtr conn)
{
int ret;
-
+
ret = _fs_poll_connect (conn->trans_conn, 0);
switch (ret) {
case FSIO_READY:
*error = ret;
return 0;
}
-
+
setup = (fsConnSetup *) data;
if (setup->major_version > FS_PROTOCOL)
{
int i, alt_len;
int setup_len;
char *alt_save, *alt_names;
-
+
setup = _fs_get_conn_setup (conn, &ret, &setup_len);
if (!setup)
return ret;
{
int ret;
char *servername;
-
+
if (conn->alternate == 0)
servername = conn->servername;
else
char *cat;
char len;
char *end;
- int num_res;
+ int num_res;
FontResolutionPtr res;
#define CATALOGUE_SEP '+'
res = GetClientResolutions(&num_res);
- if (num_res)
+ if (num_res)
{
srreq.reqType = FS_SetResolution;
srreq.num_resolutions = num_res;
catalogues = _fs_catalog_name (conn->alts[conn->alternate-1].name);
if (!catalogues)
catalogues = _fs_catalog_name (conn->servername);
-
+
if (!catalogues)
{
conn->has_catalogues = FALSE;
return FSIO_READY;
}
conn->has_catalogues = TRUE;
-
+
/* turn cats into counted list */
catalogues++;
screq.reqType = FS_SetCatalogues;
screq.num_catalogues = num_cats;
screq.length = (SIZEOF(fsSetCataloguesReq) + clen + 3) >> 2;
-
+
_fs_add_req_log(conn, FS_SetCatalogues);
if (_fs_write(conn, (char *) &screq, SIZEOF(fsSetCataloguesReq)) != FSIO_READY)
return FSIO_ERROR;
-
+
while (*cat)
{
num_cats++;
return FSIO_ERROR;
cat = end;
}
-
+
if (_fs_write (conn, "....", _fs_pad_length (clen) - clen) != FSIO_READY)
return FSIO_ERROR;
-
+
return FSIO_READY;
}
_fs_send_cat_sync (FSFpePtr conn)
{
fsListCataloguesReq lcreq;
-
+
/*
* now sync up with the font server, to see if an error was generated
* by a bogus catalogue
reply = fs_get_reply (conn, &err);
if (!reply)
return err;
-
+
ret = FSIO_READY;
if (reply->type == FS_Error)
{
_fs_do_setup_connection (FSFpePtr conn)
{
int ret;
-
+
do
{
#ifdef DEBUG
_fs_check_reconnect (FSFpePtr conn)
{
int ret;
-
+
ret = _fs_do_setup_connection (conn);
switch (ret) {
case FSIO_READY:
projects / framework / uifw / xorg / lib / libxfont.git / blobdiff