gimp/app/gimpcontext.c

/* The GIMP -- an image manipulation program
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
 * gimpcontext.c: Copyright (C) 1999 Michael Natterer <mitch@gimp.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
#include <gtk/gtk.h>

#include "appenv.h"
#include "gimpbrush.h"
#include "gimpbrushlist.h"
#include "gimpcontext.h"
#include "gimprc.h"
#include "gimpsignal.h"
#include "gradient_header.h"
#include "patterns.h"

#include "libgimp/gimpintl.h"

#define context_return_if_fail(context) \
        g_return_if_fail ((context) != NULL); \
        g_return_if_fail (GIMP_IS_CONTEXT (context))

#define context_return_val_if_fail(context,val) \
        g_return_val_if_fail ((context) != NULL, (val)); \
        g_return_val_if_fail (GIMP_IS_CONTEXT (context), (val))

#define context_check_current(context) \
        ((context) = (context) ? (context) : current_context)

#define context_find_defined(context,arg_mask) \
        while (!(((context)->defined_args) & arg_mask) && (context)->parent) \
          (context) = (context)->parent

typedef void (* GimpContextCopyArgFunc) (GimpContext *src, GimpContext *dest);

/*  local function prototypes  */

/*  image  */
static void gimp_context_real_set_image      (GimpContext      *context,
					      GimpImage        *image);
static void gimp_context_copy_image          (GimpContext      *src,
					      GimpContext      *dest);
static void gimp_context_image_changed       (GimpContext      *parent,
					      GimpImage        *image,
					      GimpContext      *child);

/*  display  */
static void gimp_context_real_set_display    (GimpContext      *context,
					      GDisplay         *display);
static void gimp_context_copy_display        (GimpContext      *src,
					      GimpContext      *dest);
static void gimp_context_display_changed     (GimpContext      *parent,
					      GDisplay         *display,
					      GimpContext      *child);

/*  tool  */
static void gimp_context_real_set_tool       (GimpContext      *context,
					      ToolType          tool);
static void gimp_context_copy_tool           (GimpContext      *src,
					      GimpContext      *dest);
static void gimp_context_tool_changed        (GimpContext      *parent,
					      ToolType          tool,
					      GimpContext      *child);

/*  foreground  */
static void gimp_context_real_set_foreground (GimpContext      *context,
					      gint              r,
					      gint              g,
					      gint              b);
static void gimp_context_copy_foreground     (GimpContext      *src,
					      GimpContext      *dest);
static void gimp_context_foreground_changed  (GimpContext      *parent,
					      gint              r,
					      gint              g,
					      gint              b,
					      GimpContext      *child);

/*  background  */
static void gimp_context_real_set_background (GimpContext      *context,
					      gint              r,
					      gint              g,
					      gint              b);
static void gimp_context_copy_background     (GimpContext      *src,
					      GimpContext      *dest);
static void gimp_context_background_changed  (GimpContext      *parent,
					      gint              r,
					      gint              g,
					      gint              b,
					      GimpContext      *child);

/*  opacity  */
static void gimp_context_real_set_opacity    (GimpContext      *context,
					      gdouble           opacity);
static void gimp_context_copy_opacity        (GimpContext      *src,
					      GimpContext      *dest);
static void gimp_context_opacity_changed     (GimpContext      *parent,
					      gdouble           opacity,
					      GimpContext      *child);

/*  paint mode  */
static void gimp_context_real_set_paint_mode (GimpContext      *context,
					      LayerModeEffects  paint_mode);
static void gimp_context_copy_paint_mode     (GimpContext      *src,
					      GimpContext      *dest);
static void gimp_context_paint_mode_changed  (GimpContext      *parent,
					      LayerModeEffects  paint_mode,
					      GimpContext      *child);

/*  brush  */
static void gimp_context_real_set_brush      (GimpContext      *context,
					      GimpBrush        *brush);
static void gimp_context_copy_brush          (GimpContext      *src,
					      GimpContext      *dest);
static void gimp_context_brush_changed       (GimpContext      *parent,
					      GimpBrush        *brush,
					      GimpContext      *child);

/*  pattern  */
static void gimp_context_real_set_pattern    (GimpContext      *context,
					      GPattern         *pattern);
static void gimp_context_copy_pattern        (GimpContext      *src,
					      GimpContext      *dest);
static void gimp_context_pattern_changed     (GimpContext      *parent,
					      GPattern         *pattern,
					      GimpContext      *child);

/*  gradient  */
static void gimp_context_real_set_gradient   (GimpContext      *context,
					      gradient_t       *gradient);
static void gimp_context_copy_gradient       (GimpContext      *src,
					      GimpContext      *dest);
static void gimp_context_gradient_changed    (GimpContext      *parent,
					      gradient_t       *gradient,
					      GimpContext      *child);

/*  arguments  */

enum
{
  ARG_0,
  ARG_IMAGE,
  ARG_DISPLAY,
  ARG_TOOL,
  ARG_FOREGROUND,
  ARG_BACKGROUND,
  ARG_OPACITY,
  ARG_PAINT_MODE,
  ARG_BRUSH,
  ARG_PATTERN,
  ARG_GRADIENT
};

static gchar *gimp_context_arg_names[] =
{
  "GimpContext::image",
  "GimpContext::display",
  "GimpContext::tool",
  "GimpContext::foreground",
  "GimpContext::background",
  "GimpContext::opacity",
  "GimpContext::paint_mode",
  "GimpContext::brush",
  "GimpContext::pattern",
  "GimpContext::gradient"
};

static GimpContextCopyArgFunc gimp_context_copy_arg_funcs[] =
{
  gimp_context_copy_image,
  gimp_context_copy_display,
  gimp_context_copy_tool,
  gimp_context_copy_foreground,
  gimp_context_copy_background,
  gimp_context_copy_opacity,
  gimp_context_copy_paint_mode,
  gimp_context_copy_brush,
  gimp_context_copy_pattern,
  gimp_context_copy_gradient
};

/*  signals  */

