Commit 5e07ceb8 authored by Michael Natterer's avatar Michael Natterer 😴 Committed by Michael Natterer

app/paint/Makefile.am app/paint/gimpink-blob.[ch] app/paint/gimpink.[ch]

2004-05-26  Michael Natterer  <mitch@gimp.org>

	* app/paint/Makefile.am
	* app/paint/gimpink-blob.[ch]
	* app/paint/gimpink.[ch]
	* app/paint/gimpinkoptions.[ch]: new files. Ported the ink tool
	to be a direct GimpPaintCore subclass without any GUI.

	* app/paint/gimp-paint.c: register GimpInk with the list of paint
	cores.

	* app/tools/Makefile.am
	* app/tools/gimpinkoptions.[ch]
	* app/tools/gimpinktool-blob.[ch]: removed these files.

	* app/tools/gimpinkoptions-gui.[ch]: new files containing only
	the GUI for GimpInkOptions.

	* app/tools/gimpinktool.[ch]: reduced to some few lines which
	implement a simple GimpPaintTool subclass.

	* app/tools/gimp-tools.c: associate the GimpInk paint_core with
	the GimpInkTool.
parent 35eeae14
2004-05-26 Michael Natterer <mitch@gimp.org>
* app/paint/Makefile.am
* app/paint/gimpink-blob.[ch]
* app/paint/gimpink.[ch]
* app/paint/gimpinkoptions.[ch]: new files. Ported the ink tool
to be a direct GimpPaintCore subclass without any GUI.
* app/paint/gimp-paint.c: register GimpInk with the list of paint
cores.
* app/tools/Makefile.am
* app/tools/gimpinkoptions.[ch]
* app/tools/gimpinktool-blob.[ch]: removed these files.
* app/tools/gimpinkoptions-gui.[ch]: new files containing only
the GUI for GimpInkOptions.
* app/tools/gimpinktool.[ch]: reduced to some few lines which
implement a simple GimpPaintTool subclass.
* app/tools/gimp-tools.c: associate the GimpInk paint_core with
the GimpInkTool.
2004-05-26 Michael Natterer <mitch@gimp.org>
* app/paint/gimppaintcore-stroke.c: check if we really have
......
......@@ -43,6 +43,12 @@ libapppaint_a_sources = \
gimperaser.h \
gimperaseroptions.c \
gimperaseroptions.h \
gimpink.c \
gimpink.h \
gimpink-blob.c \
gimpink-blob.h \
gimpinkoptions.c \
gimpinkoptions.h \
gimppaintcore.c \
gimppaintcore.h \
gimppaintcore-stroke.c \
......
......@@ -32,6 +32,7 @@
#include "gimpconvolve.h"
#include "gimpdodgeburn.h"
#include "gimperaser.h"
#include "gimpink.h"
#include "gimppaintoptions.h"
#include "gimppaintbrush.h"
#include "gimppencil.h"
......@@ -61,6 +62,7 @@ gimp_paint_init (Gimp *gimp)
gimp_eraser_register,
gimp_paintbrush_register,
gimp_pencil_register,
gimp_ink_register
};
gint i;
......
This diff is collapsed.
/* blob.h: routines for manipulating scan converted convex
* polygons.
*
*
* Copyright 1998, Owen Taylor <otaylor@gtk.org>
*
* > Please contact the above author before modifying the copy <
......@@ -22,20 +22,20 @@
*
*/
#ifndef __GIMP_INK_TOOL_BLOB_H__
#define __GIMP_INK_TOOL_BLOB_H__
#ifndef __GIMP_INK_BLOB_H__
#define __GIMP_INK_BLOB_H__
typedef struct _BlobPoint BlobPoint;
typedef struct _BlobSpan BlobSpan;
typedef struct _Blob Blob;
typedef Blob * (* BlobFunc) (gdouble,
gdouble,
gdouble,
gdouble,
gdouble,
gdouble);
typedef Blob * (* BlobFunc) (gdouble xc,
gdouble yc,
gdouble xp,
gdouble yp,
gdouble xq,
gdouble yq);
struct _BlobPoint
{
......@@ -57,33 +57,33 @@ struct _Blob
};
Blob * blob_convex_union (Blob *b1,
Blob *b2);
Blob * blob_polygon (BlobPoint *points,
gint npoints);
gint npoints);
Blob * blob_square (gdouble xc,
gdouble yc,
gdouble xp,
gdouble yp,
gdouble xq,
gdouble yq);
gdouble yc,
gdouble xp,
gdouble yp,
gdouble xq,
gdouble yq);
Blob * blob_diamond (gdouble xc,
gdouble yc,
gdouble xp,
gdouble yp,
gdouble xq,
gdouble yq);
gdouble yc,
gdouble xp,
gdouble yp,
gdouble xq,
gdouble yq);
Blob * blob_ellipse (gdouble xc,
gdouble yc,
gdouble xp,
gdouble yp,
gdouble xq,
gdouble yq);
gdouble yc,
gdouble xp,
gdouble yp,
gdouble xq,
gdouble yq);
void blob_bounds (Blob *b,
gint *x,
gint *y,
gint *width,
gint *height);
gint *x,
gint *y,
gint *width,
gint *height);
Blob * blob_convex_union (Blob *b1,
Blob *b2);
#endif /* __GIMP_INK_TOOL_BLOB_H__ */
#endif /* __GIMP_INK_BLOB_H__ */
This diff is collapsed.
......@@ -16,62 +16,60 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_INK_TOOL_H__
#define __GIMP_INK_TOOL_H__
#ifndef __GIMP_INK_H__
#define __GIMP_INK_H__
#include "gimptool.h"
#include "gimpinktool-blob.h" /* only used by ink */
#include "gimppaintcore.h"
#include "gimpink-blob.h"
#define DIST_SMOOTHER_BUFFER 10
#define TIME_SMOOTHER_BUFFER 10
#define GIMP_TYPE_INK_TOOL (gimp_ink_tool_get_type ())
#define GIMP_INK_TOOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_INK_TOOL, GimpInkTool))
#define GIMP_INK_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_INK_TOOL, GimpInkToolClass))
#define GIMP_IS_INK_TOOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_INK_TOOL))
#define GIMP_IS_INK_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_INK_TOOL))
#define GIMP_INK_TOOL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_INK_TOOL, GimpInkToolClass))
#define GIMP_TYPE_INK (gimp_ink_get_type ())
#define GIMP_INK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_INK, GimpInk))
#define GIMP_INK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_INK, GimpInkClass))
#define GIMP_IS_INK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_INK))
#define GIMP_IS_INK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_INK))
#define GIMP_INK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_INK, GimpInkClass))
typedef struct _GimpInkTool GimpInkTool;
typedef struct _GimpInkToolClass GimpInkToolClass;
typedef struct _GimpInk GimpInk;
typedef struct _GimpInkClass GimpInkClass;
struct _GimpInkTool
struct _GimpInk
{
GimpTool parent_instance;
Blob *last_blob; /* blob for last cursor position */
GimpPaintCore parent_instance;
gint x1, y1; /* image space coordinate */
gint x2, y2; /* image space coords */
Blob *blob; /* current blob */
Blob *last_blob; /* blob for last cursor position */
/* circular distance history buffer */
gdouble dt_buffer[DIST_SMOOTHER_BUFFER];
gint dt_index;
gdouble dt_buffer[DIST_SMOOTHER_BUFFER];
gint dt_index;
/* circular timing history buffer */
guint32 ts_buffer[TIME_SMOOTHER_BUFFER];
gint ts_index;
guint32 ts_buffer[TIME_SMOOTHER_BUFFER];
gint ts_index;
gdouble last_time; /* previous time of a motion event */
gdouble lastx, lasty; /* previous position of a motion event */
gdouble last_time; /* previous time of a motion event */
gdouble lastx, lasty; /* previous position of a motion event */
gboolean init_velocity;
gboolean init_velocity;
};
struct _GimpInkToolClass
struct _GimpInkClass
{
GimpToolClass parent_class;
GimpPaintCoreClass parent_class;
};
void gimp_ink_tool_register (GimpToolRegisterCallback callback,
gpointer data);
void gimp_ink_register (Gimp *gimp,
GimpPaintRegisterCallback callback);
GType gimp_ink_tool_get_type (void) G_GNUC_CONST;
GType gimp_ink_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_INK_TOOL_H__ */
#endif /* __GIMP_INK_H__ */
......@@ -18,23 +18,18 @@
#include "config.h"
#include <gtk/gtk.h>
#include <glib-object.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "tools-types.h"
#include "paint-types.h"
#include "config/gimpconfig-params.h"
#include "core/gimp.h"
#include "core/gimpdrawable.h"
#include "core/gimptoolinfo.h"
#include "widgets/gimppropwidgets.h"
#include "core/gimppaintinfo.h"
#include "gimpinkoptions.h"
#include "gimpinktool-blob.h"
#include "gimppaintoptions-gui.h"
#include "gimpink-blob.h"
#include "gimp-intl.h"
......@@ -65,9 +60,6 @@ static void gimp_ink_options_get_property (GObject *object,
GValue *value,
GParamSpec *pspec);
static GtkWidget * brush_widget_new (GimpInkOptions *options);
static GtkWidget * blob_button_new (GimpInkBlobType blob_type);
static GimpPaintOptionsClass *parent_class = NULL;
......@@ -103,9 +95,7 @@ gimp_ink_options_get_type (void)
static void
gimp_ink_options_class_init (GimpInkOptionsClass *klass)
{
GObjectClass *object_class;
object_class = G_OBJECT_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
......@@ -160,9 +150,7 @@ gimp_ink_options_set_property (GObject *object,
const GValue *value,
GParamSpec *pspec)
{
GimpInkOptions *options;
options = GIMP_INK_OPTIONS (object);
GimpInkOptions *options = GIMP_INK_OPTIONS (object);
switch (property_id)
{
......@@ -202,9 +190,7 @@ gimp_ink_options_get_property (GObject *object,
GValue *value,
GParamSpec *pspec)
{
GimpInkOptions *options;
options = GIMP_INK_OPTIONS (object);
GimpInkOptions *options = GIMP_INK_OPTIONS (object);
switch (property_id)
{
......@@ -237,472 +223,3 @@ gimp_ink_options_get_property (GObject *object,
break;
}
}
GtkWidget *
gimp_ink_options_gui (GimpToolOptions *tool_options)
{
GObject *config;
GtkWidget *table;
GtkWidget *vbox;
GtkWidget *brush_vbox;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *brush;
config = G_OBJECT (tool_options);
vbox = gimp_paint_options_gui (tool_options);
/* adjust sliders */
frame = gimp_frame_new (_("Adjustment"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
gtk_widget_show (frame);
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 2);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
/* size slider */
gimp_prop_scale_entry_new (config, "size",
GTK_TABLE (table), 0, 0,
_("Size:"),
1.0, 2.0, 1,
FALSE, 0.0, 0.0);
/* angle adjust slider */
gimp_prop_scale_entry_new (config, "tilt-angle",
GTK_TABLE (table), 0, 1,
_("Angle:"),
1.0, 10.0, 1,
FALSE, 0.0, 0.0);
/* sens sliders */
frame = gimp_frame_new (_("Sensitivity"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
gtk_widget_show (frame);
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 2);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
/* size sens slider */
gimp_prop_scale_entry_new (config, "size-sensitivity",
GTK_TABLE (table), 0, 0,
_("Size:"),
0.01, 0.1, 1,
FALSE, 0.0, 0.0);
/* tilt sens slider */
gimp_prop_scale_entry_new (config, "tilt-sensitivity",
GTK_TABLE (table), 0, 1,
_("Tilt:"),
0.01, 0.1, 1,
FALSE, 0.0, 0.0);
/* velocity sens slider */
gimp_prop_scale_entry_new (config, "vel-sensitivity",
GTK_TABLE (table), 0, 2,
_("Speed:"),
0.01, 0.1, 1,
FALSE, 0.0, 0.0);
/* bottom hbox */
hbox = gtk_hbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
/* Brush type radiobuttons */
frame = gimp_prop_enum_radio_frame_new (config, "blob-type",
_("Type"), 0, 0);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
{
GList *children;
GList *list;
GimpInkBlobType blob_type;
children =
gtk_container_get_children (GTK_CONTAINER (GTK_BIN (frame)->child));
for (list = children, blob_type = GIMP_INK_BLOB_TYPE_ELLIPSE;
list;
list = g_list_next (list), blob_type++)
{
GtkWidget *radio;
GtkWidget *blob;
radio = GTK_WIDGET (list->data);
gtk_container_remove (GTK_CONTAINER (radio), GTK_BIN (radio)->child);
blob = blob_button_new (blob_type);
gtk_container_add (GTK_CONTAINER (radio), blob);
gtk_widget_show (blob);
}
g_list_free (children);
}
/* Brush shape widget */
frame = gimp_frame_new (_("Shape"));
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
brush_vbox = gtk_vbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (brush_vbox), 2);
gtk_container_add (GTK_CONTAINER (frame), brush_vbox);
gtk_widget_show (brush_vbox);
frame = gtk_aspect_frame_new (NULL, 0.0, 0.5, 1.0, FALSE);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (brush_vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
brush = brush_widget_new (GIMP_INK_OPTIONS (tool_options));
gtk_container_add (GTK_CONTAINER (frame), brush);
gtk_widget_show (brush);
return vbox;
}
/* BrushWidget functions */
typedef struct _BrushWidget BrushWidget;
struct _BrushWidget
{
GtkWidget *widget;
gboolean active;
/* EEK */
GimpInkOptions *ink_options;
};
static void brush_widget_notify (GimpInkOptions *options,
GParamSpec *pspec,
BrushWidget *brush_widget);
static void brush_widget_active_rect (BrushWidget *brush_widget,
GtkWidget *widget,
GdkRectangle *rect);
static void brush_widget_realize (GtkWidget *widget);
static gboolean brush_widget_expose (GtkWidget *widget,
GdkEventExpose *event,
BrushWidget *brush_widget);
static gboolean brush_widget_button_press (GtkWidget *widget,
GdkEventButton *event,
BrushWidget *brush_widget);
static gboolean brush_widget_button_release (GtkWidget *widget,
GdkEventButton *event,
BrushWidget *brush_widget);
static gboolean brush_widget_motion_notify (GtkWidget *widget,
GdkEventMotion *event,
BrushWidget *brush_widget);
static void paint_blob (GdkDrawable *drawable,
GdkGC *gc,
Blob *blob);
static GtkWidget *
brush_widget_new (GimpInkOptions *options)
{
BrushWidget *brush_w;
brush_w = g_new (BrushWidget, 1);
brush_w->widget = gtk_drawing_area_new ();
brush_w->active = FALSE;
brush_w->ink_options = options;
gtk_widget_set_size_request (brush_w->widget, 60, 60);
gtk_widget_set_events (brush_w->widget,
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK |
GDK_EXPOSURE_MASK);
g_signal_connect (options, "notify",
G_CALLBACK (brush_widget_notify),
brush_w);
g_signal_connect (brush_w->widget, "button_press_event",
G_CALLBACK (brush_widget_button_press),
brush_w);
g_signal_connect (brush_w->widget, "button_release_event",
G_CALLBACK (brush_widget_button_release),
brush_w);
g_signal_connect (brush_w->widget, "motion_notify_event",
G_CALLBACK (brush_widget_motion_notify),
brush_w);
g_signal_connect (brush_w->widget, "expose_event",
G_CALLBACK (brush_widget_expose),
brush_w);
g_signal_connect (brush_w->widget, "realize",
G_CALLBACK (brush_widget_realize),
brush_w);
g_object_weak_ref (G_OBJECT (brush_w->widget),
(GWeakNotify) g_free, brush_w);
return brush_w->widget;
}
static void
brush_widget_notify (GimpInkOptions *options,
GParamSpec *pspec,
BrushWidget *brush_w)
{
switch (pspec->param_id)
{
case PROP_BLOB_TYPE:
case PROP_BLOB_ASPECT:
case PROP_BLOB_ANGLE:
gtk_widget_queue_draw (brush_w->widget);
break;
default:
break;
}
}
static void
brush_widget_active_rect (BrushWidget *brush_widget,
GtkWidget *widget,
GdkRectangle *rect)
{
gint x,y;
gint r;
r = MIN (widget->allocation.width, widget->allocation.height) / 2;
x = (widget->allocation.width / 2 +
0.85 * r * brush_widget->ink_options->blob_aspect / 10.0 *
cos (brush_widget->ink_options->blob_angle));
y = (widget->allocation.height / 2 +
0.85 * r * brush_widget->ink_options->blob_aspect / 10.0 *
sin (brush_widget->ink_options->blob_angle));
rect->x = x - 5;
rect->y = y - 5;
rect->width = 10;
rect->height = 10;
}
static void
brush_widget_realize (GtkWidget *widget)
{
gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
}
static void
brush_widget_draw_brush (BrushWidget *brush_widget,
GtkWidget *widget,
gdouble xc,
gdouble yc,
gdouble radius)
{
BlobFunc function = blob_ellipse;
Blob *blob;
switch (brush_widget->ink_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;
}
blob = (* function) (xc, yc,
radius * cos (brush_widget->ink_options->blob_angle),
radius * sin (brush_widget->ink_options->blob_angle),
(- (radius / brush_widget->ink_options->blob_aspect) *
sin (brush_widget->ink_options->blob_angle)),
((radius / brush_widget->ink_options->blob_aspect) *
cos (brush_widget->ink_options->blob_angle)));
paint_blob (widget->window, widget->style->fg_gc[widget->state], blob);
g_free (blob);
}
static gboolean
brush_widget_expose (GtkWidget *widget,
GdkEventExpose *event,
BrushWidget *brush_widget)
{
GdkRectangle rect;
gint r0;
r0 = MIN (widget->allocation.width, widget->allocation.height) / 2;
if (r0 < 2)
return TRUE;
brush_widget_draw_brush (brush_widget, widget,
widget->allocation.width / 2,
widget->allocation.height / 2,
0.9 * r0);
brush_widget_active_rect (brush_widget, widget, &rect);
gdk_draw_rectangle (widget->window, widget->style->bg_gc[GTK_STATE_NORMAL],
TRUE, /* filled */
rect.x, rect.y,
rect.width, rect.height);
gtk_paint_shadow (widget->style, widget->window, widget->state,
GTK_SHADOW_OUT,
NULL, widget, NULL,
rect.x, rect.y,
rect.width, rect.height);
return TRUE;
}
static gboolean
brush_widget_button_press (GtkWidget *widget,
GdkEventButton *event,
BrushWidget *brush_widget)
{
GdkRectangle rect;
brush_widget_active_rect (brush_widget, widget, &rect);
if ((event->x >= rect.x) && (event->x-rect.x < rect.width) &&
(event->y >= rect.y) && (event->y-rect.y < rect.height))
{
brush_widget->active = TRUE;
}
return TRUE;
}
static gboolean
brush_widget_button_release (GtkWidget *widget,
GdkEventButton *event,
BrushWidget *brush_widget)
{
brush_widget->active = FALSE;
return TRUE;
}
static gboolean
brush_widget_motion_notify (GtkWidget *widget,
GdkEventMotion *event,
BrushWidget *brush_widget)
{
if (brush_widget->active)
{
gint x;
gint y;
gint rsquare;
x = event->x - widget->allocation.width / 2;
y = event->y - widget->allocation.height / 2;
rsquare = x*x + y*y;
if (rsquare != 0)
{
gint r0;
gdouble angle;
gdouble aspect;
r0 = MIN (widget->allocation.width, widget->allocation.height) / 2;
angle = atan2 (y, x);
aspect = 10.0 * sqrt ((gdouble) rsquare / (r0 * r0)) / 0.85;
aspect = CLAMP (aspect, 1.0, 10.0);
g_object_set (brush_widget->ink_options,
"blob-angle", angle,
"blob-aspect", aspect,
NULL);
gtk_widget_queue_draw (widget);
}
}
return TRUE;
}
/* blob button functions */
static gboolean blob_button_expose (GtkWidget *widget,
GdkEventExpose *event,
BlobFunc function);
static GtkWidget *
blob_button_new (GimpInkBlobType blob_type)
{
GtkWidget *blob;
BlobFunc function = blob_ellipse;
switch (blob_type)
{
case GIMP_INK_BLOB_TYPE_ELLIPSE:
function = blob_ellipse;
break;