2003-01-31 17:22:42 +08:00
|
|
|
/* The GIMP -- an image manipulation program
|
|
|
|
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
|
|
|
*
|
2003-08-14 23:39:30 +08:00
|
|
|
* GimpTextLayer
|
2004-01-05 08:28:12 +08:00
|
|
|
* Copyright (C) 2002-2004 Sven Neumann <sven@gimp.org>
|
2003-01-31 17:22:42 +08:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
2003-02-01 09:44:35 +08:00
|
|
|
#include <string.h>
|
|
|
|
|
2003-01-31 17:22:42 +08:00
|
|
|
#include <glib-object.h>
|
2003-07-21 05:23:01 +08:00
|
|
|
#include <pango/pangoft2.h>
|
2003-01-31 17:22:42 +08:00
|
|
|
|
|
|
|
#include "text-types.h"
|
|
|
|
|
|
|
|
#include "base/pixel-region.h"
|
|
|
|
#include "base/tile-manager.h"
|
|
|
|
|
|
|
|
#include "paint-funcs/paint-funcs.h"
|
|
|
|
|
2003-02-11 21:52:47 +08:00
|
|
|
#include "config/gimpconfig.h"
|
2003-10-28 05:50:41 +08:00
|
|
|
#include "config/gimpconfig-params.h"
|
|
|
|
#include "config/gimpconfig-utils.h"
|
2003-02-11 21:52:47 +08:00
|
|
|
|
2003-07-08 19:44:12 +08:00
|
|
|
#include "core/gimp.h"
|
2003-11-05 07:59:58 +08:00
|
|
|
#include "core/gimpcontainer.h"
|
2003-01-31 17:22:42 +08:00
|
|
|
#include "core/gimpimage.h"
|
2004-01-05 08:28:12 +08:00
|
|
|
#include "core/gimpimage-undo-push.h"
|
2003-10-28 05:50:41 +08:00
|
|
|
#include "core/gimpparasitelist.h"
|
2003-01-31 17:22:42 +08:00
|
|
|
|
|
|
|
#include "gimptext.h"
|
2003-07-21 05:23:01 +08:00
|
|
|
#include "gimptext-bitmap.h"
|
|
|
|
#include "gimptext-private.h"
|
2003-01-31 17:22:42 +08:00
|
|
|
#include "gimptextlayer.h"
|
2003-08-16 03:45:41 +08:00
|
|
|
#include "gimptextlayer-transform.h"
|
2003-02-05 16:29:12 +08:00
|
|
|
#include "gimptextlayout.h"
|
2003-07-07 02:43:58 +08:00
|
|
|
#include "gimptextlayout-render.h"
|
2003-01-31 17:22:42 +08:00
|
|
|
|
2003-04-01 01:47:00 +08:00
|
|
|
#include "gimp-intl.h"
|
2003-01-31 17:22:42 +08:00
|
|
|
|
|
|
|
|
2003-04-01 01:47:00 +08:00
|
|
|
static void gimp_text_layer_class_init (GimpTextLayerClass *klass);
|
|
|
|
static void gimp_text_layer_init (GimpTextLayer *layer);
|
|
|
|
static void gimp_text_layer_dispose (GObject *object);
|
2003-10-28 05:50:41 +08:00
|
|
|
static void gimp_text_layer_finalize (GObject *object);
|
2003-04-01 01:47:00 +08:00
|
|
|
|
2003-11-17 01:51:36 +08:00
|
|
|
static gint64 gimp_text_layer_get_memsize (GimpObject *object,
|
|
|
|
gint64 *gui_size);
|
2003-10-28 05:50:41 +08:00
|
|
|
|
2003-04-01 01:47:00 +08:00
|
|
|
static GimpItem * gimp_text_layer_duplicate (GimpItem *item,
|
|
|
|
GType new_type,
|
|
|
|
gboolean add_alpha);
|
|
|
|
static void gimp_text_layer_rename (GimpItem *item,
|
|
|
|
const gchar *new_name,
|
|
|
|
const gchar *undo_desc);
|
2003-08-16 03:45:41 +08:00
|
|
|
|
2003-10-28 05:50:41 +08:00
|
|
|
static void gimp_text_layer_text_notify (GimpTextLayer *layer);
|
2003-04-01 01:47:00 +08:00
|
|
|
static gboolean gimp_text_layer_idle_render (GimpTextLayer *layer);
|
2003-08-16 03:45:41 +08:00
|
|
|
static gboolean gimp_text_layer_render_now (GimpTextLayer *layer);
|
2003-04-01 01:47:00 +08:00
|
|
|
static void gimp_text_layer_render_layout (GimpTextLayer *layer,
|
|
|
|
GimpTextLayout *layout);
|
2003-01-31 17:22:42 +08:00
|
|
|
|
|
|
|
|
|
|
|
static GimpLayerClass *parent_class = NULL;
|
|
|
|
|
|
|
|
|
|
|
|
GType
|
|
|
|
gimp_text_layer_get_type (void)
|
|
|
|
{
|
|
|
|
static GType layer_type = 0;
|
|
|
|
|
|
|
|
if (! layer_type)
|
|
|
|
{
|
|
|
|
static const GTypeInfo layer_info =
|
|
|
|
{
|
|
|
|
sizeof (GimpTextLayerClass),
|
|
|
|
(GBaseInitFunc) NULL,
|
|
|
|
(GBaseFinalizeFunc) NULL,
|
|
|
|
(GClassInitFunc) gimp_text_layer_class_init,
|
|
|
|
NULL, /* class_finalize */
|
|
|
|
NULL, /* class_data */
|
|
|
|
sizeof (GimpTextLayer),
|
|
|
|
0, /* n_preallocs */
|
|
|
|
(GInstanceInitFunc) gimp_text_layer_init,
|
|
|
|
};
|
|
|
|
|
|
|
|
layer_type = g_type_register_static (GIMP_TYPE_LAYER,
|
|
|
|
"GimpTextLayer",
|
|
|
|
&layer_info, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return layer_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gimp_text_layer_class_init (GimpTextLayerClass *klass)
|
|
|
|
{
|
|
|
|
GObjectClass *object_class;
|
|
|
|
GimpObjectClass *gimp_object_class;
|
|
|
|
GimpViewableClass *viewable_class;
|
2003-02-11 21:52:47 +08:00
|
|
|
GimpItemClass *item_class;
|
2003-01-31 17:22:42 +08:00
|
|
|
|
|
|
|
object_class = G_OBJECT_CLASS (klass);
|
|
|
|
gimp_object_class = GIMP_OBJECT_CLASS (klass);
|
|
|
|
viewable_class = GIMP_VIEWABLE_CLASS (klass);
|
2003-02-11 21:52:47 +08:00
|
|
|
item_class = GIMP_ITEM_CLASS (klass);
|
2003-01-31 17:22:42 +08:00
|
|
|
|
|
|
|
parent_class = g_type_class_peek_parent (klass);
|
|
|
|
|
2003-02-27 02:08:26 +08:00
|
|
|
object_class->dispose = gimp_text_layer_dispose;
|
2003-10-28 05:50:41 +08:00
|
|
|
object_class->finalize = gimp_text_layer_finalize;
|
2003-01-31 17:22:42 +08:00
|
|
|
|
2003-02-27 02:08:26 +08:00
|
|
|
gimp_object_class->get_memsize = gimp_text_layer_get_memsize;
|
2003-01-31 17:22:42 +08:00
|
|
|
|
2003-03-27 20:29:54 +08:00
|
|
|
viewable_class->default_stock_id = "gimp-text-layer";
|
2003-02-11 21:52:47 +08:00
|
|
|
|
2003-08-16 03:45:41 +08:00
|
|
|
item_class->default_name = _("Text Layer");
|
2003-02-27 02:08:26 +08:00
|
|
|
item_class->duplicate = gimp_text_layer_duplicate;
|
2003-04-01 01:47:00 +08:00
|
|
|
item_class->rename = gimp_text_layer_rename;
|
2003-08-16 03:45:41 +08:00
|
|
|
|
|
|
|
#if 0
|
|
|
|
item_class->scale = gimp_text_layer_scale;
|
|
|
|
item_class->flip = gimp_text_layer_flip;
|
|
|
|
item_class->rotate = gimp_text_layer_rotate;
|
|
|
|
item_class->transform = gimp_text_layer_transform;
|
|
|
|
#endif
|
2003-01-31 17:22:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gimp_text_layer_init (GimpTextLayer *layer)
|
|
|
|
{
|
2003-04-01 01:47:00 +08:00
|
|
|
layer->text = NULL;
|
2003-10-28 05:50:41 +08:00
|
|
|
layer->text_parasite = NULL;
|
2003-04-01 01:47:00 +08:00
|
|
|
layer->idle_render_id = 0;
|
|
|
|
layer->auto_rename = TRUE;
|
2003-01-31 17:22:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2003-02-06 02:23:58 +08:00
|
|
|
gimp_text_layer_dispose (GObject *object)
|
2003-01-31 17:22:42 +08:00
|
|
|
{
|
2003-10-28 05:50:41 +08:00
|
|
|
GimpTextLayer *layer = GIMP_TEXT_LAYER (object);
|
2003-01-31 17:22:42 +08:00
|
|
|
|
2003-02-06 02:23:58 +08:00
|
|
|
if (layer->idle_render_id)
|
|
|
|
{
|
|
|
|
g_source_remove (layer->idle_render_id);
|
|
|
|
layer->idle_render_id = 0;
|
|
|
|
}
|
2003-10-28 05:50:41 +08:00
|
|
|
|
|
|
|
G_OBJECT_CLASS (parent_class)->dispose (object);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gimp_text_layer_finalize (GObject *object)
|
|
|
|
{
|
|
|
|
GimpTextLayer *layer = GIMP_TEXT_LAYER (object);
|
|
|
|
|
2003-01-31 17:22:42 +08:00
|
|
|
if (layer->text)
|
|
|
|
{
|
|
|
|
g_object_unref (layer->text);
|
|
|
|
layer->text = NULL;
|
|
|
|
}
|
|
|
|
|
2003-10-28 05:50:41 +08:00
|
|
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
2003-01-31 17:22:42 +08:00
|
|
|
}
|
|
|
|
|
2003-11-17 01:51:36 +08:00
|
|
|
static gint64
|
2003-08-25 18:45:16 +08:00
|
|
|
gimp_text_layer_get_memsize (GimpObject *object,
|
2003-11-17 01:51:36 +08:00
|
|
|
gint64 *gui_size)
|
2003-02-11 21:52:47 +08:00
|
|
|
{
|
|
|
|
GimpTextLayer *text_layer;
|
2003-11-17 01:51:36 +08:00
|
|
|
gint64 memsize = 0;
|
2003-02-11 21:52:47 +08:00
|
|
|
|
|
|
|
text_layer = GIMP_TEXT_LAYER (object);
|
|
|
|
|
|
|
|
if (text_layer->text)
|
2003-08-25 18:45:16 +08:00
|
|
|
memsize += gimp_object_get_memsize (GIMP_OBJECT (text_layer->text),
|
|
|
|
gui_size);
|
2003-02-11 21:52:47 +08:00
|
|
|
|
2003-08-25 18:45:16 +08:00
|
|
|
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
|
|
|
|
gui_size);
|
2003-02-11 21:52:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static GimpItem *
|
|
|
|
gimp_text_layer_duplicate (GimpItem *item,
|
|
|
|
GType new_type,
|
|
|
|
gboolean add_alpha)
|
|
|
|
{
|
|
|
|
GimpTextLayer *text_layer;
|
|
|
|
GimpItem *new_item;
|
|
|
|
GimpTextLayer *new_text_layer;
|
|
|
|
|
|
|
|
g_return_val_if_fail (g_type_is_a (new_type, GIMP_TYPE_DRAWABLE), NULL);
|
|
|
|
|
|
|
|
new_item = GIMP_ITEM_CLASS (parent_class)->duplicate (item, new_type,
|
|
|
|
add_alpha);
|
|
|
|
|
|
|
|
if (! GIMP_IS_TEXT_LAYER (new_item))
|
|
|
|
return new_item;
|
|
|
|
|
|
|
|
text_layer = GIMP_TEXT_LAYER (item);
|
|
|
|
new_text_layer = GIMP_TEXT_LAYER (new_item);
|
|
|
|
|
2004-01-05 08:28:12 +08:00
|
|
|
if (text_layer->text)
|
|
|
|
{
|
|
|
|
new_text_layer->text =
|
|
|
|
gimp_config_duplicate (GIMP_CONFIG (text_layer->text));
|
2003-02-11 21:52:47 +08:00
|
|
|
|
2004-01-05 08:28:12 +08:00
|
|
|
g_signal_connect_object (new_text_layer->text, "notify",
|
|
|
|
G_CALLBACK (gimp_text_layer_text_notify),
|
|
|
|
new_text_layer, G_CONNECT_SWAPPED);
|
|
|
|
}
|
|
|
|
|
|
|
|
new_text_layer->text_parasite = text_layer->text_parasite;
|
2003-02-11 21:52:47 +08:00
|
|
|
|
|
|
|
return new_item;
|
|
|
|
}
|
|
|
|
|
2003-04-01 01:47:00 +08:00
|
|
|
static void
|
|
|
|
gimp_text_layer_rename (GimpItem *item,
|
|
|
|
const gchar *new_name,
|
|
|
|
const gchar *undo_desc)
|
|
|
|
{
|
|
|
|
GIMP_TEXT_LAYER (item)->auto_rename = FALSE;
|
2003-08-14 23:39:30 +08:00
|
|
|
|
2003-04-01 01:47:00 +08:00
|
|
|
GIMP_ITEM_CLASS (parent_class)->rename (item, new_name, undo_desc);
|
|
|
|
}
|
|
|
|
|
2003-08-16 03:45:41 +08:00
|
|
|
/**
|
|
|
|
* gimp_text_layer_new:
|
|
|
|
* @image: the #GimpImage the layer should belong to
|
|
|
|
* @text: a #GimpText object
|
|
|
|
*
|
|
|
|
* Creates a new text layer.
|
|
|
|
*
|
|
|
|
* Return value: a new #GimpTextLayer or %NULL in case of a problem
|
|
|
|
**/
|
2003-01-31 17:22:42 +08:00
|
|
|
GimpLayer *
|
2003-01-31 21:36:27 +08:00
|
|
|
gimp_text_layer_new (GimpImage *image,
|
2003-08-16 03:45:41 +08:00
|
|
|
GimpText *text)
|
2003-01-31 17:22:42 +08:00
|
|
|
{
|
2003-06-24 21:58:34 +08:00
|
|
|
GimpTextLayer *layer;
|
2003-09-12 03:52:29 +08:00
|
|
|
|
2003-01-31 21:36:27 +08:00
|
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
|
2003-01-31 17:22:42 +08:00
|
|
|
g_return_val_if_fail (GIMP_IS_TEXT (text), NULL);
|
2003-09-12 03:52:29 +08:00
|
|
|
|
2003-10-28 05:50:41 +08:00
|
|
|
if (! text->text)
|
2003-01-31 17:22:42 +08:00
|
|
|
return NULL;
|
2003-09-12 03:52:29 +08:00
|
|
|
|
2003-01-31 17:22:42 +08:00
|
|
|
layer = g_object_new (GIMP_TYPE_TEXT_LAYER, NULL);
|
2003-09-12 03:52:29 +08:00
|
|
|
|
2003-02-01 02:57:10 +08:00
|
|
|
gimp_drawable_configure (GIMP_DRAWABLE (layer),
|
|
|
|
image,
|
|
|
|
0, 0, 0, 0,
|
|
|
|
gimp_image_base_type_with_alpha (image),
|
|
|
|
NULL);
|
2003-09-12 03:52:29 +08:00
|
|
|
|
2003-06-24 21:58:34 +08:00
|
|
|
gimp_text_layer_set_text (layer, text);
|
2003-09-12 03:52:29 +08:00
|
|
|
|
2003-08-16 03:45:41 +08:00
|
|
|
if (! gimp_text_layer_render_now (layer))
|
2003-01-31 17:22:42 +08:00
|
|
|
{
|
|
|
|
g_object_unref (layer);
|
|
|
|
return NULL;
|
|
|
|
}
|
2003-09-12 03:52:29 +08:00
|
|
|
|
2003-06-24 21:58:34 +08:00
|
|
|
return GIMP_LAYER (layer);
|
|
|
|
}
|
2003-09-12 03:52:29 +08:00
|
|
|
|
2003-10-28 05:50:41 +08:00
|
|
|
void
|
2003-06-24 21:58:34 +08:00
|
|
|
gimp_text_layer_set_text (GimpTextLayer *layer,
|
|
|
|
GimpText *text)
|
|
|
|
{
|
|
|
|
g_return_if_fail (GIMP_IS_TEXT_LAYER (layer));
|
2004-01-05 08:28:12 +08:00
|
|
|
g_return_if_fail (text == NULL || GIMP_IS_TEXT (text));
|
|
|
|
|
|
|
|
if (layer->text == text)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (layer->text)
|
|
|
|
{
|
|
|
|
gimp_text_layer_flush (layer);
|
|
|
|
|
|
|
|
g_signal_handlers_disconnect_by_func (layer->text,
|
|
|
|
G_CALLBACK (gimp_text_layer_text_notify),
|
|
|
|
layer);
|
|
|
|
|
|
|
|
g_object_unref (layer->text);
|
|
|
|
layer->text = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (text)
|
|
|
|
{
|
|
|
|
layer->text = g_object_ref (text);
|
|
|
|
|
|
|
|
g_signal_connect_object (text, "notify",
|
|
|
|
G_CALLBACK (gimp_text_layer_text_notify),
|
|
|
|
layer, G_CONNECT_SWAPPED);
|
|
|
|
}
|
2003-06-24 21:58:34 +08:00
|
|
|
|
2004-01-05 08:28:12 +08:00
|
|
|
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (layer));
|
2003-01-31 17:22:42 +08:00
|
|
|
}
|
|
|
|
|
2003-02-01 00:37:03 +08:00
|
|
|
GimpText *
|
|
|
|
gimp_text_layer_get_text (GimpTextLayer *layer)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (GIMP_IS_TEXT_LAYER (layer), NULL);
|
2003-08-14 23:39:30 +08:00
|
|
|
|
2003-02-01 00:37:03 +08:00
|
|
|
return layer->text;
|
|
|
|
}
|
|
|
|
|
2004-01-05 08:28:12 +08:00
|
|
|
/**
|
|
|
|
* gimp_text_layer_discard:
|
|
|
|
* @layer: a #GimpTextLayer
|
|
|
|
*
|
|
|
|
* Discards the text information. This makes @layer behave like a
|
|
|
|
* normal layer.
|
|
|
|
*/
|
2003-08-16 03:45:41 +08:00
|
|
|
void
|
2004-01-05 08:28:12 +08:00
|
|
|
gimp_text_layer_discard (GimpTextLayer *layer)
|
2003-08-16 03:45:41 +08:00
|
|
|
{
|
|
|
|
g_return_if_fail (GIMP_IS_TEXT_LAYER (layer));
|
|
|
|
|
2004-01-05 08:28:12 +08:00
|
|
|
if (! layer->text)
|
|
|
|
return;
|
|
|
|
|
|
|
|
gimp_image_undo_push_text_layer (gimp_item_get_image (GIMP_ITEM (layer)),
|
|
|
|
_("Discard Text Information"),
|
|
|
|
layer);
|
|
|
|
|
|
|
|
gimp_text_layer_set_text (layer, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gimp_text_layer_flush:
|
|
|
|
* @layer: a #GimpTextLayer
|
|
|
|
*
|
|
|
|
* Flushes pending changes to the text layer that would otherwise be
|
|
|
|
* performed in an idle handler.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gimp_text_layer_flush (GimpTextLayer *layer)
|
|
|
|
{
|
|
|
|
g_return_if_fail (GIMP_IS_TEXT_LAYER (layer));
|
|
|
|
|
|
|
|
if (layer->idle_render_id)
|
|
|
|
gimp_text_layer_render_now (layer);
|
2003-08-16 03:45:41 +08:00
|
|
|
}
|
|
|
|
|
2003-02-06 02:23:58 +08:00
|
|
|
static void
|
2003-10-28 05:50:41 +08:00
|
|
|
gimp_text_layer_text_notify (GimpTextLayer *layer)
|
2003-02-06 02:23:58 +08:00
|
|
|
{
|
2003-10-28 05:50:41 +08:00
|
|
|
/* If the text layer was created from a parasite, it's time to
|
|
|
|
* remove that parasite now.
|
|
|
|
*/
|
|
|
|
if (layer->text_parasite)
|
|
|
|
{
|
|
|
|
gimp_parasite_list_remove (GIMP_ITEM (layer)->parasites,
|
|
|
|
layer->text_parasite);
|
|
|
|
layer->text_parasite = NULL;
|
|
|
|
}
|
|
|
|
|
2003-02-06 02:23:58 +08:00
|
|
|
if (layer->idle_render_id)
|
2003-02-08 01:01:38 +08:00
|
|
|
g_source_remove (layer->idle_render_id);
|
2003-02-06 02:23:58 +08:00
|
|
|
|
|
|
|
layer->idle_render_id =
|
|
|
|
g_idle_add_full (G_PRIORITY_LOW,
|
|
|
|
(GSourceFunc) gimp_text_layer_idle_render, layer,
|
|
|
|
NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
gimp_text_layer_idle_render (GimpTextLayer *layer)
|
|
|
|
{
|
|
|
|
layer->idle_render_id = 0;
|
|
|
|
|
2003-08-16 03:45:41 +08:00
|
|
|
gimp_text_layer_render_now (layer);
|
2003-02-06 02:23:58 +08:00
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2003-01-31 21:36:27 +08:00
|
|
|
static gboolean
|
2003-08-16 03:45:41 +08:00
|
|
|
gimp_text_layer_render_now (GimpTextLayer *layer)
|
2003-01-31 17:22:42 +08:00
|
|
|
{
|
2003-02-01 02:57:10 +08:00
|
|
|
GimpDrawable *drawable;
|
2003-05-08 21:12:46 +08:00
|
|
|
GimpItem *item;
|
|
|
|
GimpImage *image;
|
2003-02-05 16:29:12 +08:00
|
|
|
GimpTextLayout *layout;
|
|
|
|
gint width;
|
|
|
|
gint height;
|
2003-01-31 17:22:42 +08:00
|
|
|
|
2003-10-28 05:50:41 +08:00
|
|
|
if (layer->idle_render_id)
|
|
|
|
{
|
|
|
|
g_source_remove (layer->idle_render_id);
|
|
|
|
layer->idle_render_id = 0;
|
|
|
|
}
|
|
|
|
|
2004-01-05 08:28:12 +08:00
|
|
|
if (! layer->text)
|
|
|
|
return FALSE;
|
|
|
|
|
2003-02-08 01:01:38 +08:00
|
|
|
drawable = GIMP_DRAWABLE (layer);
|
2003-05-08 21:12:46 +08:00
|
|
|
item = GIMP_ITEM (layer);
|
|
|
|
image = gimp_item_get_image (item);
|
2003-01-31 17:22:42 +08:00
|
|
|
|
2003-11-05 07:59:58 +08:00
|
|
|
if (gimp_container_num_children (image->gimp->fonts) == 0)
|
|
|
|
{
|
2003-11-14 23:33:40 +08:00
|
|
|
g_message (_("Due to lack of any fonts, "
|
2003-11-05 07:59:58 +08:00
|
|
|
"text functionality is not available."));
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2003-02-05 16:29:12 +08:00
|
|
|
layout = gimp_text_layout_new (layer->text, image);
|
|
|
|
|
2003-02-08 01:01:38 +08:00
|
|
|
if (gimp_text_layout_get_size (layout, &width, &height))
|
2003-01-31 21:36:27 +08:00
|
|
|
{
|
2003-05-08 21:12:46 +08:00
|
|
|
if (width != gimp_item_width (item) ||
|
|
|
|
height != gimp_item_height (item))
|
2003-02-08 01:01:38 +08:00
|
|
|
{
|
|
|
|
gimp_drawable_update (drawable,
|
|
|
|
0, 0,
|
2003-05-08 21:12:46 +08:00
|
|
|
gimp_item_width (item),
|
|
|
|
gimp_item_height (item));
|
2003-08-14 23:39:30 +08:00
|
|
|
|
2003-07-26 00:12:35 +08:00
|
|
|
/* Make sure we're not caching any old selection info */
|
2003-09-04 19:33:06 +08:00
|
|
|
gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (layer));
|
2003-07-26 00:12:35 +08:00
|
|
|
|
2003-05-08 19:52:31 +08:00
|
|
|
GIMP_ITEM (drawable)->width = width;
|
|
|
|
GIMP_ITEM (drawable)->height = height;
|
2003-08-14 23:39:30 +08:00
|
|
|
|
2003-02-08 01:01:38 +08:00
|
|
|
if (drawable->tiles)
|
2003-05-27 01:02:06 +08:00
|
|
|
tile_manager_unref (drawable->tiles);
|
2003-08-14 23:39:30 +08:00
|
|
|
|
2003-02-08 01:01:38 +08:00
|
|
|
drawable->tiles = tile_manager_new (width, height, drawable->bytes);
|
|
|
|
|
To optimize duplicate and/or wrong image updates away, introduced new
2003-09-06 Michael Natterer <mitch@gimp.org>
To optimize duplicate and/or wrong image updates away, introduced
new policy that a child object must never explicitly update or
invalidate its parent object (just like the GUI is not updated
explicitly by the core):
* app/core/gimpdrawable.[ch]: added new signal
GimpDrawable::update(). Never update or invalidate the image when
the drawable is updated or invalidated.
(gimp_drawable_set_visible): don't gimp_drawable_update() the
drawable since its pixels have not changed.
* app/core/gimpimage.[ch]: connect to the "add" and "remove"
signals of the layers and channels containers. Also connect to the
"update" and "visibility_changed" signals of all drawables in
these containers (optimizes away updates issued by drawables which
are not yet added to the image and updates of the selection
mask). Also, don't propagate updates to the image if the emitting
drawable is invisible (optimizes away updates issued by invisible
drawables).
(gimp_image_add_layer,channel)
(gimp_image_remove_layer,channel): don't update the image since
that's done by our "add" and "remove" handlers now.
(gimp_image_position_layer,channel): update just the image, not
the drawable since its pixels have not changed.
(gimp_image_real_colormap_changed)
(gimp_image_set_component_visible): always call
gimp_image_update() *and* gimp_viewable_invalidate_preview() to
get everything updated, since update and invalidate of images are
not connected.
* app/core/gimpimage-undo-push.c (undo_pop_layer,channel): don't
update the drawable since (a) its pixels don't change and (b) the
image updates itself upon adding/removing now.
(undo_pop_layer_mod): replaced gimp_image_update() by
gimp_drawable_update() (just for consistency with other similar
functions).
* app/core/gimplayer.c: connect to "update" of the layer mask and
issue updates on the layer if the mask update has any effect on
the projection.
(gimp_layer_create_mask): don't set the mask's offsets here since
they may be different when we later add the mask to the layer.
* app/core/gimplayermask.c (gimp_layer_mask_set_layer): set the
mask offsets here instead.
* app/core/gimpchannel.c (gimp_channel_translate): update the
channel even if push_undo == FALSE.
* app/paint/gimppaintcore.c (gimp_paint_core_finish)
* app/tools/gimpinktool.c (ink_finish): invalidate both the
drawable and the image preview since invalidating the drawable
doesn't invalidate the image any more.
* app/text/gimptextlayer.c (gimp_text_layer_render_now): also
update the new extents of the text layer, not only the old one.
(gimp_text_layer_render_layout): don't update the drawable since
gimp_drawable_fill() already updated it.
2003-09-07 04:06:53 +08:00
|
|
|
gimp_drawable_update (drawable,
|
|
|
|
0, 0,
|
|
|
|
gimp_item_width (item),
|
|
|
|
gimp_item_height (item));
|
|
|
|
|
2003-02-08 01:01:38 +08:00
|
|
|
gimp_viewable_size_changed (GIMP_VIEWABLE (layer));
|
|
|
|
}
|
2003-01-31 21:36:27 +08:00
|
|
|
}
|
2003-02-01 02:57:10 +08:00
|
|
|
|
2003-04-01 01:47:00 +08:00
|
|
|
if (layer->auto_rename)
|
|
|
|
gimp_object_set_name_safe (GIMP_OBJECT (layer),
|
|
|
|
layer->text->text ?
|
|
|
|
layer->text->text : _("Empty Text Layer"));
|
2003-01-31 21:36:27 +08:00
|
|
|
|
2003-02-05 16:29:12 +08:00
|
|
|
gimp_text_layer_render_layout (layer, layout);
|
2003-01-31 21:36:27 +08:00
|
|
|
g_object_unref (layout);
|
2003-01-31 17:22:42 +08:00
|
|
|
|
2003-02-01 00:37:03 +08:00
|
|
|
gimp_image_flush (image);
|
|
|
|
|
2003-02-08 01:01:38 +08:00
|
|
|
return (width > 0 && height > 0);
|
2003-01-31 17:22:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2003-02-05 16:29:12 +08:00
|
|
|
gimp_text_layer_render_layout (GimpTextLayer *layer,
|
|
|
|
GimpTextLayout *layout)
|
2003-01-31 17:22:42 +08:00
|
|
|
{
|
2003-05-08 21:12:46 +08:00
|
|
|
GimpDrawable *drawable;
|
|
|
|
GimpItem *item;
|
2003-01-31 17:22:42 +08:00
|
|
|
TileManager *mask;
|
2003-07-21 05:23:01 +08:00
|
|
|
FT_Bitmap bitmap;
|
2003-01-31 17:22:42 +08:00
|
|
|
PixelRegion textPR;
|
|
|
|
PixelRegion maskPR;
|
2003-07-21 05:23:01 +08:00
|
|
|
gint i;
|
2003-05-08 21:12:46 +08:00
|
|
|
|
|
|
|
drawable = GIMP_DRAWABLE (layer);
|
|
|
|
item = GIMP_ITEM (layer);
|
|
|
|
|
2003-01-31 17:22:42 +08:00
|
|
|
gimp_drawable_fill (drawable, &layer->text->color);
|
|
|
|
|
2003-07-21 05:23:01 +08:00
|
|
|
bitmap.width = gimp_item_width (item);
|
|
|
|
bitmap.rows = gimp_item_height (item);
|
|
|
|
bitmap.pitch = bitmap.width;
|
|
|
|
if (bitmap.pitch & 3)
|
|
|
|
bitmap.pitch += 4 - (bitmap.pitch & 3);
|
2003-01-31 17:22:42 +08:00
|
|
|
|
2003-07-21 05:23:01 +08:00
|
|
|
bitmap.buffer = g_malloc0 (bitmap.rows * bitmap.pitch);
|
2003-01-31 17:22:42 +08:00
|
|
|
|
2003-07-21 05:23:01 +08:00
|
|
|
gimp_text_layout_render (layout,
|
|
|
|
(GimpTextRenderFunc) gimp_text_render_bitmap,
|
|
|
|
&bitmap);
|
|
|
|
|
|
|
|
mask = tile_manager_new (bitmap.width, bitmap.rows, 1);
|
|
|
|
pixel_region_init (&maskPR, mask, 0, 0, bitmap.width, bitmap.rows, TRUE);
|
|
|
|
|
|
|
|
for (i = 0; i < bitmap.rows; i++)
|
|
|
|
pixel_region_set_row (&maskPR,
|
|
|
|
0, i, bitmap.width,
|
|
|
|
bitmap.buffer + i * bitmap.pitch);
|
|
|
|
|
|
|
|
g_free (bitmap.buffer);
|
|
|
|
|
|
|
|
pixel_region_init (&textPR, drawable->tiles,
|
|
|
|
0, 0, bitmap.width, bitmap.rows, TRUE);
|
|
|
|
pixel_region_init (&maskPR, mask,
|
|
|
|
0, 0, bitmap.width, bitmap.rows, FALSE);
|
2003-01-31 17:22:42 +08:00
|
|
|
|
|
|
|
apply_mask_to_region (&textPR, &maskPR, OPAQUE_OPACITY);
|
2003-08-14 23:39:30 +08:00
|
|
|
|
2003-05-27 01:02:06 +08:00
|
|
|
tile_manager_unref (mask);
|
2003-02-08 01:01:38 +08:00
|
|
|
|
To optimize duplicate and/or wrong image updates away, introduced new
2003-09-06 Michael Natterer <mitch@gimp.org>
To optimize duplicate and/or wrong image updates away, introduced
new policy that a child object must never explicitly update or
invalidate its parent object (just like the GUI is not updated
explicitly by the core):
* app/core/gimpdrawable.[ch]: added new signal
GimpDrawable::update(). Never update or invalidate the image when
the drawable is updated or invalidated.
(gimp_drawable_set_visible): don't gimp_drawable_update() the
drawable since its pixels have not changed.
* app/core/gimpimage.[ch]: connect to the "add" and "remove"
signals of the layers and channels containers. Also connect to the
"update" and "visibility_changed" signals of all drawables in
these containers (optimizes away updates issued by drawables which
are not yet added to the image and updates of the selection
mask). Also, don't propagate updates to the image if the emitting
drawable is invisible (optimizes away updates issued by invisible
drawables).
(gimp_image_add_layer,channel)
(gimp_image_remove_layer,channel): don't update the image since
that's done by our "add" and "remove" handlers now.
(gimp_image_position_layer,channel): update just the image, not
the drawable since its pixels have not changed.
(gimp_image_real_colormap_changed)
(gimp_image_set_component_visible): always call
gimp_image_update() *and* gimp_viewable_invalidate_preview() to
get everything updated, since update and invalidate of images are
not connected.
* app/core/gimpimage-undo-push.c (undo_pop_layer,channel): don't
update the drawable since (a) its pixels don't change and (b) the
image updates itself upon adding/removing now.
(undo_pop_layer_mod): replaced gimp_image_update() by
gimp_drawable_update() (just for consistency with other similar
functions).
* app/core/gimplayer.c: connect to "update" of the layer mask and
issue updates on the layer if the mask update has any effect on
the projection.
(gimp_layer_create_mask): don't set the mask's offsets here since
they may be different when we later add the mask to the layer.
* app/core/gimplayermask.c (gimp_layer_mask_set_layer): set the
mask offsets here instead.
* app/core/gimpchannel.c (gimp_channel_translate): update the
channel even if push_undo == FALSE.
* app/paint/gimppaintcore.c (gimp_paint_core_finish)
* app/tools/gimpinktool.c (ink_finish): invalidate both the
drawable and the image preview since invalidating the drawable
doesn't invalidate the image any more.
* app/text/gimptextlayer.c (gimp_text_layer_render_now): also
update the new extents of the text layer, not only the old one.
(gimp_text_layer_render_layout): don't update the drawable since
gimp_drawable_fill() already updated it.
2003-09-07 04:06:53 +08:00
|
|
|
/* no need to gimp_drawable_update() since gimp_drawable_fill()
|
|
|
|
* did that for us.
|
|
|
|
*/
|
2003-01-31 17:22:42 +08:00
|
|
|
}
|