enum
{
  IMAGE_CHANGED,
  DISPLAY_CHANGED,
  TOOL_CHANGED,
  FOREGROUND_CHANGED,
  BACKGROUND_CHANGED,
  OPACITY_CHANGED,
  PAINT_MODE_CHANGED,
  BRUSH_CHANGED,
  PATTERN_CHANGED,
  GRADIENT_CHANGED,
  LAST_SIGNAL
};

static guint gimp_context_signals[LAST_SIGNAL] = { 0 };

static gchar *gimp_context_signal_names[] =
{
  "image_changed",
  "display_changed",
  "tool_changed",
  "foreground_changed",
  "background_changed",
  "opacity_changed",
  "paint_mode_changed",
  "brush_changed",
  "pattern_changed",
  "gradient_changed"
};

static GtkSignalFunc gimp_context_signal_handlers[] =
{
  gimp_context_image_changed,
  gimp_context_display_changed,
  gimp_context_tool_changed,
  gimp_context_foreground_changed,
  gimp_context_background_changed,
  gimp_context_opacity_changed,
  gimp_context_paint_mode_changed,
  gimp_context_brush_changed,
  gimp_context_pattern_changed,
  gimp_context_gradient_changed
};

static GimpObjectClass * parent_class = NULL;

/*  the currently active context  */
static GimpContext *current_context  = NULL;

/*  the context user by the interface  */
static GimpContext *user_context     = NULL;

/*  the default context which is initialized from gimprc  */
static GimpContext *default_context  = NULL;

/*  the hardcoded standard context  */
static GimpContext *standard_context = NULL;

/*  the list of all contexts  */
static GSList      *context_list     = NULL;

/*****************************************************************************/
/*  private functions  *******************************************************/

static void
gimp_context_set_arg (GtkObject *object,
		      GtkArg    *arg,
		      guint      arg_id)
{
  GimpContext *context;

  context = GIMP_CONTEXT (object);

  switch (arg_id)
    {
    case ARG_IMAGE:
      gimp_context_set_image (context, GTK_VALUE_POINTER (*arg));
      break;
    case ARG_DISPLAY:
      gimp_context_set_display (context, GTK_VALUE_POINTER (*arg));
      break;
    case ARG_TOOL:
      gimp_context_set_tool (context, GTK_VALUE_INT (*arg));
      break;
    case ARG_FOREGROUND:
      {
	guchar *col = GTK_VALUE_POINTER (*arg);
	gimp_context_set_foreground (context, col[0], col[1], col[2]);
      }
      break;
    case ARG_BACKGROUND:
      {
	guchar *col = GTK_VALUE_POINTER (*arg);
	gimp_context_set_background (context, col[0], col[1], col[2]);
      }
      break;
    case ARG_OPACITY:
      gimp_context_set_opacity (context, GTK_VALUE_DOUBLE (*arg));
      break;
    case ARG_PAINT_MODE:
      gimp_context_set_paint_mode (context, GTK_VALUE_INT (*arg));
      break;
    case ARG_BRUSH:
      gimp_context_set_brush (context, GTK_VALUE_POINTER (*arg));
      break;
    case ARG_PATTERN:
      gimp_context_set_pattern (context, GTK_VALUE_POINTER (*arg));
      break;
    case ARG_GRADIENT:
      gimp_context_set_gradient (context, GTK_VALUE_POINTER (*arg));
      break;
    default:
      break;
    }
}

static void
gimp_context_get_arg (GtkObject *object,
		      GtkArg    *arg,
		      guint      arg_id)
{
  GimpContext *context;

  context = GIMP_CONTEXT (object);

  switch (arg_id)
    {
    case ARG_IMAGE:
      GTK_VALUE_POINTER (*arg) = gimp_context_get_image (context);
      break;
    case ARG_DISPLAY:
      GTK_VALUE_POINTER (*arg) = gimp_context_get_display (context);
      break;
    case ARG_TOOL:
      GTK_VALUE_INT (*arg) = gimp_context_get_tool (context);
      break;
    case ARG_FOREGROUND:
      {
	guchar *col = GTK_VALUE_POINTER (*arg);
	gimp_context_get_foreground (context, &col[0], &col[1], &col[2]);
      }
      break;
    case ARG_BACKGROUND:
      {
	guchar *col = GTK_VALUE_POINTER (*arg);
	gimp_context_get_background (context, &col[0], &col[1], &col[2]);
      }
      break;
    case ARG_OPACITY:
      GTK_VALUE_DOUBLE (*arg) = gimp_context_get_opacity (context);
      break;
    case ARG_PAINT_MODE:
      GTK_VALUE_INT (*arg) = gimp_context_get_paint_mode (context);
      break;
    case ARG_BRUSH:
      GTK_VALUE_POINTER (*arg) = gimp_context_get_brush (context);
      break;
    case ARG_PATTERN:
      GTK_VALUE_POINTER (*arg) = gimp_context_get_pattern (context);
      break;
    case ARG_GRADIENT:
      GTK_VALUE_POINTER (*arg) = gimp_context_get_gradient (context);
      break;
    default:
      arg->type = GTK_TYPE_INVALID;
      break;
    }
}

static void
gimp_context_destroy (GtkObject *object)
{
  GimpContext *context;

  context = GIMP_CONTEXT (object);

  if (context->parent)
    gimp_context_unset_parent (context);

  if (context->name)
    {
      g_free (context->name);
      context->name = NULL;
    }

  if (context->image)
    gtk_signal_disconnect_by_data (GTK_OBJECT (image_context), context);

  if (context->display)
    gtk_signal_disconnect_by_data (GTK_OBJECT (context->display->shell),
				   context);

  if (context->brush)
    {
      gtk_signal_disconnect_by_data (GTK_OBJECT (context->brush), context);
      gtk_signal_disconnect_by_data (GTK_OBJECT (brush_list), context);
    }

  if (context->brush_name)
    {
      g_free (context->brush_name);
      context->brush_name = NULL;
    }

  if (context->pattern_name)
    {
      g_free (context->pattern_name);
      context->pattern_name = NULL;
    }

  if (context->gradient_name)
    {
      g_free (context->gradient_name);
      context->gradient_name = NULL;
    }

  if (GTK_OBJECT_CLASS (parent_class)->destroy)
    (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);

  context_list = g_slist_remove (context_list, context);
}

