adg/adg-toy-text.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009 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-toy-text.h"
  40 #include "adg-toy-text-private.h"
  41 #include "adg-dress-builtins.h"
  42 #include "adg-font-style.h"
  43 #include "adg-intl.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     invalidate              (AdgEntity      *entity);
  67 static void     arrange                 (AdgEntity      *entity);
  68 static void     render                  (AdgEntity      *entity,
  69                                          cairo_t        *cr);
  70 static gboolean set_font_dress          (AdgToyText     *toy_text,
  71                                          AdgDress        dress);
  72 static gboolean set_label               (AdgToyText     *toy_text,
  73                                          const gchar    *label);
  74 static void     unset_font              (AdgToyText     *toy_text);
  75 static void     unset_glyphs            (AdgToyText     *toy_text);
  76
  77
  78 G_DEFINE_TYPE(AdgToyText, adg_toy_text, ADG_TYPE_ENTITY);
  79
  80
  81 static void
  82 adg_toy_text_class_init(AdgToyTextClass *klass)
  83 {
  84     GObjectClass *gobject_class;
  85     AdgEntityClass *entity_class;
  86     GParamSpec *param;
  87
  88     gobject_class = (GObjectClass *) klass;
  89     entity_class = (AdgEntityClass *) klass;
  90
  91     g_type_class_add_private(klass, sizeof(AdgToyTextPrivate));
  92
  93     gobject_class->finalize = finalize;
  94     gobject_class->get_property = get_property;
  95     gobject_class->set_property = set_property;
  96
  97     entity_class->global_changed = global_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_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_TEXT;
 125     data->label = NULL;
 126     data->glyphs = NULL;
 127
 128     toy_text->data = data;
 129
 130     adg_entity_set_normalized((AdgEntity *) toy_text, TRUE);
 131 }
 132
 133 static void
 134 finalize(GObject *object)
 135 {
 136     AdgToyText *toy_text;
 137     AdgToyTextPrivate *data;
 138
 139     toy_text = (AdgToyText *) object;
 140     data = toy_text->data;
 141
 142     g_free(data->label);
 143     unset_font(toy_text);
 144     unset_glyphs(toy_text);
 145
 146     if (PARENT_OBJECT_CLASS->finalize != NULL)
 147         PARENT_OBJECT_CLASS->finalize(object);
 148 }
 149
 150 static void
 151 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 152 {
 153     AdgToyTextPrivate *data = ((AdgToyText *) object)->data;
 154
 155     switch (prop_id) {
 156     case PROP_FONT_DRESS:
 157         g_value_set_int(value, data->font_dress);
 158         break;
 159     case PROP_LABEL:
 160         g_value_set_string(value, data->label);
 161         break;
 162     default:
 163         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 164         break;
 165     }
 166 }
 167
 168 static void
 169 set_property(GObject *object, guint prop_id,
 170              const GValue *value, GParamSpec *pspec)
 171 {
 172     AdgToyText *toy_text = (AdgToyText *) object;
 173
 174     switch (prop_id) {
 175     case PROP_FONT_DRESS:
 176         set_font_dress(toy_text, g_value_get_int(value));
 177         break;
 178     case PROP_LABEL:
 179         set_label(toy_text, g_value_get_string(value));
 180         break;
 181     default:
 182         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 183         break;
 184     }
 185 }
 186
 187
 188 /**
 189  * adg_toy_text_new:
 190  * @label: the label text
 191  *
 192  * Creates a new toy text entity using @label as its text
 193  *
 194  * Returns: the newly created toy text entity
 195  **/
 196 AdgToyText *
 197 adg_toy_text_new(const gchar *label)
 198 {
 199     return g_object_new(ADG_TYPE_TOY_TEXT, "label", label, NULL);
 200 }
 201
 202 /**
 203  * adg_toy_text_get_font_dress:
 204  * @toy_text: an #AdgToyText
 205  *
 206  * Gets the font dress to be used in rendering @toy_text.
 207  *
 208  * Returns: the current font dress
 209  **/
 210 AdgDress
 211 adg_toy_text_get_font_dress(AdgToyText *toy_text)
 212 {
 213     AdgToyTextPrivate *data;
 214
 215     g_return_val_if_fail(ADG_IS_TOY_TEXT(toy_text), ADG_DRESS_UNDEFINED);
 216
 217     data = toy_text->data;
 218
 219     return data->font_dress;
 220 }
 221
 222 /**
 223  * adg_toy_text_set_font_dress:
 224  * @toy_text: an #AdgToyText
 225  * @dress: the new #AdgDress to use
 226  *
 227  * Sets a new font dress for rendering @toy_text. The new dress
 228  * must be related to the original dress for this property:
 229  * you cannot set a dress used for line styles to a dress
 230  * managing fonts.
 231  *
 232  * The check is done by calling adg_dress_are_related() with
 233  * @dress and the previous dress as arguments. Check out its
 234  * documentation for details on what is a related dress.
 235  **/
 236 void
 237 adg_toy_text_set_font_dress(AdgToyText *toy_text, AdgDress dress)
 238 {
 239     g_return_if_fail(ADG_IS_TOY_TEXT(toy_text));
 240
 241     if (set_font_dress(toy_text, dress))
 242         g_object_notify((GObject *) toy_text, "font-dress");
 243 }
 244
 245 /**
 246  * adg_toy_text_get_label:
 247  * @toy_text: an #AdgToyText
 248  *
 249  * Gets the label text. The string is internally owned and
 250  * must not be freed or modified.
 251  *
 252  * Returns: the label text
 253  **/
 254 const gchar *
 255 adg_toy_text_get_label(AdgToyText *toy_text)
 256 {
 257     AdgToyTextPrivate *data;
 258
 259     g_return_val_if_fail(ADG_IS_TOY_TEXT(toy_text), NULL);
 260
 261     data = toy_text->data;
 262
 263     return data->label;
 264 }
 265
 266 /**
 267  * adg_toy_text_set_label:
 268  * @toy_text: an #AdgToyText
 269  * @label: the label text
 270  *
 271  * Sets a new label for @toy_text. @label can be also %NULL,
 272  * in which case will be treated as an empty string.
 273  **/
 274 void
 275 adg_toy_text_set_label(AdgToyText *toy_text, const gchar *label)
 276 {
 277     g_return_if_fail(ADG_IS_TOY_TEXT(toy_text));
 278
 279     if (set_label(toy_text, label))
 280         g_object_notify((GObject *) toy_text, "label");
 281 }
 282
 283
 284 static void
 285 global_changed(AdgEntity *entity)
 286 {
 287     PARENT_ENTITY_CLASS->global_changed(entity);
 288     unset_font((AdgToyText *) entity);
 289 }
 290
 291 static void
 292 invalidate(AdgEntity *entity)
 293 {
 294     unset_font((AdgToyText *) entity);
 295     unset_glyphs((AdgToyText *) entity);
 296
 297     if (PARENT_ENTITY_CLASS->invalidate != NULL)
 298         return PARENT_ENTITY_CLASS->invalidate(entity);
 299 }
 300
 301 static void
 302 arrange(AdgEntity *entity)
 303 {
 304     AdgToyText *toy_text;
 305     AdgToyTextPrivate *data;
 306     AdgMatrix local;
 307     CpmlExtents extents;
 308
 309     toy_text = (AdgToyText *) entity;
 310     data = toy_text->data;
 311
 312     if (data->font == NULL) {
 313         AdgFontStyle *font_style = (AdgFontStyle *)
 314             adg_entity_style(entity, data->font_dress);
 315
 316         data->font = adg_font_style_font(font_style, adg_entity_ctm(entity));
 317     }
 318
 319     if (data->label == NULL || data->label[0] == '\0') {
 320         /* Undefined label */
 321         extents.is_defined = FALSE;
 322         adg_entity_set_extents(entity, &extents);
 323         return;
 324     }
 325
 326     if (data->glyphs == NULL) {
 327         cairo_status_t status;
 328         cairo_text_extents_t cairo_extents;
 329
 330         status = cairo_scaled_font_text_to_glyphs(data->font, 0, 0,
 331                                                   data->label, -1,
 332                                                   &data->glyphs,
 333                                                   &data->num_glyphs,
 334                                                   NULL, NULL, NULL);
 335
 336         if (status != CAIRO_STATUS_SUCCESS) {
 337             unset_glyphs(toy_text);
 338             g_error("Unable to build glyphs (cairo message: %s)",
 339                     cairo_status_to_string(status));
 340             return;
 341         }
 342
 343         cairo_scaled_font_glyph_extents(data->font, data->glyphs,
 344                                         data->num_glyphs, &cairo_extents);
 345         cpml_extents_from_cairo_text(&extents, &cairo_extents);
 346         adg_entity_get_local_map(entity, &local);
 347         cairo_matrix_transform_point(&local, &extents.org.x, &extents.org.y);
 348         cairo_matrix_transform_distance(&local, &extents.size.x, &extents.size.y);
 349
 350         adg_entity_set_extents(entity, &extents);
 351     }
 352 }
 353
 354 static void
 355 render(AdgEntity *entity, cairo_t *cr)
 356 {
 357     AdgToyText *toy_text;
 358     AdgToyTextPrivate *data;
 359
 360     toy_text = (AdgToyText *) entity;
 361     data = toy_text->data;
 362
 363     if (data->glyphs != NULL) {
 364         adg_entity_apply_dress(entity, data->font_dress, cr);
 365         cairo_set_matrix(cr, adg_entity_ctm(entity));
 366         cairo_show_glyphs(cr, data->glyphs, data->num_glyphs);
 367     }
 368 }
 369
 370 static gboolean
 371 set_font_dress(AdgToyText *toy_text, AdgDress dress)
 372 {
 373     AdgToyTextPrivate *data = toy_text->data;
 374
 375     if (adg_dress_set(&data->font_dress, dress)) {
 376         unset_font(toy_text);
 377         return TRUE;
 378     }
 379
 380     return FALSE;
 381 }
 382
 383 static gboolean
 384 set_label(AdgToyText *toy_text, const gchar *label)
 385 {
 386     AdgToyTextPrivate *data = toy_text->data;
 387
 388     /* Check if the new label differs from the current label */
 389     if (adg_strcmp(label, data->label) == 0)
 390         return FALSE;
 391
 392     g_free(data->label);
 393     data->label = g_strdup(label);
 394
 395     unset_glyphs(toy_text);
 396     return TRUE;
 397 }
 398
 399 static void
 400 unset_font(AdgToyText *toy_text)
 401 {
 402     AdgToyTextPrivate *data = toy_text->data;
 403
 404     data->font = NULL;
 405 }
 406
 407 static void
 408 unset_glyphs(AdgToyText *toy_text)
 409 {
 410     AdgToyTextPrivate *data = toy_text->data;
 411
 412     if (data->glyphs != NULL) {
 413         cairo_glyph_free(data->glyphs);
 414         data->glyphs = NULL;
 415     }
 416
 417     data->num_glyphs = 0;
 418 }