1998-06-15 06:42:36 +08:00
|
|
|
/* The GIMP -- an image manipulation program
|
|
|
|
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
2000-12-17 05:37:03 +08:00
|
|
|
|
app/appenv.h New file. Includes <math.h>. Move G_PI, RINT(), ROUND() etc
1999-09-01 Tor Lillqvist <tml@iki.fi>
* app/appenv.h
* libgimp/gimpmath.h: New file. Includes <math.h>. Move G_PI,
RINT(), ROUND() etc from app/appenv.h here, so plug-ins can
use them, too. Remove some commented-out old stuff in appenv.h.
* libgimp/gimp.h: Include gimpmath.h.
* libgimp/gimp.c (gimp_main): Win32: Don't install signal
handlers, we can't do anything useful in the handler ourselves
anyway (it would be nice to print out a backtrace, but that seems
pretty hard to do, even if not impossible). Let Windows inform the
user about the crash. If the plug-in was compiled with MSVC, and
the user also has it, she is offered a chance to start the
debugger automatically anyway.
* app/*several*.c: Include gimpmath.h for G_PI etc. Don't include
<math.h>, as gimpmath.h includes it.
* plug-ins/*/*many*.c: Include config.h. Don't include <math.h>.
Remove all the duplicated definitions of G_PI and rint(). Use
RINT() instead of rint().
* app/app_procs.[ch]: app_exit() takes a gboolean.
* app/batch.c
* app/commands.c
* app/interface.c: Call app_exit() with FALSE or TRUE.
* app/main.c (on_error): Call gimp_fatal_error. (main): Don't
install any signal handler on Win32 here, either.
* app/errors.c (gimp_fatal_error, gimp_terminate): Win32: Format
the message and call MessageBox with it. g_on_error_query doesn't
do anything useful on Win32, and printf'ing a message to stdout or
stderr doesn't do anything, either, in a windowing application.
1999-09-02 04:30:56 +08:00
|
|
|
#include "config.h"
|
|
|
|
|
1999-04-13 01:55:06 +08:00
|
|
|
#include <stdlib.h>
|
1999-03-07 20:56:03 +08:00
|
|
|
#include <string.h>
|
app/appenv.h New file. Includes <math.h>. Move G_PI, RINT(), ROUND() etc
1999-09-01 Tor Lillqvist <tml@iki.fi>
* app/appenv.h
* libgimp/gimpmath.h: New file. Includes <math.h>. Move G_PI,
RINT(), ROUND() etc from app/appenv.h here, so plug-ins can
use them, too. Remove some commented-out old stuff in appenv.h.
* libgimp/gimp.h: Include gimpmath.h.
* libgimp/gimp.c (gimp_main): Win32: Don't install signal
handlers, we can't do anything useful in the handler ourselves
anyway (it would be nice to print out a backtrace, but that seems
pretty hard to do, even if not impossible). Let Windows inform the
user about the crash. If the plug-in was compiled with MSVC, and
the user also has it, she is offered a chance to start the
debugger automatically anyway.
* app/*several*.c: Include gimpmath.h for G_PI etc. Don't include
<math.h>, as gimpmath.h includes it.
* plug-ins/*/*many*.c: Include config.h. Don't include <math.h>.
Remove all the duplicated definitions of G_PI and rint(). Use
RINT() instead of rint().
* app/app_procs.[ch]: app_exit() takes a gboolean.
* app/batch.c
* app/commands.c
* app/interface.c: Call app_exit() with FALSE or TRUE.
* app/main.c (on_error): Call gimp_fatal_error. (main): Don't
install any signal handler on Win32 here, either.
* app/errors.c (gimp_fatal_error, gimp_terminate): Win32: Format
the message and call MessageBox with it. g_on_error_query doesn't
do anything useful on Win32, and printf'ing a message to stdout or
stderr doesn't do anything, either, in a windowing application.
1999-09-02 04:30:56 +08:00
|
|
|
|
2000-12-29 23:22:01 +08:00
|
|
|
#include <gtk/gtk.h>
|
2000-12-17 05:37:03 +08:00
|
|
|
|
2001-01-25 06:36:18 +08:00
|
|
|
#include "libgimpwidgets/gimpwidgets.h"
|
2001-01-24 07:56:18 +08:00
|
|
|
|
2002-05-03 20:45:22 +08:00
|
|
|
#include "tools-types.h"
|
2000-12-17 05:37:03 +08:00
|
|
|
|
2001-05-15 19:25:25 +08:00
|
|
|
#include "base/pixel-region.h"
|
|
|
|
#include "base/temp-buf.h"
|
|
|
|
#include "base/tile.h"
|
|
|
|
#include "base/tile-manager.h"
|
|
|
|
|
2001-04-07 23:58:26 +08:00
|
|
|
#include "paint-funcs/paint-funcs.h"
|
|
|
|
|
2001-07-07 20:17:23 +08:00
|
|
|
#include "core/gimp.h"
|
2003-09-03 23:13:19 +08:00
|
|
|
#include "core/gimpchannel.h"
|
2001-05-09 10:32:03 +08:00
|
|
|
#include "core/gimpimage.h"
|
2003-02-14 22:14:29 +08:00
|
|
|
#include "core/gimpimage-undo-push.h"
|
2001-11-20 21:53:21 +08:00
|
|
|
#include "core/gimptoolinfo.h"
|
2001-05-09 10:32:03 +08:00
|
|
|
|
2002-02-22 00:02:30 +08:00
|
|
|
#include "paint/gimppaintoptions.h"
|
|
|
|
|
2003-08-22 09:42:57 +08:00
|
|
|
#include "widgets/gimphelp-ids.h"
|
|
|
|
|
2001-09-26 07:23:09 +08:00
|
|
|
#include "display/gimpdisplay.h"
|
|
|
|
|
2003-02-05 22:39:40 +08:00
|
|
|
#include "gimpinkoptions.h"
|
2001-03-08 09:07:03 +08:00
|
|
|
#include "gimpinktool.h"
|
|
|
|
#include "gimpinktool-blob.h"
|
2003-04-16 00:05:52 +08:00
|
|
|
#include "gimptoolcontrol.h"
|
2001-01-25 06:36:18 +08:00
|
|
|
|
2003-03-26 00:38:19 +08:00
|
|
|
#include "gimp-intl.h"
|
2000-12-29 23:22:01 +08:00
|
|
|
|
1998-06-15 06:42:36 +08:00
|
|
|
|
2001-02-28 08:10:58 +08:00
|
|
|
#define SUBSAMPLE 8
|
1999-04-10 22:55:17 +08:00
|
|
|
|
1999-04-13 01:55:06 +08:00
|
|
|
|
1998-06-15 06:42:36 +08:00
|
|
|
/* local function prototypes */
|
1999-04-13 01:55:06 +08:00
|
|
|
|
2001-02-28 08:10:58 +08:00
|
|
|
static void gimp_ink_tool_class_init (GimpInkToolClass *klass);
|
|
|
|
static void gimp_ink_tool_init (GimpInkTool *tool);
|
|
|
|
|
2001-08-14 22:53:55 +08:00
|
|
|
static void gimp_ink_tool_finalize (GObject *object);
|
2001-02-28 08:10:58 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
static void gimp_ink_tool_control (GimpTool *tool,
|
2002-02-19 01:00:09 +08:00
|
|
|
GimpToolAction action,
|
2001-11-20 21:53:21 +08:00
|
|
|
GimpDisplay *gdisp);
|
|
|
|
static void gimp_ink_tool_button_press (GimpTool *tool,
|
|
|
|
GimpCoords *coords,
|
|
|
|
guint32 time,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpDisplay *gdisp);
|
|
|
|
static void gimp_ink_tool_button_release (GimpTool *tool,
|
|
|
|
GimpCoords *coords,
|
|
|
|
guint32 time,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpDisplay *gdisp);
|
|
|
|
static void gimp_ink_tool_motion (GimpTool *tool,
|
|
|
|
GimpCoords *coords,
|
|
|
|
guint32 time,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpDisplay *gdisp);
|
|
|
|
static void gimp_ink_tool_cursor_update (GimpTool *tool,
|
|
|
|
GimpCoords *coords,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpDisplay *gdisp);
|
|
|
|
|
2003-02-05 22:39:40 +08:00
|
|
|
static Blob * ink_pen_ellipse (GimpInkOptions *options,
|
2001-11-21 07:00:47 +08:00
|
|
|
gdouble x_center,
|
2001-11-20 21:53:21 +08:00
|
|
|
gdouble y_center,
|
|
|
|
gdouble pressure,
|
|
|
|
gdouble xtilt,
|
|
|
|
gdouble ytilt,
|
|
|
|
gdouble velocity);
|
2001-07-18 04:50:01 +08:00
|
|
|
|
|
|
|
static void time_smoother_add (GimpInkTool *ink_tool,
|
|
|
|
guint32 value);
|
|
|
|
static gdouble time_smoother_result (GimpInkTool *ink_tool);
|
|
|
|
static void time_smoother_init (GimpInkTool *ink_tool,
|
|
|
|
guint32 initval);
|
|
|
|
static void dist_smoother_add (GimpInkTool *ink_tool,
|
|
|
|
gdouble value);
|
|
|
|
static gdouble dist_smoother_result (GimpInkTool *ink_tool);
|
|
|
|
static void dist_smoother_init (GimpInkTool *ink_tool,
|
|
|
|
gdouble initval);
|
|
|
|
|
2003-08-22 09:42:57 +08:00
|
|
|
static void ink_init (GimpInkTool *ink_tool,
|
|
|
|
GimpDrawable *drawable,
|
|
|
|
gdouble x,
|
2001-07-18 04:50:01 +08:00
|
|
|
gdouble y);
|
2003-08-22 09:42:57 +08:00
|
|
|
static void ink_finish (GimpInkTool *ink_tool,
|
2001-07-18 04:50:01 +08:00
|
|
|
GimpDrawable *drawable);
|
2000-12-31 12:07:42 +08:00
|
|
|
static void ink_cleanup (void);
|
|
|
|
|
1999-06-22 06:12:07 +08:00
|
|
|
/* Rendering functions */
|
2003-08-22 09:42:57 +08:00
|
|
|
static void ink_set_paint_area (GimpInkTool *ink_tool,
|
|
|
|
GimpDrawable *drawable,
|
2001-07-18 04:50:01 +08:00
|
|
|
Blob *blob);
|
2003-08-22 09:42:57 +08:00
|
|
|
static void ink_paste (GimpInkTool *ink_tool,
|
2001-07-18 04:50:01 +08:00
|
|
|
GimpDrawable *drawable,
|
|
|
|
Blob *blob);
|
|
|
|
|
|
|
|
static void ink_to_canvas_tiles (GimpInkTool *ink_tool,
|
|
|
|
Blob *blob,
|
|
|
|
guchar *color);
|
|
|
|
|
|
|
|
static void ink_set_undo_tiles (GimpDrawable *drawable,
|
2003-08-22 09:42:57 +08:00
|
|
|
gint x,
|
2001-07-18 04:50:01 +08:00
|
|
|
gint y,
|
2003-08-22 09:42:57 +08:00
|
|
|
gint w,
|
2001-07-18 04:50:01 +08:00
|
|
|
gint h);
|
2003-08-22 09:42:57 +08:00
|
|
|
static void ink_set_canvas_tiles (gint x,
|
2001-07-18 04:50:01 +08:00
|
|
|
gint y,
|
2003-08-22 09:42:57 +08:00
|
|
|
gint w,
|
2001-07-18 04:50:01 +08:00
|
|
|
gint h);
|
1998-06-15 06:42:36 +08:00
|
|
|
|
|
|
|
|
2000-12-31 12:07:42 +08:00
|
|
|
/* local variables */
|
|
|
|
|
|
|
|
/* undo blocks variables */
|
|
|
|
static TileManager *undo_tiles = NULL;
|
|
|
|
|
|
|
|
/* Tiles used to render the stroke at 1 byte/pp */
|
|
|
|
static TileManager *canvas_tiles = NULL;
|
|
|
|
|
|
|
|
/* Flat buffer that is used to used to render the dirty region
|
|
|
|
* for composition onto the destination drawable
|
|
|
|
*/
|
|
|
|
static TempBuf *canvas_buf = NULL;
|
|
|
|
|
2001-11-21 07:00:47 +08:00
|
|
|
static GimpToolClass *parent_class = NULL;
|
2001-02-28 08:10:58 +08:00
|
|
|
|
2000-12-31 12:07:42 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
/* public functions */
|
1999-04-09 06:25:54 +08:00
|
|
|
|
2001-02-28 08:10:58 +08:00
|
|
|
void
|
2002-03-29 11:50:29 +08:00
|
|
|
gimp_ink_tool_register (GimpToolRegisterCallback callback,
|
2002-05-03 19:31:08 +08:00
|
|
|
gpointer data)
|
2001-02-28 08:10:58 +08:00
|
|
|
{
|
2002-03-29 11:50:29 +08:00
|
|
|
(* callback) (GIMP_TYPE_INK_TOOL,
|
2003-02-05 22:39:40 +08:00
|
|
|
GIMP_TYPE_INK_OPTIONS,
|
|
|
|
gimp_ink_options_gui,
|
2004-05-04 19:26:22 +08:00
|
|
|
GIMP_CONTEXT_FOREGROUND_MASK |
|
|
|
|
GIMP_CONTEXT_BACKGROUND_MASK |
|
|
|
|
GIMP_CONTEXT_OPACITY_MASK |
|
2003-06-28 19:20:37 +08:00
|
|
|
GIMP_CONTEXT_PAINT_MODE_MASK,
|
2002-03-21 20:17:17 +08:00
|
|
|
"gimp-ink-tool",
|
2002-11-01 07:06:09 +08:00
|
|
|
_("Ink"),
|
2001-11-21 07:00:47 +08:00
|
|
|
_("Draw in ink"),
|
2004-04-29 21:19:28 +08:00
|
|
|
N_("In_k"), "K",
|
2003-08-22 09:42:57 +08:00
|
|
|
NULL, GIMP_HELP_TOOL_INK,
|
2002-03-29 11:50:29 +08:00
|
|
|
GIMP_STOCK_TOOL_INK,
|
2002-05-03 19:31:08 +08:00
|
|
|
data);
|
2001-02-28 08:10:58 +08:00
|
|
|
}
|
|
|
|
|
2001-08-14 22:53:55 +08:00
|
|
|
GType
|
2001-02-28 08:10:58 +08:00
|
|
|
gimp_ink_tool_get_type (void)
|
|
|
|
{
|
2001-08-14 22:53:55 +08:00
|
|
|
static GType tool_type = 0;
|
2001-02-28 08:10:58 +08:00
|
|
|
|
|
|
|
if (! tool_type)
|
|
|
|
{
|
2001-08-14 22:53:55 +08:00
|
|
|
static const GTypeInfo tool_info =
|
2001-02-28 08:10:58 +08:00
|
|
|
{
|
2001-08-14 22:53:55 +08:00
|
|
|
sizeof (GimpInkToolClass),
|
|
|
|
(GBaseInitFunc) NULL,
|
|
|
|
(GBaseFinalizeFunc) NULL,
|
|
|
|
(GClassInitFunc) gimp_ink_tool_class_init,
|
|
|
|
NULL, /* class_finalize */
|
|
|
|
NULL, /* class_data */
|
2001-02-28 08:10:58 +08:00
|
|
|
sizeof (GimpInkTool),
|
2001-08-14 22:53:55 +08:00
|
|
|
0, /* n_preallocs */
|
|
|
|
(GInstanceInitFunc) gimp_ink_tool_init,
|
2001-02-28 08:10:58 +08:00
|
|
|
};
|
|
|
|
|
2001-08-14 22:53:55 +08:00
|
|
|
tool_type = g_type_register_static (GIMP_TYPE_TOOL,
|
2003-08-22 09:42:57 +08:00
|
|
|
"GimpInkTool",
|
2001-08-14 22:53:55 +08:00
|
|
|
&tool_info, 0);
|
2001-02-28 08:10:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return tool_type;
|
|
|
|
}
|
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
|
|
|
|
/* private functions */
|
|
|
|
|
2001-02-28 08:10:58 +08:00
|
|
|
static void
|
|
|
|
gimp_ink_tool_class_init (GimpInkToolClass *klass)
|
|
|
|
{
|
2001-08-14 22:53:55 +08:00
|
|
|
GObjectClass *object_class;
|
2001-02-28 08:10:58 +08:00
|
|
|
GimpToolClass *tool_class;
|
|
|
|
|
2001-08-14 22:53:55 +08:00
|
|
|
object_class = G_OBJECT_CLASS (klass);
|
|
|
|
tool_class = GIMP_TOOL_CLASS (klass);
|
2001-02-28 08:10:58 +08:00
|
|
|
|
2001-08-14 22:53:55 +08:00
|
|
|
parent_class = g_type_class_peek_parent (klass);
|
2001-02-28 08:10:58 +08:00
|
|
|
|
2001-08-14 22:53:55 +08:00
|
|
|
object_class->finalize = gimp_ink_tool_finalize;
|
2001-02-28 08:10:58 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
tool_class->control = gimp_ink_tool_control;
|
|
|
|
tool_class->button_press = gimp_ink_tool_button_press;
|
|
|
|
tool_class->button_release = gimp_ink_tool_button_release;
|
|
|
|
tool_class->motion = gimp_ink_tool_motion;
|
|
|
|
tool_class->cursor_update = gimp_ink_tool_cursor_update;
|
2001-02-28 08:10:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gimp_ink_tool_init (GimpInkTool *ink_tool)
|
|
|
|
{
|
|
|
|
GimpTool *tool;
|
|
|
|
|
|
|
|
tool = GIMP_TOOL (ink_tool);
|
2001-11-09 03:14:51 +08:00
|
|
|
|
2002-05-03 05:03:27 +08:00
|
|
|
gimp_tool_control_set_motion_mode (tool->control, GIMP_MOTION_MODE_EXACT);
|
|
|
|
gimp_tool_control_set_tool_cursor (tool->control, GIMP_INK_TOOL_CURSOR);
|
2001-02-28 08:10:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2001-08-14 22:53:55 +08:00
|
|
|
gimp_ink_tool_finalize (GObject *object)
|
2001-02-28 08:10:58 +08:00
|
|
|
{
|
|
|
|
GimpInkTool *ink_tool;
|
|
|
|
|
|
|
|
ink_tool = GIMP_INK_TOOL (object);
|
|
|
|
|
|
|
|
if (ink_tool->last_blob)
|
2001-08-14 22:53:55 +08:00
|
|
|
{
|
|
|
|
g_free (ink_tool->last_blob);
|
|
|
|
ink_tool->last_blob = NULL;
|
|
|
|
}
|
2001-02-28 08:10:58 +08:00
|
|
|
|
|
|
|
ink_cleanup ();
|
|
|
|
|
2001-08-14 22:53:55 +08:00
|
|
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
2001-02-28 08:10:58 +08:00
|
|
|
}
|
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
static void
|
2002-02-19 01:00:09 +08:00
|
|
|
gimp_ink_tool_control (GimpTool *tool,
|
|
|
|
GimpToolAction action,
|
|
|
|
GimpDisplay *gdisp)
|
1999-04-13 01:55:06 +08:00
|
|
|
{
|
2001-11-20 21:53:21 +08:00
|
|
|
GimpInkTool *ink_tool;
|
1999-04-13 01:55:06 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
ink_tool = GIMP_INK_TOOL (tool);
|
1999-04-13 01:55:06 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
switch (action)
|
|
|
|
{
|
|
|
|
case PAUSE:
|
|
|
|
break;
|
1999-04-09 06:25:54 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
case RESUME:
|
|
|
|
break;
|
2001-04-01 04:41:39 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
case HALT:
|
|
|
|
ink_cleanup ();
|
|
|
|
break;
|
1999-04-22 22:34:00 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2002-02-19 01:00:09 +08:00
|
|
|
|
|
|
|
GIMP_TOOL_CLASS (parent_class)->control (tool, action, gdisp);
|
1999-04-09 06:25:54 +08:00
|
|
|
}
|
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
static void
|
|
|
|
gimp_ink_tool_button_press (GimpTool *tool,
|
|
|
|
GimpCoords *coords,
|
|
|
|
guint32 time,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpDisplay *gdisp)
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
2003-02-05 22:39:40 +08:00
|
|
|
GimpInkTool *ink_tool;
|
|
|
|
GimpInkOptions *options;
|
|
|
|
GimpDrawable *drawable;
|
2003-02-10 19:38:03 +08:00
|
|
|
GimpCoords curr_coords;
|
2003-05-08 22:06:03 +08:00
|
|
|
gint off_x, off_y;
|
2003-02-05 22:39:40 +08:00
|
|
|
Blob *b;
|
1999-04-13 01:55:06 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
ink_tool = GIMP_INK_TOOL (tool);
|
2003-02-05 22:39:40 +08:00
|
|
|
options = GIMP_INK_OPTIONS (tool->tool_info->tool_options);
|
2001-11-21 07:00:47 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
drawable = gimp_image_active_drawable (gdisp->gimage);
|
2000-04-16 20:10:24 +08:00
|
|
|
|
2003-02-10 19:38:03 +08:00
|
|
|
curr_coords = *coords;
|
|
|
|
|
2003-05-08 22:06:03 +08:00
|
|
|
gimp_item_offsets (GIMP_ITEM (drawable), &off_x, &off_y);
|
2003-02-10 19:38:03 +08:00
|
|
|
|
2003-05-08 22:06:03 +08:00
|
|
|
curr_coords.x -= off_x;
|
|
|
|
curr_coords.y -= off_y;
|
2003-02-10 19:38:03 +08:00
|
|
|
|
|
|
|
ink_init (ink_tool, drawable, curr_coords.x, curr_coords.y);
|
2000-04-16 20:10:24 +08:00
|
|
|
|
2002-05-03 19:31:08 +08:00
|
|
|
gimp_tool_control_activate (tool->control);
|
2003-08-22 09:42:57 +08:00
|
|
|
tool->gdisp = gdisp;
|
1999-04-09 06:25:54 +08:00
|
|
|
|
2002-02-05 19:35:03 +08:00
|
|
|
/* pause the current selection */
|
2001-11-20 21:53:21 +08:00
|
|
|
gimp_image_selection_control (gdisp->gimage, GIMP_SELECTION_PAUSE);
|
Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)
2001-07-24 Michael Natterer <mitch@gimp.org>
Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)
* configure.in: require glib/gtk+ >= 1.3.7, commented out the
gtkxmhtml stuff.
From now on, you will need glib, pango, atk and gtk+ HEAD from CVS
to hack or use GIMP HEAD.
Beware, it crashes randomly :)
* app/core/Makefile.am
* app/core/gimpmarshal.list: new file plus rules to generate
gimpmarshal.[ch] from it.
* app/core/*
* app/tools/*
* app/widgets/*
* libgimpwidgets/*: started to use the glib object system. All
core/ objects are still gtk objects however. All signals are
created using g_signal_new(). There are many gtk+ artefacts left.
Finally, we will _not_ use the gtk_signal_foo() wrappers and
friends any more.
* app/colormaps.c
* app/devices.[ch]
* app/disp_callbacks.c
* app/errorconsole.c
* app/file-save.[ch]
* app/interface.c
* app/module_db.c
* app/nav_window.c
* app/ops_buttons.c
* app/scroll.c
* app/user_install.c
* app/gui/about-dialog.c
* app/gui/brush-editor.c
* app/gui/brushes-commands.c
* app/gui/color-notebook.c
* app/gui/colormap-dialog.c
* app/gui/dialogs-commands.c
* app/gui/dialogs-constructors.c
* app/gui/file-commands.c
* app/gui/file-dialog-utils.c
* app/gui/file-new-dialog.c
* app/gui/file-open-dialog.[ch]
* app/gui/file-save-dialog.c
* app/gui/gradient-editor.c
* app/gui/gradients-commands.c
* app/gui/image-commands.c
* app/gui/info-dialog.[ch]
* app/gui/layer-select.c
* app/gui/layers-commands.c
* app/gui/menus.c
* app/gui/offset-dialog.c
* app/gui/palette-editor.c
* app/gui/palettes-commands.c
* app/gui/patterns-commands.c
* app/gui/preferences-dialog.c
* app/gui/resize-dialog.[ch]
* app/gui/splash.c
* app/gui/tips-dialog.c
* app/gui/tool-options-dialog.c
* app/gui/toolbox.c
* app/gui/tools-commands.c
* libgimp/gimpbrushmenu.c
* libgimp/gimpmenu.c
* libgimp/gimppatternmenu.c
* libgimp/gimpui.c
* libgimpbase/gimpenv.c: tons and tons of changes like "const
gchar*", switch from GdkDeviceInfo to GdkDevice (very incomplete
and currently disables), lots of s/gtk_signal/g_signal/,
removal/replacement of deprecated stuff,
s/GtkSignalFunc/GCallback/ and lots of small changes and fixes
while I was on it, zillions of warnings left...
* modules/Makefile.am: disabled the water color selector
temporarily (XInput issues).
* plug-ins/Makefile.am
* plug-ins/common/.cvsignore
* plug-ins/common/Makefile.am
* plug-ins/common/plugin-defs.pl: simply excluded all plug-ins
which did not build (including Script-Fu). They are trivial to
fix.
2001-07-25 05:27:11 +08:00
|
|
|
|
2001-11-21 07:00:47 +08:00
|
|
|
b = ink_pen_ellipse (options,
|
2003-02-10 19:38:03 +08:00
|
|
|
curr_coords.x,
|
|
|
|
curr_coords.y,
|
|
|
|
curr_coords.pressure,
|
|
|
|
curr_coords.xtilt,
|
|
|
|
curr_coords.ytilt,
|
2001-11-20 21:53:21 +08:00
|
|
|
10.0);
|
2000-04-16 20:10:24 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
ink_paste (ink_tool, drawable, b);
|
|
|
|
ink_tool->last_blob = b;
|
Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)
2001-07-24 Michael Natterer <mitch@gimp.org>
Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)
* configure.in: require glib/gtk+ >= 1.3.7, commented out the
gtkxmhtml stuff.
From now on, you will need glib, pango, atk and gtk+ HEAD from CVS
to hack or use GIMP HEAD.
Beware, it crashes randomly :)
* app/core/Makefile.am
* app/core/gimpmarshal.list: new file plus rules to generate
gimpmarshal.[ch] from it.
* app/core/*
* app/tools/*
* app/widgets/*
* libgimpwidgets/*: started to use the glib object system. All
core/ objects are still gtk objects however. All signals are
created using g_signal_new(). There are many gtk+ artefacts left.
Finally, we will _not_ use the gtk_signal_foo() wrappers and
friends any more.
* app/colormaps.c
* app/devices.[ch]
* app/disp_callbacks.c
* app/errorconsole.c
* app/file-save.[ch]
* app/interface.c
* app/module_db.c
* app/nav_window.c
* app/ops_buttons.c
* app/scroll.c
* app/user_install.c
* app/gui/about-dialog.c
* app/gui/brush-editor.c
* app/gui/brushes-commands.c
* app/gui/color-notebook.c
* app/gui/colormap-dialog.c
* app/gui/dialogs-commands.c
* app/gui/dialogs-constructors.c
* app/gui/file-commands.c
* app/gui/file-dialog-utils.c
* app/gui/file-new-dialog.c
* app/gui/file-open-dialog.[ch]
* app/gui/file-save-dialog.c
* app/gui/gradient-editor.c
* app/gui/gradients-commands.c
* app/gui/image-commands.c
* app/gui/info-dialog.[ch]
* app/gui/layer-select.c
* app/gui/layers-commands.c
* app/gui/menus.c
* app/gui/offset-dialog.c
* app/gui/palette-editor.c
* app/gui/palettes-commands.c
* app/gui/patterns-commands.c
* app/gui/preferences-dialog.c
* app/gui/resize-dialog.[ch]
* app/gui/splash.c
* app/gui/tips-dialog.c
* app/gui/tool-options-dialog.c
* app/gui/toolbox.c
* app/gui/tools-commands.c
* libgimp/gimpbrushmenu.c
* libgimp/gimpmenu.c
* libgimp/gimppatternmenu.c
* libgimp/gimpui.c
* libgimpbase/gimpenv.c: tons and tons of changes like "const
gchar*", switch from GdkDeviceInfo to GdkDevice (very incomplete
and currently disables), lots of s/gtk_signal/g_signal/,
removal/replacement of deprecated stuff,
s/GtkSignalFunc/GCallback/ and lots of small changes and fixes
while I was on it, zillions of warnings left...
* modules/Makefile.am: disabled the water color selector
temporarily (XInput issues).
* plug-ins/Makefile.am
* plug-ins/common/.cvsignore
* plug-ins/common/Makefile.am
* plug-ins/common/plugin-defs.pl: simply excluded all plug-ins
which did not build (including Script-Fu). They are trivial to
fix.
2001-07-25 05:27:11 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
time_smoother_init (ink_tool, time);
|
|
|
|
ink_tool->last_time = time;
|
2003-02-10 19:38:03 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
dist_smoother_init (ink_tool, 0.0);
|
|
|
|
ink_tool->init_velocity = TRUE;
|
2003-02-10 19:38:03 +08:00
|
|
|
|
|
|
|
ink_tool->lastx = curr_coords.x;
|
|
|
|
ink_tool->lasty = curr_coords.y;
|
2000-04-16 20:10:24 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
gimp_display_flush_now (gdisp);
|
|
|
|
}
|
2000-04-16 20:10:24 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
static void
|
|
|
|
gimp_ink_tool_button_release (GimpTool *tool,
|
|
|
|
GimpCoords *coords,
|
|
|
|
guint32 time,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpDisplay *gdisp)
|
|
|
|
{
|
|
|
|
GimpInkTool *ink_tool;
|
|
|
|
GimpImage *gimage;
|
2000-04-16 20:10:24 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
ink_tool = GIMP_INK_TOOL (tool);
|
Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)
2001-07-24 Michael Natterer <mitch@gimp.org>
Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)
* configure.in: require glib/gtk+ >= 1.3.7, commented out the
gtkxmhtml stuff.
From now on, you will need glib, pango, atk and gtk+ HEAD from CVS
to hack or use GIMP HEAD.
Beware, it crashes randomly :)
* app/core/Makefile.am
* app/core/gimpmarshal.list: new file plus rules to generate
gimpmarshal.[ch] from it.
* app/core/*
* app/tools/*
* app/widgets/*
* libgimpwidgets/*: started to use the glib object system. All
core/ objects are still gtk objects however. All signals are
created using g_signal_new(). There are many gtk+ artefacts left.
Finally, we will _not_ use the gtk_signal_foo() wrappers and
friends any more.
* app/colormaps.c
* app/devices.[ch]
* app/disp_callbacks.c
* app/errorconsole.c
* app/file-save.[ch]
* app/interface.c
* app/module_db.c
* app/nav_window.c
* app/ops_buttons.c
* app/scroll.c
* app/user_install.c
* app/gui/about-dialog.c
* app/gui/brush-editor.c
* app/gui/brushes-commands.c
* app/gui/color-notebook.c
* app/gui/colormap-dialog.c
* app/gui/dialogs-commands.c
* app/gui/dialogs-constructors.c
* app/gui/file-commands.c
* app/gui/file-dialog-utils.c
* app/gui/file-new-dialog.c
* app/gui/file-open-dialog.[ch]
* app/gui/file-save-dialog.c
* app/gui/gradient-editor.c
* app/gui/gradients-commands.c
* app/gui/image-commands.c
* app/gui/info-dialog.[ch]
* app/gui/layer-select.c
* app/gui/layers-commands.c
* app/gui/menus.c
* app/gui/offset-dialog.c
* app/gui/palette-editor.c
* app/gui/palettes-commands.c
* app/gui/patterns-commands.c
* app/gui/preferences-dialog.c
* app/gui/resize-dialog.[ch]
* app/gui/splash.c
* app/gui/tips-dialog.c
* app/gui/tool-options-dialog.c
* app/gui/toolbox.c
* app/gui/tools-commands.c
* libgimp/gimpbrushmenu.c
* libgimp/gimpmenu.c
* libgimp/gimppatternmenu.c
* libgimp/gimpui.c
* libgimpbase/gimpenv.c: tons and tons of changes like "const
gchar*", switch from GdkDeviceInfo to GdkDevice (very incomplete
and currently disables), lots of s/gtk_signal/g_signal/,
removal/replacement of deprecated stuff,
s/GtkSignalFunc/GCallback/ and lots of small changes and fixes
while I was on it, zillions of warnings left...
* modules/Makefile.am: disabled the water color selector
temporarily (XInput issues).
* plug-ins/Makefile.am
* plug-ins/common/.cvsignore
* plug-ins/common/Makefile.am
* plug-ins/common/plugin-defs.pl: simply excluded all plug-ins
which did not build (including Script-Fu). They are trivial to
fix.
2001-07-25 05:27:11 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
gimage = gdisp->gimage;
|
Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)
2001-07-24 Michael Natterer <mitch@gimp.org>
Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)
* configure.in: require glib/gtk+ >= 1.3.7, commented out the
gtkxmhtml stuff.
From now on, you will need glib, pango, atk and gtk+ HEAD from CVS
to hack or use GIMP HEAD.
Beware, it crashes randomly :)
* app/core/Makefile.am
* app/core/gimpmarshal.list: new file plus rules to generate
gimpmarshal.[ch] from it.
* app/core/*
* app/tools/*
* app/widgets/*
* libgimpwidgets/*: started to use the glib object system. All
core/ objects are still gtk objects however. All signals are
created using g_signal_new(). There are many gtk+ artefacts left.
Finally, we will _not_ use the gtk_signal_foo() wrappers and
friends any more.
* app/colormaps.c
* app/devices.[ch]
* app/disp_callbacks.c
* app/errorconsole.c
* app/file-save.[ch]
* app/interface.c
* app/module_db.c
* app/nav_window.c
* app/ops_buttons.c
* app/scroll.c
* app/user_install.c
* app/gui/about-dialog.c
* app/gui/brush-editor.c
* app/gui/brushes-commands.c
* app/gui/color-notebook.c
* app/gui/colormap-dialog.c
* app/gui/dialogs-commands.c
* app/gui/dialogs-constructors.c
* app/gui/file-commands.c
* app/gui/file-dialog-utils.c
* app/gui/file-new-dialog.c
* app/gui/file-open-dialog.[ch]
* app/gui/file-save-dialog.c
* app/gui/gradient-editor.c
* app/gui/gradients-commands.c
* app/gui/image-commands.c
* app/gui/info-dialog.[ch]
* app/gui/layer-select.c
* app/gui/layers-commands.c
* app/gui/menus.c
* app/gui/offset-dialog.c
* app/gui/palette-editor.c
* app/gui/palettes-commands.c
* app/gui/patterns-commands.c
* app/gui/preferences-dialog.c
* app/gui/resize-dialog.[ch]
* app/gui/splash.c
* app/gui/tips-dialog.c
* app/gui/tool-options-dialog.c
* app/gui/toolbox.c
* app/gui/tools-commands.c
* libgimp/gimpbrushmenu.c
* libgimp/gimpmenu.c
* libgimp/gimppatternmenu.c
* libgimp/gimpui.c
* libgimpbase/gimpenv.c: tons and tons of changes like "const
gchar*", switch from GdkDeviceInfo to GdkDevice (very incomplete
and currently disables), lots of s/gtk_signal/g_signal/,
removal/replacement of deprecated stuff,
s/GtkSignalFunc/GCallback/ and lots of small changes and fixes
while I was on it, zillions of warnings left...
* modules/Makefile.am: disabled the water color selector
temporarily (XInput issues).
* plug-ins/Makefile.am
* plug-ins/common/.cvsignore
* plug-ins/common/Makefile.am
* plug-ins/common/plugin-defs.pl: simply excluded all plug-ins
which did not build (including Script-Fu). They are trivial to
fix.
2001-07-25 05:27:11 +08:00
|
|
|
|
2002-02-05 19:35:03 +08:00
|
|
|
/* resume the current selection */
|
2001-11-20 21:53:21 +08:00
|
|
|
gimp_image_selection_control (gdisp->gimage, GIMP_SELECTION_RESUME);
|
1999-04-10 22:55:17 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
/* Set tool state to inactive -- no longer painting */
|
2003-01-03 21:59:23 +08:00
|
|
|
gimp_tool_control_halt (tool->control);
|
1999-04-10 22:55:17 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
/* free the last blob */
|
|
|
|
g_free (ink_tool->last_blob);
|
|
|
|
ink_tool->last_blob = NULL;
|
1998-11-26 15:44:17 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
ink_finish (ink_tool, gimp_image_active_drawable (gdisp->gimage));
|
2002-05-09 01:48:24 +08:00
|
|
|
gimp_image_flush (gdisp->gimage);
|
2001-11-20 21:53:21 +08:00
|
|
|
}
|
1999-04-09 06:25:54 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
static void
|
|
|
|
gimp_ink_tool_motion (GimpTool *tool,
|
|
|
|
GimpCoords *coords,
|
|
|
|
guint32 time,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpDisplay *gdisp)
|
|
|
|
{
|
2003-02-05 22:39:40 +08:00
|
|
|
GimpInkTool *ink_tool;
|
|
|
|
GimpInkOptions *options;
|
|
|
|
GimpDrawable *drawable;
|
2003-02-10 19:38:03 +08:00
|
|
|
GimpCoords curr_coords;
|
2003-05-08 22:06:03 +08:00
|
|
|
gint off_x, off_y;
|
2003-02-10 19:38:03 +08:00
|
|
|
Blob *b;
|
|
|
|
Blob *blob_union;
|
|
|
|
gdouble velocity;
|
|
|
|
gdouble dist;
|
|
|
|
gdouble lasttime, thistime;
|
2001-11-21 07:00:47 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
ink_tool = GIMP_INK_TOOL (tool);
|
2003-02-05 22:39:40 +08:00
|
|
|
options = GIMP_INK_OPTIONS (tool->tool_info->tool_options);
|
2001-11-21 07:00:47 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
drawable = gimp_image_active_drawable (gdisp->gimage);
|
1999-02-03 12:29:08 +08:00
|
|
|
|
2003-02-10 19:38:03 +08:00
|
|
|
curr_coords = *coords;
|
|
|
|
|
2003-05-08 22:06:03 +08:00
|
|
|
gimp_item_offsets (GIMP_ITEM (drawable), &off_x, &off_y);
|
2003-02-10 19:38:03 +08:00
|
|
|
|
2003-05-08 22:06:03 +08:00
|
|
|
curr_coords.x -= off_x;
|
|
|
|
curr_coords.y -= off_y;
|
2003-02-10 19:38:03 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
lasttime = ink_tool->last_time;
|
Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)
2001-07-24 Michael Natterer <mitch@gimp.org>
Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)
* configure.in: require glib/gtk+ >= 1.3.7, commented out the
gtkxmhtml stuff.
From now on, you will need glib, pango, atk and gtk+ HEAD from CVS
to hack or use GIMP HEAD.
Beware, it crashes randomly :)
* app/core/Makefile.am
* app/core/gimpmarshal.list: new file plus rules to generate
gimpmarshal.[ch] from it.
* app/core/*
* app/tools/*
* app/widgets/*
* libgimpwidgets/*: started to use the glib object system. All
core/ objects are still gtk objects however. All signals are
created using g_signal_new(). There are many gtk+ artefacts left.
Finally, we will _not_ use the gtk_signal_foo() wrappers and
friends any more.
* app/colormaps.c
* app/devices.[ch]
* app/disp_callbacks.c
* app/errorconsole.c
* app/file-save.[ch]
* app/interface.c
* app/module_db.c
* app/nav_window.c
* app/ops_buttons.c
* app/scroll.c
* app/user_install.c
* app/gui/about-dialog.c
* app/gui/brush-editor.c
* app/gui/brushes-commands.c
* app/gui/color-notebook.c
* app/gui/colormap-dialog.c
* app/gui/dialogs-commands.c
* app/gui/dialogs-constructors.c
* app/gui/file-commands.c
* app/gui/file-dialog-utils.c
* app/gui/file-new-dialog.c
* app/gui/file-open-dialog.[ch]
* app/gui/file-save-dialog.c
* app/gui/gradient-editor.c
* app/gui/gradients-commands.c
* app/gui/image-commands.c
* app/gui/info-dialog.[ch]
* app/gui/layer-select.c
* app/gui/layers-commands.c
* app/gui/menus.c
* app/gui/offset-dialog.c
* app/gui/palette-editor.c
* app/gui/palettes-commands.c
* app/gui/patterns-commands.c
* app/gui/preferences-dialog.c
* app/gui/resize-dialog.[ch]
* app/gui/splash.c
* app/gui/tips-dialog.c
* app/gui/tool-options-dialog.c
* app/gui/toolbox.c
* app/gui/tools-commands.c
* libgimp/gimpbrushmenu.c
* libgimp/gimpmenu.c
* libgimp/gimppatternmenu.c
* libgimp/gimpui.c
* libgimpbase/gimpenv.c: tons and tons of changes like "const
gchar*", switch from GdkDeviceInfo to GdkDevice (very incomplete
and currently disables), lots of s/gtk_signal/g_signal/,
removal/replacement of deprecated stuff,
s/GtkSignalFunc/GCallback/ and lots of small changes and fixes
while I was on it, zillions of warnings left...
* modules/Makefile.am: disabled the water color selector
temporarily (XInput issues).
* plug-ins/Makefile.am
* plug-ins/common/.cvsignore
* plug-ins/common/Makefile.am
* plug-ins/common/plugin-defs.pl: simply excluded all plug-ins
which did not build (including Script-Fu). They are trivial to
fix.
2001-07-25 05:27:11 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
time_smoother_add (ink_tool, time);
|
|
|
|
thistime = ink_tool->last_time = time_smoother_result (ink_tool);
|
1999-04-18 07:18:43 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
/* The time resolution on X-based GDK motion events is
|
|
|
|
bloody awful, hence the use of the smoothing function.
|
|
|
|
Sadly this also means that there is always the chance of
|
|
|
|
having an indeterminite velocity since this event and
|
|
|
|
the previous several may still appear to issue at the same
|
|
|
|
instant. -ADM */
|
1999-02-03 12:29:08 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
if (thistime == lasttime)
|
|
|
|
thistime = lasttime + 1;
|
1999-02-03 12:29:08 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
if (ink_tool->init_velocity)
|
|
|
|
{
|
|
|
|
dist_smoother_init (ink_tool,
|
2003-02-10 19:38:03 +08:00
|
|
|
dist = sqrt ((ink_tool->lastx - curr_coords.x) *
|
|
|
|
(ink_tool->lastx - curr_coords.x) +
|
|
|
|
(ink_tool->lasty - curr_coords.y) *
|
|
|
|
(ink_tool->lasty - curr_coords.y)));
|
2001-11-20 21:53:21 +08:00
|
|
|
ink_tool->init_velocity = FALSE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
dist_smoother_add (ink_tool,
|
2003-02-10 19:38:03 +08:00
|
|
|
sqrt ((ink_tool->lastx - curr_coords.x) *
|
|
|
|
(ink_tool->lastx - curr_coords.x) +
|
|
|
|
(ink_tool->lasty - curr_coords.y) *
|
|
|
|
(ink_tool->lasty - curr_coords.y)));
|
1999-02-03 12:29:08 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
dist = dist_smoother_result (ink_tool);
|
|
|
|
}
|
Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)
2001-07-24 Michael Natterer <mitch@gimp.org>
Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)
* configure.in: require glib/gtk+ >= 1.3.7, commented out the
gtkxmhtml stuff.
From now on, you will need glib, pango, atk and gtk+ HEAD from CVS
to hack or use GIMP HEAD.
Beware, it crashes randomly :)
* app/core/Makefile.am
* app/core/gimpmarshal.list: new file plus rules to generate
gimpmarshal.[ch] from it.
* app/core/*
* app/tools/*
* app/widgets/*
* libgimpwidgets/*: started to use the glib object system. All
core/ objects are still gtk objects however. All signals are
created using g_signal_new(). There are many gtk+ artefacts left.
Finally, we will _not_ use the gtk_signal_foo() wrappers and
friends any more.
* app/colormaps.c
* app/devices.[ch]
* app/disp_callbacks.c
* app/errorconsole.c
* app/file-save.[ch]
* app/interface.c
* app/module_db.c
* app/nav_window.c
* app/ops_buttons.c
* app/scroll.c
* app/user_install.c
* app/gui/about-dialog.c
* app/gui/brush-editor.c
* app/gui/brushes-commands.c
* app/gui/color-notebook.c
* app/gui/colormap-dialog.c
* app/gui/dialogs-commands.c
* app/gui/dialogs-constructors.c
* app/gui/file-commands.c
* app/gui/file-dialog-utils.c
* app/gui/file-new-dialog.c
* app/gui/file-open-dialog.[ch]
* app/gui/file-save-dialog.c
* app/gui/gradient-editor.c
* app/gui/gradients-commands.c
* app/gui/image-commands.c
* app/gui/info-dialog.[ch]
* app/gui/layer-select.c
* app/gui/layers-commands.c
* app/gui/menus.c
* app/gui/offset-dialog.c
* app/gui/palette-editor.c
* app/gui/palettes-commands.c
* app/gui/patterns-commands.c
* app/gui/preferences-dialog.c
* app/gui/resize-dialog.[ch]
* app/gui/splash.c
* app/gui/tips-dialog.c
* app/gui/tool-options-dialog.c
* app/gui/toolbox.c
* app/gui/tools-commands.c
* libgimp/gimpbrushmenu.c
* libgimp/gimpmenu.c
* libgimp/gimppatternmenu.c
* libgimp/gimpui.c
* libgimpbase/gimpenv.c: tons and tons of changes like "const
gchar*", switch from GdkDeviceInfo to GdkDevice (very incomplete
and currently disables), lots of s/gtk_signal/g_signal/,
removal/replacement of deprecated stuff,
s/GtkSignalFunc/GCallback/ and lots of small changes and fixes
while I was on it, zillions of warnings left...
* modules/Makefile.am: disabled the water color selector
temporarily (XInput issues).
* plug-ins/Makefile.am
* plug-ins/common/.cvsignore
* plug-ins/common/Makefile.am
* plug-ins/common/plugin-defs.pl: simply excluded all plug-ins
which did not build (including Script-Fu). They are trivial to
fix.
2001-07-25 05:27:11 +08:00
|
|
|
|
2003-02-10 19:38:03 +08:00
|
|
|
ink_tool->lastx = curr_coords.x;
|
|
|
|
ink_tool->lasty = curr_coords.y;
|
Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)
2001-07-24 Michael Natterer <mitch@gimp.org>
Port to glib/gtk+ 2.0 episode I (every segfault has it's beginning)
* configure.in: require glib/gtk+ >= 1.3.7, commented out the
gtkxmhtml stuff.
From now on, you will need glib, pango, atk and gtk+ HEAD from CVS
to hack or use GIMP HEAD.
Beware, it crashes randomly :)
* app/core/Makefile.am
* app/core/gimpmarshal.list: new file plus rules to generate
gimpmarshal.[ch] from it.
* app/core/*
* app/tools/*
* app/widgets/*
* libgimpwidgets/*: started to use the glib object system. All
core/ objects are still gtk objects however. All signals are
created using g_signal_new(). There are many gtk+ artefacts left.
Finally, we will _not_ use the gtk_signal_foo() wrappers and
friends any more.
* app/colormaps.c
* app/devices.[ch]
* app/disp_callbacks.c
* app/errorconsole.c
* app/file-save.[ch]
* app/interface.c
* app/module_db.c
* app/nav_window.c
* app/ops_buttons.c
* app/scroll.c
* app/user_install.c
* app/gui/about-dialog.c
* app/gui/brush-editor.c
* app/gui/brushes-commands.c
* app/gui/color-notebook.c
* app/gui/colormap-dialog.c
* app/gui/dialogs-commands.c
* app/gui/dialogs-constructors.c
* app/gui/file-commands.c
* app/gui/file-dialog-utils.c
* app/gui/file-new-dialog.c
* app/gui/file-open-dialog.[ch]
* app/gui/file-save-dialog.c
* app/gui/gradient-editor.c
* app/gui/gradients-commands.c
* app/gui/image-commands.c
* app/gui/info-dialog.[ch]
* app/gui/layer-select.c
* app/gui/layers-commands.c
* app/gui/menus.c
* app/gui/offset-dialog.c
* app/gui/palette-editor.c
* app/gui/palettes-commands.c
* app/gui/patterns-commands.c
* app/gui/preferences-dialog.c
* app/gui/resize-dialog.[ch]
* app/gui/splash.c
* app/gui/tips-dialog.c
* app/gui/tool-options-dialog.c
* app/gui/toolbox.c
* app/gui/tools-commands.c
* libgimp/gimpbrushmenu.c
* libgimp/gimpmenu.c
* libgimp/gimppatternmenu.c
* libgimp/gimpui.c
* libgimpbase/gimpenv.c: tons and tons of changes like "const
gchar*", switch from GdkDeviceInfo to GdkDevice (very incomplete
and currently disables), lots of s/gtk_signal/g_signal/,
removal/replacement of deprecated stuff,
s/GtkSignalFunc/GCallback/ and lots of small changes and fixes
while I was on it, zillions of warnings left...
* modules/Makefile.am: disabled the water color selector
temporarily (XInput issues).
* plug-ins/Makefile.am
* plug-ins/common/.cvsignore
* plug-ins/common/Makefile.am
* plug-ins/common/plugin-defs.pl: simply excluded all plug-ins
which did not build (including Script-Fu). They are trivial to
fix.
2001-07-25 05:27:11 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
velocity = 10.0 * sqrt ((dist) / (gdouble) (thistime - lasttime));
|
1999-04-18 07:18:43 +08:00
|
|
|
|
2001-11-21 07:00:47 +08:00
|
|
|
b = ink_pen_ellipse (options,
|
2003-02-10 19:38:03 +08:00
|
|
|
curr_coords.x,
|
|
|
|
curr_coords.y,
|
|
|
|
curr_coords.pressure,
|
|
|
|
curr_coords.xtilt,
|
|
|
|
curr_coords.ytilt,
|
2001-11-20 21:53:21 +08:00
|
|
|
velocity);
|
1999-04-09 06:25:54 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
blob_union = blob_convex_union (ink_tool->last_blob, b);
|
|
|
|
g_free (ink_tool->last_blob);
|
|
|
|
ink_tool->last_blob = b;
|
1998-06-15 06:42:36 +08:00
|
|
|
|
2003-08-22 09:42:57 +08:00
|
|
|
ink_paste (ink_tool, drawable, blob_union);
|
2001-11-20 21:53:21 +08:00
|
|
|
g_free (blob_union);
|
1999-02-03 12:29:08 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
gimp_display_flush_now (gdisp);
|
|
|
|
}
|
2000-04-16 20:10:24 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
static void
|
|
|
|
gimp_ink_tool_cursor_update (GimpTool *tool,
|
|
|
|
GimpCoords *coords,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpDisplay *gdisp)
|
|
|
|
{
|
2003-05-08 22:06:03 +08:00
|
|
|
GdkCursorType ctype = GDK_TOP_LEFT_ARROW;
|
1999-04-18 07:18:43 +08:00
|
|
|
|
2003-05-08 22:06:03 +08:00
|
|
|
if (gimp_display_coords_in_active_drawable (gdisp, coords))
|
2001-11-20 21:53:21 +08:00
|
|
|
{
|
2003-09-03 23:13:19 +08:00
|
|
|
GimpChannel *selection = gimp_image_get_mask (gdisp->gimage);
|
|
|
|
|
2003-05-08 22:06:03 +08:00
|
|
|
/* One more test--is there a selected region?
|
|
|
|
* if so, is cursor inside?
|
|
|
|
*/
|
2003-09-03 23:13:19 +08:00
|
|
|
if (gimp_channel_is_empty (selection))
|
2003-05-08 22:06:03 +08:00
|
|
|
ctype = GIMP_MOUSE_CURSOR;
|
2003-09-03 23:13:19 +08:00
|
|
|
else if (gimp_channel_value (selection, coords->x, coords->y))
|
2003-05-08 22:06:03 +08:00
|
|
|
ctype = GIMP_MOUSE_CURSOR;
|
2001-11-20 21:53:21 +08:00
|
|
|
}
|
1998-06-15 06:42:36 +08:00
|
|
|
|
2002-05-03 19:31:08 +08:00
|
|
|
gimp_tool_control_set_cursor (tool->control, ctype);
|
2002-02-05 01:43:01 +08:00
|
|
|
|
|
|
|
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, gdisp);
|
1998-06-15 06:42:36 +08:00
|
|
|
}
|
|
|
|
|
1999-04-13 01:55:06 +08:00
|
|
|
|
1998-06-15 06:42:36 +08:00
|
|
|
static Blob *
|
2003-02-05 22:39:40 +08:00
|
|
|
ink_pen_ellipse (GimpInkOptions *options,
|
|
|
|
gdouble x_center,
|
|
|
|
gdouble y_center,
|
|
|
|
gdouble pressure,
|
|
|
|
gdouble xtilt,
|
|
|
|
gdouble ytilt,
|
|
|
|
gdouble velocity)
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
2003-02-08 23:27:51 +08:00
|
|
|
BlobFunc function = blob_ellipse;
|
|
|
|
gdouble size;
|
|
|
|
gdouble tsin, tcos;
|
|
|
|
gdouble aspect, radmin;
|
|
|
|
gdouble x,y;
|
|
|
|
gdouble tscale;
|
|
|
|
gdouble tscale_c;
|
|
|
|
gdouble tscale_s;
|
2001-11-21 07:00:47 +08:00
|
|
|
|
1999-04-10 22:55:17 +08:00
|
|
|
/* Adjust the size depending on pressure. */
|
|
|
|
|
2003-02-09 05:12:03 +08:00
|
|
|
size = options->size * (1.0 + options->size_sensitivity *
|
2001-11-21 07:00:47 +08:00
|
|
|
(2.0 * pressure - 1.0) );
|
1999-04-10 22:55:17 +08:00
|
|
|
|
|
|
|
/* Adjust the size further depending on pointer velocity
|
|
|
|
and velocity-sensitivity. These 'magic constants' are
|
|
|
|
'feels natural' tigert-approved. --ADM */
|
|
|
|
|
|
|
|
if (velocity < 3.0)
|
|
|
|
velocity = 3.0;
|
|
|
|
|
|
|
|
#ifdef VERBOSE
|
2004-03-12 21:50:36 +08:00
|
|
|
g_printerr ("%g (%g) -> ", size, velocity);
|
2003-08-22 09:42:57 +08:00
|
|
|
#endif
|
1999-04-10 22:55:17 +08:00
|
|
|
|
2003-02-09 05:12:03 +08:00
|
|
|
size = (options->vel_sensitivity *
|
|
|
|
((4.5 * size) / (1.0 + options->vel_sensitivity * (2.0 * velocity)))
|
|
|
|
+ (1.0 - options->vel_sensitivity) * size);
|
1999-04-10 22:55:17 +08:00
|
|
|
|
|
|
|
#ifdef VERBOSE
|
2004-03-12 21:50:36 +08:00
|
|
|
g_printerr ("%g\n", (gfloat) size);
|
1999-04-10 22:55:17 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Clamp resulting size to sane limits */
|
|
|
|
|
2003-02-09 05:12:03 +08:00
|
|
|
if (size > options->size * (1.0 + options->size_sensitivity))
|
|
|
|
size = options->size * (1.0 + options->size_sensitivity);
|
1998-06-15 06:42:36 +08:00
|
|
|
|
2003-02-09 05:12:03 +08:00
|
|
|
if (size * SUBSAMPLE < 1.0)
|
|
|
|
size = 1.0 / SUBSAMPLE;
|
1999-04-10 22:55:17 +08:00
|
|
|
|
|
|
|
/* Add brush angle/aspect to tilt vectorially */
|
1998-06-15 06:42:36 +08:00
|
|
|
|
1998-11-26 15:44:17 +08:00
|
|
|
/* I'm not happy with the way the brush widget info is combined with
|
|
|
|
tilt info from the brush. My personal feeling is that representing
|
|
|
|
both as affine transforms would make the most sense. -RLL */
|
|
|
|
|
2001-11-21 07:00:47 +08:00
|
|
|
tscale = options->tilt_sensitivity * 10.0;
|
|
|
|
tscale_c = tscale * cos (gimp_deg_to_rad (options->tilt_angle));
|
|
|
|
tscale_s = tscale * sin (gimp_deg_to_rad (options->tilt_angle));
|
|
|
|
|
2003-02-08 23:27:51 +08:00
|
|
|
x = (options->blob_aspect * cos (options->blob_angle) +
|
2001-11-21 07:00:47 +08:00
|
|
|
xtilt * tscale_c - ytilt * tscale_s);
|
2003-02-08 23:27:51 +08:00
|
|
|
y = (options->blob_aspect * sin (options->blob_angle) +
|
2001-11-21 07:00:47 +08:00
|
|
|
ytilt * tscale_c + xtilt * tscale_s);
|
|
|
|
|
1998-11-26 15:44:17 +08:00
|
|
|
#ifdef VERBOSE
|
2004-03-12 21:50:36 +08:00
|
|
|
g_printerr ("angle %g aspect %g; %g %g; %g %g\n",
|
|
|
|
options->blob_angle, options->blob_aspect,
|
|
|
|
tscale_c, tscale_s, x, y);
|
1998-11-26 15:44:17 +08:00
|
|
|
#endif
|
2003-02-08 23:27:51 +08:00
|
|
|
|
|
|
|
aspect = sqrt (x*x + y*y);
|
1998-06-15 06:42:36 +08:00
|
|
|
|
|
|
|
if (aspect != 0)
|
|
|
|
{
|
2003-02-08 23:27:51 +08:00
|
|
|
tcos = x / aspect;
|
|
|
|
tsin = y / aspect;
|
1998-06-15 06:42:36 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2003-02-08 23:27:51 +08:00
|
|
|
tsin = sin (options->blob_angle);
|
|
|
|
tcos = cos (options->blob_angle);
|
|
|
|
}
|
|
|
|
|
|
|
|
aspect = CLAMP (aspect, 1.0, 10.0);
|
|
|
|
|
|
|
|
radmin = MAX (1.0, SUBSAMPLE * size / aspect);
|
|
|
|
|
|
|
|
switch (options->blob_type)
|
|
|
|
{
|
|
|
|
case GIMP_INK_BLOB_TYPE_ELLIPSE:
|
|
|
|
function = blob_ellipse;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GIMP_INK_BLOB_TYPE_SQUARE:
|
|
|
|
function = blob_square;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GIMP_INK_BLOB_TYPE_DIAMOND:
|
|
|
|
function = blob_diamond;
|
|
|
|
break;
|
1998-06-15 06:42:36 +08:00
|
|
|
}
|
1999-04-09 06:25:54 +08:00
|
|
|
|
2003-02-08 23:27:51 +08:00
|
|
|
return (* function) (x_center * SUBSAMPLE,
|
|
|
|
y_center * SUBSAMPLE,
|
|
|
|
radmin * aspect * tcos,
|
2003-08-22 09:42:57 +08:00
|
|
|
radmin * aspect * tsin,
|
2003-02-08 23:27:51 +08:00
|
|
|
-radmin * tsin,
|
|
|
|
radmin * tcos);
|
1998-06-15 06:42:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2001-11-20 21:53:21 +08:00
|
|
|
dist_smoother_init (GimpInkTool *ink_tool,
|
|
|
|
gdouble initval)
|
2001-11-09 03:14:51 +08:00
|
|
|
{
|
2001-11-20 21:53:21 +08:00
|
|
|
gint i;
|
2001-11-09 03:14:51 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
ink_tool->dt_index = 0;
|
2001-11-09 03:14:51 +08:00
|
|
|
|
2003-02-08 23:27:51 +08:00
|
|
|
for (i = 0; i < DIST_SMOOTHER_BUFFER; i++)
|
2001-11-09 03:14:51 +08:00
|
|
|
{
|
2001-11-20 21:53:21 +08:00
|
|
|
ink_tool->dt_buffer[i] = initval;
|
|
|
|
}
|
|
|
|
}
|
2001-11-09 03:14:51 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
static gdouble
|
|
|
|
dist_smoother_result (GimpInkTool *ink_tool)
|
|
|
|
{
|
|
|
|
gint i;
|
|
|
|
gdouble result = 0.0;
|
2001-11-09 03:14:51 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
for (i = 0; i < DIST_SMOOTHER_BUFFER; i++)
|
|
|
|
{
|
|
|
|
result += ink_tool->dt_buffer[i];
|
2001-11-09 03:14:51 +08:00
|
|
|
}
|
2001-11-20 21:53:21 +08:00
|
|
|
|
|
|
|
return (result / (gdouble) DIST_SMOOTHER_BUFFER);
|
2001-11-09 03:14:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2001-11-20 21:53:21 +08:00
|
|
|
dist_smoother_add (GimpInkTool *ink_tool,
|
|
|
|
gdouble value)
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
2001-11-20 21:53:21 +08:00
|
|
|
ink_tool->dt_buffer[ink_tool->dt_index] = value;
|
2001-11-01 05:20:09 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
if ((++ink_tool->dt_index) == DIST_SMOOTHER_BUFFER)
|
|
|
|
ink_tool->dt_index = 0;
|
|
|
|
}
|
1998-06-15 06:42:36 +08:00
|
|
|
|
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
static void
|
|
|
|
time_smoother_init (GimpInkTool *ink_tool,
|
|
|
|
guint32 initval)
|
|
|
|
{
|
|
|
|
gint i;
|
1998-06-15 06:42:36 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
ink_tool->ts_index = 0;
|
1998-06-15 06:42:36 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
for (i = 0; i < TIME_SMOOTHER_BUFFER; i++)
|
2001-11-09 03:14:51 +08:00
|
|
|
{
|
2001-11-20 21:53:21 +08:00
|
|
|
ink_tool->ts_buffer[i] = initval;
|
2001-11-09 03:14:51 +08:00
|
|
|
}
|
2001-11-20 21:53:21 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static gdouble
|
|
|
|
time_smoother_result (GimpInkTool *ink_tool)
|
|
|
|
{
|
|
|
|
gint i;
|
|
|
|
guint64 result = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < TIME_SMOOTHER_BUFFER; i++)
|
2001-11-09 03:14:51 +08:00
|
|
|
{
|
2001-11-20 21:53:21 +08:00
|
|
|
result += ink_tool->ts_buffer[i];
|
2001-11-09 03:14:51 +08:00
|
|
|
}
|
1998-06-15 06:42:36 +08:00
|
|
|
|
2001-11-20 21:53:21 +08:00
|
|
|
#ifdef _MSC_VER
|
|
|
|
return (gdouble) (gint64) (result / TIME_SMOOTHER_BUFFER);
|
|
|
|
#else
|
|
|
|
return (result / TIME_SMOOTHER_BUFFER);
|
|
|
|
#endif
|
|
|
|
}
|
1999-04-10 22:55:17 +08:00
|
|
|
|
|
|
|
static void
|
2001-02-28 08:10:58 +08:00
|
|
|
time_smoother_add (GimpInkTool *ink_tool,
|
|
|
|
guint32 value)
|
1999-04-10 22:55:17 +08:00
|
|
|
{
|
|
|
|
ink_tool->ts_buffer[ink_tool->ts_index] = value;
|
|
|
|
|
|
|
|
if ((++ink_tool->ts_index) == TIME_SMOOTHER_BUFFER)
|
|
|
|
ink_tool->ts_index = 0;
|
|
|
|
}
|
|
|
|
|
1998-06-15 06:42:36 +08:00
|
|
|
static void
|
2001-02-28 08:10:58 +08:00
|
|
|
ink_init (GimpInkTool *ink_tool,
|
2003-08-22 09:42:57 +08:00
|
|
|
GimpDrawable *drawable,
|
2000-12-31 12:07:42 +08:00
|
|
|
gdouble x,
|
|
|
|
gdouble y)
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
2003-05-08 21:12:46 +08:00
|
|
|
GimpItem *item = GIMP_ITEM (drawable);
|
|
|
|
|
2003-05-27 01:02:06 +08:00
|
|
|
/* Allocate the undo structure */
|
1998-06-15 06:42:36 +08:00
|
|
|
if (undo_tiles)
|
2003-05-27 01:02:06 +08:00
|
|
|
tile_manager_unref (undo_tiles);
|
1998-06-15 06:42:36 +08:00
|
|
|
|
2003-05-08 21:12:46 +08:00
|
|
|
undo_tiles = tile_manager_new (gimp_item_width (item),
|
|
|
|
gimp_item_height (item),
|
2001-01-15 05:11:52 +08:00
|
|
|
gimp_drawable_bytes (drawable));
|
1998-06-15 06:42:36 +08:00
|
|
|
|
|
|
|
/* Allocate the canvas blocks structure */
|
2003-05-27 01:02:06 +08:00
|
|
|
if (canvas_tiles)
|
|
|
|
tile_manager_unref (canvas_tiles);
|
|
|
|
|
2003-05-08 21:12:46 +08:00
|
|
|
canvas_tiles = tile_manager_new (gimp_item_width (item),
|
|
|
|
gimp_item_height (item), 1);
|
1998-06-15 06:42:36 +08:00
|
|
|
|
|
|
|
/* Get the initial undo extents */
|
|
|
|
ink_tool->x1 = ink_tool->x2 = x;
|
|
|
|
ink_tool->y1 = ink_tool->y2 = y;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2001-02-28 08:10:58 +08:00
|
|
|
ink_finish (GimpInkTool *ink_tool,
|
|
|
|
GimpDrawable *drawable)
|
1998-06-15 06:42:36 +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
|
|
|
GimpImage *gimage;
|
|
|
|
|
2003-02-14 22:14:29 +08:00
|
|
|
gimp_drawable_push_undo (drawable, _("Ink"),
|
2002-06-07 03:44:05 +08:00
|
|
|
ink_tool->x1, ink_tool->y1,
|
|
|
|
ink_tool->x2, ink_tool->y2,
|
|
|
|
undo_tiles, TRUE);
|
2003-05-27 01:02:06 +08:00
|
|
|
|
|
|
|
tile_manager_unref (undo_tiles);
|
1998-06-15 06:42:36 +08:00
|
|
|
undo_tiles = NULL;
|
|
|
|
|
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
|
|
|
gimage = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
|
|
|
|
|
|
/* invalidate the previews -- have to do it here, because
|
1998-06-15 06:42:36 +08:00
|
|
|
* it is not done during the actual painting.
|
|
|
|
*/
|
2001-02-05 06:10:54 +08:00
|
|
|
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (drawable));
|
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_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
|
1998-06-15 06:42:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
ink_cleanup (void)
|
|
|
|
{
|
|
|
|
/* If the undo tiles exist, nuke them */
|
|
|
|
if (undo_tiles)
|
|
|
|
{
|
2003-05-27 01:02:06 +08:00
|
|
|
tile_manager_unref (undo_tiles);
|
1998-06-15 06:42:36 +08:00
|
|
|
undo_tiles = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If the canvas blocks exist, nuke them */
|
|
|
|
if (canvas_tiles)
|
|
|
|
{
|
2003-05-27 01:02:06 +08:00
|
|
|
tile_manager_unref (canvas_tiles);
|
1998-06-15 06:42:36 +08:00
|
|
|
canvas_tiles = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free the temporary buffer if it exist */
|
|
|
|
if (canvas_buf)
|
2001-02-28 08:10:58 +08:00
|
|
|
{
|
|
|
|
temp_buf_free (canvas_buf);
|
|
|
|
canvas_buf = NULL;
|
|
|
|
}
|
1998-06-15 06:42:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*********************************
|
|
|
|
* Rendering functions *
|
|
|
|
*********************************/
|
|
|
|
|
2003-08-22 09:42:57 +08:00
|
|
|
/* Some of this stuff should probably be combined with the
|
1998-06-15 06:42:36 +08:00
|
|
|
* code it was copied from in paint_core.c; but I wanted
|
|
|
|
* to learn this stuff, so I've kept it simple.
|
|
|
|
*
|
|
|
|
* The following only supports CONSTANT mode. Incremental
|
|
|
|
* would, I think, interact strangely with the way we
|
|
|
|
* do things. But it wouldn't be hard to implement at all.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
2003-08-22 09:42:57 +08:00
|
|
|
ink_set_paint_area (GimpInkTool *ink_tool,
|
|
|
|
GimpDrawable *drawable,
|
1998-06-15 06:42:36 +08:00
|
|
|
Blob *blob)
|
|
|
|
{
|
2003-05-08 21:12:46 +08:00
|
|
|
GimpItem *item = GIMP_ITEM (drawable);
|
|
|
|
gint x, y, width, height;
|
|
|
|
gint x1, y1, x2, y2;
|
|
|
|
gint bytes;
|
2001-02-28 08:10:58 +08:00
|
|
|
|
1998-06-15 06:42:36 +08:00
|
|
|
blob_bounds (blob, &x, &y, &width, &height);
|
|
|
|
|
2004-01-19 04:37:41 +08:00
|
|
|
bytes = gimp_drawable_bytes_with_alpha (drawable);
|
1998-06-15 06:42:36 +08:00
|
|
|
|
2004-01-19 04:37:41 +08:00
|
|
|
x1 = CLAMP (x / SUBSAMPLE - 1, 0, gimp_item_width (item));
|
|
|
|
y1 = CLAMP (y / SUBSAMPLE - 1, 0, gimp_item_height (item));
|
|
|
|
x2 = CLAMP ((x + width) / SUBSAMPLE + 2, 0, gimp_item_width (item));
|
|
|
|
y2 = CLAMP ((y + height) / SUBSAMPLE + 2, 0, gimp_item_height (item));
|
1998-06-15 06:42:36 +08:00
|
|
|
|
|
|
|
/* configure the canvas buffer */
|
|
|
|
if ((x2 - x1) && (y2 - y1))
|
|
|
|
canvas_buf = temp_buf_resize (canvas_buf, bytes, x1, y1,
|
|
|
|
(x2 - x1), (y2 - y1));
|
|
|
|
}
|
|
|
|
|
|
|
|
enum { ROW_START, ROW_STOP };
|
|
|
|
|
|
|
|
/* The insertion sort here, for SUBSAMPLE = 8, tends to beat out
|
|
|
|
* qsort() by 4x with CFLAGS=-O2, 2x with CFLAGS=-g
|
|
|
|
*/
|
2000-12-31 12:07:42 +08:00
|
|
|
static void
|
|
|
|
insert_sort (gint *data,
|
|
|
|
gint n)
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
2000-12-31 12:07:42 +08:00
|
|
|
gint i, j, k;
|
|
|
|
gint tmp1, tmp2;
|
1998-06-15 06:42:36 +08:00
|
|
|
|
|
|
|
for (i=2; i<2*n; i+=2)
|
|
|
|
{
|
|
|
|
tmp1 = data[i];
|
|
|
|
tmp2 = data[i+1];
|
|
|
|
j = 0;
|
|
|
|
while (data[j] < tmp1)
|
|
|
|
j += 2;
|
|
|
|
|
|
|
|
for (k=i; k>j; k-=2)
|
|
|
|
{
|
|
|
|
data[k] = data[k-2];
|
|
|
|
data[k+1] = data[k-1];
|
|
|
|
}
|
|
|
|
|
|
|
|
data[j] = tmp1;
|
|
|
|
data[j+1] = tmp2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
fill_run (guchar *dest,
|
|
|
|
guchar alpha,
|
2000-12-31 12:07:42 +08:00
|
|
|
gint w)
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
|
|
|
if (alpha == 255)
|
|
|
|
{
|
|
|
|
memset (dest, 255, w);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
while (w--)
|
|
|
|
{
|
1998-11-28 06:42:15 +08:00
|
|
|
*dest = MAX(*dest, alpha);
|
1998-06-15 06:42:36 +08:00
|
|
|
dest++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2000-12-31 12:07:42 +08:00
|
|
|
render_blob_line (Blob *blob,
|
|
|
|
guchar *dest,
|
|
|
|
gint x,
|
|
|
|
gint y,
|
|
|
|
gint width)
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
2001-02-28 08:10:58 +08:00
|
|
|
gint buf[4 * SUBSAMPLE];
|
|
|
|
gint *data = buf;
|
|
|
|
gint n = 0;
|
2000-12-31 12:07:42 +08:00
|
|
|
gint i, j;
|
|
|
|
gint current = 0; /* number of filled rows at this point
|
|
|
|
* in the scan line
|
|
|
|
*/
|
|
|
|
gint last_x;
|
1998-06-15 06:42:36 +08:00
|
|
|
|
|
|
|
/* Sort start and ends for all lines */
|
2003-08-22 09:42:57 +08:00
|
|
|
|
1998-06-15 06:42:36 +08:00
|
|
|
j = y * SUBSAMPLE - blob->y;
|
2001-02-28 08:10:58 +08:00
|
|
|
for (i = 0; i < SUBSAMPLE; i++)
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
|
|
|
if (j >= blob->height)
|
|
|
|
break;
|
2001-02-28 08:10:58 +08:00
|
|
|
|
1998-06-15 06:42:36 +08:00
|
|
|
if ((j > 0) && (blob->data[j].left <= blob->data[j].right))
|
|
|
|
{
|
2001-02-28 08:10:58 +08:00
|
|
|
data[2 * n] = blob->data[j].left;
|
|
|
|
data[2 * n + 1] = ROW_START;
|
|
|
|
data[2 * SUBSAMPLE + 2 * n] = blob->data[j].right;
|
|
|
|
data[2 * SUBSAMPLE + 2 * n + 1] = ROW_STOP;
|
1998-06-15 06:42:36 +08:00
|
|
|
n++;
|
|
|
|
}
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we have less than SUBSAMPLE rows, compress */
|
|
|
|
if (n < SUBSAMPLE)
|
|
|
|
{
|
2001-02-28 08:10:58 +08:00
|
|
|
for (i = 0; i < 2 * n; i++)
|
|
|
|
data[2 * n + i] = data[2 * SUBSAMPLE + i];
|
1998-06-15 06:42:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Now count start and end separately */
|
|
|
|
n *= 2;
|
|
|
|
|
|
|
|
insert_sort (data, n);
|
|
|
|
|
|
|
|
/* Discard portions outside of tile */
|
|
|
|
|
|
|
|
while ((n > 0) && (data[0] < SUBSAMPLE*x))
|
|
|
|
{
|
|
|
|
if (data[1] == ROW_START)
|
|
|
|
current++;
|
|
|
|
else
|
|
|
|
current--;
|
|
|
|
data += 2;
|
|
|
|
n--;
|
|
|
|
}
|
|
|
|
|
|
|
|
while ((n > 0) && (data[2*(n-1)] >= SUBSAMPLE*(x+width)))
|
|
|
|
n--;
|
2003-08-22 09:42:57 +08:00
|
|
|
|
1998-06-15 06:42:36 +08:00
|
|
|
/* Render the row */
|
|
|
|
|
|
|
|
last_x = 0;
|
2001-02-28 08:10:58 +08:00
|
|
|
for (i = 0; i < n;)
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
2001-02-28 08:10:58 +08:00
|
|
|
gint cur_x = data[2 * i] / SUBSAMPLE - x;
|
2000-12-31 12:07:42 +08:00
|
|
|
gint pixel;
|
1998-06-15 06:42:36 +08:00
|
|
|
|
|
|
|
/* Fill in portion leading up to this pixel */
|
|
|
|
if (current && cur_x != last_x)
|
2001-02-28 08:10:58 +08:00
|
|
|
fill_run (dest + last_x, (255 * current) / SUBSAMPLE, cur_x - last_x);
|
1998-06-15 06:42:36 +08:00
|
|
|
|
|
|
|
/* Compute the value for this pixel */
|
2003-08-22 09:42:57 +08:00
|
|
|
pixel = current * SUBSAMPLE;
|
1998-06-15 06:42:36 +08:00
|
|
|
|
|
|
|
while (i<n)
|
|
|
|
{
|
2001-02-28 08:10:58 +08:00
|
|
|
gint tmp_x = data[2 * i] / SUBSAMPLE;
|
|
|
|
|
1998-06-15 06:42:36 +08:00
|
|
|
if (tmp_x - x != cur_x)
|
|
|
|
break;
|
|
|
|
|
2001-02-28 08:10:58 +08:00
|
|
|
if (data[2 * i + 1] == ROW_START)
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
|
|
|
current++;
|
2001-02-28 08:10:58 +08:00
|
|
|
pixel += ((tmp_x + 1) * SUBSAMPLE) - data[2 * i];
|
1998-06-15 06:42:36 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
current--;
|
2001-02-28 08:10:58 +08:00
|
|
|
pixel -= ((tmp_x + 1) * SUBSAMPLE) - data[2 * i];
|
1998-06-15 06:42:36 +08:00
|
|
|
}
|
2003-08-22 09:42:57 +08:00
|
|
|
|
1998-06-15 06:42:36 +08:00
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
2000-12-31 12:07:42 +08:00
|
|
|
dest[cur_x] = MAX (dest[cur_x], (pixel * 255) / (SUBSAMPLE * SUBSAMPLE));
|
1998-06-15 06:42:36 +08:00
|
|
|
|
|
|
|
last_x = cur_x + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (current != 0)
|
2001-02-28 08:10:58 +08:00
|
|
|
fill_run (dest + last_x, (255 * current)/ SUBSAMPLE, width - last_x);
|
1998-06-15 06:42:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2000-12-31 12:07:42 +08:00
|
|
|
render_blob (PixelRegion *dest,
|
|
|
|
Blob *blob)
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
2000-12-31 12:07:42 +08:00
|
|
|
gint i;
|
|
|
|
gint h;
|
|
|
|
guchar *s;
|
|
|
|
gpointer pr;
|
1998-06-15 06:42:36 +08:00
|
|
|
|
2003-08-22 09:42:57 +08:00
|
|
|
for (pr = pixel_regions_register (1, dest);
|
|
|
|
pr != NULL;
|
1998-06-15 06:42:36 +08:00
|
|
|
pr = pixel_regions_process (pr))
|
|
|
|
{
|
|
|
|
h = dest->h;
|
|
|
|
s = dest->data;
|
|
|
|
|
|
|
|
for (i=0; i<h; i++)
|
|
|
|
{
|
|
|
|
render_blob_line (blob, s,
|
|
|
|
dest->x, dest->y + i, dest->w);
|
|
|
|
s += dest->rowstride;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2003-08-22 09:42:57 +08:00
|
|
|
ink_paste (GimpInkTool *ink_tool,
|
1998-06-15 06:42:36 +08:00
|
|
|
GimpDrawable *drawable,
|
|
|
|
Blob *blob)
|
|
|
|
{
|
2001-02-28 08:10:58 +08:00
|
|
|
GimpImage *gimage;
|
2001-07-07 20:17:23 +08:00
|
|
|
GimpContext *context;
|
2000-12-31 12:07:42 +08:00
|
|
|
PixelRegion srcPR;
|
|
|
|
gint offx, offy;
|
2003-07-03 02:01:19 +08:00
|
|
|
guchar col[MAX_CHANNELS];
|
1998-06-15 06:42:36 +08:00
|
|
|
|
2002-02-26 01:58:50 +08:00
|
|
|
if (! (gimage = gimp_item_get_image (GIMP_ITEM (drawable))))
|
1998-06-15 06:42:36 +08:00
|
|
|
return;
|
1998-08-17 07:54:51 +08:00
|
|
|
|
2003-02-06 00:59:04 +08:00
|
|
|
context = GIMP_CONTEXT (GIMP_TOOL (ink_tool)->tool_info->tool_options);
|
2001-07-07 20:17:23 +08:00
|
|
|
|
1998-06-15 06:42:36 +08:00
|
|
|
/* Get the the buffer */
|
|
|
|
ink_set_paint_area (ink_tool, drawable, blob);
|
2003-08-22 09:42:57 +08:00
|
|
|
|
1998-08-17 07:54:51 +08:00
|
|
|
/* check to make sure there is actually a canvas to draw on */
|
|
|
|
if (!canvas_buf)
|
|
|
|
return;
|
1998-06-15 06:42:36 +08:00
|
|
|
|
2004-04-15 07:37:34 +08:00
|
|
|
gimp_image_get_foreground (gimage, drawable, context, col);
|
1998-06-15 06:42:36 +08:00
|
|
|
|
|
|
|
/* set the alpha channel */
|
|
|
|
col[canvas_buf->bytes - 1] = OPAQUE_OPACITY;
|
|
|
|
|
|
|
|
/* color the pixels */
|
|
|
|
color_pixels (temp_buf_data (canvas_buf), col,
|
|
|
|
canvas_buf->width * canvas_buf->height, canvas_buf->bytes);
|
|
|
|
|
|
|
|
/* set undo blocks */
|
|
|
|
ink_set_undo_tiles (drawable,
|
|
|
|
canvas_buf->x, canvas_buf->y,
|
|
|
|
canvas_buf->width, canvas_buf->height);
|
|
|
|
|
|
|
|
/* initialize any invalid canvas tiles */
|
|
|
|
ink_set_canvas_tiles (canvas_buf->x, canvas_buf->y,
|
|
|
|
canvas_buf->width, canvas_buf->height);
|
|
|
|
|
|
|
|
ink_to_canvas_tiles (ink_tool, blob, col);
|
|
|
|
|
|
|
|
/* initialize canvas buf source pixel regions */
|
|
|
|
srcPR.bytes = canvas_buf->bytes;
|
|
|
|
srcPR.x = 0; srcPR.y = 0;
|
|
|
|
srcPR.w = canvas_buf->width;
|
|
|
|
srcPR.h = canvas_buf->height;
|
|
|
|
srcPR.rowstride = canvas_buf->width * canvas_buf->bytes;
|
|
|
|
srcPR.data = temp_buf_data (canvas_buf);
|
|
|
|
|
|
|
|
/* apply the paint area to the gimage */
|
2003-10-06 22:40:12 +08:00
|
|
|
gimp_drawable_apply_region (drawable, &srcPR,
|
|
|
|
FALSE, NULL,
|
|
|
|
gimp_context_get_opacity (context),
|
|
|
|
gimp_context_get_paint_mode (context),
|
|
|
|
undo_tiles, /* specify an alternative src1 */
|
|
|
|
canvas_buf->x, canvas_buf->y);
|
1998-06-15 06:42:36 +08:00
|
|
|
|
|
|
|
/* Update the undo extents */
|
|
|
|
ink_tool->x1 = MIN (ink_tool->x1, canvas_buf->x);
|
|
|
|
ink_tool->y1 = MIN (ink_tool->y1, canvas_buf->y);
|
|
|
|
ink_tool->x2 = MAX (ink_tool->x2, (canvas_buf->x + canvas_buf->width));
|
|
|
|
ink_tool->y2 = MAX (ink_tool->y2, (canvas_buf->y + canvas_buf->height));
|
|
|
|
|
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
|
|
|
/* Update the gimage -- it is important to call gimp_image_update()
|
|
|
|
* instead of gimp_drawable_update() because we don't want the
|
|
|
|
* drawable and image previews to be constantly invalidated
|
1998-06-15 06:42:36 +08:00
|
|
|
*/
|
2003-05-08 22:06:03 +08:00
|
|
|
gimp_item_offsets (GIMP_ITEM (drawable), &offx, &offy);
|
2001-11-01 05:20:09 +08:00
|
|
|
gimp_image_update (gimage,
|
|
|
|
canvas_buf->x + offx,
|
|
|
|
canvas_buf->y + offy,
|
|
|
|
canvas_buf->width,
|
|
|
|
canvas_buf->height);
|
1998-06-15 06:42:36 +08:00
|
|
|
}
|
|
|
|
|
1998-11-28 06:42:15 +08:00
|
|
|
/* This routine a) updates the representation of the stroke
|
|
|
|
* in the canvas tiles, then renders the dirty bit of it
|
|
|
|
* into canvas_buf.
|
|
|
|
*/
|
1998-06-15 06:42:36 +08:00
|
|
|
static void
|
2001-02-28 08:10:58 +08:00
|
|
|
ink_to_canvas_tiles (GimpInkTool *ink_tool,
|
|
|
|
Blob *blob,
|
|
|
|
guchar *color)
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
|
|
|
PixelRegion srcPR, maskPR;
|
|
|
|
|
|
|
|
/* draw the blob on the canvas tiles */
|
|
|
|
pixel_region_init (&srcPR, canvas_tiles,
|
|
|
|
canvas_buf->x, canvas_buf->y,
|
|
|
|
canvas_buf->width, canvas_buf->height, TRUE);
|
|
|
|
|
|
|
|
render_blob (&srcPR, blob);
|
|
|
|
|
|
|
|
/* combine the canvas tiles and the canvas buf */
|
|
|
|
srcPR.bytes = canvas_buf->bytes;
|
|
|
|
srcPR.x = 0; srcPR.y = 0;
|
|
|
|
srcPR.w = canvas_buf->width;
|
|
|
|
srcPR.h = canvas_buf->height;
|
|
|
|
srcPR.rowstride = canvas_buf->width * canvas_buf->bytes;
|
|
|
|
srcPR.data = temp_buf_data (canvas_buf);
|
|
|
|
|
|
|
|
pixel_region_init (&maskPR, canvas_tiles,
|
|
|
|
canvas_buf->x, canvas_buf->y,
|
|
|
|
canvas_buf->width, canvas_buf->height, FALSE);
|
|
|
|
|
|
|
|
/* apply the canvas tiles to the canvas buf */
|
|
|
|
apply_mask_to_region (&srcPR, &maskPR, OPAQUE_OPACITY);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
1999-05-01 05:11:27 +08:00
|
|
|
ink_set_undo_tiles (GimpDrawable *drawable,
|
2001-02-28 08:10:58 +08:00
|
|
|
gint x,
|
|
|
|
gint y,
|
|
|
|
gint w,
|
|
|
|
gint h)
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
2001-02-28 08:10:58 +08:00
|
|
|
gint i, j;
|
1998-06-15 06:42:36 +08:00
|
|
|
Tile *src_tile;
|
|
|
|
Tile *dest_tile;
|
|
|
|
|
|
|
|
for (i = y; i < (y + h); i += (TILE_HEIGHT - (i % TILE_HEIGHT)))
|
|
|
|
{
|
|
|
|
for (j = x; j < (x + w); j += (TILE_WIDTH - (j % TILE_WIDTH)))
|
|
|
|
{
|
1998-08-16 03:17:36 +08:00
|
|
|
dest_tile = tile_manager_get_tile (undo_tiles, j, i, FALSE, FALSE);
|
2004-02-19 02:57:43 +08:00
|
|
|
|
|
|
|
if (! tile_is_valid (dest_tile))
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
2001-01-15 05:11:52 +08:00
|
|
|
src_tile = tile_manager_get_tile (gimp_drawable_data (drawable),
|
|
|
|
j, i, TRUE, FALSE);
|
1998-08-16 03:17:36 +08:00
|
|
|
tile_manager_map_tile (undo_tiles, j, i, src_tile);
|
1998-07-10 10:43:12 +08:00
|
|
|
tile_release (src_tile, FALSE);
|
1998-06-15 06:42:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
2000-12-31 12:07:42 +08:00
|
|
|
ink_set_canvas_tiles (gint x,
|
|
|
|
gint y,
|
|
|
|
gint w,
|
|
|
|
gint h)
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
|
|
|
Tile *tile;
|
2004-02-19 02:57:43 +08:00
|
|
|
gint i, j;
|
1998-06-15 06:42:36 +08:00
|
|
|
|
|
|
|
for (i = y; i < (y + h); i += (TILE_HEIGHT - (i % TILE_HEIGHT)))
|
|
|
|
{
|
|
|
|
for (j = x; j < (x + w); j += (TILE_WIDTH - (j % TILE_WIDTH)))
|
|
|
|
{
|
1998-08-16 03:17:36 +08:00
|
|
|
tile = tile_manager_get_tile (canvas_tiles, j, i, FALSE, FALSE);
|
2004-02-19 02:57:43 +08:00
|
|
|
|
|
|
|
if (! tile_is_valid (tile))
|
1998-06-15 06:42:36 +08:00
|
|
|
{
|
1998-08-16 03:17:36 +08:00
|
|
|
tile = tile_manager_get_tile (canvas_tiles, j, i, TRUE, TRUE);
|
2003-08-22 09:42:57 +08:00
|
|
|
memset (tile_data_pointer (tile, 0, 0),
|
|
|
|
0,
|
1998-08-12 01:35:34 +08:00
|
|
|
tile_size (tile));
|
1998-07-10 10:43:12 +08:00
|
|
|
tile_release (tile, TRUE);
|
1998-06-15 06:42:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|