static void
gimp_context_class_init (GimpContextClass *klass)
{
  GtkObjectClass *object_class;

  object_class = GTK_OBJECT_CLASS (klass);

  gtk_object_add_arg_type (gimp_context_arg_names[IMAGE_CHANGED],
			   GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_IMAGE);
  gtk_object_add_arg_type (gimp_context_arg_names[DISPLAY_CHANGED],
			   GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_DISPLAY);
  gtk_object_add_arg_type (gimp_context_arg_names[TOOL_CHANGED],
			   GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_TOOL);
  gtk_object_add_arg_type (gimp_context_arg_names[FOREGROUND_CHANGED],
			   GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_FOREGROUND);
  gtk_object_add_arg_type (gimp_context_arg_names[BACKGROUND_CHANGED],
			   GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_BACKGROUND);
  gtk_object_add_arg_type (gimp_context_arg_names[OPACITY_CHANGED],
			   GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_OPACITY);
  gtk_object_add_arg_type (gimp_context_arg_names[PAINT_MODE_CHANGED],
			   GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_PAINT_MODE);
  gtk_object_add_arg_type (gimp_context_arg_names[BRUSH_CHANGED],
			   GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_BRUSH);
  gtk_object_add_arg_type (gimp_context_arg_names[PATTERN_CHANGED],
			   GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_PATTERN);
  gtk_object_add_arg_type (gimp_context_arg_names[GRADIENT_CHANGED],
			   GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_GRADIENT);

  parent_class = gtk_type_class (gimp_object_get_type ());

  gimp_context_signals[IMAGE_CHANGED] =
    gimp_signal_new (gimp_context_signal_names[IMAGE_CHANGED],
		     GTK_RUN_FIRST,
		     object_class->type,
		     GTK_SIGNAL_OFFSET (GimpContextClass,
					image_changed),
		     gimp_sigtype_pointer);

  gimp_context_signals[DISPLAY_CHANGED] =
    gimp_signal_new (gimp_context_signal_names[DISPLAY_CHANGED],
		     GTK_RUN_FIRST,
		     object_class->type,
		     GTK_SIGNAL_OFFSET (GimpContextClass,
					display_changed),
		     gimp_sigtype_pointer);

  gimp_context_signals[TOOL_CHANGED] =
    gimp_signal_new (gimp_context_signal_names[TOOL_CHANGED],
		     GTK_RUN_FIRST,
		     object_class->type,
		     GTK_SIGNAL_OFFSET (GimpContextClass,
					tool_changed),
		     gimp_sigtype_int);

  gimp_context_signals[FOREGROUND_CHANGED] =
    gimp_signal_new (gimp_context_signal_names[FOREGROUND_CHANGED],
		     GTK_RUN_FIRST,
		     object_class->type,
		     GTK_SIGNAL_OFFSET (GimpContextClass,
					foreground_changed),
		     gimp_sigtype_int_int_int);

  gimp_context_signals[BACKGROUND_CHANGED] =
    gimp_signal_new (gimp_context_signal_names[BACKGROUND_CHANGED],
		     GTK_RUN_FIRST,
		     object_class->type,
		     GTK_SIGNAL_OFFSET (GimpContextClass,
					background_changed),
		     gimp_sigtype_int_int_int);

  gimp_context_signals[OPACITY_CHANGED] =
    gimp_signal_new (gimp_context_signal_names[OPACITY_CHANGED],
		     GTK_RUN_FIRST,
		     object_class->type,
		     GTK_SIGNAL_OFFSET (GimpContextClass,
					opacity_changed),
		     gimp_sigtype_double);

  gimp_context_signals[PAINT_MODE_CHANGED] =
    gimp_signal_new (gimp_context_signal_names[PAINT_MODE_CHANGED],
		     GTK_RUN_FIRST,
		     object_class->type,
		     GTK_SIGNAL_OFFSET (GimpContextClass,
					paint_mode_changed),
		     gimp_sigtype_int);

  gimp_context_signals[BRUSH_CHANGED] =
    gimp_signal_new (gimp_context_signal_names[BRUSH_CHANGED],
		     GTK_RUN_FIRST,
		     object_class->type,
		     GTK_SIGNAL_OFFSET (GimpContextClass,
					brush_changed),
		     gimp_sigtype_pointer);

  gimp_context_signals[PATTERN_CHANGED] =
    gimp_signal_new (gimp_context_signal_names[PATTERN_CHANGED],
		     GTK_RUN_FIRST,
		     object_class->type,
		     GTK_SIGNAL_OFFSET (GimpContextClass,
					pattern_changed),
		     gimp_sigtype_pointer);

  gimp_context_signals[GRADIENT_CHANGED] =
    gimp_signal_new (gimp_context_signal_names[GRADIENT_CHANGED],
		     GTK_RUN_FIRST,
		     object_class->type,
		     GTK_SIGNAL_OFFSET (GimpContextClass,
					gradient_changed),
		     gimp_sigtype_pointer);

  gtk_object_class_add_signals (object_class, gimp_context_signals,
				LAST_SIGNAL);

  object_class->set_arg = gimp_context_set_arg;
  object_class->get_arg = gimp_context_get_arg;
  object_class->destroy = gimp_context_destroy;

  klass->image_changed      = NULL;
  klass->display_changed    = NULL;
  klass->tool_changed       = NULL;
  klass->foreground_changed = NULL;
  klass->background_changed = NULL;
  klass->opacity_changed    = NULL;
  klass->paint_mode_changed = NULL;
  klass->brush_changed      = NULL;
  klass->pattern_changed    = NULL;
  klass->gradient_changed   = NULL;
}

