gschem/src/gschem_pango.c

   1 /* gEDA - GPL Electronic Design Automation
   2  * gschem - gEDA Schematic Capture
   3  * Copyright (C) 2008-2010 gEDA Contributors (see ChangeLog for details)
   4  * Copyright (C) 2000 Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  *
  21  * This file based on GDK's gdkpango.c (LGPL V2+)
  22  * Copyright (C) 2000 Red Hat, Inc.
  23  */
  24
  25 #include <config.h>
  26
  27 #include "gschem.h"
  28
  29 #include <math.h>
  30 #include <pango/pangocairo.h>
  31 #include <gschem_pango.h>
  32
  33 #define MAGIC_OVERBAR_POS_CONSTANT 0.8
  34
  35 struct _GschemPangoRendererPrivate
  36 {
  37   cairo_surface_t *surface;
  38
  39   /* GschemPangoRenderer specific state */
  40   gboolean overbar;
  41
  42   cairo_t *cr;
  43 };
  44
  45 static PangoAttrType gschem_pango_attr_overbar_type;
  46
  47 enum {
  48   PROP_0,
  49   PROP_CR
  50 };
  51
  52 G_DEFINE_TYPE (GschemPangoRenderer, gschem_pango_renderer, PANGO_TYPE_RENDERER)
  53
  54 static void
  55 gschem_pango_renderer_finalize (GObject *object)
  56 {
  57   G_OBJECT_CLASS (gschem_pango_renderer_parent_class)->finalize (object);
  58 }
  59
  60 static GObject*
  61 gschem_pango_renderer_constructor (GType                  type,
  62                                    guint                  n_construct_properties,
  63                                    GObjectConstructParam *construct_params)
  64 {
  65   GObject *object;
  66   GschemPangoRenderer *gschem_renderer;
  67
  68   object = G_OBJECT_CLASS (gschem_pango_renderer_parent_class)->constructor (type,
  69                                                                              n_construct_properties,
  70                                                                              construct_params);
  71
  72   gschem_renderer = GSCHEM_PANGO_RENDERER (object);
  73
  74   if (gschem_renderer->priv->cr == NULL) {
  75     g_warning ("Cairo context must be specified at construct time for GschemPangoRenderer");
  76   }
  77
  78   return object;
  79 }
  80
  81 static cairo_t *
  82 get_cairo_context (GschemPangoRenderer *gschem_renderer,
  83                    PangoRenderPart   part)
  84 {
  85   GschemPangoRendererPrivate *priv = gschem_renderer->priv;
  86
  87   return priv->cr;
  88 }
  89
  90 static void
  91 gschem_pango_renderer_draw_glyphs (PangoRenderer    *renderer,
  92                                    PangoFont        *font,
  93                                    PangoGlyphString *glyphs,
  94                                    int               x,
  95                                    int               y)
  96 {
  97   GschemPangoRenderer *gschem_renderer = GSCHEM_PANGO_RENDERER (renderer);
  98   GschemPangoRendererPrivate *priv = gschem_renderer->priv;
  99   cairo_t *cr;
 100
 101   cr = get_cairo_context (gschem_renderer,
 102                           PANGO_RENDER_PART_FOREGROUND);
 103
 104
 105   if (priv->overbar) {
 106     double rx, ry, rwidth, rheight, cheight;
 107     PangoFontMetrics *metrics;
 108     PangoRectangle logical;
 109     int underline_thickness;
 110
 111     /* Make the thickness the same as for the font's underline */
 112     metrics = pango_font_get_metrics (font, NULL);
 113     underline_thickness = pango_font_metrics_get_underline_thickness (metrics);
 114     pango_font_metrics_unref (metrics);
 115
 116     pango_glyph_string_extents (glyphs, font, NULL, &logical);
 117
 118     rx = x;
 119     ry = y - logical.height * MAGIC_OVERBAR_POS_CONSTANT;
 120     rwidth = logical.width;
 121     rheight = underline_thickness;
 122
 123     cheight = rheight / PANGO_SCALE;
 124
 125     /* Allow the overbar to fade out as it becomes < 1px high */
 126     if (cheight > 1.0)
 127       cheight = (int)(cheight);
 128
 129     /* \note The +1 on width is a hack to ensure hinting doesn't
 130      *       sometimes cause the overbars to be broken by a 1px gap
 131      *       if the overbar spans multiple calls to this function.
 132      */
 133     cairo_rectangle (cr,
 134                      (int)(rx / PANGO_SCALE), (int)(ry / PANGO_SCALE),
 135                      (int)(rwidth / PANGO_SCALE) + 1, cheight);
 136     cairo_fill (cr);
 137   }
 138
 139   cairo_move_to (cr, (double)x / PANGO_SCALE, (double)y / PANGO_SCALE);
 140   pango_cairo_show_glyph_string (cr, font, glyphs);
 141 }
 142
 143 static void
 144 gschem_pango_renderer_draw_rectangle (PangoRenderer    *renderer,
 145                                       PangoRenderPart   part,
 146                                       int               x,
 147                                       int               y,
 148                                       int               width,
 149                                       int               height)
 150 {
 151   GschemPangoRenderer *gschem_renderer = GSCHEM_PANGO_RENDERER (renderer);
 152   cairo_t *cr;
 153
 154   cr = get_cairo_context (gschem_renderer, part);
 155
 156   cairo_rectangle (cr,
 157                    (double)x / PANGO_SCALE, (double)y / PANGO_SCALE,
 158                    (double)width / PANGO_SCALE, (double)height / PANGO_SCALE);
 159   cairo_fill (cr);
 160 }
 161
 162 static void
 163 gschem_pango_renderer_draw_error_underline (PangoRenderer    *renderer,
 164                                             int               x,
 165                                             int               y,
 166                                             int               width,
 167                                             int               height)
 168 {
 169   GschemPangoRenderer *gschem_renderer = GSCHEM_PANGO_RENDERER (renderer);
 170   cairo_t *cr;
 171
 172   cr = get_cairo_context (gschem_renderer, PANGO_RENDER_PART_UNDERLINE);
 173
 174   pango_cairo_show_error_underline (cr,
 175         (double)x / PANGO_SCALE, (double)y / PANGO_SCALE,
 176         (double)width / PANGO_SCALE, (double)height / PANGO_SCALE);
 177 }
 178
 179 static void
 180 gschem_pango_renderer_part_changed (PangoRenderer   *renderer,
 181                                     PangoRenderPart  part)
 182 {
 183 }
 184
 185 static void
 186 gschem_pango_renderer_begin (PangoRenderer *renderer)
 187 {
 188 }
 189
 190 static void
 191 gschem_pango_renderer_end (PangoRenderer *renderer)
 192 {
 193 }
 194
 195 static void
 196 gschem_pango_renderer_prepare_run (PangoRenderer  *renderer,
 197                                    PangoLayoutRun *run)
 198 {
 199   GschemPangoRenderer *gschem_renderer = GSCHEM_PANGO_RENDERER (renderer);
 200   gboolean overbar = FALSE;
 201   gboolean changed = FALSE;
 202   GSList *l;
 203
 204   for (l = run->item->analysis.extra_attrs; l; l = l->next) {
 205     PangoAttribute *attr = l->data;
 206
 207     /* overbar_type isn't necessarily initialized, but it is 0,
 208      * which is an invalid type so won't occur.
 209      */
 210     if (attr->klass->type == gschem_pango_attr_overbar_type) {
 211       overbar = ((GschemPangoAttrOverbar*)attr)->overbar;
 212     }
 213   }
 214
 215   if (overbar != gschem_renderer->priv->overbar) {
 216     gschem_renderer->priv->overbar = overbar;
 217     changed = TRUE;
 218   }
 219
 220   if (changed)
 221     pango_renderer_part_changed (renderer, PANGO_RENDER_PART_FOREGROUND);
 222
 223   PANGO_RENDERER_CLASS (gschem_pango_renderer_parent_class)->prepare_run (renderer, run);
 224 }
 225
 226 static void
 227 gschem_pango_renderer_set_property (GObject *object, guint prop_id,
 228                                     const GValue *value, GParamSpec *pspec)
 229 {
 230   GschemPangoRenderer *gschem_renderer = GSCHEM_PANGO_RENDERER (object);
 231
 232   switch (prop_id) {
 233     case PROP_CR:
 234       gschem_renderer->priv->cr = g_value_get_pointer (value);
 235       break;
 236     default:
 237       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 238       break;
 239   }
 240 }
 241
 242 static void
 243 gschem_pango_renderer_get_property (GObject *object, guint prop_id,
 244                                     GValue *value, GParamSpec *pspec)
 245 {
 246   GschemPangoRenderer *gschem_renderer = GSCHEM_PANGO_RENDERER (object);
 247
 248   switch (prop_id) {
 249     case PROP_CR:
 250       g_value_set_pointer (value, gschem_renderer->priv->cr);
 251       break;
 252     default:
 253       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 254       break;
 255   }
 256 }
 257
 258 static void
 259 gschem_pango_renderer_init (GschemPangoRenderer *renderer)
 260 {
 261   renderer->priv = G_TYPE_INSTANCE_GET_PRIVATE (renderer,
 262                                                 GSCHEM_TYPE_PANGO_RENDERER,
 263                                                 GschemPangoRendererPrivate);
 264 }
 265
 266 static void
 267 gschem_pango_renderer_class_init (GschemPangoRendererClass *klass)
 268 {
 269   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 270
 271   PangoRendererClass *renderer_class = PANGO_RENDERER_CLASS (klass);
 272
 273   renderer_class->draw_glyphs = gschem_pango_renderer_draw_glyphs;
 274   renderer_class->draw_rectangle = gschem_pango_renderer_draw_rectangle;
 275   renderer_class->draw_error_underline = gschem_pango_renderer_draw_error_underline;
 276   renderer_class->part_changed = gschem_pango_renderer_part_changed;
 277   renderer_class->begin = gschem_pango_renderer_begin;
 278   renderer_class->end = gschem_pango_renderer_end;
 279   renderer_class->prepare_run = gschem_pango_renderer_prepare_run;
 280
 281   object_class->finalize = gschem_pango_renderer_finalize;
 282   object_class->constructor = gschem_pango_renderer_constructor;
 283   object_class->set_property = gschem_pango_renderer_set_property;
 284   object_class->get_property = gschem_pango_renderer_get_property;
 285
 286   g_object_class_install_property (object_class,
 287                                    PROP_CR,
 288                                    g_param_spec_pointer ("cr",
 289                                                          _("cairo context"),
 290                                                          _("the cairo context for the renderer"),
 291                                                          G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 292                                                          G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK |
 293                                                          G_PARAM_STATIC_BLURB));
 294
 295   g_type_class_add_private (object_class, sizeof (GschemPangoRendererPrivate));
 296 }
 297
 298 /*!
 299  * \brief Create a new PangoRenderer
 300  *
 301  * Create a new #PangoRenderer. Normally you can use the results
 302  * of gschem_pango_renderer_get_default() rather than creating a new renderer.
 303  *
 304  * \param [in] cr a cairo renderer
 305  * \return a newly created #PangoRenderer. Free with g_object_unref().
 306  */
 307 PangoRenderer *
 308 gschem_pango_renderer_new (cairo_t *cr)
 309 {
 310   return g_object_new (GSCHEM_TYPE_PANGO_RENDERER, "cr", cr, NULL);
 311 }
 312
 313 void
 314 gschem_pango_show_layout (cairo_t     *cr,
 315                           PangoLayout *pl)
 316 {
 317   static PangoRenderer *renderer = NULL;
 318   static cairo_t *cr_cache = NULL;
 319   double x_off, y_off;
 320
 321   if (cr_cache != cr && renderer != NULL) {
 322     g_object_unref (renderer);
 323     renderer = NULL;
 324   }
 325
 326   if (renderer == NULL) {
 327     renderer = gschem_pango_renderer_new (cr);
 328     cr_cache = cr;
 329   }
 330
 331   cairo_get_current_point (cr, &x_off, &y_off);
 332
 333   pango_renderer_draw_layout (renderer, pl, x_off * PANGO_SCALE, y_off * PANGO_SCALE);
 334 }
 335
 336
 337 /* GschemPangoAttrOverbar */
 338
 339 static PangoAttribute *
 340 gschem_pango_attr_overbar_copy (const PangoAttribute *attr)
 341 {
 342   const GschemPangoAttrOverbar *e = (const GschemPangoAttrOverbar*) attr;
 343
 344   return gschem_pango_attr_overbar_new (e->overbar);
 345 }
 346
 347 static void
 348 gschem_pango_attr_overbar_destroy (PangoAttribute *attr)
 349 {
 350   g_free (attr);
 351 }
 352
 353 static gboolean
 354 gschem_pango_attr_overbar_compare (const PangoAttribute *attr1,
 355                                    const PangoAttribute *attr2)
 356 {
 357   const GschemPangoAttrOverbar *e1 = (const GschemPangoAttrOverbar*) attr1;
 358   const GschemPangoAttrOverbar *e2 = (const GschemPangoAttrOverbar*) attr2;
 359
 360   return e1->overbar == e2->overbar;
 361 }
 362
 363 /*!
 364  * Creates a new attribute flagging a region as being drawn with overbar or not
 365  *
 366  * \param [in] overbar if the region should be drawn with an overbar
 367  * \return a new #PangoAttribute
 368  */
 369 PangoAttribute *
 370 gschem_pango_attr_overbar_new (gboolean overbar)
 371 {
 372   GschemPangoAttrOverbar *result;
 373
 374   static PangoAttrClass klass = { 0,
 375                                   gschem_pango_attr_overbar_copy,
 376                                   gschem_pango_attr_overbar_destroy,
 377                                   gschem_pango_attr_overbar_compare };
 378
 379   if (!klass.type)
 380     klass.type = gschem_pango_attr_overbar_type =
 381       pango_attr_type_register ("GschemPangoAttrOverbar");
 382
 383   result = g_new (GschemPangoAttrOverbar, 1);
 384   result->attr.klass = &klass;
 385   result->overbar = overbar;
 386
 387   return (PangoAttribute *)result;
 388 }