Rounding to nearest does not make sense.  Callers like
gtkcellrenderertext.c's get_size expect rounding up, at least for width
and height.

(This becomes obvious if ones changes

  pango_layout_get_pixel_extents (layout, NULL, &rect);

to

  pango_layout_get_pixel_extents (layout, &rect, NULL);

in get_size.)

A few points:

 1) We should use the same function (floor, round, ceil) on both x and x+width, or we will see gaps between neighbouring runs, or overlaps.

 2) With pixel devices, we are really talking about hinted metrics only, so the only difference that the conversion function makes is for cases that a rounding error has been introduced somewhere, like the eclipse bug I fixed for example:

  https://bugs.freedesktop.org/show_bug.cgi?id=5200

for this reason I think rounding makes more sense.

I'm not sure I understand you correctly re 2.  If you try the gtk+ change
I mentioned, you will see that occasionally a letter gets its bottom cut
off.  If you round height up [this place cares about width and height only]
then that never happens.

Are you saying that gtk+ has a separate bug here?

I fear that there are really two different classes of users of the _pixel_
functions:

1. Those who want to know the width of the layout in the sense that all
   the ink will fall inside the rectangle.  [round up]

2. Those who want the width in the sense that here+width is where the next
   item should be drawn.  [round nearest]

1) What if you try with my patch?

2) Do you have hinting off by any chance?  There's a separate bug that with unhinted fonts metrics are not hinted correctly.  That can cause you see a difference if you round up.



As for your two usecases, note that these two functions are pure convenience.  One can call pango_layout_get_extents and round how they like it.  I had the same vision as you, but came up to the conclusion that your two cases should always give the same result, and that is true given that we know all metrics are always hinted for pixel display (oh oh, except for ink extents of course, causing what you observe.)

1. My ->x and ->y always seem to be N*1024.  So no difference.

2. Clearly on.  But this is a self-compiled bastard system, so who knows
   what kind of problems have been introduced.

I would agree with Morten that ink metrics should be expanded, not
rounded. 

The guarantee that we make is that you can render a layout onto a
pixmap the size of its ink metrics and it won't get clipped.

Overlap isn't an issue, because ink metrics for adjacent elements
can and do overlap already.

For logical metrics, rounding is probably more sensible.

Ok, now we have:

#define PANGO_SCALE 1024
#define PANGO_PIXELS(d) (((int)(d) + 512) >> 10)
#define PANGO_PIXELS_FLOOR(d) (((int)(d)) >> 10)
#define PANGO_PIXELS_CEIL(d) (((int)(d) + 1023) >> 10)

and:

void
pango_layout_get_pixel_extents (PangoLayout *layout,
                                PangoRectangle *ink_rect,
                                PangoRectangle *logical_rect)
{
  g_return_if_fail (PANGO_IS_LAYOUT (layout));

  pango_layout_get_extents (layout, ink_rect, logical_rect);

  if (ink_rect)
    {
      int orig_x = ink_rect->x;
      int orig_y = ink_rect->y;

      ink_rect->x = PANGO_PIXELS_FLOOR (ink_rect->x);
      ink_rect->y = PANGO_PIXELS_FLOOR (ink_rect->y);

      ink_rect->width  = PANGO_PIXELS_CEIL (orig_x + ink_rect->width ) - ink_rect->x;
      ink_rect->height = PANGO_PIXELS_CEIL (orig_y + ink_rect->height) - ink_rect->y;
    }

  if (logical_rect)
    {
      int orig_x = logical_rect->x;
      int orig_y = logical_rect->y;

      logical_rect->x = PANGO_PIXELS (logical_rect->x);
      logical_rect->y = PANGO_PIXELS (logical_rect->y);

      logical_rect->width  = PANGO_PIXELS (orig_x + logical_rect->width ) - logical_rect->x;
      logical_rect->height = PANGO_PIXELS (orig_y + logical_rect->height) - logical_rect->y;
    }
}

How does it look?

I'm a bit concerned about what may happen in the sums overflow.  Not sure if it matters.

2006-04-29  Behdad Esfahbod  <behdad@gnome.org>

        Bug 329547 – pango_layout_get_pixel_extents and
        pango_layout_get_pixel_size cause off-by-one metrics

        * docs/pango-sections.txt:
        * docs/tmpl/glyphs.sgml:
        * pango/pango-types.h: Define PANGO_PIXELS_FLOOR and PANGO_PIXELS_CEIL.

        * pango/pango-layout.c (pango_layout_get_pixel_extents),
        (pango_layout_get_pixel_size): Make sure logical rects are
        consistent and ink rects are inclusive.


Only on HEAD.  Please test.