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-font-style.h"
  42 #include "adg-intl.h"
  43
  44 #define PARENT_OBJECT_CLASS  ((GObjectClass *) adg_toy_text_parent_class)
  45 #define PARENT_ENTITY_CLASS  ((AdgEntityClass *) adg_toy_text_parent_class)
  46
  47
  48 enum {
  49     PROP_0,
  50     PROP_DRESS,
  51     PROP_LABEL
  52 };
  53
  54
  55 static void     finalize                (GObject        *object);
  56 static void     get_property            (GObject        *object,
  57                                          guint           param_id,
  58                                          GValue         *value,
  59                                          GParamSpec     *pspec);
  60 static void     set_property            (GObject        *object,
  61                                          guint           param_id,
  62                                          const GValue   *value,
  63                                          GParamSpec     *pspec);
  64 static void     global_changed          (AdgEntity      *entity);
  65 static void     invalidate              (AdgEntity      *entity);
  66 static void     arrange                 (AdgEntity      *entity);
  67 static void     render                  (AdgEntity      *entity,
  68                                          cairo_t        *cr);
  69 static gboolean set_dress               (AdgToyText     *toy_text,
  70                                          AdgDress        dress);
  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->invalidate = invalidate;
  98     entity_class->arrange = arrange;
  99     entity_class->render = render;
 100
 101     param = adg_param_spec_dress("dress",
 102                                  P_("Font Dress"),
 103                                  P_("The font dress to use for rendering this text"),
 104                                  ADG_DRESS_TEXT_REGULAR,
 105                                  G_PARAM_READWRITE);
 106     g_object_class_install_property(gobject_class, PROP_DRESS, param);
 107
 108     param = g_param_spec_string("label",
 109                                 P_("Label"),
 110                                 P_("The label to display"),
 111                                 NULL,
 112                                 G_PARAM_READWRITE);
 113     g_object_class_install_property(gobject_class, PROP_LABEL, param);
 114 }
 115
 116 static void
 117 adg_toy_text_init(AdgToyText *toy_text)
 118 {
 119     AdgToyTextPrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(toy_text,
 120                                                           ADG_TYPE_TOY_TEXT,
 121                                                           AdgToyTextPrivate);
 122
 123     data->dress = ADG_DRESS_TEXT_REGULAR;
 124     data->label = NULL;
 125     data->glyphs = NULL;
 126
 127     adg_entity_set_local_mode((AdgEntity *) toy_text,
 128                               ADG_TRANSFORM_BEFORE_NORMALIZED);
 129
 130     toy_text->data = data;
 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_DRESS:
 157         g_value_set_int(value, data->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_DRESS:
 176         set_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_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_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->dress;
 220 }
 221
 222 /**
 223  * adg_toy_text_set_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_dress(AdgToyText *toy_text, AdgDress dress)
 238 {
 239     g_return_if_fail(ADG_IS_TOY_TEXT(toy_text));
 240
 241     if (set_dress(toy_text, dress))
 242         g_object_notify((GObject *) toy_text, "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;
 314         AdgMatrix ctm;
 315
 316         font_style = (AdgFontStyle *) adg_entity_style(entity, data->dress);
 317         adg_entity_get_ctm(entity, &ctm);
 318
 319         data->font = adg_font_style_font(font_style, &ctm);
 320     }
 321
 322     if (data->label == NULL || data->label[0] == '\0') {
 323         /* Undefined label */
 324         extents.is_defined = FALSE;
 325         adg_entity_set_extents(entity, &extents);
 326         return;
 327     }
 328
 329     if (data->glyphs == NULL) {
 330         cairo_status_t status;
 331         cairo_text_extents_t cairo_extents;
 332
 333         status = cairo_scaled_font_text_to_glyphs(data->font, 0, 0,
 334                                                   data->label, -1,
 335                                                   &data->glyphs,
 336                                                   &data->num_glyphs,
 337                                                   NULL, NULL, NULL);
 338
 339         if (status != CAIRO_STATUS_SUCCESS) {
 340             unset_glyphs(toy_text);
 341             g_error("Unable to build glyphs (cairo message: %s)",
 342                     cairo_status_to_string(status));
 343             return;
 344         }
 345
 346         cairo_scaled_font_glyph_extents(data->font, data->glyphs,
 347                                         data->num_glyphs, &cairo_extents);
 348         cpml_extents_from_cairo_text(&extents, &cairo_extents);
 349         adg_entity_get_local_map(entity, &local);
 350         cairo_matrix_transform_point(&local, &extents.org.x, &extents.org.y);
 351         cairo_matrix_transform_distance(&local, &extents.size.x, &extents.size.y);
 352
 353         adg_entity_set_extents(entity, &extents);
 354     }
 355 }
 356
 357 static void
 358 render(AdgEntity *entity, cairo_t *cr)
 359 {
 360     AdgToyText *toy_text;
 361     AdgToyTextPrivate *data;
 362
 363     toy_text = (AdgToyText *) entity;
 364     data = toy_text->data;
 365
 366     if (data->glyphs != NULL) {
 367         AdgMatrix ctm;
 368
 369         adg_entity_get_ctm(entity, &ctm);
 370
 371         cairo_set_scaled_font(cr, data->font);
 372         cairo_set_matrix(cr, &ctm);
 373         cairo_show_glyphs(cr, data->glyphs, data->num_glyphs);
 374     }
 375 }
 376
 377 static gboolean
 378 set_dress(AdgToyText *toy_text, AdgDress dress)
 379 {
 380     AdgToyTextPrivate *data = toy_text->data;
 381
 382     if (adg_dress_set(&data->dress, dress)) {
 383         unset_font(toy_text);
 384         return TRUE;
 385     }
 386
 387     return FALSE;
 388 }
 389
 390 static gboolean
 391 set_label(AdgToyText *toy_text, const gchar *label)
 392 {
 393     AdgToyTextPrivate *data = toy_text->data;
 394
 395     /* Check if the new label differs from the current label */
 396     if (adg_strcmp(label, data->label) == 0)
 397         return FALSE;
 398
 399     g_free(data->label);
 400     data->label = g_strdup(label);
 401
 402     unset_glyphs(toy_text);
 403     return TRUE;
 404 }
 405
 406 static void
 407 unset_font(AdgToyText *toy_text)
 408 {
 409     AdgToyTextPrivate *data = toy_text->data;
 410
 411     data->font = NULL;
 412 }
 413
 414 static void
 415 unset_glyphs(AdgToyText *toy_text)
 416 {
 417     AdgToyTextPrivate *data = toy_text->data;
 418
 419     if (data->glyphs != NULL) {
 420         cairo_glyph_free(data->glyphs);
 421         data->glyphs = NULL;
 422     }
 423
 424     data->num_glyphs = 0;
 425 }