src/adg/adg-toy-text.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009,2010  Nicola Fontana <ntd at entidi.it>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA  02110-1301, USA.
  18  */
  19
  20
  21 /**
  22  * SECTION:adg-toy-text
  23  * @short_description: Simple text entity that use the cairo "toy" text API
  24  *
  25  * The #AdgToyText class is a basic class to show simple text. It internally
  26  * uses the so called cairo "toy" API and it shares the same limitations.
  27  *
  28  * The toy text entity is not subject to the local matrix, only its origin is.
  29  **/
  30
  31 /**
  32  * AdgToyText:
  33  *
  34  * All fields are privates and should not be used directly.
  35  * Use its public methods instead.
  36  **/
  37
  38
  39 #include "adg-internal.h"
  40 #include "adg-toy-text.h"
  41 #include "adg-toy-text-private.h"
  42 #include "adg-dress-builtins.h"
  43 #include "adg-font-style.h"
  44
  45 #define PARENT_OBJECT_CLASS  ((GObjectClass *) adg_toy_text_parent_class)
  46 #define PARENT_ENTITY_CLASS  ((AdgEntityClass *) adg_toy_text_parent_class)
  47
  48
  49 enum {
  50     PROP_0,
  51     PROP_FONT_DRESS,
  52     PROP_LABEL
  53 };
  54
  55
  56 static void     finalize                (GObject        *object);
  57 static void     get_property            (GObject        *object,
  58                                          guint           param_id,
  59                                          GValue         *value,
  60                                          GParamSpec     *pspec);
  61 static void     set_property            (GObject        *object,
  62                                          guint           param_id,
  63                                          const GValue   *value,
  64                                          GParamSpec     *pspec);
  65 static void     global_changed          (AdgEntity      *entity);
  66 static void     local_changed           (AdgEntity      *entity);
  67 static void     invalidate              (AdgEntity      *entity);
  68 static void     arrange                 (AdgEntity      *entity);
  69 static void     render                  (AdgEntity      *entity,
  70                                          cairo_t        *cr);
  71 static gboolean set_label               (AdgToyText     *toy_text,
  72                                          const gchar    *label);
  73 static void     unset_font              (AdgToyText     *toy_text);
  74 static void     unset_glyphs            (AdgToyText     *toy_text);
  75
  76
  77 G_DEFINE_TYPE(AdgToyText, adg_toy_text, ADG_TYPE_ENTITY);
  78
  79
  80 static void
  81 adg_toy_text_class_init(AdgToyTextClass *klass)
  82 {
  83     GObjectClass *gobject_class;
  84     AdgEntityClass *entity_class;
  85     GParamSpec *param;
  86
  87     gobject_class = (GObjectClass *) klass;
  88     entity_class = (AdgEntityClass *) klass;
  89
  90     g_type_class_add_private(klass, sizeof(AdgToyTextPrivate));
  91
  92     gobject_class->finalize = finalize;
  93     gobject_class->get_property = get_property;
  94     gobject_class->set_property = set_property;
  95
  96     entity_class->global_changed = global_changed;
  97     entity_class->local_changed = local_changed;
  98     entity_class->invalidate = invalidate;
  99     entity_class->arrange = arrange;
 100     entity_class->render = render;
 101
 102     param = adg_param_spec_dress("font-dress",
 103                                  P_("Font Dress"),
 104                                  P_("The font dress to use for rendering this text"),
 105                                  ADG_DRESS_FONT_TEXT,
 106                                  G_PARAM_READWRITE);
 107     g_object_class_install_property(gobject_class, PROP_FONT_DRESS, param);
 108
 109     param = g_param_spec_string("label",
 110                                 P_("Label"),
 111                                 P_("The label to display"),
 112                                 NULL,
 113                                 G_PARAM_READWRITE);
 114     g_object_class_install_property(gobject_class, PROP_LABEL, param);
 115 }
 116
 117 static void
 118 adg_toy_text_init(AdgToyText *toy_text)
 119 {
 120     AdgToyTextPrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(toy_text,
 121                                                           ADG_TYPE_TOY_TEXT,
 122                                                           AdgToyTextPrivate);
 123
 124     data->font_dress = ADG_DRESS_FONT_TEXT;
 125     data->label = NULL;
 126     data->glyphs = NULL;
 127
 128     toy_text->data = data;
 129 }
 130
 131 static void
 132 finalize(GObject *object)
 133 {
 134     AdgToyText *toy_text;
 135     AdgToyTextPrivate *data;
 136
 137     toy_text = (AdgToyText *) object;
 138     data = toy_text->data;
 139
 140     g_free(data->label);
 141     unset_font(toy_text);
 142     unset_glyphs(toy_text);
 143
 144     if (PARENT_OBJECT_CLASS->finalize)
 145         PARENT_OBJECT_CLASS->finalize(object);
 146 }
 147
 148 static void
 149 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 150 {
 151     AdgToyTextPrivate *data = ((AdgToyText *) object)->data;
 152
 153     switch (prop_id) {
 154     case PROP_FONT_DRESS:
 155         g_value_set_int(value, data->font_dress);
 156         break;
 157     case PROP_LABEL:
 158         g_value_set_string(value, data->label);
 159         break;
 160     default:
 161         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 162         break;
 163     }
 164 }
 165
 166 static void
 167 set_property(GObject *object, guint prop_id,
 168              const GValue *value, GParamSpec *pspec)
 169 {
 170     AdgToyText *toy_text;
 171     AdgToyTextPrivate *data;
 172
 173     toy_text = (AdgToyText *) object;
 174     data = toy_text->data;
 175
 176     switch (prop_id) {
 177     case PROP_FONT_DRESS:
 178         data->font_dress = g_value_get_int(value);
 179         unset_font(toy_text);
 180         break;
 181     case PROP_LABEL:
 182         set_label(toy_text, g_value_get_string(value));
 183         break;
 184     default:
 185         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 186         break;
 187     }
 188 }
 189
 190
 191 /**
 192  * adg_toy_text_new:
 193  * @label: the label text
 194  *
 195  * Creates a new toy text entity using @label as its text. The
 196  * #AdgEntity:local-method property is set by default to
 197  * #ADG_LOCAL_NORMALIZED.
 198  *
 199  * Returns: the newly created toy text entity
 200  **/
 201 AdgToyText *
 202 adg_toy_text_new(const gchar *label)
 203 {
 204     return g_object_new(ADG_TYPE_TOY_TEXT,
 205                         "local-method", ADG_MIX_ANCESTORS_NORMALIZED,
 206                         "label", label, NULL);
 207 }
 208
 209 /**
 210  * adg_toy_text_set_font_dress:
 211  * @toy_text: an #AdgToyText
 212  * @dress: the new #AdgDress to use
 213  *
 214  * Sets a new font dress for rendering @toy_text. The new dress
 215  * must be related to the original dress for this property:
 216  * you cannot set a dress used for line styles to a dress
 217  * managing fonts.
 218  *
 219  * The check is done by calling adg_dress_are_related() with
 220  * @dress and the previous dress as arguments. Check out its
 221  * documentation for details on what is a related dress.
 222  **/
 223 void
 224 adg_toy_text_set_font_dress(AdgToyText *toy_text, AdgDress dress)
 225 {
 226     g_return_if_fail(ADG_IS_TOY_TEXT(toy_text));
 227     g_object_set((GObject *) toy_text, "font-dress", dress, NULL);
 228 }
 229
 230 /**
 231  * adg_toy_text_get_font_dress:
 232  * @toy_text: an #AdgToyText
 233  *
 234  * Gets the font dress to be used in rendering @toy_text.
 235  *
 236  * Returns: the current font dress
 237  **/
 238 AdgDress
 239 adg_toy_text_get_font_dress(AdgToyText *toy_text)
 240 {
 241     AdgToyTextPrivate *data;
 242
 243     g_return_val_if_fail(ADG_IS_TOY_TEXT(toy_text), ADG_DRESS_UNDEFINED);
 244
 245     data = toy_text->data;
 246
 247     return data->font_dress;
 248 }
 249
 250 /**
 251  * adg_toy_text_set_label:
 252  * @toy_text: an #AdgToyText
 253  * @label: the label text
 254  *
 255  * Sets a new label for @toy_text. @label can be also %NULL,
 256  * in which case will be treated as an empty string.
 257  **/
 258 void
 259 adg_toy_text_set_label(AdgToyText *toy_text, const gchar *label)
 260 {
 261     g_return_if_fail(ADG_IS_TOY_TEXT(toy_text));
 262
 263     if (set_label(toy_text, label))
 264         g_object_notify((GObject *) toy_text, "label");
 265 }
 266
 267 /**
 268  * adg_toy_text_get_label:
 269  * @toy_text: an #AdgToyText
 270  *
 271  * Gets the label text. The string is internally owned and
 272  * must not be freed or modified.
 273  *
 274  * Returns: the label text
 275  **/
 276 const gchar *
 277 adg_toy_text_get_label(AdgToyText *toy_text)
 278 {
 279     AdgToyTextPrivate *data;
 280
 281     g_return_val_if_fail(ADG_IS_TOY_TEXT(toy_text), NULL);
 282
 283     data = toy_text->data;
 284
 285     return data->label;
 286 }
 287
 288
 289 static void
 290 global_changed(AdgEntity *entity)
 291 {
 292     if (PARENT_ENTITY_CLASS->global_changed)
 293         PARENT_ENTITY_CLASS->global_changed(entity);
 294
 295     adg_entity_invalidate(entity);
 296 }
 297
 298 static void
 299 local_changed(AdgEntity *entity)
 300 {
 301     if (PARENT_ENTITY_CLASS->local_changed)
 302         PARENT_ENTITY_CLASS->local_changed(entity);
 303
 304     adg_entity_invalidate(entity);
 305 }
 306
 307 static void
 308 invalidate(AdgEntity *entity)
 309 {
 310     unset_font((AdgToyText *) entity);
 311     unset_glyphs((AdgToyText *) entity);
 312
 313     if (PARENT_ENTITY_CLASS->invalidate)
 314         PARENT_ENTITY_CLASS->invalidate(entity);
 315 }
 316
 317 static void
 318 arrange(AdgEntity *entity)
 319 {
 320     AdgToyText *toy_text;
 321     AdgToyTextPrivate *data;
 322     CpmlExtents extents;
 323
 324     toy_text = (AdgToyText *) entity;
 325     data = toy_text->data;
 326
 327     if (data->font == NULL) {
 328         AdgDress dress;
 329         AdgFontStyle *font_style;
 330         AdgMatrix ctm;
 331
 332         dress = data->font_dress;
 333         font_style = (AdgFontStyle *) adg_entity_style(entity, dress);
 334
 335         adg_matrix_copy(&ctm, adg_entity_get_global_matrix(entity));
 336         adg_matrix_transform(&ctm, adg_entity_get_local_matrix(entity),
 337                              ADG_TRANSFORM_BEFORE);
 338
 339         data->font = adg_font_style_get_scaled_font(font_style, &ctm);
 340     }
 341
 342     if (adg_is_string_empty(data->label)) {
 343         /* Undefined label */
 344         extents.is_defined = FALSE;
 345     } else if (data->glyphs != NULL) {
 346         /* Cached result */
 347         return;
 348     } else {
 349         cairo_status_t status;
 350         cairo_text_extents_t cairo_extents;
 351
 352         status = cairo_scaled_font_text_to_glyphs(data->font, 0, 0,
 353                                                   data->label, -1,
 354                                                   &data->glyphs,
 355                                                   &data->num_glyphs,
 356                                                   NULL, NULL, NULL);
 357
 358         if (status != CAIRO_STATUS_SUCCESS) {
 359             unset_glyphs(toy_text);
 360             g_error("Unable to build glyphs (cairo message: %s)",
 361                     cairo_status_to_string(status));
 362             return;
 363         }
 364
 365         cairo_scaled_font_glyph_extents(data->font, data->glyphs,
 366                                         data->num_glyphs, &cairo_extents);
 367         cpml_extents_from_cairo_text(&extents, &cairo_extents);
 368         cpml_extents_transform(&extents, adg_entity_get_local_matrix(entity));
 369         cpml_extents_transform(&extents, adg_entity_get_global_matrix(entity));
 370
 371     }
 372
 373     adg_entity_set_extents(entity, &extents);
 374 }
 375
 376 static void
 377 render(AdgEntity *entity, cairo_t *cr)
 378 {
 379     AdgToyText *toy_text;
 380     AdgToyTextPrivate *data;
 381
 382     toy_text = (AdgToyText *) entity;
 383     data = toy_text->data;
 384
 385     if (data->glyphs != NULL) {
 386         adg_entity_apply_dress(entity, data->font_dress, cr);
 387         cairo_transform(cr, adg_entity_get_local_matrix(entity));
 388         cairo_show_glyphs(cr, data->glyphs, data->num_glyphs);
 389     }
 390 }
 391
 392 static gboolean
 393 set_label(AdgToyText *toy_text, const gchar *label)
 394 {
 395     AdgToyTextPrivate *data = toy_text->data;
 396
 397     /* Check if the new label differs from the current label */
 398     if (g_strcmp0(label, data->label) == 0)
 399         return FALSE;
 400
 401     g_free(data->label);
 402     data->label = g_strdup(label);
 403
 404     unset_glyphs(toy_text);
 405     return TRUE;
 406 }
 407
 408 static void
 409 unset_font(AdgToyText *toy_text)
 410 {
 411     AdgToyTextPrivate *data = toy_text->data;
 412
 413     data->font = NULL;
 414 }
 415
 416 static void
 417 unset_glyphs(AdgToyText *toy_text)
 418 {
 419     AdgToyTextPrivate *data = toy_text->data;
 420
 421     if (data->glyphs != NULL) {
 422         cairo_glyph_free(data->glyphs);
 423         data->glyphs = NULL;
 424     }
 425
 426     data->num_glyphs = 0;
 427 }