static void
gimp_context_init (GimpContext *context)
{
  context->name   = NULL;
  context->parent = NULL;

  context->defined_args = GIMP_CONTEXT_ALL_ARGS_MASK;

  context->image   = NULL;
  context->display = NULL;

  context->tool = RECT_SELECT;

  context->foreground[0] = 0;
  context->foreground[1] = 0;
  context->foreground[2] = 0;

  context->background[0] = 255;
  context->background[1] = 255;
  context->background[2] = 255;

  context->opacity    = 1.0;
  context->paint_mode = NORMAL_MODE;

  context->brush      = NULL;
  context->brush_name = NULL;

  context->pattern      = NULL;
  context->pattern_name = NULL;

  context->gradient      = NULL;
  context->gradient_name = NULL;

  context_list = g_slist_prepend (context_list, context);
}

/*****************************************************************************/
/*  public functions  ********************************************************/

GtkType
gimp_context_get_type (void)
{
  static GtkType context_type = 0;

  if (! context_type)
    {
      GtkTypeInfo context_info =
      {
	"GimpContext",
	sizeof (GimpContext),
	sizeof (GimpContextClass),
	(GtkClassInitFunc) gimp_context_class_init,
	(GtkObjectInitFunc) gimp_context_init,
	/* reserved_1 */ NULL,
	/* reserved_2 */ NULL,
	(GtkClassInitFunc) NULL
      };

      context_type = gtk_type_unique (gimp_object_get_type (), &context_info);
    }

  return context_type;
}

GimpContext *
gimp_context_new (gchar       *name,
		  GimpContext *template)
{
  GimpContext *context;

  g_return_val_if_fail (!template || GIMP_IS_CONTEXT (template), NULL);

  context = gtk_type_new (gimp_context_get_type ());

  /*  FIXME: need unique names here  */
  context->name = g_strdup (name ? name : "Unnamed");

  if (template)
    {
      context->defined_args = template->defined_args;

      gimp_context_copy_args (template, context, GIMP_CONTEXT_ALL_ARGS_MASK);
    }

  return context;
}

/*****************************************************************************/
/*  getting/setting the special contexts  ************************************/

GimpContext *
gimp_context_get_current (void)
{
  return current_context;
}

void
gimp_context_set_current (GimpContext *context)
{
  current_context = context;
}

GimpContext *
gimp_context_get_user (void)
{
  return user_context;
}

void
gimp_context_set_user (GimpContext *context)
{
  user_context = context;
}

GimpContext *
gimp_context_get_default (void)
{
  return default_context;
}

void
gimp_context_set_default (GimpContext *context)
{
  default_context = context;
}

GimpContext *
gimp_context_get_standard (void)
{
  if (! standard_context)
    {
      standard_context = gimp_context_new ("Standard", NULL);

      gtk_quit_add_destroy (TRUE, GTK_OBJECT (standard_context));
    }

  return standard_context;
}

/*****************************************************************************/
/*  functions manipulating a single context  *********************************/

gchar *
gimp_context_get_name (GimpContext *context)
{
  context_check_current (context);
  context_return_val_if_fail (context, NULL);

  return context->name;
}

void
gimp_context_set_name (GimpContext *context,
		       gchar       *name)
{
  context_check_current (context);
  context_return_if_fail (context);

  if (context->name)
    g_free (context->name);

  context->name = g_strdup (name ? name : "Unnamed");
}

GimpContext *
gimp_context_get_parent (GimpContext *context)
{
  context_check_current (context);
  context_return_val_if_fail (context, NULL);

  return context->parent;
}

void
gimp_context_set_parent (GimpContext *context,
			 GimpContext *parent)
{
  GimpContextArgType arg;

  context_check_current (context);
  context_return_if_fail (context);
  g_return_if_fail (!parent || GIMP_IS_CONTEXT (parent));

  if (context == parent)
    return;

  for (arg = 0; arg < GIMP_CONTEXT_NUM_ARGS; arg++)
    if (! ((1 << arg) & context->defined_args))
      {
	gimp_context_copy_arg (parent, context, arg);
	gtk_signal_connect (GTK_OBJECT (parent),
			    gimp_context_signal_names[arg],
			    gimp_context_signal_handlers[arg],
			    context);
      }

  context->parent = parent;
}

void
gimp_context_unset_parent (GimpContext *context)
{
  context_check_current (context);
  context_return_if_fail (context);

  if (context->parent)
    {
      if (context->defined_args != GIMP_CONTEXT_ALL_ARGS_MASK)
	gtk_signal_disconnect_by_data (GTK_OBJECT (context->parent), context);

      context->parent = NULL;
    }
}

/*  define / undefinine context arguments  */

void
gimp_context_define_arg (GimpContext        *context,
			 GimpContextArgType  arg,
			 gboolean            defined)
{
  GimpContextArgMask mask;

  context_check_current (context);
  context_return_if_fail (context);
  g_return_if_fail ((arg >= 0) && (arg < GIMP_CONTEXT_NUM_ARGS));

  mask = (1 << arg);

  if (defined)
    {
      if (! (context->defined_args & mask))
	{
	  context->defined_args |= mask;
	  if (context->parent)
	    gtk_signal_disconnect_by_func (GTK_OBJECT (context->parent),
					   gimp_context_signal_handlers[arg],
					   context);
	}
    }
  else
    {
      if (context->defined_args & mask)
	{
	  context->defined_args &= ~mask;
	  if (context->parent)
	    {
	      gimp_context_copy_arg (context->parent, context, arg);
	      gtk_signal_connect (GTK_OBJECT (context->parent),
				  gimp_context_signal_names[arg],
				  gimp_context_signal_handlers[arg],
				  context);
	    }
	}
    }
}

gboolean
gimp_context_arg_defined (GimpContext        *context,
			  GimpContextArgType  arg)
{
  context_check_current (context);
  context_return_val_if_fail (context, FALSE);

  return (context->defined_args & (1 << arg)) ? TRUE : FALSE;
}

void
gimp_context_define_args (GimpContext *context,
			  guint32      args_mask,
			  gboolean     defined)
{
  GimpContextArgType arg;

  context_check_current (context);
  context_return_if_fail (context);

  for (arg = 0; arg < GIMP_CONTEXT_NUM_ARGS; arg++)
    if ((1 << arg) & args_mask)
      gimp_context_define_arg (context, arg, defined);
}

