← Back to branch summary

~ubuntu-branches/ubuntu/karmic/emacs-snapshot/karmic

« back to all changes in this revision

Viewing changes to src/xfont.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2009-04-05 09:14:30 UTC
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: james.westby@ubuntu.com-20090405091430-nw07lynn2arotjbe
Tags: upstream-20090320
Import upstream version 20090320

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/xfont.c
1
1
/* xfont.c -- X core font driver.
2
 
   Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc.
3
 
   Copyright (C) 2006, 2007, 2008
 
2
   Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
 
3
   Copyright (C) 2006, 2007, 2008, 2009
4
4
     National Institute of Advanced Industrial Science and Technology (AIST)
5
5
     Registration Number H13PRO009
6
6
 
210
210
                      *(const unsigned char **) name2);
211
211
}
212
212
 
 
213
/* Decode XLFD as iso-8859-1 into OUTPUT, and return the byte length
 
214
   of the decoding result.  LEN is the byte length of XLFD, or -1 if
 
215
   XLFD is NULL terminated.  The caller must assure that OUTPUT is at
 
216
   least twice (plus 1) as large as XLFD.  */
 
217
 
 
218
static int
 
219
xfont_decode_coding_xlfd (char *xlfd, int len, char *output)
 
220
{
 
221
  char *p0 = xlfd, *p1 = output;
 
222
  int c;
 
223
 
 
224
  while (*p0)
 
225
    {
 
226
      c = *(unsigned char *) p0++;
 
227
      p1 += CHAR_STRING (c, p1);
 
228
      if (--len == 0)
 
229
        break;
 
230
    }
 
231
  *p1 = 0;
 
232
  return (p1 - output);
 
233
}
 
234
 
 
235
/* Encode XLFD from UTF-8 to iso-8859-1 destructively, and return the
 
236
   resulting byte length.  If XLFD contains unencodable character,
 
237
   return -1.  */
 
238
 
 
239
static int
 
240
xfont_encode_coding_xlfd (char *xlfd)
 
241
{
 
242
  const unsigned char *p0 = (unsigned char *) xlfd;
 
243
  unsigned char *p1 = (unsigned char *) xlfd;
 
244
  int len = 0;
 
245
 
 
246
  while (*p0)
 
247
    {
 
248
      int c = STRING_CHAR_ADVANCE (p0);
 
249
 
 
250
      if (c >= 0x100)
 
251
        return -1;
 
252
      *p1++ = c;
 
253
      len++;
 
254
    }
 
255
  *p1 = 0;
 
256
  return len;
 
257
}
 
258
 
213
259
static Lisp_Object xfont_list_pattern P_ ((Lisp_Object, Display *, char *));
214
260
 
215
261
static Lisp_Object
221
267
  Lisp_Object list = Qnil;
222
268
  int i, limit, num_fonts;
223
269
  char **names;
 
270
  /* Large enough to decode the longest XLFD (255 bytes). */
 
271
  char buf[512];
224
272
 
225
273
  BLOCK_INPUT;
226
274
  x_catch_errors (display);
