1 /* 2 3 Copyright 1991, 1998 The Open Group 4 5 Permission to use, copy, modify, distribute, and sell this software and its 6 documentation for any purpose is hereby granted without fee, provided that 7 the above copyright notice appear in all copies and that both that 8 copyright notice and this permission notice appear in supporting 9 documentation. 10 11 The above copyright notice and this permission notice shall be included 12 in all copies or substantial portions of the Software. 13 14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 15 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 16 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 17 IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 OTHER DEALINGS IN THE SOFTWARE. 21 22 Except as contained in this notice, the name of The Open Group shall 23 not be used in advertising or otherwise to promote the sale, use or 24 other dealings in this Software without prior written authorization 25 from The Open Group. 26 27 */ 28 29 /* 30 * Author: Keith Packard, MIT X Consortium 31 */ 32 33 #ifdef HAVE_CONFIG_H 34 #include <config.h> 35 #endif 36 #include <X11/fonts/fontmisc.h> 37 #include <X11/fonts/fontstruct.h> 38 #include <X11/fonts/FSproto.h> 39 #include <X11/fonts/fontutil.h> 40 41 /* Define global here... doesn't hurt the servers, and avoids 42 unresolved references in font clients. */ 43 44 static int defaultGlyphCachingMode = DEFAULT_GLYPH_CACHING_MODE; 45 int glyphCachingMode = DEFAULT_GLYPH_CACHING_MODE; 46 47 void 48 GetGlyphs(FontPtr font, 49 unsigned long count, 50 unsigned char *chars, 51 FontEncoding fontEncoding, 52 unsigned long *glyphcount, /* RETURN */ 53 CharInfoPtr *glyphs) /* RETURN */ 54 { 55 (*font->get_glyphs) (font, count, chars, fontEncoding, glyphcount, glyphs); 56 } 57 58 #define MIN(a,b) ((a)<(b)?(a):(b)) 59 #define MAX(a,b) ((a)>(b)?(a):(b)) 60 61 void 62 QueryGlyphExtents(FontPtr pFont, 63 CharInfoPtr *charinfo, 64 unsigned long count, 65 ExtentInfoRec *info) 66 { 67 register unsigned long i; 68 xCharInfo *pCI; 69 70 info->drawDirection = pFont->info.drawDirection; 71 72 info->fontAscent = pFont->info.fontAscent; 73 info->fontDescent = pFont->info.fontDescent; 74 75 if (count != 0) { 76 77 pCI = &((*charinfo)->metrics); charinfo++; 78 /* ignore nonexisting characters when calculating text extents */ 79 if ( !((pCI->characterWidth == 0) 80 && (pCI->rightSideBearing == 0) 81 && (pCI->leftSideBearing == 0) 82 && (pCI->ascent == 0) 83 && (pCI->descent == 0)) ) { 84 info->overallAscent = pCI->ascent; 85 info->overallDescent = pCI->descent; 86 info->overallLeft = pCI->leftSideBearing; 87 info->overallRight = pCI->rightSideBearing; 88 info->overallWidth = pCI->characterWidth; 89 } 90 91 if (pFont->info.constantMetrics && pFont->info.noOverlap) { 92 info->overallWidth *= count; 93 info->overallRight += (info->overallWidth - 94 pCI->characterWidth); 95 } else { 96 for (i = 1; i < count; i++) { 97 pCI = &((*charinfo)->metrics); charinfo++; 98 /* ignore nonexisting characters when calculating extents */ 99 if ( !((pCI->characterWidth == 0) 100 && (pCI->rightSideBearing == 0) 101 && (pCI->leftSideBearing == 0) 102 && (pCI->ascent == 0) 103 && (pCI->descent == 0)) ) { 104 info->overallAscent = MAX( 105 info->overallAscent, 106 pCI->ascent); 107 info->overallDescent = MAX( 108 info->overallDescent, 109 pCI->descent); 110 info->overallLeft = MIN( 111 info->overallLeft, 112 info->overallWidth + pCI->leftSideBearing); 113 info->overallRight = MAX( 114 info->overallRight, 115 info->overallWidth + pCI->rightSideBearing); 116 /* 117 * yes, this order is correct; overallWidth IS incremented 118 * last 119 */ 120 info->overallWidth += pCI->characterWidth; 121 } 122 } 123 } 124 } else { 125 info->overallAscent = 0; 126 info->overallDescent = 0; 127 info->overallWidth = 0; 128 info->overallLeft = 0; 129 info->overallRight = 0; 130 } 131 } 132 133 Bool 134 QueryTextExtents(FontPtr pFont, 135 unsigned long count, 136 unsigned char *chars, 137 ExtentInfoRec *info) 138 { 139 xCharInfo **charinfo; 140 unsigned long n; 141 FontEncoding encoding; 142 int cm; 143 int i; 144 unsigned long t; 145 xCharInfo *defaultChar = 0; 146 unsigned char defc[2]; 147 int firstReal; 148 149 charinfo = malloc(count * sizeof(xCharInfo *)); 150 if (!charinfo) 151 return FALSE; 152 encoding = TwoD16Bit; 153 if (pFont->info.lastRow == 0) 154 encoding = Linear16Bit; 155 (*pFont->get_metrics) (pFont, count, chars, encoding, &n, charinfo); 156 157 /* Do default character substitution as get_metrics doesn't */ 158 159 #define IsNonExistentChar(ci) (!(ci) || \ 160 ((ci)->ascent == 0 && \ 161 (ci)->descent == 0 && \ 162 (ci)->leftSideBearing == 0 && \ 163 (ci)->rightSideBearing == 0 && \ 164 (ci)->characterWidth == 0)) 165 166 firstReal = n; 167 defc[0] = pFont->info.defaultCh >> 8; 168 defc[1] = pFont->info.defaultCh; 169 (*pFont->get_metrics) (pFont, 1, defc, encoding, &t, &defaultChar); 170 if ((IsNonExistentChar (defaultChar))) 171 defaultChar = 0; 172 for (i = 0; i < n; i++) 173 { 174 if ((IsNonExistentChar (charinfo[i]))) 175 { 176 if (!defaultChar) 177 continue; 178 charinfo[i] = defaultChar; 179 } 180 if (firstReal == n) 181 firstReal = i; 182 } 183 cm = pFont->info.constantMetrics; 184 pFont->info.constantMetrics = FALSE; 185 QueryGlyphExtents(pFont, (CharInfoPtr*) charinfo + firstReal, 186 n - firstReal, info); 187 pFont->info.constantMetrics = cm; 188 free(charinfo); 189 return TRUE; 190 } 191 192 Bool 193 ParseGlyphCachingMode(char *str) 194 { 195 if (!strcmp(str, "none")) defaultGlyphCachingMode = CACHING_OFF; 196 else if (!strcmp(str, "all")) defaultGlyphCachingMode = CACHE_ALL_GLYPHS; 197 else if (!strcmp(str, "16")) defaultGlyphCachingMode = CACHE_16_BIT_GLYPHS; 198 else return FALSE; 199 return TRUE; 200 } 201 202 void 203 InitGlyphCaching(void) 204 { 205 /* Set glyphCachingMode to the mode the server hopes to 206 support. DDX drivers that do not support the requested level 207 of glyph caching can call SetGlyphCachingMode to lower the 208 level of support. 209 */ 210 211 glyphCachingMode = defaultGlyphCachingMode; 212 } 213 214 /* ddxen can call SetGlyphCachingMode to inform us of what level of glyph 215 * caching they can support. 216 */ 217 void 218 SetGlyphCachingMode(int newmode) 219 { 220 if ( (glyphCachingMode > newmode) && (newmode >= 0) ) 221 glyphCachingMode = newmode; 222 } 223 224 #define range_alloc_granularity 16 225 #define mincharp(p) ((p)->min_char_low + ((p)->min_char_high << 8)) 226 #define maxcharp(p) ((p)->max_char_low + ((p)->max_char_high << 8)) 227 228 /* add_range(): Add range to a list of ranges, with coalescence */ 229 int 230 add_range(fsRange *newrange, 231 int *nranges, 232 fsRange **range, 233 Bool charset_subset) 234 { 235 int first, last, middle; 236 unsigned long keymin, keymax; 237 unsigned long ptrmin = 0, ptrmax = 0; 238 fsRange *ptr = NULL, *ptr1, *ptr2, *endptr; 239 240 /* There are two different ways to treat ranges: 241 242 1) Charset subsetting (support of the HP XLFD enhancements), in 243 which a range of 0x1234,0x3456 means all numbers between 244 0x1234 and 0x3456, and in which min and max might be swapped. 245 246 2) Row/column ranges, in which a range of 0x1234,0x3456 means the 247 ranges 0x1234-0x1256, 0x1334-0x1356, ... , 0x3434-0x3456. 248 This is for support of glyph caching. 249 250 The choice of treatment is selected with the "charset_subset" 251 flag */ 252 253 /* If newrange covers multiple rows; break up the rows */ 254 if (!charset_subset && newrange->min_char_high != newrange->max_char_high) 255 { 256 int i, err = 0; 257 fsRange temprange; 258 for (i = newrange->min_char_high; 259 i <= newrange->max_char_high; 260 i++) 261 { 262 temprange.min_char_low = newrange->min_char_low; 263 temprange.max_char_low = newrange->max_char_low; 264 temprange.min_char_high = temprange.max_char_high = i; 265 err = add_range(&temprange, nranges, range, charset_subset); 266 if (err != Successful) break; 267 } 268 return err; 269 } 270 271 keymin = mincharp(newrange); 272 keymax = maxcharp(newrange); 273 274 if (charset_subset && keymin > keymax) 275 { 276 unsigned long temp = keymin; 277 keymin = keymax; 278 keymax = temp; 279 } 280 281 /* add_range() maintains a sorted list; this makes possible coalescence 282 and binary searches */ 283 284 /* Binary search for a range with which the new range can merge */ 285 286 first = middle = 0; 287 last = *nranges - 1; 288 while (last >= first) 289 { 290 middle = (first + last) / 2; 291 ptr = (*range) + middle; 292 ptrmin = mincharp(ptr); 293 ptrmax = maxcharp(ptr); 294 295 if (ptrmin > 0 && keymax < ptrmin - 1) last = middle - 1; 296 else if (keymin > ptrmax + 1) first = middle + 1; 297 else if (!charset_subset) 298 { 299 /* We might have a range with which to merge... IF the 300 result doesn't cross rows */ 301 if (newrange->min_char_high != ptr->min_char_high) 302 last = first - 1; /* Force adding a new range */ 303 break; 304 } 305 else break; /* We have at least one range with which we can merge */ 306 } 307 308 if (last < first) 309 { 310 /* Search failed; we need to add a new range to the list. */ 311 312 /* Grow the list if necessary */ 313 if (*nranges == 0 || *range == (fsRange *)0) 314 { 315 *range = malloc(range_alloc_granularity * SIZEOF(fsRange)); 316 *nranges = 0; 317 } 318 else if (!(*nranges % range_alloc_granularity)) 319 { 320 *range = realloc(*range, (*nranges + range_alloc_granularity) * 321 SIZEOF(fsRange)); 322 } 323 324 /* If alloc failed, just return a null list */ 325 if (*range == (fsRange *)0) 326 { 327 *nranges = 0; 328 return AllocError; 329 } 330 331 /* Should new entry go *at* or *after* ptr? */ 332 ptr = (*range) + middle; 333 if (middle < *nranges && keymin > ptrmin) ptr++; /* after */ 334 335 /* Open up a space for our new range */ 336 memmove((char *)(ptr + 1), 337 (char *)ptr, 338 (char *)(*range + *nranges) - (char *)ptr); 339 340 /* Insert the new range */ 341 ptr->min_char_low = keymin & 0xff; 342 ptr->min_char_high = keymin >> 8; 343 ptr->max_char_low = keymax & 0xff; 344 ptr->max_char_high = keymax >> 8; 345 346 /* Update range count */ 347 (*nranges)++; 348 349 /* Done */ 350 return Successful; 351 } 352 353 /* Join our new range to that pointed to by "ptr" */ 354 if (keymin < ptrmin) 355 { 356 ptr->min_char_low = keymin & 0xff; 357 ptr->min_char_high = keymin >> 8; 358 } 359 if (keymax > ptrmax) 360 { 361 ptr->max_char_low = keymax & 0xff; 362 ptr->max_char_high = keymax >> 8; 363 } 364 365 ptrmin = mincharp(ptr); 366 ptrmax = maxcharp(ptr); 367 368 endptr = *range + *nranges; 369 370 for (ptr1 = ptr; ptr1 >= *range; ptr1--) 371 { 372 if (ptrmin <= maxcharp(ptr1) + 1) 373 { 374 if (!charset_subset && ptr->min_char_high != ptr1->min_char_high) 375 break; 376 if (ptrmin >= mincharp(ptr1)) 377 ptrmin = mincharp(ptr1); 378 } 379 else break; 380 } 381 for (ptr2 = ptr; ptr2 < endptr; ptr2++) 382 { 383 if ((ptr2->min_char_low == 0 && ptr2->min_char_high == 0) || 384 ptrmax >= mincharp(ptr2) - 1) 385 { 386 if (!charset_subset && ptr->min_char_high != ptr2->min_char_high) 387 break; 388 if (ptrmax <= maxcharp(ptr2)) 389 ptrmax = maxcharp(ptr2); 390 } 391 else break; 392 } 393 394 /* We need to coalesce ranges between ptr1 and ptr2 exclusive */ 395 ptr1++; 396 ptr2--; 397 if (ptr1 != ptr2) 398 { 399 memmove(ptr1, ptr2, (char *)endptr - (char *)ptr2); 400 *nranges -= (ptr2 - ptr1); 401 } 402 403 /* Write the new range into the range list */ 404 ptr1->min_char_low = ptrmin & 0xff; 405 ptr1->min_char_high = ptrmin >> 8; 406 ptr1->max_char_low = ptrmax & 0xff; 407 ptr1->max_char_high = ptrmax >> 8; 408 409 return Successful; 410 } 411
Indexes created Sat Oct 24 00:25:45 UTC 2026