/*  copying context arguments  */

void
gimp_context_copy_arg (GimpContext        *src,
		       GimpContext        *dest,
		       GimpContextArgType  arg)
{
  context_check_current (src);
  context_return_if_fail (src);
  context_check_current (dest);
  context_return_if_fail (dest);
  g_return_if_fail ((arg >= 0) && (arg < GIMP_CONTEXT_NUM_ARGS));

  (* gimp_context_copy_arg_funcs[arg]) (src, dest);
}

void
gimp_context_copy_args (GimpContext        *src,
			GimpContext        *dest,
			GimpContextArgMask  args_mask)
{
  GimpContextArgType arg;

  context_check_current (src);
  context_return_if_fail (src);
  context_check_current (dest);
  context_return_if_fail (dest);

  for (arg = 0; arg < GIMP_CONTEXT_NUM_ARGS; arg++)
    if ((1 << arg) & args_mask)
      {
	gimp_context_copy_arg (src, dest, arg);
      }
}

/*  attribute access functions  */

/*****************************************************************************/
/*  image  *******************************************************************/

GimpImage *
gimp_context_get_image (GimpContext *context)
{
  context_check_current (context);
  context_return_val_if_fail (context, NULL);

  return context->image;
}

void
gimp_context_set_image (GimpContext *context,
			GimpImage   *image)
{
  context_check_current (context);
  context_return_if_fail (context);
  context_find_defined (context, GIMP_CONTEXT_IMAGE_MASK);

  gimp_context_real_set_image (context, image);
}

/*  handle disappearing images  */
static void
gimp_context_image_removed (GimpSet     *set,
			    GimpImage   *image,
			    GimpContext *context)
{
  if (context->image == image)
    gimp_context_real_set_image (context, NULL);
}

static void
gimp_context_real_set_image (GimpContext *context,
			     GimpImage   *image)
{
  if (context->image == image)
    return;

  if (image == NULL)
    gtk_signal_disconnect_by_data (GTK_OBJECT (image_context), context);

  if (context->image == NULL)
    gtk_signal_connect (GTK_OBJECT (image_context), "remove",
			GTK_SIGNAL_FUNC (gimp_context_image_removed),
			context);

  context->image = image;
  gtk_signal_emit (GTK_OBJECT (context),
		   gimp_context_signals[IMAGE_CHANGED],
		   image);
}

static void
gimp_context_copy_image (GimpContext *src,
			 GimpContext *dest)
{
  gimp_context_real_set_image (dest, src->image);
}

static void
gimp_context_image_changed (GimpContext *parent,
			    GimpImage   *image,
			    GimpContext *child)
{
  gimp_context_real_set_image (child, image);
}

/*****************************************************************************/
/*  display  *****************************************************************/

GDisplay *
gimp_context_get_display (GimpContext *context)
{
  context_check_current (context);
  context_return_val_if_fail (context, NULL);

  return context->display;
}

void
gimp_context_set_display (GimpContext *context,
			  GDisplay    *display)
{
  context_check_current (context);
  context_return_if_fail (context);
  context_find_defined (context, GIMP_CONTEXT_DISPLAY_MASK);

  gimp_context_real_set_display (context, display);
}

/*  handle dissapearing displays  */
static void
gimp_context_display_destroy (GtkWidget   *disp_shell,
			      GimpContext *context)
{
  context->display = NULL;
  gtk_signal_emit (GTK_OBJECT (context),
		   gimp_context_signals[DISPLAY_CHANGED],
		   NULL);
}

static void
gimp_context_real_set_display (GimpContext *context,
			       GDisplay    *display)
{
  if (context->display == display)
    return;

  if (context->display && GTK_IS_OBJECT (context->display->shell))
    gtk_signal_disconnect_by_data (GTK_OBJECT (context->display->shell),
				   context);

  if (display)
    gtk_signal_connect (GTK_OBJECT (display->shell), "destroy",
			GTK_SIGNAL_FUNC (gimp_context_display_destroy),
			context);

  context->display = display;

  /*  set the image _before_ emitting the display_changed signal  */
  if (display)
    gimp_context_real_set_image (context, display->gimage);

  gtk_signal_emit (GTK_OBJECT (context),
		   gimp_context_signals[DISPLAY_CHANGED],
		   display);
}

static void
gimp_context_copy_display (GimpContext *src,
			   GimpContext *dest)
{
  gimp_context_real_set_display (dest, src->display);
}

static void
gimp_context_display_changed (GimpContext *parent,
			      GDisplay    *display,
			      GimpContext *child)
{
  gimp_context_real_set_display (child, display);
}

/*****************************************************************************/
/*  tool  ********************************************************************/

ToolType
gimp_context_get_tool (GimpContext *context)
{
  context_check_current (context);
  context_return_val_if_fail (context, 0);

  return context->tool;
}

void
gimp_context_set_tool (GimpContext *context,
		       ToolType     tool)
{
  context_check_current (context);
  context_return_if_fail (context);
  context_find_defined (context, GIMP_CONTEXT_TOOL_MASK);

  gimp_context_real_set_tool (context, tool);
}

static void
gimp_context_real_set_tool (GimpContext *context,
			    ToolType     tool)
{
  if (context->tool == tool)
    return;

  context->tool = tool;
  gtk_signal_emit (GTK_OBJECT (context),
		   gimp_context_signals[TOOL_CHANGED],
		   tool);
}

static void
gimp_context_copy_tool (GimpContext *src,
			GimpContext *dest)
{
  gimp_context_real_set_tool (dest, src->tool);
}

static void
gimp_context_tool_changed (GimpContext *parent,
			   ToolType     tool,
			   GimpContext *child)
{
  gimp_context_real_set_tool (child, tool);
}

/*****************************************************************************/
/*  foreground color  ********************************************************/

