home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / app / channels_dialog.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-12-20  |  79.6 KB  |  2,770 lines
  1. /* The GIMP -- an image manipulation program
  2.  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License as published by
  6.  * the Free Software Foundation; either version 2 of the License, or
  7.  * (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17.  */
  18.  
  19. #include "config.h"
  20.  
  21. #include <gtk/gtk.h>
  22. #include <gdk/gdkkeysyms.h>
  23.  
  24. #include "apptypes.h"
  25.  
  26. #include "appenv.h"
  27. #include "channels_dialog.h"
  28. #include "color_panel.h"
  29. #include "drawable.h"
  30. #include "gdisplay.h"
  31. #include "gimage.h"
  32. #include "gimage_mask.h"
  33. #include "gimpdnd.h"
  34. #include "gimppreviewcache.h"
  35. #include "gimprc.h"
  36. #include "gimpui.h"
  37. #include "layers_dialogP.h"
  38. #include "lc_dialogP.h"
  39. #include "menus.h"
  40. #include "ops_buttons.h"
  41. #include "paint_funcs.h"
  42. #include "undo.h"
  43.  
  44. #include "channel_pvt.h"
  45.  
  46. #include "libgimp/gimpintl.h"
  47. #include "libgimp/gimpmath.h"
  48.  
  49. #include "pixmaps/eye.xbm"
  50. #include "pixmaps/channel.xbm"
  51. #include "pixmaps/new.xpm"
  52. #include "pixmaps/raise.xpm"
  53. #include "pixmaps/lower.xpm"
  54. #include "pixmaps/duplicate.xpm"
  55. #include "pixmaps/delete.xpm"
  56. #include "pixmaps/toselection.xpm"
  57.  
  58. #define COMPONENT_BASE_ID 0x10000000
  59.  
  60. typedef struct _ChannelsDialog ChannelsDialog;
  61.  
  62. struct _ChannelsDialog
  63. {
  64.   GtkWidget     *vbox;
  65.   GtkWidget     *channel_list;
  66.   GtkWidget     *scrolled_win;
  67.   GtkWidget     *preview;
  68.   GtkWidget     *ops_menu;
  69.   GtkAccelGroup *accel_group;
  70.  
  71.   /*  state information  */
  72.   GimpImage   *gimage;
  73.   gint         image_width, image_height;
  74.   gint         gimage_width, gimage_height;
  75.   gdouble      ratio;
  76.  
  77.   gint         num_components;
  78.   gint         base_type;
  79.   ChannelType  components[3];
  80.  
  81.   Channel     *active_channel;
  82.   Layer       *floating_sel;
  83.   GSList      *channel_widgets;
  84. };
  85.  
  86. typedef struct _ChannelWidget ChannelWidget;
  87.  
  88. struct _ChannelWidget
  89. {
  90.   GtkWidget *eye_widget;
  91.   GtkWidget *clip_widget;
  92.   GtkWidget *channel_preview;
  93.   GtkWidget *list_item;
  94.   GtkWidget *label;
  95.  
  96.   GdkPixmap *channel_pixmap;
  97.  
  98.   /*  state information  */
  99.   GimpImage   *gimage;
  100.   Channel     *channel;
  101.   gint         width, height;
  102.  
  103.   ChannelType  type;
  104.   gint         ID;
  105.   gboolean     visited;
  106.  
  107.   GimpDropType drop_type;
  108. };
  109.  
  110. /*  channels dialog widget routines  */
  111. static void channels_dialog_preview_extents      (void);
  112. static void channels_dialog_set_menu_sensitivity (void);
  113. static void channels_dialog_set_channel          (ChannelWidget  *cw);
  114. static void channels_dialog_unset_channel        (ChannelWidget  *cw);
  115. static void channels_dialog_position_channel     (Channel        *channel,
  116.                           gint            position);
  117. static void channels_dialog_add_channel          (Channel        *channel);
  118. static void channels_dialog_remove_channel       (ChannelWidget  *cw);
  119.  
  120. static gint channel_list_events                  (GtkWidget      *widget,
  121.                           GdkEvent       *event);
  122.  
  123. /*  for (un)installing the menu accelarators  */
  124. static void channels_dialog_map_callback         (GtkWidget      *widget,
  125.                           gpointer        data);
  126. static void channels_dialog_unmap_callback       (GtkWidget      *widget,
  127.                           gpointer        data);
  128.  
  129. /*  ops buttons dnd callbacks  */
  130. static gboolean channels_dialog_drag_new_channel_callback
  131.                                                  (GtkWidget      *widget,
  132.                           GdkDragContext *context,
  133.                           gint            x,
  134.                           gint            y,
  135.                           guint           time);
  136. static gboolean channels_dialog_drag_duplicate_channel_callback
  137.                                                  (GtkWidget      *widget,
  138.                           GdkDragContext *context,
  139.                           gint            x,
  140.                           gint            y,
  141.                           guint           time);
  142. static gboolean channels_dialog_drag_channel_to_sel_callback
  143.                                                  (GtkWidget      *widget,
  144.                           GdkDragContext *context,
  145.                           gint            x,
  146.                           gint            y,
  147.                           guint           time);
  148. static gboolean channels_dialog_drag_delete_channel_callback
  149.                                                  (GtkWidget      *widget,
  150.                           GdkDragContext *context,
  151.                           gint            x,
  152.                           gint            y,
  153.                           guint           time);
  154.  
  155. /*  channel widget function prototypes  */
  156. static ChannelWidget * channel_widget_get_ID     (Channel        *channel);
  157. static ChannelWidget * channel_widget_create     (GimpImage      *gimage,
  158.                           Channel        *channel,
  159.                           ChannelType     channel_type);
  160.  
  161. static gboolean channel_widget_drag_motion_callback
  162.                                                  (GtkWidget      *widget,
  163.                           GdkDragContext *context,
  164.                           gint            x,
  165.                           gint            y,
  166.                           guint           time);
  167. static gboolean channel_widget_drag_drop_callback(GtkWidget      *widget,
  168.                           GdkDragContext *context,
  169.                           gint            x,
  170.                           gint            y,
  171.                           guint           time);
  172. static void channel_widget_drag_begin_callback   (GtkWidget      *widget,
  173.                           GdkDragContext *context);
  174. static void channel_widget_drag_leave_callback   (GtkWidget      *widget,
  175.                           GdkDragContext *context,
  176.                           guint           time);
  177. static void channel_widget_drag_indicator_callback
  178.                                                  (GtkWidget      *widget,
  179.                           gpointer        data);
  180.  
  181. static void channel_widget_drop_color            (GtkWidget      *widget,
  182.                           guchar          r,
  183.                           guchar          g,
  184.                           guchar          b,
  185.                           gpointer        data);
  186. static void channel_widget_draw_drop_indicator   (ChannelWidget  *cw,
  187.                           GimpDropType    drop_type);
  188. static void channel_widget_delete                (ChannelWidget  *cw);
  189. static void channel_widget_select_update         (GtkWidget      *widget,
  190.                           gpointer        data);
  191. static gint channel_widget_button_events         (GtkWidget      *widget,
  192.                           GdkEvent       *event,
  193.                           gpointer        data);
  194. static gint channel_widget_preview_events        (GtkWidget      *widget,
  195.                           GdkEvent       *event,
  196.                           gpointer        data);
  197. static void channel_widget_preview_redraw        (ChannelWidget  *cw);
  198. static void channel_widget_no_preview_redraw     (ChannelWidget  *cw);
  199. static void channel_widget_eye_redraw            (ChannelWidget  *cw);
  200. static void channel_widget_exclusive_visible     (ChannelWidget  *cw);
  201. static void channel_widget_channel_flush         (GtkWidget      *widget,
  202.                           gpointer        data);
  203.  
  204. /*  assorted query dialogs  */
  205. static void channels_dialog_new_channel_query    (GimpImage      *gimage);
  206. static void channels_dialog_edit_channel_query   (ChannelWidget  *cw);
  207.  
  208. /****************/
  209. /*  Local data  */
  210. /****************/
  211.  
  212. static ChannelsDialog *channelsD = NULL;
  213.  
  214. static GdkPixmap *eye_pixmap[]     = { NULL, NULL, NULL };
  215. static GdkPixmap *channel_pixmap[] = { NULL, NULL, NULL };
  216.  
  217. static gint suspend_gimage_notify = 0;
  218.  
  219. /*  the ops buttons  */
  220. static GtkSignalFunc to_selection_ext_callbacks[] = 
  221. { 
  222.   channels_dialog_add_channel_to_sel_callback,          /* SHIFT */
  223.   channels_dialog_sub_channel_from_sel_callback,        /* CTRL  */
  224.   channels_dialog_intersect_channel_with_sel_callback,  /* MOD1  */
  225.   channels_dialog_intersect_channel_with_sel_callback,  /* SHIFT + CTRL */
  226. };
  227.  
  228. static OpsButton channels_ops_buttons[] =
  229. {
  230.   { new_xpm, channels_dialog_new_channel_callback, NULL,
  231.     N_("New Channel"),
  232.     "channels/dialogs/new_channel.html",
  233.     NULL, 0 },
  234.   { raise_xpm, channels_dialog_raise_channel_callback, NULL,
  235.     N_("Raise Channel"),
  236.     "channels/raise_channel.html",
  237.     NULL, 0 },
  238.   { lower_xpm, channels_dialog_lower_channel_callback, NULL,
  239.     N_("Lower Channel"),
  240.     "channels/lower_channel.html",
  241.     NULL, 0 },
  242.   { duplicate_xpm, channels_dialog_duplicate_channel_callback, NULL,
  243.     N_("Duplicate Channel"),
  244.     "channels/duplicate_channel.html",
  245.     NULL, 0 },
  246.   { toselection_xpm, channels_dialog_channel_to_sel_callback,
  247.     to_selection_ext_callbacks,
  248.     N_("Channel to Selection \n"
  249.        "<Shift> Add          "
  250.        "<Ctrl> Subtract      "
  251.        "<Shift><Ctrl> Intersect"),
  252.     "channels/channel_to_selection.html",
  253.     NULL, 0 },
  254.   { delete_xpm, channels_dialog_delete_channel_callback, NULL,
  255.     N_("Delete Channel"),
  256.     "channels/delete_channel.html",
  257.     NULL, 0 },
  258.   { NULL, NULL, NULL, NULL, NULL, NULL, 0 }
  259. };
  260.  
  261. /*  dnd structures  */
  262. static GtkTargetEntry channel_color_target_table[] =
  263. {
  264.   GIMP_TARGET_CHANNEL,
  265.   GIMP_TARGET_COLOR
  266. };
  267. static guint n_channel_color_targets = (sizeof (channel_color_target_table) /
  268.                     sizeof (channel_color_target_table[0]));
  269.  
  270. static GtkTargetEntry channel_target_table[] =
  271. {
  272.   GIMP_TARGET_CHANNEL
  273. };
  274. static guint n_channel_targets = (sizeof (channel_target_table) /
  275.                   sizeof (channel_target_table[0]));
  276.  
  277. static GtkTargetEntry component_target_table[] =
  278. {
  279.   GIMP_TARGET_COMPONENT
  280. };
  281. static guint n_component_targets = (sizeof (component_target_table) /
  282.                     sizeof (component_target_table[0]));
  283.  
  284.  
  285. /**************************************/
  286. /*  Public channels dialog functions  */
  287. /**************************************/
  288.  
  289. GtkWidget *
  290. channels_dialog_create (void)
  291. {
  292.   GtkWidget *vbox;
  293.   GtkWidget *button_box;
  294.  
  295.   if (channelsD)
  296.     return channelsD->vbox;
  297.  
  298.   channelsD = g_new (ChannelsDialog, 1);
  299.   channelsD->preview         = NULL;
  300.   channelsD->gimage          = NULL;
  301.   channelsD->active_channel  = NULL;
  302.   channelsD->floating_sel    = NULL;
  303.   channelsD->channel_widgets = NULL;
  304.  
  305.   if (preview_size)
  306.     {
  307.       channelsD->preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
  308.       gtk_preview_size (GTK_PREVIEW (channelsD->preview),
  309.             preview_size, preview_size);
  310.     }
  311.  
  312.   /*  The main vbox  */
  313.   channelsD->vbox = gtk_event_box_new ();
  314.  
  315.   gimp_help_set_help_data (channelsD->vbox, NULL,
  316.                "dialogs/channels/channels.html");
  317.  
  318.   vbox = gtk_vbox_new (FALSE, 1);
  319.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
  320.   gtk_container_add (GTK_CONTAINER (channelsD->vbox), vbox);
  321.  
  322.   /*  The channels commands pulldown menu  */
  323.   menus_get_channels_menu (&channelsD->ops_menu, &channelsD->accel_group);
  324.  
  325.   /*  The channels listbox  */
  326.   channelsD->scrolled_win = gtk_scrolled_window_new (NULL, NULL);
  327.   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (channelsD->scrolled_win), 
  328.                   GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
  329.   gtk_widget_set_usize (channelsD->scrolled_win, LIST_WIDTH, LIST_HEIGHT);
  330.   gtk_box_pack_start (GTK_BOX (vbox), channelsD->scrolled_win, TRUE, TRUE, 2);
  331.  
  332.   channelsD->channel_list = gtk_list_new ();
  333.   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (channelsD->scrolled_win),
  334.                      channelsD->channel_list);
  335.   gtk_list_set_selection_mode (GTK_LIST (channelsD->channel_list),
  336.                    GTK_SELECTION_MULTIPLE);
  337.   gtk_signal_connect (GTK_OBJECT (channelsD->channel_list), "event",
  338.               (GtkSignalFunc) channel_list_events,
  339.               channelsD);
  340.   gtk_container_set_focus_vadjustment (GTK_CONTAINER (channelsD->channel_list),
  341.                        gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (channelsD->scrolled_win)));
  342.   GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (channelsD->scrolled_win)->vscrollbar,
  343.               GTK_CAN_FOCUS);
  344.  
  345.   gtk_widget_show (channelsD->channel_list);
  346.   gtk_widget_show (channelsD->scrolled_win);
  347.  
  348.   /*  The ops buttons  */
  349.   button_box = ops_button_box_new (channels_ops_buttons, OPS_BUTTON_NORMAL);
  350.   gtk_box_pack_start (GTK_BOX (vbox), button_box, FALSE, FALSE, 2);
  351.   gtk_widget_show (button_box);
  352.  
  353.   /*  Drop to new  */
  354.   gtk_drag_dest_set (channels_ops_buttons[0].widget,
  355.                      GTK_DEST_DEFAULT_ALL,
  356.                      channel_target_table, n_channel_targets,
  357.                      GDK_ACTION_COPY);
  358.   gtk_signal_connect (GTK_OBJECT (channels_ops_buttons[0].widget), "drag_drop",
  359.                       GTK_SIGNAL_FUNC (channels_dialog_drag_new_channel_callback),
  360.                       NULL);
  361.  
  362.   /*  Drop to duplicate  */
  363.   gtk_drag_dest_set (channels_ops_buttons[3].widget,
  364.                      GTK_DEST_DEFAULT_ALL,
  365.                      channel_target_table, n_channel_targets,
  366.                      GDK_ACTION_COPY);
  367.   gtk_signal_connect (GTK_OBJECT (channels_ops_buttons[3].widget), "drag_drop",
  368.                       GTK_SIGNAL_FUNC (channels_dialog_drag_duplicate_channel_callback),
  369.               NULL);
  370.  
  371.   /*  Drop to channel to selection  */
  372.   gtk_drag_dest_set (channels_ops_buttons[4].widget,
  373.                      GTK_DEST_DEFAULT_ALL,
  374.                      channel_target_table, n_channel_targets,
  375.                      GDK_ACTION_COPY);
  376.   gtk_signal_connect (GTK_OBJECT (channels_ops_buttons[4].widget), "drag_drop",
  377.                       GTK_SIGNAL_FUNC (channels_dialog_drag_channel_to_sel_callback),
  378.               NULL);
  379.  
  380.   /*  Drop to trahcan  */
  381.   gtk_drag_dest_set (channels_ops_buttons[5].widget,
  382.                      GTK_DEST_DEFAULT_ALL,
  383.                      channel_target_table, n_channel_targets,
  384.                      GDK_ACTION_COPY);
  385.   gtk_signal_connect (GTK_OBJECT (channels_ops_buttons[5].widget), "drag_drop",
  386.                       GTK_SIGNAL_FUNC (channels_dialog_drag_delete_channel_callback),
  387.                       NULL);
  388.  
  389.   /*  Set up signals for map/unmap for the accelerators  */
  390.   gtk_signal_connect (GTK_OBJECT (channelsD->vbox), "map",
  391.               (GtkSignalFunc) channels_dialog_map_callback,
  392.               NULL);
  393.   gtk_signal_connect (GTK_OBJECT (channelsD->vbox), "unmap",
  394.               (GtkSignalFunc) channels_dialog_unmap_callback,
  395.               NULL);
  396.  
  397.   gtk_widget_show (vbox);
  398.   gtk_widget_show (channelsD->vbox);
  399.  
  400.   return channelsD->vbox;
  401. }
  402.  
  403. void
  404. channels_dialog_free (void)
  405. {
  406.   ChannelWidget *cw;
  407.   GSList *list;
  408.  
  409.   if (!channelsD)
  410.     return;
  411.  
  412.   suspend_gimage_notify++;
  413.   /*  Free all elements in the channels listbox  */
  414.   gtk_list_clear_items (GTK_LIST (channelsD->channel_list), 0, -1);
  415.   suspend_gimage_notify--;
  416.  
  417.   list = channelsD->channel_widgets;
  418.   while (list)
  419.     {
  420.       cw = (ChannelWidget *) list->data;
  421.       list = g_slist_next (list);
  422.       channel_widget_delete (cw);
  423.     }
  424.   channelsD->channel_widgets = NULL;
  425.   channelsD->active_channel  = NULL;
  426.   channelsD->floating_sel    = NULL;
  427.  
  428.   if (channelsD->preview)
  429.     gtk_object_sink (GTK_OBJECT (channelsD->preview));
  430.  
  431.   g_free (channelsD);
  432.   channelsD = NULL;
  433. }
  434.  
  435. void
  436. channels_dialog_update (GimpImage* gimage)
  437. {
  438.   Channel       *channel;
  439.   ChannelWidget *cw;
  440.   GSList        *list;
  441.   GList         *item_list;
  442.  
  443.   if (!channelsD || channelsD->gimage == gimage)
  444.     return;
  445.  
  446.   channelsD->gimage = gimage;
  447.  
  448.   suspend_gimage_notify++;
  449.   /*  Free all elements in the channels listbox  */
  450.   gtk_list_clear_items (GTK_LIST (channelsD->channel_list), 0, -1);
  451.   suspend_gimage_notify--;
  452.  
  453.   list = channelsD->channel_widgets;
  454.   while (list)
  455.     {
  456.       cw = (ChannelWidget *) list->data;
  457.       list = g_slist_next (list);
  458.       channel_widget_delete (cw);
  459.     }
  460.   channelsD->channel_widgets = NULL;
  461.  
  462.   /*  Find the preview extents  */
  463.   channels_dialog_preview_extents ();
  464.  
  465.   channelsD->active_channel = NULL;
  466.   channelsD->floating_sel = NULL;
  467.  
  468.   /*  The image components  */
  469.   item_list = NULL;
  470.   switch ((channelsD->base_type = gimp_image_base_type (gimage)))
  471.     {
  472.     case RGB:
  473.       cw = channel_widget_create (gimage, NULL, RED_CHANNEL);
  474.       channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
  475.       item_list = g_list_append (item_list, cw->list_item);
  476.       channelsD->components[0] = RED_CHANNEL;
  477.  
  478.       cw = channel_widget_create (gimage, NULL, GREEN_CHANNEL);
  479.       channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
  480.       item_list = g_list_append (item_list, cw->list_item);
  481.       channelsD->components[1] = GREEN_CHANNEL;
  482.  
  483.       cw = channel_widget_create (gimage, NULL, BLUE_CHANNEL);
  484.       channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
  485.       item_list = g_list_append (item_list, cw->list_item);
  486.       channelsD->components[2] = BLUE_CHANNEL;
  487.  
  488.       channelsD->num_components = 3;
  489.       break;
  490.  
  491.     case GRAY:
  492.       cw = channel_widget_create (gimage, NULL, GRAY_CHANNEL);
  493.       channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
  494.       item_list = g_list_append (item_list, cw->list_item);
  495.       channelsD->components[0] = GRAY_CHANNEL;
  496.  
  497.       channelsD->num_components = 1;
  498.       break;
  499.  
  500.     case INDEXED:
  501.       cw = channel_widget_create (gimage, NULL, INDEXED_CHANNEL);
  502.       channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
  503.       item_list = g_list_append (item_list, cw->list_item);
  504.       channelsD->components[0] = INDEXED_CHANNEL;
  505.  
  506.       channelsD->num_components = 1;
  507.       break;
  508.     }
  509.  
  510.   /*  The auxillary image channels  */
  511.   for (list = gimage->channels; list; list = g_slist_next (list))
  512.     {
  513.       /*  create a channel list item  */
  514.       channel = (Channel *) list->data;
  515.       cw = channel_widget_create (gimage, channel, AUXILLARY_CHANNEL);
  516.       channelsD->channel_widgets = g_slist_append (channelsD->channel_widgets, cw);
  517.       item_list = g_list_append (item_list, cw->list_item);
  518.     }
  519.  
  520.   /*  get the index of the active channel  */
  521.   if (item_list)
  522.     gtk_list_insert_items (GTK_LIST (channelsD->channel_list), item_list, 0);
  523. }
  524.  
  525. void
  526. channels_dialog_flush (void)
  527. {
  528.   GimpImage     *gimage;
  529.   Channel       *channel;
  530.   ChannelWidget *cw;
  531.   GSList        *list;
  532.   gint           pos;
  533.  
  534.   if (!channelsD || !(gimage = channelsD->gimage))
  535.     return;
  536.  
  537.   /*  Check if the gimage extents have changed  */
  538.   if ((gimage->width != channelsD->gimage_width) ||
  539.       (gimage->height != channelsD->gimage_height) ||
  540.       (gimp_image_base_type (gimage) != channelsD->base_type))
  541.     {
  542.       channelsD->gimage = NULL;
  543.       channels_dialog_update (gimage);
  544.     }
  545.   else
  546.     {
  547.       /*  Set all current channel widgets to visited = FALSE  */
  548.       for (list = channelsD->channel_widgets; list; list = g_slist_next (list))
  549.     {
  550.       cw = (ChannelWidget *) list->data;
  551.       cw->visited = FALSE;
  552.     }
  553.  
  554.       /*  Add any missing channels  */
  555.       for (list = gimage->channels; list; list = g_slist_next (list))
  556.     {
  557.       channel = (Channel *) list->data;
  558.       cw = channel_widget_get_ID (channel);
  559.  
  560.       /*  If the channel isn't in the channel widget list, add it  */
  561.       if (cw == NULL)
  562.         {
  563.           /*  sets visited = TRUE  */
  564.           channels_dialog_add_channel (channel);
  565.         }
  566.       else
  567.         cw->visited = TRUE;
  568.     }
  569.  
  570.       /*  Remove any extraneous auxillary channels  */
  571.       list = channelsD->channel_widgets;
  572.       while (list)
  573.     {
  574.       cw = (ChannelWidget *) list->data;
  575.       list = g_slist_next (list);
  576.       if (cw->visited == FALSE && cw->type == AUXILLARY_CHANNEL)
  577.         {
  578.           /*  will only be true for auxillary channels  */
  579.           channels_dialog_remove_channel (cw);
  580.         }
  581.     }
  582.  
  583.       /*  Switch positions of items if necessary  */
  584.       pos = 0;
  585.       for (list = gimage->channels; list; list = g_slist_next (list))
  586.     {
  587.       channel = (Channel *) list->data;
  588.       channels_dialog_position_channel (channel, pos++);
  589.     }
  590.  
  591.       /*  Set the active channel  */
  592.       if (channelsD->active_channel != gimage->active_channel)
  593.     channelsD->active_channel = gimage->active_channel;
  594.  
  595.       /*  set the menus if floating sel status has changed  */
  596.       if (channelsD->floating_sel != gimage->floating_sel)
  597.     channelsD->floating_sel = gimage->floating_sel;
  598.  
  599.       channels_dialog_set_menu_sensitivity ();
  600.  
  601.       gtk_container_foreach (GTK_CONTAINER (channelsD->channel_list),
  602.                  channel_widget_channel_flush, NULL);
  603.     }
  604. }
  605.  
  606. void
  607. channels_dialog_clear (void)
  608. {
  609.   if (!channelsD)
  610.     return;
  611.  
  612.   suspend_gimage_notify++;
  613.   gtk_list_clear_items (GTK_LIST (channelsD->channel_list), 0, -1);
  614.   suspend_gimage_notify--;
  615.  
  616.   channelsD->gimage = NULL;
  617. }
  618.  
  619. static void
  620. channels_dialog_preview_extents (void)
  621. {
  622.   GimpImage *gimage;
  623.  
  624.   g_return_if_fail (channelsD);
  625.   if (! (gimage = channelsD->gimage))
  626.     return;
  627.  
  628.   channelsD->gimage_width  = gimage->width;
  629.   channelsD->gimage_height = gimage->height;
  630.  
  631.   /*  Get the image width and height variables, based on the gimage  */
  632.   if (gimage->width > gimage->height)
  633.     channelsD->ratio = (gdouble) preview_size / (gdouble) gimage->width;
  634.   else  
  635.     channelsD->ratio = (gdouble) preview_size / (gdouble) gimage->height;
  636.  
  637.   if (preview_size)
  638.     {
  639.       channelsD->image_width  = RINT (channelsD->ratio * gimage->width);
  640.       channelsD->image_height = RINT (channelsD->ratio * gimage->height);
  641.  
  642.       if (channelsD->image_width < 1)  channelsD->image_width  = 1;
  643.       if (channelsD->image_height < 1) channelsD->image_height = 1;
  644.     }
  645.   else
  646.     {
  647.       channelsD->image_width  = channel_width;
  648.       channelsD->image_height = channel_height;
  649.     }
  650. }
  651.  
  652. static void
  653. channels_dialog_set_menu_sensitivity (void)
  654. {
  655.   ChannelWidget *cw;
  656.   gint fs_sens;
  657.   gint aux_sens;
  658.  
  659.   cw = channel_widget_get_ID (channelsD->active_channel);
  660.   fs_sens = (channelsD->floating_sel != NULL);
  661.  
  662.   if (cw)
  663.     aux_sens = (cw->type == AUXILLARY_CHANNEL);
  664.   else
  665.     aux_sens = FALSE;
  666.  
  667. #define SET_SENSITIVE(menu,condition) \
  668.         menus_set_sensitive ("<Channels>/" menu, (condition) != 0)
  669. #define SET_OPS_SENSITIVE(button,condition) \
  670.         gtk_widget_set_sensitive (channels_ops_buttons[(button)].widget, \
  671.                                  (condition) != 0)
  672.  
  673.   SET_SENSITIVE ("New Channel...", !fs_sens);
  674.   SET_OPS_SENSITIVE (0, !fs_sens);
  675.  
  676.   SET_SENSITIVE ("Raise Channel", !fs_sens && aux_sens);
  677.   SET_OPS_SENSITIVE (1, !fs_sens && aux_sens);
  678.  
  679.   SET_SENSITIVE ("Lower Channel", !fs_sens && aux_sens);
  680.   SET_OPS_SENSITIVE (2, !fs_sens && aux_sens);
  681.  
  682.   SET_SENSITIVE ("Duplicate Channel", !fs_sens && aux_sens);
  683.   SET_OPS_SENSITIVE (3, !fs_sens && aux_sens);
  684.  
  685.   SET_SENSITIVE ("Channel to Selection", aux_sens);
  686.   SET_OPS_SENSITIVE (4, aux_sens);
  687.  
  688.   SET_SENSITIVE ("Add to Selection", aux_sens);
  689.   SET_SENSITIVE ("Subtract from Selection", aux_sens);
  690.   SET_SENSITIVE ("Intersect with Selection", aux_sens);
  691.  
  692.   SET_SENSITIVE ("Delete Channel", !fs_sens && aux_sens);
  693.   SET_OPS_SENSITIVE (5, !fs_sens && aux_sens);
  694.  
  695.   SET_SENSITIVE ("Edit Channel Attributes...", !fs_sens && aux_sens);
  696.  
  697. #undef SET_OPS_SENSITIVE
  698. #undef SET_SENSITIVE
  699. }
  700.  
  701. static gint
  702. channels_dialog_idle_set_channel_focus (gpointer data)
  703. {
  704.   gtk_widget_grab_focus (GTK_WIDGET (data));
  705.  
  706.   return FALSE;
  707. }
  708.  
  709. static void
  710. channels_dialog_set_channel (ChannelWidget *channel_widget)
  711. {
  712.   GtkStateType state;
  713.   gint index;
  714.  
  715.   if (!channelsD || !channel_widget)
  716.     return;
  717.  
  718.   /*  Make sure the gimage is not notified of this change  */
  719.   suspend_gimage_notify++;
  720.  
  721.   /*  get the list item data  */
  722.   state = channel_widget->list_item->state;
  723.  
  724.   if (channel_widget->type == AUXILLARY_CHANNEL)
  725.     {
  726.       /*  turn on the specified auxillary channel  */
  727.       index = gimp_image_get_channel_index (channel_widget->gimage,
  728.                         channel_widget->channel);
  729.       if ((index >= 0) && (state != GTK_STATE_SELECTED))
  730.     {
  731.       gtk_object_set_user_data (GTK_OBJECT (channel_widget->list_item),
  732.                     NULL);
  733.       gtk_list_select_item (GTK_LIST (channelsD->channel_list),
  734.                 index + channelsD->num_components);
  735.       /*  let dnd finish it's work before setting the focus  */
  736.       gtk_idle_add ((GtkFunction) channels_dialog_idle_set_channel_focus,
  737.             channel_widget->list_item);
  738.       gtk_object_set_user_data (GTK_OBJECT (channel_widget->list_item),
  739.                     channel_widget);
  740.       /* channels_dialog_scroll_index (index + channelsD->num_components); */
  741.     }
  742.     }
  743.   else
  744.     {
  745.       if (state != GTK_STATE_SELECTED)
  746.     {
  747.       gtk_object_set_user_data (GTK_OBJECT (channel_widget->list_item),
  748.                     NULL);
  749.       switch (channel_widget->type)
  750.         {
  751.         case RED_CHANNEL:
  752.         case GRAY_CHANNEL:
  753.         case INDEXED_CHANNEL:
  754.           gtk_list_select_item (GTK_LIST (channelsD->channel_list), 0);
  755.           break;
  756.         case GREEN_CHANNEL:
  757.           gtk_list_select_item (GTK_LIST (channelsD->channel_list), 1);
  758.           break;
  759.         case BLUE_CHANNEL:
  760.           gtk_list_select_item (GTK_LIST (channelsD->channel_list), 2);
  761.           break;
  762.         case AUXILLARY_CHANNEL:
  763.           g_error ("error in %s at %d: this shouldn't happen.",
  764.                __FILE__, __LINE__);
  765.           break;
  766.         }
  767.  
  768.       gtk_object_set_user_data (GTK_OBJECT (channel_widget->list_item),
  769.                     channel_widget);
  770.       /* channels_dialog_scroll_index (0); */
  771.     }
  772.     }
  773.   suspend_gimage_notify--;
  774. }
  775.  
  776. static void
  777. channels_dialog_unset_channel (ChannelWidget *channel_widget)
  778. {
  779.   GtkStateType state;
  780.   gint index;
  781.  
  782.   if (!channelsD || !channel_widget)
  783.     return;
  784.  
  785.   /*  Make sure the gimage is not notified of this change  */
  786.   suspend_gimage_notify++;
  787.  
  788.   /*  get the list item data  */
  789.   state = channel_widget->list_item->state;
  790.  
  791.   if (channel_widget->type == AUXILLARY_CHANNEL)
  792.     {
  793.       /*  turn off the specified auxillary channel  */
  794.       index = gimp_image_get_channel_index (channel_widget->gimage,
  795.                         channel_widget->channel);
  796.       if ((index >= 0) && (state == GTK_STATE_SELECTED))
  797.     {
  798.       gtk_object_set_user_data (GTK_OBJECT (channel_widget->list_item),
  799.                     NULL);
  800.       gtk_list_unselect_item (GTK_LIST (channelsD->channel_list),
  801.                   index + channelsD->num_components);
  802.       gtk_object_set_user_data (GTK_OBJECT (channel_widget->list_item),
  803.                     channel_widget);
  804.     }
  805.     }
  806.   else
  807.     {
  808.       if (state == GTK_STATE_SELECTED)
  809.     {
  810.       gtk_object_set_user_data (GTK_OBJECT (channel_widget->list_item),
  811.                     NULL);
  812.       switch (channel_widget->type)
  813.         {
  814.         case RED_CHANNEL:
  815.         case GRAY_CHANNEL:
  816.         case INDEXED_CHANNEL:
  817.           gtk_list_unselect_item (GTK_LIST (channelsD->channel_list), 0);
  818.           break;
  819.         case GREEN_CHANNEL:
  820.           gtk_list_unselect_item (GTK_LIST (channelsD->channel_list), 1);
  821.           break;
  822.         case BLUE_CHANNEL:
  823.           gtk_list_unselect_item (GTK_LIST (channelsD->channel_list), 2);
  824.           break;
  825.         case AUXILLARY_CHANNEL:
  826.           g_error ("error in %s at %d: this shouldn't happen.",
  827.                __FILE__, __LINE__);
  828.           break;
  829.         }
  830.  
  831.       gtk_object_set_user_data (GTK_OBJECT (channel_widget->list_item),
  832.                     channel_widget);
  833.     }
  834.     }
  835.  
  836.   suspend_gimage_notify--;
  837. }
  838.  
  839. static void
  840. channels_dialog_position_channel (Channel *channel,
  841.                   gint     new_index)
  842. {
  843.   ChannelWidget *channel_widget;
  844.   GList *list = NULL;
  845.  
  846.   channel_widget = channel_widget_get_ID (channel);
  847.   if (!channelsD || !channel_widget)
  848.     return;
  849.  
  850.   if ((new_index + channelsD->num_components) ==
  851.       g_slist_index (channelsD->channel_widgets, channel_widget))
  852.     return;
  853.  
  854.   /*  Make sure the gimage is not notified of this change  */
  855.   suspend_gimage_notify++;
  856.  
  857.   /*  Remove the channel from the dialog  */
  858.   list = g_list_append (list, channel_widget->list_item);
  859.   gtk_list_remove_items (GTK_LIST (channelsD->channel_list), list);
  860.   channelsD->channel_widgets = g_slist_remove (channelsD->channel_widgets,
  861.                            channel_widget);
  862.  
  863.   /*  Add it back at the proper index  */
  864.   gtk_list_insert_items (GTK_LIST (channelsD->channel_list), list,
  865.              new_index + channelsD->num_components);
  866.   channelsD->channel_widgets =
  867.     g_slist_insert (channelsD->channel_widgets, channel_widget,
  868.             new_index + channelsD->num_components);
  869.  
  870.   /*   channels_dialog_scroll_index (new_index > 0 ?  */
  871.   /*                 new_index + channelsD->num_components + 1 : */
  872.   /*                 channelsD->num_components); */
  873.   
  874.   suspend_gimage_notify--;
  875. }
  876.  
  877. static void
  878. channels_dialog_add_channel (Channel *channel)
  879. {
  880.   ChannelWidget *channel_widget;
  881.   GimpImage *gimage;
  882.   GList *item_list;
  883.   gint   position;
  884.  
  885.   if (!channelsD || !channel || !(gimage = channelsD->gimage))
  886.     return;
  887.  
  888.   item_list = NULL;
  889.  
  890.   channel_widget = channel_widget_create (gimage, channel, AUXILLARY_CHANNEL);
  891.   item_list = g_list_append (item_list, channel_widget->list_item);
  892.  
  893.   position = gimp_image_get_channel_index (gimage, channel);
  894.   channelsD->channel_widgets =
  895.     g_slist_insert (channelsD->channel_widgets, channel_widget,
  896.             position + channelsD->num_components);
  897.   gtk_list_insert_items (GTK_LIST (channelsD->channel_list), item_list,
  898.              position + channelsD->num_components);
  899. }
  900.  
  901. static void
  902. channels_dialog_remove_channel (ChannelWidget *channel_widget)
  903. {
  904.   GList *list = NULL;
  905.  
  906.   if (!channelsD || !channel_widget)
  907.     return;
  908.  
  909.   /*  Make sure the gimage is not notified of this change  */
  910.   suspend_gimage_notify++;
  911.  
  912.   /*  Remove the requested channel from the dialog  */
  913.   list = g_list_append (list, channel_widget->list_item);
  914.   gtk_list_remove_items (GTK_LIST (channelsD->channel_list), list);
  915.  
  916.   /*  Delete the channel_widget  */
  917.   channel_widget_delete (channel_widget);
  918.  
  919.   suspend_gimage_notify--;
  920. }
  921.  
  922. static gint
  923. channel_list_events (GtkWidget *widget,
  924.              GdkEvent  *event)
  925. {
  926.   ChannelWidget  *channel_widget;
  927.   GdkEventButton *bevent;
  928.   GtkWidget      *event_widget;
  929.  
  930.   event_widget = gtk_get_event_widget (event);
  931.  
  932.   if (GTK_IS_LIST_ITEM (event_widget))
  933.     {
  934.       channel_widget =
  935.     (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (event_widget));
  936.  
  937.       switch (event->type)
  938.     {
  939.     case GDK_BUTTON_PRESS:
  940.       bevent = (GdkEventButton *) event;
  941.       if (bevent->button == 3)
  942.         {
  943.           gtk_menu_popup (GTK_MENU (channelsD->ops_menu),
  944.                   NULL, NULL, NULL, NULL,
  945.                   bevent->button, bevent->time);
  946.           return TRUE;
  947.         }
  948.       break;
  949.  
  950.     case GDK_2BUTTON_PRESS:
  951.       if (channel_widget->type == AUXILLARY_CHANNEL)
  952.         channels_dialog_edit_channel_query (channel_widget);
  953.       return TRUE;
  954.  
  955.     default:
  956.       break;
  957.     }
  958.     }
  959.  
  960.   return FALSE;
  961. }
  962.  
  963. /*******************************/
  964. /*  channels dialog callbacks  */
  965. /*******************************/
  966.  
  967. static void
  968. channels_dialog_map_callback (GtkWidget *widget,
  969.                   gpointer   data)
  970. {
  971.   if (! channelsD)
  972.     return;
  973.  
  974.   gtk_window_add_accel_group (GTK_WINDOW (lc_dialog->shell),
  975.                   channelsD->accel_group);
  976. }
  977.  
  978. static void
  979. channels_dialog_unmap_callback (GtkWidget *widget,
  980.                 gpointer   data)
  981. {
  982.   if (! channelsD)
  983.     return;
  984.  
  985.   gtk_window_remove_accel_group (GTK_WINDOW (lc_dialog->shell),
  986.                  channelsD->accel_group);
  987. }
  988.  
  989. /***********************************/
  990. /*  callbacks exported to menus.c  */
  991. /***********************************/
  992.  
  993. void
  994. channels_dialog_new_channel_callback (GtkWidget *widget,
  995.                       gpointer   data)
  996. {
  997.   if (!channelsD || channelsD->gimage == NULL)
  998.     return;
  999.  
  1000.   channels_dialog_new_channel_query (channelsD->gimage);
  1001. }
  1002.  
  1003. void
  1004. channels_dialog_raise_channel_callback (GtkWidget *widget,
  1005.                     gpointer   data)
  1006. {
  1007.   GimpImage *gimage;
  1008.  
  1009.   if (!channelsD || !(gimage = channelsD->gimage))
  1010.     return;
  1011.  
  1012.   if (gimage->active_channel != NULL)
  1013.     {
  1014.       gimp_image_raise_channel (gimage, gimage->active_channel);
  1015.       gdisplays_flush ();
  1016.     }
  1017. }
  1018.  
  1019. void
  1020. channels_dialog_lower_channel_callback (GtkWidget *widget,
  1021.                     gpointer   data)
  1022. {
  1023.   GimpImage *gimage;
  1024.  
  1025.   if (!channelsD || !(gimage = channelsD->gimage))
  1026.     return;
  1027.  
  1028.   if (gimage->active_channel != NULL)
  1029.     {
  1030.       gimp_image_lower_channel (gimage, gimage->active_channel);
  1031.       gdisplays_flush ();
  1032.     }
  1033. }
  1034.  
  1035. void
  1036. channels_dialog_duplicate_channel_callback (GtkWidget *widget,
  1037.                         gpointer   data)
  1038. {
  1039.   GimpImage *gimage;
  1040.   Channel *active_channel;
  1041.   Channel *new_channel;
  1042.  
  1043.   if (!channelsD || !(gimage = channelsD->gimage))
  1044.     return;
  1045.  
  1046.   if ((active_channel = gimp_image_get_active_channel (gimage)))
  1047.     {
  1048.       new_channel = channel_copy (active_channel);
  1049.       gimp_image_add_channel (gimage, new_channel, -1);
  1050.       gdisplays_flush ();
  1051.     }
  1052. }
  1053.  
  1054. void
  1055. channels_dialog_delete_channel_callback (GtkWidget *widget,
  1056.                      gpointer   data)
  1057. {
  1058.   GimpImage *gimage;
  1059.  
  1060.   if (!channelsD || !(gimage = channelsD->gimage))
  1061.     return;
  1062.  
  1063.   if (gimage->active_channel != NULL)
  1064.     {
  1065.       gimp_image_remove_channel (gimage, gimage->active_channel);
  1066.       gdisplays_flush ();
  1067.     }
  1068. }
  1069.  
  1070. void
  1071. channels_dialog_channel_to_sel_callback (GtkWidget *widget,
  1072.                      gpointer   data)
  1073. {
  1074.   GimpImage *gimage;
  1075.  
  1076.   if (!channelsD || !(gimage = channelsD->gimage))
  1077.     return;
  1078.  
  1079.   if (gimage->active_channel != NULL)
  1080.     {
  1081.       gimage_mask_load (gimage, gimage->active_channel);
  1082.       gdisplays_flush ();
  1083.     }
  1084. }
  1085.  
  1086. void
  1087. channels_dialog_add_channel_to_sel_callback (GtkWidget *widget,
  1088.                          gpointer   data)
  1089. {
  1090.   GimpImage *gimage;
  1091.   Channel *active_channel;
  1092.   Channel *new_channel;
  1093.  
  1094.   if (!channelsD || !(gimage = channelsD->gimage))
  1095.     return;
  1096.  
  1097.   if ((active_channel = gimp_image_get_active_channel (gimage)))
  1098.     {
  1099.       new_channel = channel_copy (gimp_image_get_mask (gimage));
  1100.       channel_combine_mask (new_channel,
  1101.                 active_channel,
  1102.                 ADD, 
  1103.                 0, 0);  /* off x/y */
  1104.       gimage_mask_load (gimage, new_channel);
  1105.       channel_delete (new_channel);
  1106.       gdisplays_flush ();
  1107.     }
  1108. }
  1109.  
  1110. void
  1111. channels_dialog_sub_channel_from_sel_callback (GtkWidget *widget,
  1112.                            gpointer   data)
  1113. {
  1114.   GimpImage *gimage;
  1115.   Channel *active_channel;
  1116.   Channel *new_channel;
  1117.  
  1118.   if (!channelsD || !(gimage = channelsD->gimage))
  1119.     return;
  1120.  
  1121.   if ((active_channel = gimp_image_get_active_channel (gimage)))
  1122.     {
  1123.        new_channel = channel_copy (gimp_image_get_mask (gimage));
  1124.        channel_combine_mask (new_channel,
  1125.                              active_channel,
  1126.                  SUB, 
  1127.                  0, 0);  /* off x/y */
  1128.       gimage_mask_load (gimage, new_channel);
  1129.       channel_delete (new_channel);
  1130.       gdisplays_flush ();
  1131.     }
  1132. }
  1133.  
  1134. void
  1135. channels_dialog_intersect_channel_with_sel_callback (GtkWidget *widget,
  1136.                              gpointer   data)
  1137. {
  1138.   GimpImage *gimage;
  1139.   Channel *active_channel;
  1140.   Channel *new_channel;
  1141.  
  1142.   if (!channelsD || !(gimage = channelsD->gimage))
  1143.     return;
  1144.  
  1145.   if ((active_channel = gimp_image_get_active_channel (gimage)))
  1146.     {
  1147.       new_channel = channel_copy (gimp_image_get_mask (gimage));
  1148.       channel_combine_mask (new_channel,
  1149.                 active_channel,
  1150.                 INTERSECT, 
  1151.                 0, 0);  /* off x/y */
  1152.       gimage_mask_load (gimage, new_channel);
  1153.       channel_delete (new_channel);
  1154.       gdisplays_flush ();
  1155.     }
  1156. }
  1157.  
  1158. void
  1159. channels_dialog_edit_channel_attributes_callback (GtkWidget *widget,
  1160.                           gpointer   data)
  1161. {
  1162.   if (channelsD && channelsD->active_channel)
  1163.     {
  1164.       ChannelWidget *channel_widget;
  1165.  
  1166.       channel_widget = channel_widget_get_ID (channelsD->active_channel);
  1167.  
  1168.       channels_dialog_edit_channel_query (channel_widget);
  1169.     }
  1170. }
  1171.  
  1172. /*******************************/
  1173. /*  ops buttons dnd callbacks  */
  1174. /*******************************/
  1175.  
  1176. static gboolean
  1177. channels_dialog_drag_new_channel_callback (GtkWidget      *widget,
  1178.                        GdkDragContext *context,
  1179.                        gint            x,
  1180.                        gint            y,
  1181.                        guint           time)
  1182. {
  1183.   GtkWidget *src_widget;
  1184.   gboolean return_val = FALSE;
  1185.  
  1186.   if ((src_widget = gtk_drag_get_source_widget (context)))
  1187.     {
  1188.       ChannelWidget *src;
  1189.  
  1190.       src
  1191.         = (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (src_widget));
  1192.  
  1193.       if (src &&
  1194.           src->channel == channelsD->active_channel)
  1195.         {
  1196.           Channel   *channel;
  1197.           GimpImage *gimage;
  1198.           gint  width, height;
  1199.           gint  off_x, off_y;
  1200.  
  1201.           gimage = channelsD->gimage;
  1202.  
  1203.           width  = gimp_drawable_width  (GIMP_DRAWABLE (src->channel));
  1204.           height = gimp_drawable_height (GIMP_DRAWABLE (src->channel));
  1205.           gimp_drawable_offsets (GIMP_DRAWABLE (src->channel), &off_x, &off_y);
  1206.  
  1207.           /*  Start a group undo  */
  1208.           undo_push_group_start (gimage, EDIT_PASTE_UNDO);
  1209.  
  1210.           channel = channel_new (gimage, width, height,
  1211.                  _("Empty Channel Copy"),
  1212.                  src->channel->opacity,
  1213.                  src->channel->col);
  1214.           if (channel)
  1215.             {
  1216.               drawable_fill (GIMP_DRAWABLE (channel), TRANSPARENT_FILL);
  1217.               channel_translate (channel, off_x, off_y);
  1218.               gimp_image_add_channel (gimage, channel, -1);
  1219.  
  1220.               /*  End the group undo  */
  1221.               undo_push_group_end (gimage);
  1222.  
  1223.               gdisplays_flush ();
  1224.             } 
  1225.           else
  1226.             {
  1227.               g_message ("channels_dialog_drop_new_channel_callback():\n"
  1228.              "could not allocate new channel");
  1229.             }
  1230.  
  1231.           return_val = TRUE;
  1232.         }
  1233.     }
  1234.  
  1235.   gtk_drag_finish (context, return_val, FALSE, time);
  1236.  
  1237.   return return_val;
  1238. }
  1239.  
  1240. static gboolean
  1241. channels_dialog_drag_duplicate_channel_callback (GtkWidget      *widget,
  1242.                          GdkDragContext *context,
  1243.                          gint            x,
  1244.                          gint            y,
  1245.                          guint           time)
  1246. {
  1247.   GtkWidget *src_widget;
  1248.   gboolean return_val = FALSE;
  1249.  
  1250.   if ((src_widget = gtk_drag_get_source_widget (context)))
  1251.     {
  1252.       ChannelWidget *src;
  1253.  
  1254.       src
  1255.         = (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (src_widget));
  1256.  
  1257.       if (src &&
  1258.           src->channel == channelsD->active_channel)
  1259.         {
  1260.           channels_dialog_duplicate_channel_callback (widget, NULL);
  1261.  
  1262.           return_val = TRUE;
  1263.         }
  1264.     }
  1265.  
  1266.   gtk_drag_finish (context, return_val, FALSE, time);
  1267.  
  1268.   return return_val;
  1269. }
  1270.  
  1271. static gboolean
  1272. channels_dialog_drag_channel_to_sel_callback (GtkWidget      *widget,
  1273.                           GdkDragContext *context,
  1274.                           gint            x,
  1275.                           gint            y,
  1276.                           guint           time)
  1277. {
  1278.   GtkWidget *src_widget;
  1279.   gboolean return_val = FALSE;
  1280.  
  1281.   if ((src_widget = gtk_drag_get_source_widget (context)))
  1282.     {
  1283.       ChannelWidget *src;
  1284.  
  1285.       src
  1286.         = (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (src_widget));
  1287.  
  1288.       if (src &&
  1289.           src->channel == channelsD->active_channel)
  1290.         {
  1291.           channels_dialog_channel_to_sel_callback (widget, NULL);
  1292.  
  1293.           return_val = TRUE;
  1294.         }
  1295.     }
  1296.  
  1297.   gtk_drag_finish (context, return_val, FALSE, time);
  1298.  
  1299.   return return_val;
  1300. }
  1301.  
  1302. static gboolean
  1303. channels_dialog_drag_delete_channel_callback (GtkWidget      *widget,
  1304.                           GdkDragContext *context,
  1305.                           gint            x,
  1306.                           gint            y,
  1307.                           guint           time)
  1308. {
  1309.   GtkWidget *src_widget;
  1310.   gboolean return_val = FALSE;
  1311.  
  1312.   if ((src_widget = gtk_drag_get_source_widget (context)))
  1313.     {
  1314.       ChannelWidget *src;
  1315.  
  1316.       src
  1317.         = (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (src_widget));
  1318.  
  1319.       if (src &&
  1320.           src->channel == channelsD->active_channel)
  1321.         {
  1322.           channels_dialog_delete_channel_callback (widget, NULL);
  1323.  
  1324.           return_val = TRUE;
  1325.         }
  1326.     }
  1327.  
  1328.   gtk_drag_finish (context, return_val, FALSE, time);
  1329.  
  1330.   return return_val;
  1331. }
  1332.  
  1333. /******************************/
  1334. /*  channel widget functions  */
  1335. /******************************/
  1336.  
  1337. static ChannelWidget *
  1338. channel_widget_get_ID (Channel *channel)
  1339. {
  1340.   ChannelWidget *lw;
  1341.   GSList *list;
  1342.  
  1343.   if (!channelsD)
  1344.     return NULL;
  1345.  
  1346.   for (list = channelsD->channel_widgets; list; list = g_slist_next (list))
  1347.     {
  1348.       lw = (ChannelWidget *) list->data;
  1349.  
  1350.       if (lw->channel == channel)
  1351.     return lw;
  1352.     }
  1353.  
  1354.   return NULL;
  1355. }
  1356.  
  1357. static ChannelWidget *
  1358. channel_widget_create (GimpImage   *gimage,
  1359.                Channel     *channel,
  1360.                ChannelType  type)
  1361. {
  1362.   ChannelWidget *channel_widget;
  1363.   GtkWidget *list_item;
  1364.   GtkWidget *hbox;
  1365.   GtkWidget *vbox;
  1366.   GtkWidget *alignment;
  1367.  
  1368.   list_item = gtk_list_item_new ();
  1369.  
  1370.   /*  Create the channel widget and add it to the list  */
  1371.   channel_widget = g_new (ChannelWidget, 1);
  1372.   channel_widget->gimage          = gimage;
  1373.   channel_widget->channel         = channel;
  1374.   channel_widget->channel_preview = NULL;
  1375.   channel_widget->channel_pixmap  = NULL;
  1376.   channel_widget->type            = type;
  1377.   channel_widget->ID              = ((type == AUXILLARY_CHANNEL) ?
  1378.                      GIMP_DRAWABLE (channel)->ID :
  1379.                      (COMPONENT_BASE_ID + type));
  1380.   channel_widget->list_item       = list_item;
  1381.   channel_widget->width           = -1;
  1382.   channel_widget->height          = -1;
  1383.   channel_widget->visited         = TRUE;
  1384.   channel_widget->drop_type       = GIMP_DROP_NONE;
  1385.  
  1386.   /*  Need to let the list item know about the channel_widget  */
  1387.   gtk_object_set_user_data (GTK_OBJECT (list_item), channel_widget);
  1388.  
  1389.   /*  Set up the list item observer  */
  1390.   gtk_signal_connect (GTK_OBJECT (list_item), "select",
  1391.               GTK_SIGNAL_FUNC (channel_widget_select_update),
  1392.               channel_widget);
  1393.   gtk_signal_connect (GTK_OBJECT (list_item), "deselect",
  1394.               GTK_SIGNAL_FUNC (channel_widget_select_update),
  1395.               channel_widget);
  1396.  
  1397.   vbox = gtk_vbox_new (FALSE, 1);
  1398.   gtk_container_add (GTK_CONTAINER (list_item), vbox);
  1399.  
  1400.   hbox = gtk_hbox_new (FALSE, 1);
  1401.   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 1);
  1402.  
  1403.   /*  Create the visibility toggle button  */
  1404.   alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
  1405.   gtk_box_pack_start (GTK_BOX (hbox), alignment, FALSE, TRUE, 2);
  1406.   channel_widget->eye_widget = gtk_drawing_area_new ();
  1407.   gtk_drawing_area_size (GTK_DRAWING_AREA (channel_widget->eye_widget),
  1408.              eye_width, eye_height);
  1409.   gtk_widget_set_events (channel_widget->eye_widget, BUTTON_EVENT_MASK);
  1410.   gtk_signal_connect (GTK_OBJECT (channel_widget->eye_widget), "event",
  1411.               GTK_SIGNAL_FUNC (channel_widget_button_events),
  1412.               channel_widget);
  1413.   gtk_object_set_user_data (GTK_OBJECT (channel_widget->eye_widget),
  1414.                 channel_widget);
  1415.   gtk_container_add (GTK_CONTAINER (alignment), channel_widget->eye_widget);
  1416.   gtk_widget_show (channel_widget->eye_widget);
  1417.   gtk_widget_show (alignment);
  1418.  
  1419.   /*  The channel preview  */
  1420.   alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
  1421.   gtk_box_pack_start (GTK_BOX (hbox), alignment, FALSE, FALSE, 2);
  1422.   gtk_widget_show (alignment);
  1423.  
  1424.   channel_widget->channel_preview = gtk_drawing_area_new ();
  1425.   gtk_drawing_area_size (GTK_DRAWING_AREA (channel_widget->channel_preview),
  1426.              channelsD->image_width, channelsD->image_height);
  1427.   gtk_widget_set_events (channel_widget->channel_preview, PREVIEW_EVENT_MASK);
  1428.   gtk_signal_connect (GTK_OBJECT (channel_widget->channel_preview), "event",
  1429.               GTK_SIGNAL_FUNC (channel_widget_preview_events),
  1430.               channel_widget);
  1431.   gtk_object_set_user_data (GTK_OBJECT (channel_widget->channel_preview),
  1432.                 channel_widget);
  1433.   gtk_container_add (GTK_CONTAINER (alignment), channel_widget->channel_preview);
  1434.   gtk_widget_show (channel_widget->channel_preview);
  1435.  
  1436.   /*  The channel name label */
  1437.   switch (channel_widget->type)
  1438.     {
  1439.     case RED_CHANNEL:
  1440.       channel_widget->label = gtk_label_new (_("Red"));
  1441.       break;
  1442.  
  1443.     case GREEN_CHANNEL:
  1444.       channel_widget->label = gtk_label_new (_("Green"));
  1445.       break;
  1446.  
  1447.     case BLUE_CHANNEL:
  1448.       channel_widget->label = gtk_label_new (_("Blue"));
  1449.       break;
  1450.  
  1451.     case GRAY_CHANNEL:
  1452.       channel_widget->label = gtk_label_new (_("Gray"));
  1453.       break;
  1454.  
  1455.     case INDEXED_CHANNEL:
  1456.       channel_widget->label = gtk_label_new (_("Indexed"));
  1457.       break;
  1458.  
  1459.     case AUXILLARY_CHANNEL:
  1460.       channel_widget->label = gtk_label_new (channel_get_name (channel));
  1461.       break;
  1462.     }
  1463.  
  1464.   gtk_box_pack_start (GTK_BOX (hbox), channel_widget->label, FALSE, FALSE, 2);
  1465.   gtk_widget_show (channel_widget->label);
  1466.  
  1467.   if (channel_widget->type == AUXILLARY_CHANNEL)
  1468.     {
  1469.       /*  dnd destination  */
  1470.       gtk_drag_dest_set (list_item,
  1471.              GTK_DEST_DEFAULT_ALL,
  1472.              channel_color_target_table, n_channel_color_targets,
  1473.              GDK_ACTION_MOVE | GDK_ACTION_COPY);
  1474.       gimp_dnd_color_dest_set (list_item,
  1475.                    channel_widget_drop_color,
  1476.                    (gpointer) channel_widget);
  1477.  
  1478.       gtk_signal_connect (GTK_OBJECT (list_item), "drag_leave",
  1479.               GTK_SIGNAL_FUNC (channel_widget_drag_leave_callback),
  1480.               NULL);
  1481.       gtk_signal_connect (GTK_OBJECT (list_item), "drag_motion",
  1482.               GTK_SIGNAL_FUNC (channel_widget_drag_motion_callback),
  1483.               NULL);
  1484.       gtk_signal_connect (GTK_OBJECT (list_item), "drag_drop",
  1485.               GTK_SIGNAL_FUNC (channel_widget_drag_drop_callback),
  1486.               NULL);
  1487.  
  1488.       /*  re-paint the drop indicator after drawing the widget  */
  1489.       gtk_signal_connect_after (GTK_OBJECT (list_item), "draw",
  1490.                 GTK_SIGNAL_FUNC (channel_widget_drag_indicator_callback),
  1491.                 channel_widget);
  1492.  
  1493.       /*  dnd source  */
  1494.       gtk_drag_source_set (list_item,
  1495.                GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
  1496.                channel_target_table, n_channel_targets, 
  1497.                GDK_ACTION_MOVE | GDK_ACTION_COPY);
  1498.  
  1499.       gtk_signal_connect (GTK_OBJECT (list_item), "drag_begin",
  1500.               GTK_SIGNAL_FUNC (channel_widget_drag_begin_callback),
  1501.               NULL);
  1502.  
  1503.       gtk_object_set_data (GTK_OBJECT (list_item), "gimp_channel",
  1504.                (gpointer) channel);
  1505.     }
  1506.   else
  1507.     {
  1508.       /*  dnd source  */
  1509.       gtk_drag_source_set (list_item,
  1510.                GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
  1511.                component_target_table, n_component_targets, 
  1512.                GDK_ACTION_MOVE | GDK_ACTION_COPY);
  1513.  
  1514.       gtk_object_set_data (GTK_OBJECT (list_item), "gimp_component",
  1515.                (gpointer) gimage);
  1516.       gtk_object_set_data (GTK_OBJECT (list_item), "gimp_component_type",
  1517.                (gpointer) channel_widget->type);
  1518.     }
  1519.  
  1520.   gtk_widget_show (hbox);
  1521.   gtk_widget_show (vbox);
  1522.   gtk_widget_show (list_item);
  1523.  
  1524.   gtk_widget_ref (channel_widget->list_item);
  1525.  
  1526.   return channel_widget;
  1527. }
  1528.  
  1529. static gboolean
  1530. channel_widget_drag_motion_callback (GtkWidget      *widget,
  1531.                      GdkDragContext *context,
  1532.                      gint            x,
  1533.                      gint            y,
  1534.                      guint           time)
  1535. {
  1536.   ChannelWidget *dest;
  1537.   gint           dest_index;
  1538.   GtkWidget     *src_widget;
  1539.   ChannelWidget *src = NULL;
  1540.   gint           src_index;
  1541.   gint           difference;
  1542.  
  1543.   GimpDropType  drop_type   = GIMP_DROP_NONE;
  1544.   GdkDragAction drag_action = GDK_ACTION_DEFAULT;
  1545.   gboolean      return_val  = FALSE;
  1546.  
  1547.   dest = (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  1548.  
  1549.   if (dest)
  1550.     {
  1551.       src_widget = gtk_drag_get_source_widget (context);
  1552.  
  1553.       if (src_widget)
  1554.     {
  1555.       src = (ChannelWidget *)
  1556.         gtk_object_get_user_data (GTK_OBJECT (src_widget));
  1557.  
  1558.       if (src &&
  1559.           src->channel == channelsD->active_channel)
  1560.         {
  1561.           src_index  = gimp_image_get_channel_index (channelsD->gimage,
  1562.                              src->channel);
  1563.           dest_index = gimp_image_get_channel_index (channelsD->gimage,
  1564.                              dest->channel);
  1565.  
  1566.           difference = dest_index - src_index;
  1567.  
  1568.           drop_type = ((y < widget->allocation.height / 2) ?
  1569.                GIMP_DROP_ABOVE : GIMP_DROP_BELOW);
  1570.  
  1571.           if (difference < 0 &&
  1572.           drop_type == GIMP_DROP_BELOW)
  1573.         {
  1574.           dest_index++;
  1575.         }
  1576.           else if (difference > 0 &&
  1577.                drop_type == GIMP_DROP_ABOVE)
  1578.         {
  1579.           dest_index--;
  1580.         }
  1581.  
  1582.           if (src_index != dest_index)
  1583.         {
  1584.           drag_action = GDK_ACTION_MOVE;
  1585.           return_val = TRUE;
  1586.         }
  1587.           else
  1588.         {
  1589.           drop_type = GIMP_DROP_NONE;
  1590.         }
  1591.         }
  1592.     }
  1593.  
  1594.       if (!src)
  1595.     {
  1596.       drag_action = GDK_ACTION_COPY;
  1597.       return_val = TRUE;
  1598.       drop_type = GIMP_DROP_NONE;
  1599.     }
  1600.     }
  1601.  
  1602.   gdk_drag_status (context, drag_action, time);
  1603.  
  1604.   if (dest && drop_type != dest->drop_type)
  1605.     {
  1606.       channel_widget_draw_drop_indicator (dest, dest->drop_type);
  1607.       channel_widget_draw_drop_indicator (dest, drop_type);
  1608.       dest->drop_type = drop_type;
  1609.     }
  1610.  
  1611.   return return_val;
  1612. }
  1613.  
  1614. static void
  1615. channel_widget_drag_begin_callback (GtkWidget      *widget,
  1616.                     GdkDragContext *context)
  1617. {
  1618.   ChannelWidget *channel_widget;
  1619.  
  1620.   channel_widget =
  1621.     (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  1622.  
  1623.   gimp_dnd_set_drawable_preview_icon (widget, context,
  1624.                       GIMP_DRAWABLE (channel_widget->channel));
  1625. }
  1626.  
  1627. typedef struct
  1628. {
  1629.   GimpImage *gimage;
  1630.   Channel   *channel;
  1631.   gint       dest_index;
  1632. } ChannelDrop;
  1633.  
  1634. static gint
  1635. channel_widget_idle_drop_channel (gpointer data)
  1636. {
  1637.   ChannelDrop *cd;
  1638.  
  1639.   cd = (ChannelDrop *) data;
  1640.  
  1641.   gimp_image_position_channel (cd->gimage, cd->channel, cd->dest_index);
  1642.   gdisplays_flush ();
  1643.  
  1644.   g_free (cd);
  1645.  
  1646.   return FALSE;
  1647. }
  1648.  
  1649. static gboolean
  1650. channel_widget_drag_drop_callback (GtkWidget      *widget,
  1651.                    GdkDragContext *context,
  1652.                    gint            x,
  1653.                    gint            y,
  1654.                    guint           time)
  1655. {
  1656.   ChannelWidget *dest;
  1657.   gint           dest_index;
  1658.   GtkWidget     *src_widget;
  1659.   ChannelWidget *src;
  1660.   gint           src_index;
  1661.   gint           difference;
  1662.  
  1663.   GimpDropType   drop_type  = GIMP_DROP_NONE;
  1664.   gboolean       return_val = FALSE;
  1665.  
  1666.   dest = (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  1667.  
  1668.   if (dest &&
  1669.       (src_widget = gtk_drag_get_source_widget (context)))
  1670.     {
  1671.       src = (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (src_widget));
  1672.  
  1673.       if (src &&
  1674.           src->channel == channelsD->active_channel)
  1675.         {
  1676.           src_index  = gimp_image_get_channel_index (channelsD->gimage,
  1677.                              src->channel);
  1678.           dest_index = gimp_image_get_channel_index (channelsD->gimage,
  1679.                              dest->channel);
  1680.  
  1681.           difference = dest_index - src_index;
  1682.  
  1683.           drop_type = ((y < widget->allocation.height / 2) ?
  1684.                        GIMP_DROP_ABOVE : GIMP_DROP_BELOW);
  1685.  
  1686.           if (difference < 0 &&
  1687.               drop_type == GIMP_DROP_BELOW)
  1688.             {
  1689.               dest_index++;
  1690.             }
  1691.           else if (difference > 0 &&
  1692.                    drop_type == GIMP_DROP_ABOVE)
  1693.             {
  1694.               dest_index--;
  1695.             }
  1696.  
  1697.           if (src_index != dest_index)
  1698.             {
  1699.               ChannelDrop *cd;
  1700.  
  1701.               cd = g_new (ChannelDrop, 1);
  1702.               cd->gimage     = channelsD->gimage;
  1703.               cd->channel    = src->channel;
  1704.               cd->dest_index = dest_index;
  1705.  
  1706.               /*  let dnd finish it's work before changing the widget tree  */
  1707.               gtk_idle_add ((GtkFunction) channel_widget_idle_drop_channel, cd);
  1708.               return_val = TRUE;
  1709.             }
  1710.         }
  1711.     }
  1712.  
  1713.   if (dest)
  1714.     {
  1715.       if (!return_val)
  1716.     channel_widget_draw_drop_indicator (dest, dest->drop_type);
  1717.  
  1718.       dest->drop_type = GIMP_DROP_NONE;
  1719.     }
  1720.  
  1721.   gtk_drag_finish (context, return_val, FALSE, time);
  1722.  
  1723.   return return_val;
  1724. }
  1725.  
  1726. static void
  1727. channel_widget_drag_leave_callback (GtkWidget      *widget,
  1728.                     GdkDragContext *context,
  1729.                     guint           time)
  1730. {
  1731.   ChannelWidget *channel_widget;
  1732.  
  1733.   channel_widget =
  1734.     (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  1735.  
  1736.   channel_widget->drop_type = GIMP_DROP_NONE;
  1737. }
  1738.  
  1739. static void
  1740. channel_widget_drag_indicator_callback (GtkWidget *widget,
  1741.                     gpointer   data)
  1742. {
  1743.   ChannelWidget *channel_widget;
  1744.  
  1745.   channel_widget =
  1746.     (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  1747.  
  1748.   channel_widget_draw_drop_indicator (channel_widget, channel_widget->drop_type);
  1749. }
  1750.  
  1751. static void
  1752. channel_widget_drop_color (GtkWidget *widget,
  1753.                guchar     r,
  1754.                guchar     g,
  1755.                guchar     b,
  1756.                gpointer   data)
  1757. {
  1758.   ChannelWidget *channel_widget = (ChannelWidget *) data;
  1759.   Channel *channel = channel_widget->channel;
  1760.  
  1761.   if (r != channel->col[0] ||
  1762.       g != channel->col[1] ||
  1763.       b != channel->col[2])
  1764.     {
  1765.       channel->col[0] = r;
  1766.       channel->col[1] = g;
  1767.       channel->col[2] = b;
  1768.  
  1769.       drawable_update (GIMP_DRAWABLE (channel), 0, 0,
  1770.                GIMP_DRAWABLE (channel)->width,
  1771.                GIMP_DRAWABLE (channel)->height);
  1772.       gdisplays_flush ();
  1773.     }
  1774. }
  1775.  
  1776. static void
  1777. channel_widget_draw_drop_indicator (ChannelWidget *channel_widget,
  1778.                     GimpDropType   drop_type)
  1779. {
  1780.   static GdkGC *gc = NULL;
  1781.   gint y = 0;
  1782.  
  1783.   if (!gc)
  1784.     {
  1785.       GdkColor fg, bg;
  1786.  
  1787.       gc = gdk_gc_new (channel_widget->list_item->window);
  1788.  
  1789.       fg.pixel = 0xFFFFFFFF;
  1790.       bg.pixel = 0x00000000;
  1791.  
  1792.       gdk_gc_set_function (gc, GDK_INVERT);
  1793.       gdk_gc_set_foreground (gc, &fg);
  1794.       gdk_gc_set_background (gc, &bg);
  1795.       gdk_gc_set_line_attributes (gc, 5, GDK_LINE_SOLID,
  1796.                                   GDK_CAP_BUTT, GDK_JOIN_MITER);
  1797.     }
  1798.  
  1799.   if (drop_type != GIMP_DROP_NONE)
  1800.     {
  1801.       y = ((drop_type == GIMP_DROP_ABOVE) ?
  1802.            3 : channel_widget->list_item->allocation.height - 4);
  1803.  
  1804.       gdk_draw_line (channel_widget->list_item->window, gc,
  1805.                      2, y, channel_widget->list_item->allocation.width - 3, y);
  1806.     }
  1807. }
  1808.  
  1809. static void
  1810. channel_widget_delete (ChannelWidget *channel_widget)
  1811. {
  1812.   if (channel_widget->channel_pixmap)
  1813.     gdk_pixmap_unref (channel_widget->channel_pixmap);
  1814.  
  1815.   /*  Remove the channel widget from the list  */
  1816.   channelsD->channel_widgets = g_slist_remove (channelsD->channel_widgets,
  1817.                            channel_widget);
  1818.  
  1819.   /*  Release the widget  */
  1820.   gtk_widget_unref (channel_widget->list_item);
  1821.   g_free (channel_widget);
  1822. }
  1823.  
  1824. static void
  1825. channel_widget_select_update (GtkWidget *widget,
  1826.                   gpointer   data)
  1827. {
  1828.   ChannelWidget *channel_widget;
  1829.  
  1830.   if ((channel_widget = (ChannelWidget *) data) == NULL)
  1831.     return;
  1832.  
  1833.   if (suspend_gimage_notify == 0)
  1834.     {
  1835.       if (channel_widget->type == AUXILLARY_CHANNEL)
  1836.     {
  1837.       if (widget->state == GTK_STATE_SELECTED)
  1838.         /*  set the gimage's active channel to be this channel  */
  1839.         gimp_image_set_active_channel (channel_widget->gimage,
  1840.                        channel_widget->channel);
  1841.       else
  1842.         /*  unset the gimage's active channel  */
  1843.         gimp_image_unset_active_channel (channel_widget->gimage);
  1844.  
  1845.       gdisplays_flush ();
  1846.     }
  1847.       else if (channel_widget->type != AUXILLARY_CHANNEL)
  1848.     {
  1849.       if (widget->state == GTK_STATE_SELECTED)
  1850.         gimp_image_set_component_active (channel_widget->gimage,
  1851.                          channel_widget->type, TRUE);
  1852.       else
  1853.         gimp_image_set_component_active (channel_widget->gimage,
  1854.                          channel_widget->type, FALSE);
  1855.     }
  1856.     }
  1857. }
  1858.  
  1859. static gint
  1860. channel_widget_button_events (GtkWidget *widget,
  1861.                   GdkEvent  *event,
  1862.                   gpointer   data)
  1863. {
  1864.   ChannelWidget  *channel_widget;
  1865.   GtkWidget      *event_widget;
  1866.   GdkEventButton *bevent;
  1867.   gint return_val;
  1868.   gint visible;
  1869.   gint width, height;
  1870.  
  1871.   static gboolean button_down = FALSE;
  1872.   static GtkWidget *click_widget = NULL;
  1873.   static gint old_state;
  1874.   static gint exclusive;
  1875.  
  1876.   channel_widget =
  1877.     (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  1878.   return_val = FALSE;
  1879.  
  1880.   switch (channel_widget->type)
  1881.     {
  1882.     case AUXILLARY_CHANNEL:
  1883.       visible = GIMP_DRAWABLE (channel_widget->channel)->visible;
  1884.       width   = GIMP_DRAWABLE (channel_widget->channel)->width;
  1885.       height  = GIMP_DRAWABLE (channel_widget->channel)->height;
  1886.       break;
  1887.     default:
  1888.       visible = gimp_image_get_component_visible (channel_widget->gimage,
  1889.                           channel_widget->type);
  1890.       width   = channel_widget->gimage->width;
  1891.       height  = channel_widget->gimage->height;
  1892.       break;
  1893.     }
  1894.  
  1895.  
  1896.   switch (event->type)
  1897.     {
  1898.     case GDK_EXPOSE:
  1899.       if (widget == channel_widget->eye_widget)
  1900.     channel_widget_eye_redraw (channel_widget);
  1901.       break;
  1902.  
  1903.     case GDK_BUTTON_PRESS:
  1904.       return_val = TRUE;
  1905.       bevent = (GdkEventButton *) event;
  1906.  
  1907.       if (bevent->button == 3)
  1908.     {
  1909.       gtk_menu_popup (GTK_MENU (channelsD->ops_menu),
  1910.               NULL, NULL, NULL, NULL,
  1911.               3, bevent->time);
  1912.       return TRUE;
  1913.     }
  1914.  
  1915.       button_down = TRUE;
  1916.       click_widget = widget;
  1917.       gtk_grab_add (click_widget);
  1918.  
  1919.       if (widget == channel_widget->eye_widget)
  1920.     {
  1921.       old_state = visible;
  1922.  
  1923.       /*  If this was a shift-click, make all/none visible  */
  1924.       if (event->button.state & GDK_SHIFT_MASK)
  1925.         {
  1926.           exclusive = TRUE;
  1927.           channel_widget_exclusive_visible (channel_widget);
  1928.         }
  1929.       else
  1930.         {
  1931.           exclusive = FALSE;
  1932.           if (channel_widget->type == AUXILLARY_CHANNEL)
  1933.         GIMP_DRAWABLE (channel_widget->channel)->visible = !visible;
  1934.           else
  1935.         gimp_image_set_component_visible (channel_widget->gimage,
  1936.                           channel_widget->type,
  1937.                           !visible);
  1938.           channel_widget_eye_redraw (channel_widget);
  1939.         }
  1940.     }
  1941.       break;
  1942.  
  1943.     case GDK_BUTTON_RELEASE:
  1944.       return_val = TRUE;
  1945.  
  1946.       button_down = FALSE;
  1947.       gtk_grab_remove (click_widget);
  1948.  
  1949.       if (widget == channel_widget->eye_widget)
  1950.     {
  1951.       if (exclusive)
  1952.         {
  1953.           gdisplays_update_area (channel_widget->gimage, 0, 0, width, height);
  1954.           gdisplays_flush ();
  1955.         }
  1956.       else if (old_state != visible)
  1957.         {
  1958.           gdisplays_update_area (channel_widget->gimage, 0, 0, width, height);
  1959.           gdisplays_flush ();
  1960.         }
  1961.     }
  1962.       break;
  1963.  
  1964.     case GDK_LEAVE_NOTIFY:
  1965.       event_widget = gtk_get_event_widget (event);
  1966.  
  1967.       if (button_down && (event_widget == click_widget))
  1968.     {
  1969.       /* the user moved the cursor out of the widget before
  1970.              releasing the button -> cancel the button_press */ 
  1971.       button_down = FALSE;
  1972.       
  1973.       if (widget == channel_widget->eye_widget)
  1974.         {
  1975.           if (exclusive)
  1976.         {
  1977.           channel_widget_exclusive_visible (channel_widget);
  1978.         }
  1979.           else
  1980.         {
  1981.           if (channel_widget->type == AUXILLARY_CHANNEL)
  1982.             GIMP_DRAWABLE (channel_widget->channel)->visible = !visible;
  1983.           else
  1984.             gimp_image_set_component_visible (channel_widget->gimage,
  1985.                               channel_widget->type,
  1986.                               !visible);
  1987.           channel_widget_eye_redraw (channel_widget);
  1988.         }
  1989.         }
  1990.     }
  1991.       break;
  1992.  
  1993.     default:
  1994.       break;
  1995.     }
  1996.  
  1997.   return return_val;
  1998. }
  1999.  
  2000. static gint
  2001. channel_widget_preview_events (GtkWidget *widget,
  2002.                    GdkEvent  *event,
  2003.                    gpointer   data)
  2004. {
  2005.   ChannelWidget  *channel_widget;
  2006.   GdkEventExpose *eevent;
  2007.   GdkEventButton *bevent;
  2008.   gboolean valid;
  2009.  
  2010.   valid = FALSE;
  2011.  
  2012.   channel_widget =
  2013.     (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  2014.  
  2015.   switch (event->type)
  2016.     {
  2017.     case GDK_BUTTON_PRESS:
  2018.       bevent = (GdkEventButton *) event;
  2019.  
  2020.       if (bevent->button == 3)
  2021.     {
  2022.       gtk_menu_popup (GTK_MENU (channelsD->ops_menu),
  2023.               NULL, NULL, NULL, NULL,
  2024.               3, bevent->time);
  2025.       return TRUE;
  2026.     }
  2027.       break;
  2028.  
  2029.     case GDK_EXPOSE:
  2030.       if (!preview_size)
  2031.     channel_widget_no_preview_redraw (channel_widget);
  2032.       else
  2033.     {
  2034.       switch (channel_widget->type)
  2035.         {
  2036.         case AUXILLARY_CHANNEL:
  2037.           valid = GIMP_DRAWABLE (channel_widget->channel)->preview_valid;
  2038.           break;
  2039.         default:
  2040.           valid = gimp_image_preview_valid (channel_widget->gimage,
  2041.                         channel_widget->type);
  2042.           break;
  2043.         }
  2044.  
  2045.       if (!valid || !channel_widget->channel_pixmap)
  2046.         {
  2047.           channel_widget_preview_redraw (channel_widget);
  2048.  
  2049.           gdk_draw_pixmap (widget->window,
  2050.                    widget->style->black_gc,
  2051.                    channel_widget->channel_pixmap,
  2052.                    0, 0, 0, 0,
  2053.                    channelsD->image_width,
  2054.                    channelsD->image_height);
  2055.         }
  2056.       else
  2057.         {
  2058.           eevent = (GdkEventExpose *) event;
  2059.  
  2060.           gdk_draw_pixmap (widget->window,
  2061.                    widget->style->black_gc,
  2062.                    channel_widget->channel_pixmap,
  2063.                    eevent->area.x, eevent->area.y,
  2064.                    eevent->area.x, eevent->area.y,
  2065.                    eevent->area.width, eevent->area.height);
  2066.         }
  2067.     }
  2068.       break;
  2069.  
  2070.     default:
  2071.       break;
  2072.     }
  2073.  
  2074.   return FALSE;
  2075. }
  2076.  
  2077. static void
  2078. channel_widget_preview_redraw (ChannelWidget *channel_widget)
  2079. {
  2080.   TempBuf *preview_buf;
  2081.   gint width, height;
  2082.   gint channel;
  2083.  
  2084.   /*  allocate the channel widget pixmap  */
  2085.   if (! channel_widget->channel_pixmap)
  2086.     channel_widget->channel_pixmap =
  2087.       gdk_pixmap_new (channel_widget->channel_preview->window,
  2088.               channelsD->image_width,
  2089.               channelsD->image_height,
  2090.               -1);
  2091.  
  2092.   /*  determine width and height  */
  2093.   switch (channel_widget->type)
  2094.     {
  2095.     case AUXILLARY_CHANNEL:
  2096.       width  = GIMP_DRAWABLE (channel_widget->channel)->width;
  2097.       height = GIMP_DRAWABLE (channel_widget->channel)->height;
  2098.       channel_widget->width  = RINT (channelsD->ratio * width);
  2099.       channel_widget->height = RINT (channelsD->ratio * height);
  2100.  
  2101.       if (channelsD->ratio > 1.0) /*  Preview is scaling up!  */
  2102.     {
  2103.       preview_buf = channel_preview (channel_widget->channel,
  2104.                      channelsD->gimage_width,
  2105.                      channelsD->gimage_height);
  2106.       preview_buf = gimp_preview_scale (preview_buf,
  2107.                         channel_widget->width,
  2108.                         channel_widget->height);
  2109.     }
  2110.       else
  2111.     {
  2112.       preview_buf = channel_preview (channel_widget->channel,
  2113.                      channel_widget->width,
  2114.                      channel_widget->height);
  2115.     }
  2116.       break;
  2117.  
  2118.     default:
  2119.       width  = channel_widget->gimage->width;
  2120.       height = channel_widget->gimage->height;
  2121.       channel_widget->width  = RINT (channelsD->ratio * width);
  2122.       channel_widget->height = RINT (channelsD->ratio * height);
  2123.  
  2124.       if (channelsD->ratio > 1.0) /*  Preview is scaling up!  */
  2125.     {
  2126.       preview_buf = gimp_image_composite_preview (channel_widget->gimage,
  2127.                               channel_widget->type,
  2128.                               width,
  2129.                               height);
  2130.       preview_buf = gimp_preview_scale (preview_buf,
  2131.                         channel_widget->width,
  2132.                         channel_widget->height);
  2133.     }
  2134.       else
  2135.     {
  2136.       preview_buf = gimp_image_composite_preview (channel_widget->gimage,
  2137.                               channel_widget->type,
  2138.                               channel_widget->width,
  2139.                               channel_widget->height);
  2140.     }
  2141.       break;
  2142.     }
  2143.  
  2144.   switch (channel_widget->type)
  2145.     {
  2146.     case RED_CHANNEL:       channel = RED_PIX; break;
  2147.     case GREEN_CHANNEL:     channel = GREEN_PIX; break;
  2148.     case BLUE_CHANNEL:      channel = BLUE_PIX; break;
  2149.     case GRAY_CHANNEL:      channel = GRAY_PIX; break;
  2150.     case INDEXED_CHANNEL:   channel = INDEXED_PIX; break;
  2151.     case AUXILLARY_CHANNEL: channel = -1; break;
  2152.     default:                channel = -1; break;
  2153.     }
  2154.  
  2155.   render_preview (preview_buf,
  2156.           channelsD->preview,
  2157.           channelsD->image_width,
  2158.           channelsD->image_height,
  2159.           channel);
  2160.  
  2161.   gtk_preview_put (GTK_PREVIEW (channelsD->preview),
  2162.            channel_widget->channel_pixmap,
  2163.            channel_widget->channel_preview->style->black_gc,
  2164.            0, 0, 0, 0, 
  2165.            channelsD->image_width, channelsD->image_height);
  2166.  
  2167.   /*  make sure the image has been transfered completely to the pixmap before
  2168.    *  we use it again...
  2169.    */
  2170.   gdk_flush ();
  2171.  
  2172.   if (channelsD->ratio > 1.0)
  2173.     temp_buf_free (preview_buf);
  2174. }
  2175.  
  2176. static void
  2177. channel_widget_no_preview_redraw (ChannelWidget *channel_widget)
  2178. {
  2179.   GdkPixmap  *pixmap;
  2180.   GdkPixmap **pixmap_normal;
  2181.   GdkPixmap **pixmap_selected;
  2182.   GdkPixmap **pixmap_insensitive;
  2183.   GdkColor   *color;
  2184.   GtkWidget  *widget;
  2185.   GtkStateType state;
  2186.   gchar *bits;
  2187.   gint   width, height;
  2188.  
  2189.   state = channel_widget->list_item->state;
  2190.  
  2191.   pixmap_normal      = &channel_pixmap[NORMAL];
  2192.   pixmap_selected    = &channel_pixmap[SELECTED];
  2193.   pixmap_insensitive = &channel_pixmap[INSENSITIVE];
  2194.   widget             = channel_widget->channel_preview;
  2195.   bits               = (gchar *) channel_bits;
  2196.   width              = channel_width;
  2197.   height             = channel_height;
  2198.  
  2199.   if (GTK_WIDGET_IS_SENSITIVE (channel_widget->list_item))
  2200.     {
  2201.       if (state == GTK_STATE_SELECTED)
  2202.     color = &widget->style->bg[GTK_STATE_SELECTED];
  2203.       else
  2204.     color = &widget->style->white;
  2205.     }
  2206.   else
  2207.     color = &widget->style->bg[GTK_STATE_INSENSITIVE];
  2208.  
  2209.   gdk_window_set_background (widget->window, color);
  2210.  
  2211.   if (!*pixmap_normal)
  2212.     {
  2213.       *pixmap_normal =
  2214.     gdk_pixmap_create_from_data (widget->window,
  2215.                      bits, width, height, -1,
  2216.                      &widget->style->fg[GTK_STATE_SELECTED],
  2217.                      &widget->style->bg[GTK_STATE_SELECTED]);
  2218.       *pixmap_selected =
  2219.     gdk_pixmap_create_from_data (widget->window,
  2220.                      bits, width, height, -1,
  2221.                      &widget->style->fg[GTK_STATE_NORMAL],
  2222.                      &widget->style->white);
  2223.       *pixmap_insensitive =
  2224.     gdk_pixmap_create_from_data (widget->window,
  2225.                      bits, width, height, -1,
  2226.                      &widget->style->fg[GTK_STATE_INSENSITIVE],
  2227.                      &widget->style->bg[GTK_STATE_INSENSITIVE]);
  2228.     }
  2229.  
  2230.   if (GTK_WIDGET_IS_SENSITIVE (channel_widget->list_item))
  2231.     {
  2232.       if (state == GTK_STATE_SELECTED)
  2233.     pixmap = *pixmap_selected;
  2234.       else
  2235.     pixmap = *pixmap_normal;
  2236.     }
  2237.   else
  2238.     pixmap = *pixmap_insensitive;
  2239.  
  2240.   gdk_draw_pixmap (widget->window,
  2241.            widget->style->black_gc,
  2242.            pixmap, 0, 0, 0, 0, width, height);
  2243. }
  2244.  
  2245. static void
  2246. channel_widget_eye_redraw (ChannelWidget *channel_widget)
  2247. {
  2248.   GdkPixmap *pixmap;
  2249.   GdkColor  *color;
  2250.   GtkStateType state;
  2251.   gboolean visible;
  2252.  
  2253.   state = channel_widget->list_item->state;
  2254.  
  2255.   if (GTK_WIDGET_IS_SENSITIVE (channel_widget->list_item))
  2256.     {
  2257.       if (state == GTK_STATE_SELECTED)
  2258.     color = &channel_widget->eye_widget->style->bg[GTK_STATE_SELECTED];
  2259.       else
  2260.     color = &channel_widget->eye_widget->style->white;
  2261.     }
  2262.   else
  2263.     color = &channel_widget->eye_widget->style->bg[GTK_STATE_INSENSITIVE];
  2264.  
  2265.   gdk_window_set_background (channel_widget->eye_widget->window, color);
  2266.  
  2267.   switch (channel_widget->type)
  2268.     {
  2269.     case AUXILLARY_CHANNEL:
  2270.       visible = GIMP_DRAWABLE (channel_widget->channel)->visible;
  2271.       break;
  2272.     default:
  2273.       visible = gimp_image_get_component_visible (channel_widget->gimage,
  2274.                           channel_widget->type);
  2275.       break;
  2276.     }
  2277.  
  2278.   if (visible)
  2279.     {
  2280.       if (!eye_pixmap[NORMAL])
  2281.     {
  2282.       eye_pixmap[NORMAL] =
  2283.         gdk_pixmap_create_from_data (channel_widget->eye_widget->window,
  2284.                      (gchar*) eye_bits, eye_width, eye_height, -1,
  2285.                      &channel_widget->eye_widget->style->fg[GTK_STATE_NORMAL],
  2286.                      &channel_widget->eye_widget->style->white);
  2287.       eye_pixmap[SELECTED] =
  2288.         gdk_pixmap_create_from_data (channel_widget->eye_widget->window,
  2289.                      (gchar*) eye_bits, eye_width, eye_height, -1,
  2290.                      &channel_widget->eye_widget->style->fg[GTK_STATE_SELECTED],
  2291.                      &channel_widget->eye_widget->style->bg[GTK_STATE_SELECTED]);
  2292.       eye_pixmap[INSENSITIVE] =
  2293.         gdk_pixmap_create_from_data (channel_widget->eye_widget->window,
  2294.                      (gchar*) eye_bits, eye_width, eye_height, -1,
  2295.                      &channel_widget->eye_widget->style->fg[GTK_STATE_INSENSITIVE],
  2296.                      &channel_widget->eye_widget->style->bg[GTK_STATE_INSENSITIVE]);
  2297.     }
  2298.  
  2299.       if (GTK_WIDGET_IS_SENSITIVE (channel_widget->list_item))
  2300.     {
  2301.       if (state == GTK_STATE_SELECTED)
  2302.         pixmap = eye_pixmap[SELECTED];
  2303.       else
  2304.         pixmap = eye_pixmap[NORMAL];
  2305.     }
  2306.       else
  2307.     pixmap = eye_pixmap[INSENSITIVE];
  2308.  
  2309.       gdk_draw_pixmap (channel_widget->eye_widget->window,
  2310.                channel_widget->eye_widget->style->black_gc,
  2311.                pixmap, 0, 0, 0, 0, eye_width, eye_height);
  2312.     }
  2313.   else
  2314.     {
  2315.       gdk_window_clear (channel_widget->eye_widget->window);
  2316.     }
  2317. }
  2318.  
  2319. static void
  2320. channel_widget_exclusive_visible (ChannelWidget *channel_widget)
  2321. {
  2322.   GSList        *list;
  2323.   ChannelWidget *cw;
  2324.   gboolean       visible = FALSE;
  2325.  
  2326.   if (!channelsD)
  2327.     return;
  2328.  
  2329.   /*  First determine if _any_ other channel widgets are set to visible  */
  2330.   for (list = channelsD->channel_widgets; list;  list = g_slist_next (list))
  2331.     {
  2332.       cw = (ChannelWidget *) list->data;
  2333.  
  2334.       if (cw != channel_widget)
  2335.     {
  2336.       switch (cw->type)
  2337.         {
  2338.         case AUXILLARY_CHANNEL:
  2339.           visible |= GIMP_DRAWABLE (cw->channel)->visible;
  2340.           break;
  2341.         default:
  2342.           visible |= gimp_image_get_component_visible (cw->gimage, cw->type);
  2343.           break;
  2344.         }
  2345.     }
  2346.     }
  2347.  
  2348.   /*  Now, toggle the visibility for all channels except the specified one  */
  2349.   for (list = channelsD->channel_widgets; list;  list = g_slist_next (list))
  2350.     {
  2351.       cw = (ChannelWidget *) list->data;
  2352.  
  2353.       if (cw != channel_widget)
  2354.     switch (cw->type)
  2355.       {
  2356.       case AUXILLARY_CHANNEL:
  2357.         GIMP_DRAWABLE (cw->channel)->visible = !visible;
  2358.         break;
  2359.       default:
  2360.         gimp_image_set_component_visible (cw->gimage, cw->type, !visible);
  2361.         break;
  2362.       }
  2363.       else
  2364.     switch (cw->type)
  2365.       {
  2366.       case AUXILLARY_CHANNEL:
  2367.         GIMP_DRAWABLE (cw->channel)->visible = TRUE;
  2368.         break;
  2369.       default:
  2370.         gimp_image_set_component_visible (cw->gimage, cw->type, TRUE);
  2371.         break;
  2372.       }
  2373.  
  2374.       channel_widget_eye_redraw (cw);
  2375.     }
  2376. }
  2377.  
  2378. static void
  2379. channel_widget_channel_flush (GtkWidget *widget,
  2380.                   gpointer   data)
  2381. {
  2382.   ChannelWidget *channel_widget;
  2383.   gboolean update_preview = FALSE;
  2384.  
  2385.   channel_widget =
  2386.     (ChannelWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  2387.  
  2388.   /*  Set sensitivity  */
  2389.  
  2390.   /*  If there is a floating selection...  */
  2391.   if (channelsD->floating_sel != NULL)
  2392.     {
  2393.       /*  to insensitive if this is an auxillary channel  */
  2394.       if (channel_widget->type == AUXILLARY_CHANNEL)
  2395.     {
  2396.       if (GTK_WIDGET_IS_SENSITIVE (channel_widget->list_item))
  2397.         gtk_widget_set_sensitive (channel_widget->list_item, FALSE);
  2398.     }
  2399.       /*  to sensitive otherwise  */
  2400.       else
  2401.     {
  2402.       if (! GTK_WIDGET_IS_SENSITIVE (channel_widget->list_item))
  2403.         gtk_widget_set_sensitive (channel_widget->list_item, TRUE);
  2404.     }
  2405.     }
  2406.   else
  2407.     {
  2408.       /*  to insensitive if there is an active channel,
  2409.        *  and this is a component channel
  2410.        */
  2411.       if (channel_widget->type != AUXILLARY_CHANNEL &&
  2412.       channelsD->active_channel != NULL)
  2413.     {
  2414.       if (GTK_WIDGET_IS_SENSITIVE (channel_widget->list_item))
  2415.         gtk_widget_set_sensitive (channel_widget->list_item, FALSE);
  2416.     }
  2417.       /*  to sensitive otherwise  */
  2418.       else
  2419.     {
  2420.       if (! GTK_WIDGET_IS_SENSITIVE (channel_widget->list_item))
  2421.         gtk_widget_set_sensitive (channel_widget->list_item, TRUE);
  2422.     }
  2423.     }
  2424.  
  2425.   /*  Set selection  */
  2426.  
  2427.   /*  If this is an auxillary channel  */
  2428.   if (channel_widget->type == AUXILLARY_CHANNEL)
  2429.     {
  2430.       /*  select if this is the active channel  */
  2431.       if (channelsD->active_channel == (channel_widget->channel))
  2432.     channels_dialog_set_channel (channel_widget);
  2433.       /*  unselect if this is not the active channel  */
  2434.       else
  2435.     channels_dialog_unset_channel (channel_widget);
  2436.     }
  2437.   else
  2438.     {
  2439.       /*  If the component is active, select. otherwise, deselect  */
  2440.       if (gimp_image_get_component_active (channel_widget->gimage,
  2441.                        channel_widget->type))
  2442.     channels_dialog_set_channel (channel_widget);
  2443.       else
  2444.     channels_dialog_unset_channel (channel_widget);
  2445.     }
  2446.  
  2447.   switch (channel_widget->type)
  2448.     {
  2449.     case AUXILLARY_CHANNEL:
  2450.       update_preview = !GIMP_DRAWABLE (channel_widget->channel)->preview_valid;
  2451.       break;
  2452.     default:
  2453.       update_preview = !gimp_image_preview_valid (channel_widget->gimage,
  2454.                           channel_widget->type);
  2455.       break;
  2456.     }
  2457.  
  2458.   if (update_preview)
  2459.     gtk_widget_queue_draw (channel_widget->channel_preview);
  2460. }
  2461.  
  2462. /**********************************/
  2463. /*  The new channel query dialog  */
  2464. /**********************************/
  2465.  
  2466. typedef struct _NewChannelOptions NewChannelOptions;
  2467.  
  2468. struct _NewChannelOptions
  2469. {
  2470.   GtkWidget  *query_box;
  2471.   GtkWidget  *name_entry;
  2472.   ColorPanel *color_panel;
  2473.  
  2474.   GimpImage *gimage;
  2475.   gdouble    opacity;
  2476. };
  2477.  
  2478. static gchar  *channel_name     = NULL;
  2479. static guchar  channel_color[3] = { 0, 0, 0 };
  2480.  
  2481. static void
  2482. new_channel_query_ok_callback (GtkWidget *widget,
  2483.                    gpointer   data)
  2484. {
  2485.   NewChannelOptions *options;
  2486.   Channel   *new_channel;
  2487.   GimpImage *gimage;
  2488.   gint i;
  2489.  
  2490.   options = (NewChannelOptions *) data;
  2491.  
  2492.   if (channel_name)
  2493.     g_free (channel_name);
  2494.   channel_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (options->name_entry)));
  2495.  
  2496.   if ((gimage = options->gimage))
  2497.     {
  2498.       new_channel = channel_new (gimage, gimage->width, gimage->height,
  2499.                  channel_name,
  2500.                  (gint) (255 * options->opacity) / 100,
  2501.                  options->color_panel->color);
  2502.       drawable_fill (GIMP_DRAWABLE (new_channel), TRANSPARENT_FILL);
  2503.  
  2504.       for (i = 0; i < 3; i++)
  2505.     channel_color[i] = options->color_panel->color[i];
  2506.  
  2507.       gimp_image_add_channel (gimage, new_channel, -1);
  2508.       gdisplays_flush ();
  2509.     }
  2510.  
  2511.   gtk_widget_destroy (options->query_box);
  2512. }
  2513.  
  2514. static void
  2515. channels_dialog_new_channel_query (GimpImage* gimage)
  2516. {
  2517.   NewChannelOptions *options;
  2518.   GtkWidget *hbox;
  2519.   GtkWidget *vbox;
  2520.   GtkWidget *table;
  2521.   GtkWidget *label;
  2522.   GtkWidget *opacity_scale;
  2523.   GtkObject *opacity_scale_data;
  2524.  
  2525.   /*  the new options structure  */
  2526.   options = g_new (NewChannelOptions, 1);
  2527.   options->gimage      = gimage;
  2528.   options->opacity     = 50.0;
  2529.   options->color_panel = color_panel_new (channel_color, 48, 64);
  2530.  
  2531.   /*  The dialog  */
  2532.   options->query_box =
  2533.     gimp_dialog_new (_("New Channel Options"), "new_channel_options",
  2534.              gimp_standard_help_func,
  2535.              "dialogs/channels/new_channel.html",
  2536.              GTK_WIN_POS_MOUSE,
  2537.              FALSE, TRUE, FALSE,
  2538.  
  2539.              _("OK"), new_channel_query_ok_callback,
  2540.              options, NULL, NULL, TRUE, FALSE,
  2541.              _("Cancel"), gtk_widget_destroy,
  2542.              NULL, 1, NULL, FALSE, TRUE,
  2543.  
  2544.              NULL);
  2545.  
  2546.   gtk_signal_connect_object (GTK_OBJECT (options->query_box), "destroy",
  2547.                  GTK_SIGNAL_FUNC (g_free),
  2548.                  (GtkObject *) options);
  2549.  
  2550.   /*  The main hbox  */
  2551.   hbox = gtk_hbox_new (FALSE, 2);
  2552.   gtk_container_set_border_width (GTK_CONTAINER (hbox), 4);
  2553.   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (options->query_box)->vbox),
  2554.              hbox);
  2555.  
  2556.   /*  The vbox  */
  2557.   vbox = gtk_vbox_new (FALSE, 2);
  2558.   gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
  2559.  
  2560.   /*  The table  */
  2561.   table = gtk_table_new (2, 3, FALSE);
  2562.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  2563.   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  2564.  
  2565.   /*  The name entry hbox, label and entry  */
  2566.   label = gtk_label_new (_("Channel name:"));
  2567.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
  2568.   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
  2569.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  2570.   gtk_widget_show (label);
  2571.  
  2572.   options->name_entry = gtk_entry_new ();
  2573.   gtk_widget_set_usize (options->name_entry, 150, 0);
  2574.   gtk_table_attach_defaults (GTK_TABLE (table), options->name_entry,
  2575.                  1, 2, 0, 1);
  2576.   gtk_entry_set_text (GTK_ENTRY (options->name_entry),
  2577.               (channel_name ? channel_name : _("New Channel")));
  2578.   gtk_widget_show (options->name_entry);
  2579.  
  2580.   /*  The opacity scale  */
  2581.   label = gtk_label_new (_("Fill Opacity:"));
  2582.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
  2583.   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
  2584.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  2585.   gtk_widget_show (label);
  2586.  
  2587.   opacity_scale_data =
  2588.     gtk_adjustment_new (options->opacity, 0.0, 100.0, 1.0, 1.0, 0.0);
  2589.   opacity_scale = gtk_hscale_new (GTK_ADJUSTMENT (opacity_scale_data));
  2590.   gtk_table_attach_defaults (GTK_TABLE (table), opacity_scale, 1, 2, 1, 2);
  2591.   gtk_scale_set_value_pos (GTK_SCALE (opacity_scale), GTK_POS_TOP);
  2592.   gtk_range_set_update_policy (GTK_RANGE (opacity_scale), GTK_UPDATE_DELAYED);
  2593.   gtk_signal_connect (GTK_OBJECT (opacity_scale_data), "value_changed",
  2594.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  2595.               &options->opacity);
  2596.   gtk_widget_show (opacity_scale);
  2597.  
  2598.   /*  The color panel  */
  2599.   gtk_box_pack_start (GTK_BOX (hbox), options->color_panel->color_panel_widget,
  2600.               TRUE, TRUE, 0);
  2601.   gtk_widget_show (options->color_panel->color_panel_widget);
  2602.  
  2603.   gtk_widget_show (table);
  2604.   gtk_widget_show (vbox);
  2605.   gtk_widget_show (hbox);
  2606.   gtk_widget_show (options->query_box);
  2607. }
  2608.  
  2609. /****************************************/
  2610. /*  The edit channel attributes dialog  */
  2611. /****************************************/
  2612.  
  2613. typedef struct _EditChannelOptions EditChannelOptions;
  2614.  
  2615. struct _EditChannelOptions
  2616. {
  2617.   GtkWidget *query_box;
  2618.   GtkWidget *name_entry;
  2619.  
  2620.   ChannelWidget *channel_widget;
  2621.   GimpImage     *gimage;
  2622.   ColorPanel    *color_panel;
  2623.   gdouble        opacity;
  2624. };
  2625.  
  2626. static void
  2627. edit_channel_query_ok_callback (GtkWidget *widget,
  2628.                 gpointer   data)
  2629. {
  2630.   EditChannelOptions *options;
  2631.   Channel *channel;
  2632.   gint opacity;
  2633.   gint update = FALSE;
  2634.   gint i;
  2635.  
  2636.   options = (EditChannelOptions *) data;
  2637.   channel = options->channel_widget->channel;
  2638.   opacity = (gint) (255 * options->opacity) / 100;
  2639.  
  2640.   if (options->gimage)
  2641.     {
  2642.       /*  Set the new channel name  */
  2643.       channel_set_name (channel,
  2644.             gtk_entry_get_text (GTK_ENTRY (options->name_entry)));
  2645.       gtk_label_set_text (GTK_LABEL (options->channel_widget->label),
  2646.               channel_get_name (channel));
  2647.  
  2648.       if (channel->opacity != opacity)
  2649.     {
  2650.       channel->opacity = opacity;
  2651.       update = TRUE;
  2652.     }
  2653.       for (i = 0; i < 3; i++)
  2654.     if (options->color_panel->color[i] != channel->col[i])
  2655.       {
  2656.         channel->col[i] = options->color_panel->color[i];
  2657.         update = TRUE;
  2658.       }
  2659.  
  2660.       if (update)
  2661.     {
  2662.       drawable_update (GIMP_DRAWABLE (channel), 0, 0,
  2663.                GIMP_DRAWABLE (channel)->width,
  2664.                GIMP_DRAWABLE (channel)->height);
  2665.       gdisplays_flush ();
  2666.     }
  2667.     }
  2668.  
  2669.   gtk_widget_destroy (options->query_box);
  2670. }
  2671.  
  2672. static void
  2673. channels_dialog_edit_channel_query (ChannelWidget *channel_widget)
  2674. {
  2675.   EditChannelOptions *options;
  2676.   GtkWidget *hbox;
  2677.   GtkWidget *vbox;
  2678.   GtkWidget *table;
  2679.   GtkWidget *label;
  2680.   GtkWidget *opacity_scale;
  2681.   GtkObject *opacity_scale_data;
  2682.   gint i;
  2683.  
  2684.   /*  the new options structure  */
  2685.   options = g_new (EditChannelOptions, 1);
  2686.   options->channel_widget = channel_widget;
  2687.   options->gimage         = channel_widget->gimage;
  2688.   options->opacity        = (gdouble) channel_widget->channel->opacity / 2.55;
  2689.   for (i = 0; i < 3; i++)
  2690.     channel_color[i] = channel_widget->channel->col[i];
  2691.  
  2692.   options->color_panel = color_panel_new (channel_color, 48, 64);
  2693.  
  2694.   /*  The dialog  */
  2695.   options->query_box =
  2696.     gimp_dialog_new (_("Edit Channel Attributes"), "edit_channel_attributes",
  2697.              gimp_standard_help_func,
  2698.              "dialogs/channels/edit_channel_attributes.html",
  2699.              GTK_WIN_POS_MOUSE,
  2700.              FALSE, TRUE, FALSE,
  2701.  
  2702.              _("OK"), edit_channel_query_ok_callback,
  2703.              options, NULL, NULL, TRUE, FALSE,
  2704.              _("Cancel"), gtk_widget_destroy,
  2705.              NULL, 1, NULL, FALSE, TRUE,
  2706.  
  2707.              NULL);
  2708.  
  2709.   gtk_signal_connect_object (GTK_OBJECT (options->query_box), "destroy",
  2710.                  GTK_SIGNAL_FUNC (g_free),
  2711.                  (GtkObject *) options);
  2712.  
  2713.   /*  The main hbox  */
  2714.   hbox = gtk_hbox_new (FALSE, 2);
  2715.   gtk_container_set_border_width (GTK_CONTAINER (hbox), 4);
  2716.   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (options->query_box)->vbox),
  2717.              hbox);
  2718.  
  2719.   /*  The vbox  */
  2720.   vbox = gtk_vbox_new (FALSE, 2);
  2721.   gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
  2722.  
  2723.   /*  The table  */
  2724.   table = gtk_table_new (2, 3, FALSE);
  2725.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  2726.   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  2727.  
  2728.   /*  The name entry  */
  2729.   label = gtk_label_new (_("Channel name:"));
  2730.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
  2731.   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
  2732.             GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  2733.   gtk_widget_show (label);
  2734.  
  2735.   options->name_entry = gtk_entry_new ();
  2736.   gtk_widget_set_usize (options->name_entry, 150, 0);
  2737.   gtk_table_attach_defaults (GTK_TABLE (table), options->name_entry,
  2738.                  1, 2, 0, 1);
  2739.   gtk_entry_set_text (GTK_ENTRY (options->name_entry),
  2740.               channel_get_name (channel_widget->channel));
  2741.   gtk_widget_show (options->name_entry);
  2742.  
  2743.   /*  The opacity scale  */
  2744.   label = gtk_label_new (_("Fill Opacity:"));
  2745.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
  2746.   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
  2747.             GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  2748.   gtk_widget_show (label);
  2749.  
  2750.   opacity_scale_data =
  2751.     gtk_adjustment_new (options->opacity, 0.0, 100.0, 1.0, 1.0, 0.0);
  2752.   opacity_scale = gtk_hscale_new (GTK_ADJUSTMENT (opacity_scale_data));
  2753.   gtk_table_attach_defaults (GTK_TABLE (table), opacity_scale, 1, 2, 1, 2);
  2754.   gtk_scale_set_value_pos (GTK_SCALE (opacity_scale), GTK_POS_TOP);
  2755.   gtk_signal_connect (GTK_OBJECT (opacity_scale_data), "value_changed",
  2756.               GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  2757.               &options->opacity);
  2758.   gtk_widget_show (opacity_scale);
  2759.  
  2760.   /*  The color panel  */
  2761.   gtk_box_pack_start (GTK_BOX (hbox), options->color_panel->color_panel_widget,
  2762.               TRUE, TRUE, 0);
  2763.   gtk_widget_show (options->color_panel->color_panel_widget);
  2764.  
  2765.   gtk_widget_show (table);
  2766.   gtk_widget_show (vbox);
  2767.   gtk_widget_show (hbox);
  2768.   gtk_widget_show (options->query_box);
  2769. }
  2770.