253
301
        {
254
302
          Lisp_Object entity;
255
303
          int result;
 
304
          char *p;
256
305
 
257
306
          if (i > 0 && xstrcasecmp (indices[i - 1], indices[i]) == 0)
258
307
            continue;
259
308
 
260
309
          entity = font_make_entity ();
261
310
          ASET (entity, FONT_TYPE_INDEX, Qx);
262
 
 
263
 
          result = font_parse_xlfd (indices[i], entity);
 
311
          xfont_decode_coding_xlfd (indices[i], -1, buf);
 
312
          result = font_parse_xlfd (buf, entity);
264
313
          if (result < 0)
265
314
            {
266
315
              /* This may be an alias name.  Try to get the full XLFD name
279
328
                     Ver.3.7 is running, XGetAtomName will return null
280
329
                     string.  We must avoid such a name.  */
281
330
                  if (len > 0)
282
 
                    result = font_parse_xlfd (name, entity);
 
331
                    {
 
332
                      xfont_decode_coding_xlfd (indices[i], -1, buf);
 
333
                      result = font_parse_xlfd (buf, entity);
 
334
                    }
283
335
                  XFree (name);
284
336
                }
285
337
              XFreeFont (display, font);
309
361
  Display *display = FRAME_X_DISPLAY_INFO (f)->display;
310
362
  Lisp_Object registry, list, val, extra;
311
363
  int len;
312
 
  char name[256];
313
 
  
 
364
  /* Large enough to contain the longest XLFD (255 bytes) in UTF-8.  */
 
365
  char name[512];
 
366
 
314
367
  extra = AREF (spec, FONT_EXTRA_INDEX);
315
368
  if (CONSP (extra))
316
369
    {
326
379
    }
327
380
 
328
381
  registry = AREF (spec, FONT_REGISTRY_INDEX);
329
 
  len = font_unparse_xlfd (spec, 0, name, 256);
 
382
  len = font_unparse_xlfd (spec, 0, name, 512);
 
383
  if (len < 0 || (len = xfont_encode_coding_xlfd (name)) < 0)
 
384
    return Qnil;
330
385
  ASET (spec, FONT_REGISTRY_INDEX, registry);
331
 
  if (len < 0)
332
 
    return Qnil;
333
386
  list = xfont_list_pattern (frame, display, name);
334
387
  if (NILP (list) && NILP (registry))
335
388
    {
369
422
    {
370
423
      /* Try alias.  */
371
424
      val = assq_no_quit (QCname, AREF (spec, FONT_EXTRA_INDEX));
372
 
      if (CONSP (val) && STRINGP (XCDR (val)))
373
 
        list = xfont_list_pattern (frame, display, (char *) SDATA (XCDR (val)));
 
425
      if (CONSP (val) && STRINGP (XCDR (val)) && SBYTES (XCDR (val)) < 512)
 
426
        {
 
427
          bcopy (SDATA (XCDR (val)), name, SBYTES (XCDR (val)) + 1);
 
428
          if (xfont_encode_coding_xlfd (name) < 0)
 
429
            return Qnil;
 
430
          list = xfont_list_pattern (frame, display, name);
 
431
        }
374
432
    }
375
433
 
376
434
  return list;
383
441
  FRAME_PTR f = XFRAME (frame);
384
442
  Display *display = FRAME_X_DISPLAY_INFO (f)->display;
385
443
  Lisp_Object extra, val, entity;
386
 
  char buf[256], *name;
 
444
  char name[512];
387
445
  XFontStruct *xfont;
388
446
  unsigned long value;
389
447
 
391
449
  val = assq_no_quit (QCname, extra);
392
450
  if (! CONSP (val) || ! STRINGP (XCDR (val)))
393
451
    {
394
 
      if (font_unparse_xlfd (spec, 0, buf, 256) < 0)
 
452
      if (font_unparse_xlfd (spec, 0, name, 512) < 0)
395
453
        return Qnil;
396
 
      name = buf;
397
454
    }
 
455
  else if (SBYTES (XCDR (val)) < 512)
 
456
    bcopy (SDATA (XCDR (val)), name, SBYTES (XCDR (val)) + 1);
398
457
  else
399
 
    name = (char *) SDATA (XCDR (val));
 
458
    return Qnil;
 
459
  if (xfont_encode_coding_xlfd (name) < 0)
 
460
    return Qnil;
400
461
 
401
462
  BLOCK_INPUT;
402
463
  entity = Qnil;
406
467
      if (XGetFontProperty (xfont, XA_FONT, &value))
407
468
        {
408
469
          int len;
 
470
          char *s;
409
471
 
410
 
          name = (char *) XGetAtomName (display, (Atom) value);
411
 
          len = strlen (name);
 
472
          s = (char *) XGetAtomName (display, (Atom) value);
 
473
          len = strlen (s);
412
474
 
413
475
          /* If DXPC (a Differential X Protocol Compressor)
414
476
             Ver.3.7 is running, XGetAtomName will return null
417
479
            {
418
480
              entity = font_make_entity ();
419
481
              ASET (entity, FONT_TYPE_INDEX, Qx);
 
482
              xfont_decode_coding_xlfd (s, -1, name);
420
483
              if (font_parse_xlfd (name, entity) < 0)
421
484
                entity = Qnil;
422
485
            }
423
 
          XFree (name);
 
486
          XFree (s);
424
487
        }
425
488
      XFreeFont (display, xfont);
426
489
    }
457
520
  list = Qnil;
458
521
  for (i = 0, last_len = 0; i < num_fonts; i++)
459
522
    {
460
 
      char *p0 = names[i], *p1;
 
523
      char *p0 = names[i], *p1, buf[512];
461
524
      Lisp_Object family;
 
525
      int decoded_len;
462
526
 
463
527
      p0++;                     /* skip the leading '-' */
464
528
      while (*p0 && *p0 != '-') p0++; /* skip foundry */
473
537
        continue;
474
538
      last_len = p1 - p0;
475
539
      last_family = p0;
476
 
      family = font_intern_prop (p0, last_len, 1);
 
540
 
 
541
      decoded_len = xfont_decode_coding_xlfd (p0, last_len, buf);
 
542
      family = font_intern_prop (p0, decoded_len, 1);
477
543
      if (NILP (assq_no_quit (family, list)))
478
544
        list = Fcons (family, list);
479
545
    }
495
561
{
496
562
  Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
497
563
  Display *display = dpyinfo->display;
498
 
  char name[256];
 
564
  char name[512];
499
565
  int len;
500
566
  unsigned long value;
501
567
  Lisp_Object registry;
523
589
      else
524
590
        pixel_size = 14;
525
591
    }
526
 
  len = font_unparse_xlfd (entity, pixel_size, name, 256);
527
 
  if (len <= 0)
 
592
  len = font_unparse_xlfd (entity, pixel_size, name, 512);
 
593
  if (len <= 0 || (len = xfont_encode_coding_xlfd (name)) < 0)
528
594
    {
529
595
      font_add_log ("  x:unparse failed", entity, Qnil);
530
596
      return Qnil;
554
620
 
555
621
      temp = Fcopy_font_spec (entity);
556
622
      ASET (temp, FONT_DPI_INDEX, Qnil);
557
 
      len = font_unparse_xlfd (temp, pixel_size, name, 256);
558
 
      if (len <= 0)
 
623
      len = font_unparse_xlfd (temp, pixel_size, name, 512);
 
624
      if (len <= 0 || (len = xfont_encode_coding_xlfd (name)) < 0)
559
625
        {
560
626
          font_add_log ("  x:unparse failed", temp, Qnil);
561
627
          return Qnil;
576
642
      char *p0, *p;
577
643
      int dashes = 0;
578
644
 
579
 
      p0 = p = (char *) XGetAtomName (FRAME_X_DISPLAY (f), (Atom) value);;
 
645
      p0 = p = (char *) XGetAtomName (FRAME_X_DISPLAY (f), (Atom) value);
580
646
      /* Count the number of dashes in the "full name".
581
647
         If it is too few, this isn't really the font's full name,
582
648
         so don't use it.
590
656
        }
591
657
 
592
658
      if (dashes >= 13)
593
 
        fullname = Fdowncase (make_unibyte_string (p0, p - p0));
 
659
        {
 
660
          len = xfont_decode_coding_xlfd (p0, -1, name);
 
661
          fullname = Fdowncase (make_string (name, len));
 
662
        }
594
663
      XFree (p0);
595
664
    }
596
665
  x_uncatch_errors ();
606
675
                                  entity, pixel_size);
607
676
  ASET (font_object, FONT_TYPE_INDEX, Qx);
608
677
  if (STRINGP (fullname))
609
 
    font_parse_xlfd ((char *) SDATA (fullname), font_object);
610
 
  if (STRINGP (fullname))
611
 
    ASET (font_object, FONT_NAME_INDEX, fullname);
 
678
    {
 
679
      font_parse_xlfd ((char *) SDATA (fullname), font_object);
 
680
      ASET (font_object, FONT_NAME_INDEX, fullname);
 
681
    }
612
682
  else
613
 
    ASET (font_object, FONT_NAME_INDEX, make_unibyte_string (name, len));
 
683
    {
 
684
      char buf[512];
 
685
 
 
686
      len = xfont_decode_coding_xlfd (name, -1, buf);
 
687
      ASET (font_object, FONT_NAME_INDEX, make_string (buf, len));
 
688
    }
614
689
  ASET (font_object, FONT_FULLNAME_INDEX, fullname);
615
690
  ASET (font_object, FONT_FILE_INDEX, Qnil);
616
691
  ASET (font_object, FONT_FORMAT_INDEX, Qx);