void
gimp_context_get_foreground (GimpContext *context,
			     guchar      *r,
			     guchar      *g,
			     guchar      *b)
{
  context_check_current (context);
  context_return_if_fail (context);

  *r = context->foreground[0];
  *g = context->foreground[1];
  *b = context->foreground[2];
}

void
gimp_context_set_foreground (GimpContext *context,
			     gint         r,
			     gint         g,
			     gint         b)
{
  context_check_current (context);
  context_return_if_fail (context);
  context_find_defined (context, GIMP_CONTEXT_FOREGROUND_MASK);

  gimp_context_real_set_foreground (context, r, g, b);
}

static void
gimp_context_real_set_foreground (GimpContext *context,
				  gint         r,
				  gint         g,
				  gint         b)
{
  if (context->foreground[0] == r &&
      context->foreground[1] == g &&
      context->foreground[2] == b)
    return;

  context->foreground[0] = r;
  context->foreground[1] = g;
  context->foreground[2] = b;

  gtk_signal_emit (GTK_OBJECT (context),
		   gimp_context_signals[FOREGROUND_CHANGED],
		   r, g, b);
}

static void
gimp_context_copy_foreground (GimpContext *src,
			      GimpContext *dest)
{
  gimp_context_real_set_foreground (dest,
				    src->foreground[0],
				    src->foreground[1],
				    src->foreground[2]);
}

static void
gimp_context_foreground_changed (GimpContext *parent,
				 gint         r,
				 gint         g,
				 gint         b,
				 GimpContext *child)
{
  gimp_context_real_set_foreground (child, r, g, b);
}

/*****************************************************************************/
/*  background color  ********************************************************/

void
gimp_context_get_background (GimpContext *context,
			     guchar      *r,
			     guchar      *g,
			     guchar      *b)
{
  context_check_current (context);
  context_return_if_fail (context);

  *r = context->background[0];
  *g = context->background[1];
  *b = context->background[2];
}

void
gimp_context_set_background (GimpContext *context,
			     gint         r,
			     gint         g,
			     gint         b)
{
  context_check_current (context);
  context_return_if_fail (context);
  context_find_defined (context, GIMP_CONTEXT_BACKGROUND_MASK);

  gimp_context_real_set_background (context, r, g, b);
}

static void
gimp_context_real_set_background (GimpContext *context,
				  gint         r,
				  gint         g,
				  gint         b)
{
  if (context->background[0] == r &&
      context->background[1] == g &&
      context->background[2] == b)
    return;

  context->background[0] = r;
  context->background[1] = g;
  context->background[2] = b;

  gtk_signal_emit (GTK_OBJECT (context),
		   gimp_context_signals[BACKGROUND_CHANGED],
		   r, g, b);
}

static void
gimp_context_copy_background (GimpContext *src,
			      GimpContext *dest)
{
  gimp_context_real_set_foreground (dest,
				    src->background[0],
				    src->background[1],
				    src->background[2]);
}

static void
gimp_context_background_changed (GimpContext *parent,
				 gint         r,
				 gint         g,
				 gint         b,
				 GimpContext *child)
{
  gimp_context_real_set_background (child, r, g, b);
}

/*****************************************************************************/
/*  color utility functions  *************************************************/

void
gimp_context_set_default_colors (GimpContext *context)
{
  GimpContext *bg_context;

  bg_context = context;

  context_check_current (context);
  context_return_if_fail (context);
  context_find_defined (context, GIMP_CONTEXT_FOREGROUND_MASK);
  context_find_defined (bg_context, GIMP_CONTEXT_BACKGROUND_MASK);

  gimp_context_real_set_foreground (context, 0, 0, 0);
  gimp_context_real_set_background (bg_context, 255, 255, 255);
}

void
gimp_context_swap_colors (GimpContext *context)
{
  GimpContext *bg_context;
  guchar f_r, f_g, f_b;
  guchar b_r, b_g, b_b;

  bg_context = context;

  context_check_current (context);
  context_return_if_fail (context);
  context_find_defined (context, GIMP_CONTEXT_FOREGROUND_MASK);
  context_find_defined (bg_context, GIMP_CONTEXT_BACKGROUND_MASK);

  gimp_context_get_foreground (context, &f_r, &f_g, &f_b);
  gimp_context_get_background (bg_context, &b_r, &b_g, &b_b);

  gimp_context_real_set_foreground (context, b_r, b_g, b_b);
  gimp_context_real_set_background (bg_context, f_r, f_g, f_b);
}

/*****************************************************************************/
/*  opacity  *****************************************************************/

gdouble
gimp_context_get_opacity (GimpContext *context)
{
  context_check_current (context);
  context_return_val_if_fail (context, 1.0);

  return context->opacity;
}

void
gimp_context_set_opacity (GimpContext *context,
			  gdouble      opacity)
{
  context_check_current (context);
  context_return_if_fail (context);
  context_find_defined (context, GIMP_CONTEXT_OPACITY_MASK);

  gimp_context_real_set_opacity (context, opacity);
}

static void
gimp_context_real_set_opacity (GimpContext *context,
			       gdouble      opacity)
{
  if (context->opacity == opacity)
    return;

  context->opacity = opacity;
  gtk_signal_emit (GTK_OBJECT (context),
		   gimp_context_signals[OPACITY_CHANGED],
		   opacity);
}

static void
gimp_context_copy_opacity (GimpContext *src,
			   GimpContext *dest)
{
  gimp_context_real_set_opacity (dest, src->opacity);
}

static void
gimp_context_opacity_changed (GimpContext *parent,
			      gdouble      opacity,
			      GimpContext *child)
{
  gimp_context_real_set_opacity (child, opacity);
}

/*****************************************************************************/
/*  paint mode  **************************************************************/

LayerModeEffects
gimp_context_get_paint_mode (GimpContext *context)
{
  context_check_current (context);
  context_return_val_if_fail (context, 0);

  return context->paint_mode;
}

void
gimp_context_set_paint_mode (GimpContext     *context,
			     LayerModeEffects paint_mode)
{
  context_check_current (context);
  context_return_if_fail (context);
  context_find_defined (context, GIMP_CONTEXT_PAINT_MODE_MASK);

  gimp_context_real_set_paint_mode (context, paint_mode);
}

static void
gimp_context_real_set_paint_mode (GimpContext     *context,
				  LayerModeEffects paint_mode)
{
  if (context->paint_mode == paint_mode)
    return;

  context->paint_mode = paint_mode;
  gtk_signal_emit (GTK_OBJECT (context),
		   gimp_context_signals[PAINT_MODE_CHANGED],
		   paint_mode);
}

static void
gimp_context_copy_paint_mode (GimpContext *src,
			      GimpContext *dest)
{
  gimp_context_real_set_paint_mode (dest, src->paint_mode);
}

static void
gimp_context_paint_mode_changed (GimpContext      *parent,
				 LayerModeEffects  paint_mode,
				 GimpContext      *child)
{
  gimp_context_real_set_paint_mode (child, paint_mode);
}

/*****************************************************************************/
/*  brush  *******************************************************************/

static GimpBrush *standard_brush = NULL;

GimpBrush *
gimp_context_get_brush (GimpContext *context)
{
  context_check_current (context);
  context_return_val_if_fail (context, NULL);

  return context->brush;
}

void
gimp_context_set_brush (GimpContext *context,
			GimpBrush   *brush)
{
  context_check_current (context);
  context_return_if_fail (context);
  context_find_defined (context, GIMP_CONTEXT_BRUSH_MASK);

  gimp_context_real_set_brush (context, brush);
}

/*  the active brush was modified  */
static void
gimp_context_brush_dirty (GimpBrush   *brush,
			  GimpContext *context)
{
  g_free (context->brush_name);
  context->brush_name = g_strdup (brush->name);

  gtk_signal_emit (GTK_OBJECT (context),
		   gimp_context_signals[BRUSH_CHANGED],
		   brush);
}

/*  the active brush disappeared  */
static void
gimp_context_brush_removed (GimpBrushList *brush_list,
			    GimpBrush     *brush,
			    GimpContext   *context)
{
  if (brush == context->brush)
    {
      context->brush = NULL;

      gtk_signal_disconnect_by_data (GTK_OBJECT (brush), context);
      gtk_signal_disconnect_by_data (GTK_OBJECT (brush_list), context);
      gtk_object_unref (GTK_OBJECT (brush));
    }
}

static void
gimp_context_real_set_brush (GimpContext *context,
			     GimpBrush   *brush)
{
  if (! standard_brush)
    standard_brush = brushes_get_standard_brush ();

  if (context->brush == brush)
    return;

  if (context->brush_name && brush != standard_brush)
    {
      g_free (context->brush_name);
      context->brush_name = NULL;
    }

  /*  make sure the active brush is swapped before we get a new one...  */
  if (stingy_memory_use &&
      context->brush && context->brush->mask &&
      GTK_OBJECT (context->brush)->ref_count == 2)
    {
      temp_buf_swap (brush->mask);
    }

  /*  disconnect from the old brush's signals  */
  if (context->brush)
    {
      gtk_signal_disconnect_by_data (GTK_OBJECT (context->brush), context);
      gtk_object_unref (GTK_OBJECT (context->brush));

      /*  if we don't get a new brush, also disconnect from the brush list  */
      if (! brush)
	{
	  gtk_signal_disconnect_by_data (GTK_OBJECT (brush_list), context);
	}
    }
  /*  if we get a new brush but didn't have one before...  */
  else if (brush)
    {
      /*  ...connect to the brush list  */
      gtk_signal_connect (GTK_OBJECT (brush_list), "remove",
			  GTK_SIGNAL_FUNC (gimp_context_brush_removed),
			  context);
    }

  context->brush = brush;

  if (brush)
    {
      gtk_object_ref (GTK_OBJECT (brush));
      gtk_signal_connect (GTK_OBJECT (brush), "dirty",
			  GTK_SIGNAL_FUNC (gimp_context_brush_dirty),
			  context);
      gtk_signal_connect (GTK_OBJECT (brush), "rename",
			  GTK_SIGNAL_FUNC (gimp_context_brush_dirty),
			  context);

      /*  Make sure the active brush is unswapped... */
      if (stingy_memory_use &&
	  brush->mask &&
	  GTK_OBJECT (brush)->ref_count < 2)
	{
	  temp_buf_unswap (brush->mask);
	}

      if (brush != standard_brush)
	context->brush_name = g_strdup (brush->name);
    }

  gtk_signal_emit (GTK_OBJECT (context),
		   gimp_context_signals[BRUSH_CHANGED],
		   brush);
}

static void
gimp_context_copy_brush (GimpContext *src,
			 GimpContext *dest)
{
  gimp_context_real_set_brush (dest, src->brush);

  if ((!src->brush || src->brush == standard_brush) && src->brush_name)
    {
      g_free (dest->brush_name);
      dest->brush_name = g_strdup (src->brush_name);
    }
}

static void
gimp_context_brush_changed (GimpContext *parent,
			    GimpBrush   *brush,
			    GimpContext *child)
{
  gimp_context_real_set_brush (child, brush);
}

static void
gimp_context_refresh_brush (GimpContext *context,
			    gpointer     data)
{
  GimpBrush *brush;

  if (! context->brush_name)
    context->brush_name = g_strdup (default_brush);

  if ((brush = gimp_brush_list_get_brush (brush_list, context->brush_name)))
    {
      gimp_context_real_set_brush (context, brush);
      return;
    }

  if (gimp_brush_list_length (brush_list))
    gimp_context_real_set_brush 
      (context, gimp_brush_list_get_brush_by_index (brush_list, 0));
  else
    gimp_context_real_set_brush (context, brushes_get_standard_brush ());
}

void
gimp_context_refresh_brushes (void)
{
  g_slist_foreach (context_list, (GFunc) gimp_context_refresh_brush, NULL);
}

/*****************************************************************************/
/*  pattern  *****************************************************************/

static GPattern *standard_pattern = NULL;

GPattern *
gimp_context_get_pattern (GimpContext *context)
{
  context_check_current (context);
  context_return_val_if_fail (context, NULL);

  return context->pattern;
}

void
gimp_context_set_pattern (GimpContext *context,
			  GPattern    *pattern)
{
  context_check_current (context);
  context_return_if_fail (context);
  context_find_defined (context, GIMP_CONTEXT_PATTERN_MASK);

  gimp_context_real_set_pattern (context, pattern);
}

static void
gimp_context_real_set_pattern (GimpContext *context,
			       GPattern    *pattern)
{
  if (! standard_pattern)
    standard_pattern = patterns_get_standard_pattern ();

  if (context->pattern == pattern)
    return;

  if (context->pattern_name && pattern != standard_pattern)
    {
      g_free (context->pattern_name);
      context->pattern_name = NULL;
    }

  context->pattern = pattern;

  if (pattern && pattern != standard_pattern)
    context->pattern_name = g_strdup (pattern->name);

  gtk_signal_emit (GTK_OBJECT (context),
		   gimp_context_signals[PATTERN_CHANGED],
		   pattern);
}

static void
gimp_context_copy_pattern (GimpContext *src,
			   GimpContext *dest)
{
  gimp_context_real_set_pattern (dest, src->pattern);

  if ((!src->pattern || src->pattern == standard_pattern) && src->pattern_name)
    {
      g_free (dest->pattern_name);
      dest->pattern_name = g_strdup (src->pattern_name);
    }
}

static void
gimp_context_pattern_changed (GimpContext *parent,
			      GPattern    *pattern,
			      GimpContext *child)
{
  gimp_context_real_set_pattern (child, pattern);
}

static void
gimp_context_refresh_pattern (GimpContext *context,
			      gpointer     data)
{
  GPattern *pattern;

  if (! context->pattern_name)
    context->pattern_name = g_strdup (default_pattern);

  if ((pattern = pattern_list_get_pattern (pattern_list,
					   context->pattern_name)))
    {
      gimp_context_real_set_pattern (context, pattern);
      return;
    }

  if ((pattern = pattern_list_get_pattern_by_index (pattern_list, 0)))
    gimp_context_real_set_pattern (context, pattern);
  else
    gimp_context_real_set_pattern (context, patterns_get_standard_pattern ());
}

void
gimp_context_refresh_patterns (void)
{
  g_slist_foreach (context_list, (GFunc) gimp_context_refresh_pattern, NULL);
}

static void
gimp_context_update_pattern (GimpContext *context,
			     GPattern    *pattern)
{
  if (context->pattern == pattern)
    {
      if (context->pattern_name)
	g_free (context->pattern_name);

      context->pattern_name = g_strdup (pattern->name);

      gtk_signal_emit (GTK_OBJECT (context),
		       gimp_context_signals[PATTERN_CHANGED],
		       pattern);
    }
}

void
gimp_context_update_patterns (GPattern *pattern)
{
  g_slist_foreach (context_list, (GFunc) gimp_context_update_pattern, pattern);
}

/*****************************************************************************/
/*  gradient  ****************************************************************/

static gradient_t *standard_gradient = NULL;

gradient_t *
gimp_context_get_gradient (GimpContext *context)
{
  context_check_current (context);
  context_return_val_if_fail (context, NULL);

  return context->gradient;
}

void
gimp_context_set_gradient (GimpContext *context,
			   gradient_t  *gradient)
{
  context_check_current (context);
  context_return_if_fail (context);
  context_find_defined (context, GIMP_CONTEXT_GRADIENT_MASK);

  gimp_context_real_set_gradient (context, gradient);
}

static void
gimp_context_real_set_gradient (GimpContext *context,
				gradient_t  *gradient)
{
  if (! standard_gradient)
    standard_gradient = gradients_get_standard_gradient ();

  if (context->gradient == gradient)
    return;

  if (context->gradient_name && gradient != standard_gradient)
    {
      g_free (context->gradient_name);
      context->gradient_name = NULL;
    }

  context->gradient = gradient;

  if (gradient && gradient != standard_gradient)
    context->gradient_name = g_strdup (gradient->name);

  gtk_signal_emit (GTK_OBJECT (context),
		   gimp_context_signals[GRADIENT_CHANGED],
		   gradient);
}

static void
gimp_context_copy_gradient (GimpContext *src,
			    GimpContext *dest)
{
  gimp_context_real_set_gradient (dest, src->gradient);

  if ((!src->gradient || src->gradient == standard_gradient) &&
      src->gradient_name)
    {
      g_free (dest->gradient_name);
      dest->gradient_name = g_strdup (src->gradient_name);
    }
}

static void
gimp_context_gradient_changed (GimpContext *parent,
			       gradient_t  *gradient,
			       GimpContext *child)
{
  gimp_context_real_set_gradient (child, gradient);
}

static void
gimp_context_refresh_gradient (GimpContext *context,
			       gpointer     data)
{
  gradient_t *gradient;

  if (! context->gradient_name)
    context->gradient_name = g_strdup (default_gradient);

  if ((gradient = gradient_list_get_gradient (gradients_list,
					      context->gradient_name)))
    {
      gimp_context_real_set_gradient (context, gradient);
      return;
    }

  if (gradients_list)
    gimp_context_real_set_gradient (context,
				    (gradient_t *) gradients_list->data);
  else
    gimp_context_real_set_gradient (context, gradients_get_standard_gradient ());
}

void
gimp_context_refresh_gradients (void)
{
  g_slist_foreach (context_list, (GFunc) gimp_context_refresh_gradient, NULL);
}

static void
gimp_context_update_gradient (GimpContext *context,
			      gradient_t  *gradient)
{
  if (context->gradient == gradient)
    {
      if (context->gradient_name)
	g_free (context->gradient_name);

      context->gradient_name = g_strdup (gradient->name);

      gtk_signal_emit (GTK_OBJECT (context),
		       gimp_context_signals[GRADIENT_CHANGED],
		       gradient);
    }
}

void
gimp_context_update_gradients (gradient_t *gradient)
{
  g_slist_foreach (context_list, (GFunc) gimp_context_update_gradient, gradient);
}