home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / app / layers_dialog.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-12-17  |  116.4 KB  |  4,133 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 "colormaps.h"
  28. #include "drawable.h"
  29. #include "floating_sel.h"
  30. #include "gdisplay.h"
  31. #include "gimage.h"
  32. #include "gimage_mask.h"
  33. #include "gimpdnd.h"
  34. #include "gimprc.h"
  35. #include "gimpui.h"
  36. #include "image_render.h"
  37. #include "layers_dialog.h"
  38. #include "layers_dialogP.h"
  39. #include "lc_dialogP.h"
  40. #include "menus.h"
  41. #include "ops_buttons.h"
  42. #include "resize.h"
  43. #include "undo.h"
  44.  
  45. #include "libgimp/gimplimits.h"
  46. #include "libgimp/gimpmath.h"
  47. #include "libgimp/gimpsizeentry.h"
  48.  
  49. #include "libgimp/gimpintl.h"
  50.  
  51. #include "pixmaps/eye.xbm"
  52. #include "pixmaps/linked.xbm"
  53. #include "pixmaps/layer.xbm"
  54. #include "pixmaps/mask.xbm"
  55.  
  56. #include "pixmaps/new.xpm"
  57. #include "pixmaps/raise.xpm"
  58. #include "pixmaps/lower.xpm"
  59. #include "pixmaps/duplicate.xpm"
  60. #include "pixmaps/delete.xpm"
  61. #include "pixmaps/anchor.xpm"
  62.  
  63. #include "layer_pvt.h"
  64.  
  65.  
  66. #define LAYER_PREVIEW 0
  67. #define MASK_PREVIEW  1
  68. #define FS_PREVIEW    2
  69.  
  70. typedef struct _LayersDialog LayersDialog;
  71.  
  72. struct _LayersDialog
  73. {
  74.   GtkWidget     *vbox; 
  75.   GtkWidget     *mode_option_menu;
  76.   GtkWidget     *layer_list;
  77.   GtkWidget     *scrolled_win;
  78.   GtkWidget     *preserve_trans;
  79.   GtkWidget     *mode_box;
  80.   GtkWidget     *opacity_box;
  81.   GtkWidget     *ops_menu;
  82.   GtkAccelGroup *accel_group;
  83.   GtkAdjustment *opacity_data;
  84.   GdkGC         *red_gc;     /*  for non-applied layer masks  */
  85.   GdkGC         *green_gc;   /*  for visible layer masks      */
  86.   GtkWidget     *layer_preview;
  87.  
  88.   /*  state information  */
  89.   GimpImage *gimage;
  90.   gint       image_width, image_height;
  91.   gint       gimage_width, gimage_height;
  92.   gdouble    ratio;
  93.  
  94.   Layer     *active_layer;
  95.   Channel   *active_channel;
  96.   Layer     *floating_sel;
  97.   GSList    *layer_widgets;
  98. };
  99.  
  100. typedef struct _LayerWidget LayerWidget;
  101.  
  102. struct _LayerWidget
  103. {
  104.   GtkWidget *list_item;
  105.  
  106.   GtkWidget *eye_widget;
  107.   GtkWidget *linked_widget;
  108.   GtkWidget *clip_widget;
  109.   GtkWidget *layer_preview;
  110.   GtkWidget *mask_preview;
  111.   GtkWidget *label;
  112.  
  113.   GdkPixmap *layer_pixmap;
  114.   GdkPixmap *mask_pixmap;
  115.  
  116.  /*  state information  */
  117.   GimpImage *gimage;
  118.   Layer     *layer;
  119.   gint       width, height;
  120.  
  121.   gint       active_preview;
  122.   gboolean   layer_mask;
  123.   gboolean   apply_mask;
  124.   gboolean   edit_mask;
  125.   gboolean   show_mask;
  126.   gboolean   visited;
  127.  
  128.   GimpDropType drop_type;
  129.  
  130.   gboolean   layer_pixmap_valid;
  131. };
  132.  
  133. /*  layers dialog widget routines  */
  134. static void layers_dialog_preview_extents       (void);
  135. static void layers_dialog_set_menu_sensitivity  (void);
  136. static void layers_dialog_scroll_index          (gint            index);
  137. static void layers_dialog_set_active_layer      (Layer          *layer);
  138. static void layers_dialog_unset_layer           (Layer          *layer);
  139. static void layers_dialog_position_layer        (Layer          *layer,
  140.                          gint            new_index);
  141. static void layers_dialog_add_layer             (Layer          *layer);
  142. static void layers_dialog_remove_layer          (Layer          *layer);
  143. static void layers_dialog_add_layer_mask        (Layer          *layer);
  144. static void layers_dialog_remove_layer_mask     (Layer          *layer);
  145.  
  146. static void paint_mode_menu_callback            (GtkWidget      *widget,
  147.                          gpointer        data);
  148. static void opacity_scale_update                (GtkAdjustment  *widget,
  149.                          gpointer        data);
  150. static void preserve_trans_update               (GtkWidget      *widget,
  151.                          gpointer        data);
  152. static gint layer_list_events                   (GtkWidget      *widget,
  153.                          GdkEvent       *event,
  154.                          gpointer        data);
  155.  
  156. /*  for (un)installing the menu accelarators  */
  157. static void layers_dialog_map_callback          (GtkWidget      *widget,
  158.                          gpointer        data);
  159. static void layers_dialog_unmap_callback        (GtkWidget      *widget,
  160.                          gpointer        data);
  161.  
  162. /*  ops buttons dnd callbacks  */
  163. static gboolean layers_dialog_drag_new_layer_callback
  164.                                                 (GtkWidget      *widget,
  165.                          GdkDragContext *context,
  166.                          gint            x,
  167.                          gint            y,
  168.                          guint           time);
  169. static gboolean layers_dialog_drag_duplicate_layer_callback
  170.                                                 (GtkWidget      *widget,
  171.                          GdkDragContext *context,
  172.                          gint            x,
  173.                          gint            y,
  174.                          guint           time);
  175. static gboolean layers_dialog_drag_trashcan_callback
  176.                                                 (GtkWidget      *widget,
  177.                          GdkDragContext *context,
  178.                          gint            x,
  179.                          gint            y,
  180.                          guint           time);
  181.  
  182. /*  layer widget function prototypes  */
  183. static LayerWidget * layer_widget_get_ID        (Layer          *layer);
  184. static LayerWidget * layer_widget_create        (GimpImage      *gimage,
  185.                              Layer          *layer);
  186.  
  187. static gboolean layer_widget_drag_motion_callback
  188.                                                 (GtkWidget      *widget,
  189.                          GdkDragContext *context,
  190.                          gint            x,
  191.                          gint            y,
  192.                          guint           time);
  193. static gboolean layer_widget_drag_drop_callback (GtkWidget      *widget,
  194.                          GdkDragContext *context,
  195.                          gint            x,
  196.                          gint            y,
  197.                          guint           time);
  198. static void layer_widget_drag_begin_callback    (GtkWidget      *widget,
  199.                          GdkDragContext *context);
  200. static void layer_mask_drag_begin_callback      (GtkWidget      *widget,
  201.                          GdkDragContext *context);
  202. static void layer_widget_drag_leave_callback    (GtkWidget      *widget,
  203.                          GdkDragContext *context,
  204.                            guint           time);
  205. static void layer_widget_drag_indicator_callback(GtkWidget      *widget,
  206.                          gpointer        data);
  207.  
  208. static void layer_widget_draw_drop_indicator    (LayerWidget    *layer_widget,
  209.                          GimpDropType    drop_type);
  210. static void layer_widget_delete                 (LayerWidget    *layer_widget);
  211. static void layer_widget_select_update          (GtkWidget      *widget,
  212.                          gpointer        data);
  213. static gint layer_widget_button_events          (GtkWidget      *widget,
  214.                          GdkEvent       *event,
  215.                          gpointer        data);
  216. static gint layer_widget_preview_events         (GtkWidget      *widget,
  217.                          GdkEvent       *event,
  218.                          gpointer        data);
  219. static void layer_widget_boundary_redraw        (LayerWidget    *layer_widget,
  220.                          gint            preview_type);
  221. static void layer_widget_preview_redraw         (LayerWidget    *layer_widget,
  222.                          gint            preview_type);
  223. static void layer_widget_no_preview_redraw      (LayerWidget    *layer_widget,
  224.                          gint            preview_type);
  225. static void layer_widget_eye_redraw             (LayerWidget    *layer_widget);
  226. static void layer_widget_linked_redraw          (LayerWidget    *layer_widget);
  227. static void layer_widget_clip_redraw            (LayerWidget    *layer_widget);
  228. static void layer_widget_exclusive_visible      (LayerWidget    *layer_widget);
  229. static void layer_widget_layer_flush            (GtkWidget      *widget,
  230.                          gpointer        data);
  231.  
  232. /*  assorted query dialogs  */
  233. static void layers_dialog_new_layer_query       (GimpImage      *gimage);
  234. static void layers_dialog_edit_layer_query      (LayerWidget    *layer_widget);
  235. static void layers_dialog_add_mask_query        (Layer          *layer);
  236. static void layers_dialog_scale_layer_query     (GimpImage      *gimage,
  237.                          Layer          *layer);
  238. static void layers_dialog_resize_layer_query    (GimpImage      *gimage,
  239.                          Layer          *layer);
  240. void        layers_dialog_layer_merge_query     (GimpImage      *gimage,
  241.                          gboolean        merge_visible);
  242.  
  243. /****************/
  244. /*  Local data  */
  245. /****************/
  246.  
  247. static LayersDialog *layersD = NULL;
  248.  
  249. static GdkPixmap *eye_pixmap[]    = { NULL, NULL, NULL };
  250. static GdkPixmap *linked_pixmap[] = { NULL, NULL, NULL };
  251. static GdkPixmap *layer_pixmap[]  = { NULL, NULL, NULL };
  252. static GdkPixmap *mask_pixmap[]   = { NULL, NULL, NULL };
  253.  
  254. static gint suspend_gimage_notify = 0;
  255.  
  256. /*  the ops buttons  */
  257. static GtkSignalFunc raise_layers_ext_callbacks[] = 
  258. {
  259.   layers_dialog_raise_layer_to_top_callback, NULL, NULL, NULL
  260. };
  261.  
  262. static GtkSignalFunc lower_layers_ext_callbacks[] = 
  263. {
  264.   layers_dialog_lower_layer_to_bottom_callback, NULL, NULL, NULL
  265. };
  266.  
  267. static OpsButton layers_ops_buttons[] =
  268. {
  269.   { new_xpm, layers_dialog_new_layer_callback, NULL,
  270.     N_("New Layer"),
  271.     "layers/dialogs/new_layer.html",
  272.     NULL, 0 },
  273.   { raise_xpm, layers_dialog_raise_layer_callback, raise_layers_ext_callbacks,
  274.     N_("Raise Layer    \n"
  275.        "<Shift> To Top"),
  276.     "layers/stack/stack.html#raise_layer",
  277.     NULL, 0 },
  278.   { lower_xpm, layers_dialog_lower_layer_callback, lower_layers_ext_callbacks,
  279.     N_("Lower Layer       \n"
  280.        "<Shift> To Bottom"),
  281.     "layers/stack/stack.html#lower_layer",
  282.     NULL, 0 },
  283.   { duplicate_xpm, layers_dialog_duplicate_layer_callback, NULL,
  284.     N_("Duplicate Layer"),
  285.     "layers/duplicate_layer.html",
  286.     NULL, 0 },
  287.   { anchor_xpm, layers_dialog_anchor_layer_callback, NULL,
  288.     N_("Anchor Layer"),
  289.     "layers/anchor_layer.html",
  290.     NULL, 0 },
  291.   { delete_xpm, layers_dialog_delete_layer_callback, NULL,
  292.     N_("Delete Layer"),
  293.     "layers/delete_layer.html",
  294.     NULL, 0 },
  295.   { NULL, NULL, NULL, NULL, NULL, NULL, 0 }
  296. };
  297.  
  298. /*  dnd structures  */
  299. static GtkTargetEntry layer_target_table[] =
  300. {
  301.   GIMP_TARGET_LAYER
  302. };
  303. static guint n_layer_targets = (sizeof (layer_target_table) /
  304.                 sizeof (layer_target_table[0]));
  305.  
  306. static GtkTargetEntry layer_mask_target_table[] =
  307. {
  308.   GIMP_TARGET_LAYER_MASK
  309. };
  310. static guint n_layer_mask_targets = (sizeof (layer_mask_target_table) /
  311.                      sizeof (layer_mask_target_table[0]));
  312.  
  313. static GtkTargetEntry trashcan_target_table[] =
  314. {
  315.   GIMP_TARGET_LAYER,
  316.   GIMP_TARGET_LAYER_MASK
  317. };
  318. static guint n_trashcan_targets = (sizeof (trashcan_target_table) /
  319.                    sizeof (trashcan_target_table[0]));
  320.  
  321.  
  322. /************************************/
  323. /*  Public layers dialog functions  */
  324. /************************************/
  325.  
  326. GtkWidget *
  327. layers_dialog_create (void)
  328. {
  329.   GtkWidget *vbox;
  330.   GtkWidget *util_box;
  331.   GtkWidget *button_box;
  332.   GtkWidget *label;
  333.   GtkWidget *slider;
  334.  
  335.   if (layersD)
  336.     return layersD->vbox;
  337.  
  338.   layersD = g_new (LayersDialog, 1);
  339.   layersD->layer_preview  = NULL;
  340.   layersD->gimage         = NULL;
  341.   layersD->active_layer   = NULL;
  342.   layersD->active_channel = NULL;
  343.   layersD->floating_sel   = NULL;
  344.   layersD->layer_widgets  = NULL;
  345.   layersD->green_gc       = NULL;
  346.   layersD->red_gc         = NULL;
  347.  
  348.   if (preview_size)
  349.     {
  350.       layersD->layer_preview = gtk_preview_new (GTK_PREVIEW_COLOR);
  351.       gtk_preview_size (GTK_PREVIEW (layersD->layer_preview),
  352.             preview_size, preview_size);
  353.     }
  354.  
  355.   /*  The main vbox  */
  356.   layersD->vbox = gtk_event_box_new ();
  357.  
  358.   gimp_help_set_help_data (layersD->vbox, NULL, "dialogs/layers/layers.html");
  359.  
  360.   vbox = gtk_vbox_new (FALSE, 1);
  361.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
  362.   gtk_container_add (GTK_CONTAINER (layersD->vbox), vbox);
  363.  
  364.   /*  The layers commands pulldown menu  */
  365.   menus_get_layers_menu (&layersD->ops_menu, &layersD->accel_group);
  366.  
  367.   /*  The Mode option menu, and the preserve transparency  */
  368.   layersD->mode_box = util_box = gtk_hbox_new (FALSE, 1);
  369.   gtk_box_pack_start (GTK_BOX (vbox), util_box, FALSE, FALSE, 0);
  370.  
  371.   label = gtk_label_new (_("Mode:"));
  372.   gtk_box_pack_start (GTK_BOX (util_box), label, FALSE, FALSE, 2);
  373.   gtk_widget_show (label);
  374.  
  375.   layersD->mode_option_menu = 
  376.     gimp_option_menu_new2 (FALSE, paint_mode_menu_callback,
  377.                NULL, (gpointer) NORMAL_MODE,
  378.                _("Normal"),          (gpointer) NORMAL_MODE,       NULL,
  379.                _("Dissolve"),        (gpointer) DISSOLVE_MODE,     NULL,
  380.                _("Multiply (Burn)"), (gpointer) MULTIPLY_MODE,     NULL,
  381.                _("Divide (Dodge)"),  (gpointer) DIVIDE_MODE,       NULL,
  382.                _("Screen"),          (gpointer) SCREEN_MODE,       NULL,
  383.                _("Overlay"),         (gpointer) OVERLAY_MODE,      NULL,
  384.                _("Difference"),      (gpointer) DIFFERENCE_MODE,   NULL,
  385.                _("Addition"),        (gpointer) ADDITION_MODE,     NULL,
  386.                _("Subtract"),        (gpointer) SUBTRACT_MODE,     NULL,
  387.                _("Darken Only"),     (gpointer) DARKEN_ONLY_MODE,  NULL,
  388.                _("Lighten Only"),    (gpointer) LIGHTEN_ONLY_MODE, NULL,
  389.                _("Hue"),             (gpointer) HUE_MODE,          NULL,
  390.                _("Saturation"),      (gpointer) SATURATION_MODE,   NULL,
  391.                _("Color"),           (gpointer) COLOR_MODE,        NULL,
  392.                _("Value"),           (gpointer) VALUE_MODE,        NULL,
  393.                NULL);
  394.   
  395.   gtk_box_pack_start (GTK_BOX (util_box), layersD->mode_option_menu,
  396.               FALSE, FALSE, 2);
  397.   gtk_widget_show (layersD->mode_option_menu);
  398.  
  399.   gimp_help_set_help_data (layersD->mode_option_menu, 
  400.                NULL, "#paint_mode_menu");
  401.  
  402.   layersD->preserve_trans =
  403.     gtk_check_button_new_with_label (_("Keep Trans."));
  404.   gtk_box_pack_start (GTK_BOX (util_box), layersD->preserve_trans,
  405.               FALSE, FALSE, 2);
  406.   gtk_signal_connect (GTK_OBJECT (layersD->preserve_trans), "toggled",
  407.               (GtkSignalFunc) preserve_trans_update,
  408.               layersD);
  409.   gtk_widget_show (layersD->preserve_trans);
  410.  
  411.   gimp_help_set_help_data (layersD->preserve_trans,
  412.                _("Keep Transparency"), "#keep_trans_button");
  413.  
  414.   gtk_widget_show (util_box);
  415.  
  416.   /*  Opacity scale  */
  417.   layersD->opacity_box = util_box = gtk_hbox_new (FALSE, 1);
  418.   gtk_box_pack_start (GTK_BOX (vbox), util_box, FALSE, FALSE, 0);
  419.  
  420.   label = gtk_label_new (_("Opacity:"));
  421.   gtk_box_pack_start (GTK_BOX (util_box), label, FALSE, FALSE, 2);
  422.   gtk_widget_show (label);
  423.  
  424.   layersD->opacity_data =
  425.     GTK_ADJUSTMENT (gtk_adjustment_new (100.0, 0.0, 100.0, 1.0, 1.0, 0.0));
  426.   slider = gtk_hscale_new (layersD->opacity_data);
  427.   gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_CONTINUOUS);
  428.   gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_RIGHT);
  429.   gtk_box_pack_start (GTK_BOX (util_box), slider, TRUE, TRUE, 0);
  430.   gtk_signal_connect (GTK_OBJECT (layersD->opacity_data), "value_changed",
  431.               (GtkSignalFunc) opacity_scale_update,
  432.               layersD);
  433.   gtk_widget_show (slider);
  434.  
  435.   gimp_help_set_help_data (slider, NULL, "#opacity_scale");
  436.  
  437.   gtk_widget_show (util_box);
  438.  
  439.   /*  The layers listbox  */
  440.   layersD->scrolled_win = gtk_scrolled_window_new (NULL, NULL);
  441.   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (layersD->scrolled_win), 
  442.                   GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
  443.   gtk_widget_set_usize (layersD->scrolled_win, LIST_WIDTH, LIST_HEIGHT);
  444.   gtk_box_pack_start (GTK_BOX (vbox), layersD->scrolled_win, TRUE, TRUE, 2);
  445.  
  446.   layersD->layer_list = gtk_list_new ();
  447.   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (layersD->scrolled_win),
  448.                      layersD->layer_list);
  449.   gtk_list_set_selection_mode (GTK_LIST (layersD->layer_list),
  450.                    GTK_SELECTION_BROWSE);
  451.   gtk_signal_connect (GTK_OBJECT (layersD->layer_list), "event",
  452.               (GtkSignalFunc) layer_list_events, 
  453.               layersD);
  454.   gtk_container_set_focus_vadjustment (GTK_CONTAINER (layersD->layer_list),
  455.                        gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (layersD->scrolled_win)));
  456.   GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (layersD->scrolled_win)->vscrollbar,
  457.               GTK_CAN_FOCUS);
  458.       
  459.   gtk_widget_show (layersD->layer_list);
  460.   gtk_widget_show (layersD->scrolled_win);
  461.  
  462.   /*  The ops buttons  */
  463.   button_box = ops_button_box_new (layers_ops_buttons, OPS_BUTTON_NORMAL);
  464.   gtk_box_pack_start (GTK_BOX (vbox), button_box, FALSE, FALSE, 2);
  465.   gtk_widget_show (button_box);
  466.  
  467.   /*  Drop to new  */
  468.   gtk_drag_dest_set (layers_ops_buttons[0].widget,
  469.              GTK_DEST_DEFAULT_ALL,
  470.                      layer_target_table, n_layer_targets,
  471.                      GDK_ACTION_COPY);
  472.   gtk_signal_connect (GTK_OBJECT (layers_ops_buttons[0].widget), "drag_drop",
  473.                       GTK_SIGNAL_FUNC (layers_dialog_drag_new_layer_callback),
  474.               NULL);
  475.  
  476.   /*  Drop to duplicate  */
  477.   gtk_drag_dest_set (layers_ops_buttons[3].widget,
  478.              GTK_DEST_DEFAULT_ALL,
  479.                      layer_target_table, n_layer_targets,
  480.                      GDK_ACTION_COPY);
  481.   gtk_signal_connect (GTK_OBJECT (layers_ops_buttons[3].widget), "drag_drop",
  482.                       GTK_SIGNAL_FUNC (layers_dialog_drag_duplicate_layer_callback),
  483.               NULL);
  484.  
  485.   /*  Drop to trashcan  */
  486.   gtk_drag_dest_set (layers_ops_buttons[5].widget,
  487.              GTK_DEST_DEFAULT_ALL,
  488.                      trashcan_target_table, n_trashcan_targets,
  489.                      GDK_ACTION_COPY);
  490.   gtk_signal_connect (GTK_OBJECT (layers_ops_buttons[5].widget), "drag_drop",
  491.                       GTK_SIGNAL_FUNC (layers_dialog_drag_trashcan_callback),
  492.               NULL);
  493.  
  494.   /*  Set up signals for map/unmap for the accelerators  */
  495.   gtk_signal_connect (GTK_OBJECT (layersD->vbox), "map",
  496.               (GtkSignalFunc) layers_dialog_map_callback,
  497.               NULL);
  498.   gtk_signal_connect (GTK_OBJECT (layersD->vbox), "unmap",
  499.               (GtkSignalFunc) layers_dialog_unmap_callback,
  500.               NULL);
  501.  
  502.   gtk_widget_show (vbox);
  503.   gtk_widget_show (layersD->vbox);
  504.  
  505.   return layersD->vbox;
  506. }
  507.  
  508. void
  509. layers_dialog_free (void)
  510. {
  511.   LayerWidget *lw;
  512.   GSList *list;
  513.  
  514.   if (!layersD)
  515.     return;
  516.  
  517.   suspend_gimage_notify++;
  518.   /*  Free all elements in the layers listbox  */
  519.   gtk_list_clear_items (GTK_LIST (layersD->layer_list), 0, -1);
  520.   suspend_gimage_notify--;
  521.  
  522.   list = layersD->layer_widgets;
  523.   while (list)
  524.     {
  525.       lw = (LayerWidget *) list->data;
  526.       list = g_slist_next (list);
  527.       layer_widget_delete (lw);
  528.     }
  529.   layersD->layer_widgets  = NULL;
  530.   layersD->active_layer   = NULL;
  531.   layersD->active_channel = NULL;
  532.   layersD->floating_sel   = NULL;
  533.  
  534.   if (layersD->layer_preview)
  535.     gtk_object_sink (GTK_OBJECT (layersD->layer_preview));
  536.   if (layersD->green_gc)
  537.     gdk_gc_destroy (layersD->green_gc);
  538.   if (layersD->red_gc)
  539.     gdk_gc_destroy (layersD->red_gc);
  540.  
  541.   g_free (layersD);
  542.   layersD = NULL;
  543. }
  544.  
  545. void 
  546. layers_dialog_invalidate_previews (GimpImage *gimage)
  547. {
  548.   GSList *list = gimage->layers;
  549.   Layer  *layer;
  550.  
  551.   /*  Invalidate all previews ...
  552.    *  This is called during loading the image
  553.    */
  554.   while (list)
  555.     {
  556.       layer = (Layer *) list->data;
  557.       GIMP_DRAWABLE (layer)->preview_valid = FALSE;
  558.       list = g_slist_next (list);
  559.     }
  560. }
  561.  
  562. void
  563. layers_dialog_update (GimpImage* gimage)
  564. {
  565.   Layer       *layer;
  566.   LayerWidget *lw;
  567.   GSList      *list;
  568.   GList       *item_list;
  569.  
  570.   if (! layersD || layersD->gimage == gimage)
  571.     return;
  572.  
  573.   layersD->gimage = gimage;
  574.  
  575.   /*  Make sure the gimage is not notified of this change  */
  576.   suspend_gimage_notify++;
  577.  
  578.   /*  Free all elements in the layers listbox  */
  579.   gtk_list_clear_items (GTK_LIST (layersD->layer_list), 0, -1);
  580.  
  581.   list = layersD->layer_widgets;
  582.   while (list)
  583.     {
  584.       lw = (LayerWidget *) list->data;
  585.       list = g_slist_next (list);
  586.       layer_widget_delete (lw);
  587.     }
  588.  
  589.   if (layersD->layer_widgets)
  590.     g_warning ("layers_dialog_update(): layersD->layer_widgets not empty!");
  591.   layersD->layer_widgets = NULL;
  592.  
  593.   /*  Find the preview extents  */
  594.   layers_dialog_preview_extents ();
  595.  
  596.   layersD->active_layer   = NULL;
  597.   layersD->active_channel = NULL;
  598.   layersD->floating_sel   = NULL;
  599.  
  600.   for (list = gimage->layers, item_list = NULL; 
  601.        list; 
  602.        list = g_slist_next (list))
  603.     {
  604.       /*  create a layer list item  */
  605.       layer = (Layer *) list->data;
  606.       lw = layer_widget_create (gimage, layer);
  607.       layersD->layer_widgets = g_slist_append (layersD->layer_widgets, lw);
  608.       item_list = g_list_append (item_list, lw->list_item);
  609.     }
  610.  
  611.   /*  get the index of the active layer  */
  612.   if (item_list)
  613.     gtk_list_insert_items (GTK_LIST (layersD->layer_list), item_list, 0);
  614.  
  615.   suspend_gimage_notify--;
  616. }
  617.  
  618. void
  619. layers_dialog_flush (void)
  620. {
  621.   GimpImage   *gimage;
  622.   Layer       *layer;
  623.   LayerWidget *lw;
  624.   GSList      *list;
  625.   gint         pos;
  626.  
  627.   if (!layersD || !(gimage = layersD->gimage))
  628.     return;
  629.  
  630.   /*  Make sure the gimage is not notified of this change  */
  631.   suspend_gimage_notify++;
  632.  
  633.   /*  Check if the gimage extents have changed  */
  634.   if ((gimage->width != layersD->gimage_width) ||
  635.       (gimage->height != layersD->gimage_height))
  636.     {
  637.       layersD->gimage = NULL;
  638.       layers_dialog_update (gimage);
  639.     }
  640.   else
  641.     {
  642.       /*  Set all current layer widgets to visited = FALSE  */
  643.       for (list = layersD->layer_widgets; list; list = g_slist_next (list))
  644.         {
  645.           lw = (LayerWidget *) list->data;
  646.           lw->visited = FALSE;
  647.         }
  648.  
  649.       /*  Add any missing layers  */
  650.       for (list = gimage->layers; list; list = g_slist_next (list))
  651.         {
  652.           layer = (Layer *) list->data;
  653.           lw = layer_widget_get_ID (layer);
  654.  
  655.           /*  If the layer isn't in the layer widget list, add it  */
  656.           if (lw == NULL)
  657.         {
  658.           /*  sets visited = TRUE  */
  659.           layers_dialog_add_layer (layer);
  660.         }
  661.           else
  662.         lw->visited = TRUE;
  663.         }
  664.  
  665.       /*  Remove any extraneous layers  */
  666.       list = layersD->layer_widgets;
  667.       while (list)
  668.         {
  669.           lw = (LayerWidget *) list->data;
  670.           list = g_slist_next (list);
  671.           if (lw->visited == FALSE)
  672.         layers_dialog_remove_layer (lw->layer);
  673.         }
  674.  
  675.       /*  Switch positions of items if necessary  */
  676.       for (list = gimage->layers, pos = 0; 
  677.        list; 
  678.        list = g_slist_next (list))
  679.         {
  680.           layer = (Layer *) list->data;
  681.           layers_dialog_position_layer (layer, pos++);
  682.         }
  683.  
  684.       /*  Set the active layer  */
  685.       if (layersD->active_layer != gimage->active_layer)
  686.         layersD->active_layer = gimage->active_layer;
  687.  
  688.       /*  Set the active channel  */
  689.       if (layersD->active_channel != gimage->active_channel)
  690.         layersD->active_channel = gimage->active_channel;
  691.  
  692.       /*  set the menus if floating sel status has changed  */
  693.       if (layersD->floating_sel != gimage->floating_sel)
  694.         layersD->floating_sel = gimage->floating_sel;
  695.  
  696.       layers_dialog_set_menu_sensitivity ();
  697.  
  698.       gtk_container_foreach (GTK_CONTAINER (layersD->layer_list),
  699.                  layer_widget_layer_flush, NULL);
  700.     }
  701.  
  702.   suspend_gimage_notify--;
  703. }
  704.  
  705. void
  706. layers_dialog_clear (void)
  707. {
  708.   if (!layersD)
  709.     return;
  710.  
  711.   suspend_gimage_notify++;
  712.   gtk_list_clear_items (GTK_LIST (layersD->layer_list), 0, -1);
  713.   suspend_gimage_notify--;
  714.  
  715.   layersD->gimage = NULL;
  716. }
  717.  
  718. /***********************/
  719. /*  Preview functions  */
  720. /***********************/
  721.  
  722. void
  723. render_preview (TempBuf   *preview_buf,
  724.         GtkWidget *preview_widget,
  725.         gint       width,
  726.         gint       height,
  727.         gint       channel)
  728. {
  729.   guchar   *src, *s;
  730.   guchar   *cb;
  731.   guchar   *buf;
  732.   gint      a;
  733.   gint      i, j, b;
  734.   gint      x1, y1, x2, y2;
  735.   gint      rowstride;
  736.   gint      color_buf;
  737.   gint      color;
  738.   gint      alpha;
  739.   gboolean  has_alpha;
  740.   gint      image_bytes;
  741.   gint      offset;
  742.  
  743.   alpha = ALPHA_PIX;
  744.  
  745.   /*  Here are the different cases this functions handles correctly:
  746.    *  1)  Offset preview_buf which does not necessarily cover full image area
  747.    *  2)  Color conversion of preview_buf if it is gray and image is color
  748.    *  3)  Background check buffer for transparent preview_bufs
  749.    *  4)  Using the optional "channel" argument, one channel can be extracted
  750.    *      from a multi-channel preview_buf and composited as a grayscale
  751.    *  Prereqs:
  752.    *  1)  Grayscale preview_bufs have bytes == {1, 2}
  753.    *  2)  Color preview_bufs have bytes == {3, 4}
  754.    *  3)  If image is gray, then preview_buf should have bytes == {1, 2}
  755.    */
  756.   color_buf   = (GTK_PREVIEW (preview_widget)->type == GTK_PREVIEW_COLOR);
  757.   image_bytes = (color_buf) ? 3 : 1;
  758.   has_alpha   = (preview_buf->bytes == 2 || preview_buf->bytes == 4);
  759.   rowstride   = preview_buf->width * preview_buf->bytes;
  760.  
  761.   /*  Determine if the preview buf supplied is color
  762.    *   Generally, if the bytes == {3, 4}, this is true.
  763.    *   However, if the channel argument supplied is not -1, then
  764.    *   the preview buf is assumed to be gray despite the number of
  765.    *   channels it contains
  766.    */
  767.   color = (channel == -1) &&
  768.           (preview_buf->bytes == 3 || preview_buf->bytes == 4);
  769.  
  770.   if (has_alpha)
  771.     {
  772.       buf = check_buf;
  773.       alpha = ((color) ? ALPHA_PIX :
  774.            ((channel != -1) ? (preview_buf->bytes - 1) :
  775.         ALPHA_G_PIX));
  776.     }
  777.   else
  778.     buf = empty_buf;
  779.  
  780.   x1 = CLAMP (preview_buf->x, 0, width);
  781.   y1 = CLAMP (preview_buf->y, 0, height);
  782.   x2 = CLAMP (preview_buf->x + preview_buf->width, 0, width);
  783.   y2 = CLAMP (preview_buf->y + preview_buf->height, 0, height);
  784.  
  785.   src = temp_buf_data (preview_buf) + (y1 - preview_buf->y) * rowstride +
  786.     (x1 - preview_buf->x) * preview_buf->bytes;
  787.  
  788.   /*  One last thing for efficiency's sake:  */
  789.   if (channel == -1)
  790.     channel = 0;
  791.  
  792.   for (i = 0; i < height; i++)
  793.     {
  794.       if (i & 0x4)
  795.     {
  796.       offset = 4;
  797.       cb = buf + offset * 3;
  798.     }
  799.       else
  800.     {
  801.       offset = 0;
  802.       cb = buf;
  803.     }
  804.  
  805.       /*  The interesting stuff between leading & trailing 
  806.       vertical transparency  */
  807.       if (i >= y1 && i < y2)
  808.     {
  809.       /*  Handle the leading transparency  */
  810.       for (j = 0; j < x1; j++)
  811.         for (b = 0; b < image_bytes; b++)
  812.           temp_buf[j * image_bytes + b] = cb[j * 3 + b];
  813.  
  814.       /*  The stuff in the middle  */
  815.       s = src;
  816.       for (j = x1; j < x2; j++)
  817.         {
  818.           if (color)
  819.         {
  820.           if (has_alpha)
  821.             {
  822.               a = s[alpha] << 8;
  823.  
  824.               if ((j + offset) & 0x4)
  825.             {
  826.               temp_buf[j * 3 + 0] = 
  827.                 blend_dark_check [(a | s[RED_PIX])];
  828.               temp_buf[j * 3 + 1] = 
  829.                 blend_dark_check [(a | s[GREEN_PIX])];
  830.               temp_buf[j * 3 + 2] = 
  831.                 blend_dark_check [(a | s[BLUE_PIX])];
  832.             }
  833.               else
  834.             {
  835.               temp_buf[j * 3 + 0] = 
  836.                 blend_light_check [(a | s[RED_PIX])];
  837.               temp_buf[j * 3 + 1] = 
  838.                 blend_light_check [(a | s[GREEN_PIX])];
  839.               temp_buf[j * 3 + 2] = 
  840.                 blend_light_check [(a | s[BLUE_PIX])];
  841.             }
  842.             }
  843.           else
  844.             {
  845.               temp_buf[j * 3 + 0] = s[RED_PIX];
  846.               temp_buf[j * 3 + 1] = s[GREEN_PIX];
  847.               temp_buf[j * 3 + 2] = s[BLUE_PIX];
  848.             }
  849.         }
  850.           else
  851.         {
  852.           if (has_alpha)
  853.             {
  854.               a = s[alpha] << 8;
  855.  
  856.               if ((j + offset) & 0x4)
  857.             {
  858.               if (color_buf)
  859.                 {
  860.                   temp_buf[j * 3 + 0] = 
  861.                 blend_dark_check [(a | s[GRAY_PIX])];
  862.                   temp_buf[j * 3 + 1] = 
  863.                 blend_dark_check [(a | s[GRAY_PIX])];
  864.                   temp_buf[j * 3 + 2] = 
  865.                 blend_dark_check [(a | s[GRAY_PIX])];
  866.                 }
  867.               else
  868.                 temp_buf[j] = 
  869.                   blend_dark_check [(a | s[GRAY_PIX + channel])];
  870.             }
  871.               else
  872.             {
  873.               if (color_buf)
  874.                 {
  875.                   temp_buf[j * 3 + 0] = 
  876.                 blend_light_check [(a | s[GRAY_PIX])];
  877.                   temp_buf[j * 3 + 1] = 
  878.                 blend_light_check [(a | s[GRAY_PIX])];
  879.                   temp_buf[j * 3 + 2] = 
  880.                 blend_light_check [(a | s[GRAY_PIX])];
  881.                 }
  882.               else
  883.                 temp_buf[j] = 
  884.                   blend_light_check [(a | s[GRAY_PIX + channel])];
  885.             }
  886.             }
  887.           else
  888.             {
  889.               if (color_buf)
  890.             {
  891.               temp_buf[j * 3 + 0] = s[GRAY_PIX];
  892.               temp_buf[j * 3 + 1] = s[GRAY_PIX];
  893.               temp_buf[j * 3 + 2] = s[GRAY_PIX];
  894.             }
  895.               else
  896.             temp_buf[j] = s[GRAY_PIX + channel];
  897.             }
  898.         }
  899.  
  900.           s += preview_buf->bytes;
  901.         }
  902.  
  903.       /*  Handle the trailing transparency  */
  904.       for (j = x2; j < width; j++)
  905.         for (b = 0; b < image_bytes; b++)
  906.           temp_buf[j * image_bytes + b] = cb[j * 3 + b];
  907.  
  908.       src += rowstride;
  909.     }
  910.       else
  911.     {
  912.       for (j = 0; j < width; j++)
  913.         for (b = 0; b < image_bytes; b++)
  914.           temp_buf[j * image_bytes + b] = cb[j * 3 + b];
  915.     }
  916.  
  917.       gtk_preview_draw_row (GTK_PREVIEW (preview_widget), 
  918.                 temp_buf, 0, i, width);
  919.     }
  920. }
  921.  
  922. void
  923. render_fs_preview (GtkWidget *widget,
  924.            GdkPixmap *pixmap)
  925. {
  926.   gint      w, h;
  927.   gint      x1, y1, x2, y2;
  928.   GdkPoint  poly[6];
  929.   gint      foldh, foldw;
  930.   gint      i;
  931.  
  932.   gdk_window_get_size (pixmap, &w, &h);
  933.  
  934.   x1 = 2;
  935.   y1 = h / 8 + 2;
  936.   x2 = w - w / 8 - 2;
  937.   y2 = h - 2;
  938.   gdk_draw_rectangle (pixmap, widget->style->bg_gc[GTK_STATE_NORMAL], 1,
  939.               0, 0, w, h);
  940.   gdk_draw_rectangle (pixmap, widget->style->black_gc, 0,
  941.               x1, y1, (x2 - x1), (y2 - y1));
  942.  
  943.   foldw = w / 4;
  944.   foldh = h / 4;
  945.   x1 = w / 8 + 2;
  946.   y1 = 2;
  947.   x2 = w - 2;
  948.   y2 = h - h / 8 - 2;
  949.  
  950.   poly[0].x = x1 + foldw; poly[0].y = y1;
  951.   poly[1].x = x1 + foldw; poly[1].y = y1 + foldh;
  952.   poly[2].x = x1;         poly[2].y = y1 + foldh;
  953.   poly[3].x = x1;         poly[3].y = y2;
  954.   poly[4].x = x2;         poly[4].y = y2;
  955.   poly[5].x = x2;         poly[5].y = y1;
  956.  
  957.   gdk_draw_polygon (pixmap, widget->style->white_gc, 1, poly, 6);
  958.  
  959.   gdk_draw_line (pixmap, widget->style->black_gc,
  960.          x1, y1 + foldh, x1, y2);
  961.   gdk_draw_line (pixmap, widget->style->black_gc,
  962.          x1, y2, x2, y2);
  963.   gdk_draw_line (pixmap, widget->style->black_gc,
  964.          x2, y2, x2, y1);
  965.   gdk_draw_line (pixmap, widget->style->black_gc,
  966.          x1 + foldw, y1, x2, y1);
  967.  
  968.   for (i = 0; i < foldw; i++)
  969.     gdk_draw_line (pixmap, widget->style->black_gc,
  970.            x1 + i, y1 + foldh, x1 + i, (foldw == 1) ? y1 :
  971.            (y1 + (foldh - (foldh * i) / (foldw - 1))));
  972. }
  973.  
  974. /*************************************/
  975. /*  layers dialog widget routines    */
  976. /*************************************/
  977.  
  978. static void
  979. layers_dialog_preview_extents (void)
  980. {
  981.   GimpImage *gimage;
  982.  
  983.   if (!layersD)
  984.     return;
  985.  
  986.   gimage = layersD->gimage;
  987.  
  988.   layersD->gimage_width  = gimage->width;
  989.   layersD->gimage_height = gimage->height;
  990.  
  991.   /*  Get the image width and height variables, based on the gimage  */
  992.   if (gimage->width > gimage->height)
  993.     layersD->ratio = 
  994.       MIN (1.0, (gdouble) preview_size / (gdouble) gimage->width);
  995.   else
  996.     layersD->ratio = 
  997.       MIN (1.0, (gdouble) preview_size / (gdouble) gimage->height);
  998.  
  999.   if (preview_size)
  1000.     {
  1001.       layersD->image_width  = RINT (layersD->ratio * (gdouble) gimage->width);
  1002.       layersD->image_height = RINT (layersD->ratio * (gdouble) gimage->height);
  1003.       
  1004.       if (layersD->image_width  < 1) layersD->image_width  = 1;
  1005.       if (layersD->image_height < 1) layersD->image_height = 1;
  1006.     }
  1007.   else
  1008.     {
  1009.       layersD->image_width  = layer_width;
  1010.       layersD->image_height = layer_height;
  1011.     }
  1012. }
  1013.  
  1014. static void
  1015. layers_dialog_set_menu_sensitivity (void)
  1016. {
  1017.   gboolean  fs;         /*  no floating sel        */
  1018.   gboolean  ac;         /*  no active channel      */
  1019.   gboolean  lm;         /*  layer mask             */
  1020.   gboolean  gimage;     /*  is there a gimage      */
  1021.   gboolean  lp;         /*  layers present         */
  1022.   gboolean  alpha;      /*  alpha channel present  */
  1023.   gboolean  indexed;    /*  is indexed             */
  1024.   gboolean  next_alpha;
  1025.   GSList   *list; 
  1026.   GSList   *next;
  1027.   GSList   *prev;
  1028.   Layer    *layer;
  1029.  
  1030.   lp = FALSE;
  1031.   indexed = FALSE;
  1032.   
  1033.   if (! layersD)
  1034.     return;
  1035.  
  1036.   if ((layer = (layersD->active_layer)) != NULL)
  1037.     lm = (layer_get_mask (layer)) ? TRUE : FALSE;
  1038.   else
  1039.     lm = FALSE;
  1040.  
  1041.   fs = (layersD->floating_sel == NULL);
  1042.   ac = (layersD->active_channel == NULL);
  1043.   gimage = (layersD->gimage != NULL);
  1044.   alpha = layer && layer_has_alpha (layer);
  1045.  
  1046.   if (gimage)
  1047.     {
  1048.       lp = (layersD->gimage->layers != NULL);
  1049.       indexed = (gimp_image_base_type (layersD->gimage) == INDEXED);
  1050.     } 
  1051.      
  1052.   list = layersD->gimage->layers;
  1053.   prev = NULL;
  1054.   next = NULL;
  1055.   while (list)
  1056.     {
  1057.       layer = (Layer *)list->data;
  1058.       if (layer == (layersD->active_layer))
  1059.     {
  1060.       next = g_slist_next (list);
  1061.       break;
  1062.     }
  1063.       prev = list;
  1064.       list = g_slist_next (list);
  1065.     }
  1066.  
  1067.   if (next)
  1068.     {
  1069.       layer = (Layer *) next->data;
  1070.       next_alpha = layer_has_alpha (layer);
  1071.     }
  1072.   else
  1073.     next_alpha = FALSE;
  1074.  
  1075. #define SET_SENSITIVE(menu,condition) \
  1076.         menus_set_sensitive ("<Layers>/" menu, (condition) != 0)
  1077. #define SET_OPS_SENSITIVE(button,condition) \
  1078.         gtk_widget_set_sensitive (layers_ops_buttons[(button)].widget, \
  1079.                                  (condition) != 0)
  1080.  
  1081.   SET_SENSITIVE ("New Layer...", gimage);
  1082.   SET_OPS_SENSITIVE (0, gimage);
  1083.  
  1084.   SET_SENSITIVE ("Stack/Raise Layer",
  1085.          fs && ac && gimage && lp && alpha && prev);
  1086.   SET_OPS_SENSITIVE (1, fs && ac && gimage && lp && alpha && prev);
  1087.  
  1088.   SET_SENSITIVE ("Stack/Lower Layer",
  1089.          fs && ac && gimage && lp && next && next_alpha);
  1090.   SET_OPS_SENSITIVE (2, fs && ac && gimage && lp && next && next_alpha);
  1091.  
  1092.   SET_SENSITIVE ("Stack/Layer to Top",
  1093.          fs && ac && gimage && lp && alpha && prev);
  1094.   SET_SENSITIVE ("Stack/Layer to Bottom",
  1095.          fs && ac && gimage && lp && next && next_alpha);
  1096.  
  1097.   SET_SENSITIVE ("Duplicate Layer", fs && ac && gimage && lp);
  1098.   SET_OPS_SENSITIVE (3, fs && ac && gimage && lp);
  1099.  
  1100.   SET_SENSITIVE ("Anchor Layer", !fs && ac && gimage && lp);
  1101.   SET_OPS_SENSITIVE (4, !fs && ac && gimage && lp);
  1102.  
  1103.   SET_SENSITIVE ("Delete Layer", ac && gimage && lp);
  1104.   SET_OPS_SENSITIVE (5, ac && gimage && lp);
  1105.  
  1106.   SET_SENSITIVE ("Layer Boundary Size...", ac && gimage && lp);
  1107.   SET_SENSITIVE ("Layer to Imagesize", ac && gimage && lp);
  1108.   SET_SENSITIVE ("Scale Layer...", ac && gimage && lp);
  1109.  
  1110.   SET_SENSITIVE ("Merge Visible Layers...", fs && ac && gimage && lp);
  1111.   SET_SENSITIVE ("Merge Down", fs && ac && gimage && lp && next);
  1112.   SET_SENSITIVE ("Flatten Image", fs && ac && gimage && lp);
  1113.  
  1114.   SET_SENSITIVE ("Add Layer Mask...", 
  1115.          fs && ac && gimage && !lm && lp && alpha && !indexed);
  1116.   SET_SENSITIVE ("Apply Layer Mask", fs && ac && gimage && lm && lp);
  1117.   SET_SENSITIVE ("Delete Layer Mask", fs && ac && gimage && lm && lp);
  1118.   SET_SENSITIVE ("Mask to Selection", fs && ac && gimage && lm && lp);
  1119.  
  1120.   SET_SENSITIVE ("Add Alpha Channel", !alpha);
  1121.   SET_SENSITIVE ("Alpha to Selection", fs && ac && gimage && lp && alpha);
  1122.  
  1123.   SET_SENSITIVE ("Edit Layer Attributes...", ac && gimage && lp);
  1124.  
  1125. #undef SET_OPS_SENSITIVE
  1126. #undef SET_SENSITIVE
  1127.  
  1128.   /*  set mode, preserve transparency and opacity to insensitive
  1129.    *  if there are no layers
  1130.    */
  1131.   gtk_widget_set_sensitive (layersD->preserve_trans, lp);
  1132.   gtk_widget_set_sensitive (layersD->opacity_box, lp);
  1133.   gtk_widget_set_sensitive (layersD->mode_box, lp);
  1134. }
  1135.  
  1136. static void
  1137. layers_dialog_scroll_index (gint index)
  1138. {
  1139.   GtkAdjustment *adj;
  1140.   gint           item_height;
  1141.  
  1142.   item_height = 6 + (preview_size ? preview_size : layer_height);
  1143.   adj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (layersD->scrolled_win));
  1144.  
  1145.   if (index * item_height < adj->value)
  1146.     {
  1147.       adj->value = index * item_height;
  1148.       gtk_adjustment_value_changed (adj);
  1149.     }
  1150.   else if ((index + 1) * item_height > adj->value + adj->page_size)
  1151.     {
  1152.       adj->value = (index + 1) * item_height - adj->page_size;
  1153.       gtk_adjustment_value_changed (adj);
  1154.     }
  1155. }
  1156.  
  1157. /* Commented out because this piece of code produced strange segfaults
  1158.  
  1159. static gint
  1160. layer_dialog_idle_set_active_layer_focus (gpointer data)
  1161. {
  1162.   gtk_widget_grab_focus (GTK_WIDGET (data));
  1163.  
  1164.   return FALSE;
  1165. }
  1166.  
  1167. */
  1168.  
  1169. static void
  1170. layers_dialog_set_active_layer (Layer *layer)
  1171. {
  1172.   LayerWidget  *layer_widget;
  1173.   GtkStateType  state;
  1174.   gint          index;
  1175.  
  1176.   layer_widget = layer_widget_get_ID (layer);
  1177.   if (!layersD || !layer_widget)
  1178.     return;
  1179.  
  1180.   /*  Make sure the gimage is not notified of this change  */
  1181.   suspend_gimage_notify++;
  1182.  
  1183.   state = layer_widget->list_item->state;
  1184.   index = gimp_image_get_layer_index (layer_widget->gimage, layer);
  1185.   if ((index >= 0) && (state != GTK_STATE_SELECTED))
  1186.     {
  1187.       gtk_object_set_user_data (GTK_OBJECT (layer_widget->list_item), NULL);
  1188.       gtk_list_select_item (GTK_LIST (layersD->layer_list), index);
  1189.       /*  let dnd finish it's work before setting the focus  */
  1190.       /* Commented out because this piece of code produced strange segfaults
  1191.       gtk_idle_add ((GtkFunction) layer_dialog_idle_set_active_layer_focus,
  1192.             layer_widget->list_item);
  1193.       */
  1194.       gtk_object_set_user_data (GTK_OBJECT (layer_widget->list_item),
  1195.                 layer_widget);
  1196.  
  1197.       layers_dialog_scroll_index (index);
  1198.     }
  1199.  
  1200.   suspend_gimage_notify--;
  1201. }
  1202.  
  1203. static void
  1204. layers_dialog_unset_layer (Layer *layer)
  1205. {
  1206.   LayerWidget  *layer_widget;
  1207.   GtkStateType  state;
  1208.   gint          index;
  1209.  
  1210.   layer_widget = layer_widget_get_ID (layer);
  1211.   if (!layersD || !layer_widget)
  1212.     return;
  1213.  
  1214.   /*  Make sure the gimage is not notified of this change  */
  1215.   suspend_gimage_notify++;
  1216.  
  1217.   state = layer_widget->list_item->state;
  1218.   index = gimp_image_get_layer_index (layer_widget->gimage, layer);
  1219.   if ((index >= 0) && (state == GTK_STATE_SELECTED))
  1220.     {
  1221.       gtk_object_set_user_data (GTK_OBJECT (layer_widget->list_item), NULL);
  1222.       gtk_list_unselect_item (GTK_LIST (layersD->layer_list), index);
  1223.       gtk_object_set_user_data (GTK_OBJECT (layer_widget->list_item), 
  1224.                 layer_widget);
  1225.     }
  1226.  
  1227.   suspend_gimage_notify--;
  1228. }
  1229.  
  1230. static void
  1231. layers_dialog_position_layer (Layer *layer,
  1232.                   gint   new_index)
  1233. {
  1234.   LayerWidget *layer_widget;
  1235.   GList       *list = NULL;
  1236.  
  1237.   layer_widget = layer_widget_get_ID (layer);
  1238.   if (!layersD || !layer_widget)
  1239.     return;
  1240.  
  1241.   if (new_index == g_slist_index (layersD->layer_widgets, layer_widget))
  1242.     return;
  1243.  
  1244.   /*  Make sure the gimage is not notified of this change  */
  1245.   suspend_gimage_notify++;
  1246.  
  1247.   /*  Remove the layer from the dialog  */
  1248.   list = g_list_append (list, layer_widget->list_item);
  1249.   gtk_list_remove_items (GTK_LIST (layersD->layer_list), list);
  1250.   layersD->layer_widgets = g_slist_remove (layersD->layer_widgets,
  1251.                        layer_widget);
  1252.  
  1253.   /*  Add it back at the proper index  */
  1254.   gtk_list_insert_items (GTK_LIST (layersD->layer_list), list, new_index);
  1255.   layersD->layer_widgets = g_slist_insert (layersD->layer_widgets,
  1256.                        layer_widget, new_index);
  1257.  
  1258.   /*  Adjust the scrollbar so the layer is visible  */
  1259.   layers_dialog_scroll_index (new_index > 0 ? new_index + 1: 0);
  1260.  
  1261.   suspend_gimage_notify--;
  1262. }
  1263.  
  1264. static void
  1265. invalidate_preview_callback (GtkWidget   *widget,
  1266.                  LayerWidget *layer_widget)
  1267. {
  1268.   layer_widget->layer_pixmap_valid = FALSE;
  1269.  
  1270.   /* synthesize an expose event */
  1271.   gtk_widget_queue_draw (layer_widget->layer_preview);
  1272. }
  1273.  
  1274.  
  1275. static void
  1276. layers_dialog_add_layer (Layer *layer)
  1277. {
  1278.   LayerWidget *layer_widget;
  1279.   GimpImage   *gimage;
  1280.   GList       *item_list;
  1281.   gint         position;
  1282.  
  1283.   if (!layersD || !layer || !(gimage = layersD->gimage))
  1284.     return;
  1285.  
  1286.   item_list = NULL;
  1287.  
  1288.   layer_widget = layer_widget_create (gimage, layer);
  1289.   item_list = g_list_append (item_list, layer_widget->list_item);
  1290.  
  1291.   position = gimp_image_get_layer_index (gimage, layer);
  1292.   layersD->layer_widgets =
  1293.     g_slist_insert (layersD->layer_widgets, layer_widget, position);
  1294.   gtk_list_insert_items (GTK_LIST (layersD->layer_list), item_list, position);
  1295. }
  1296.  
  1297. static void
  1298. layers_dialog_remove_layer (Layer *layer)
  1299. {
  1300.   LayerWidget *layer_widget;
  1301.   GList       *list = NULL;
  1302.  
  1303.   layer_widget = layer_widget_get_ID (layer);
  1304.   if (!layersD || !layer_widget)
  1305.     return;
  1306.  
  1307.   /*  Make sure the gimage is not notified of this change  */
  1308.   suspend_gimage_notify++;
  1309.  
  1310.   /*  Remove the requested layer from the dialog  */
  1311.   list = g_list_append (list, layer_widget->list_item);
  1312.   gtk_list_remove_items (GTK_LIST (layersD->layer_list), list);
  1313.  
  1314.   /*  Delete layer widget  */
  1315.   layer_widget_delete (layer_widget);
  1316.  
  1317.   suspend_gimage_notify--;
  1318. }
  1319.  
  1320. static void
  1321. layers_dialog_add_layer_mask (Layer *layer)
  1322. {
  1323.   LayerWidget *layer_widget;
  1324.  
  1325.   layer_widget = layer_widget_get_ID (layer);
  1326.   if (!layersD || !layer_widget)
  1327.     return;
  1328.  
  1329.   if (! GTK_WIDGET_VISIBLE (layer_widget->mask_preview))
  1330.     {
  1331.       gtk_object_set_data (GTK_OBJECT (layer_widget->mask_preview),
  1332.                "gimp_layer_mask", layer_get_mask (layer));
  1333.       gtk_widget_show (layer_widget->mask_preview);
  1334.     }
  1335.  
  1336.   layer_widget->active_preview = MASK_PREVIEW;
  1337.  
  1338.   gtk_widget_queue_draw (layer_widget->layer_preview);
  1339. }
  1340.  
  1341. static void
  1342. layers_dialog_remove_layer_mask (Layer *layer)
  1343. {
  1344.   LayerWidget *layer_widget;
  1345.  
  1346.   layer_widget = layer_widget_get_ID (layer);
  1347.   if (!layersD || !layer_widget)
  1348.     return;
  1349.  
  1350.   if (GTK_WIDGET_VISIBLE (layer_widget->mask_preview))
  1351.     {
  1352.       gtk_object_set_data (GTK_OBJECT (layer_widget->mask_preview),
  1353.                "gimp_layer_mask", NULL);
  1354.       gtk_widget_hide (layer_widget->mask_preview);
  1355.     }
  1356.  
  1357.   layer_widget->active_preview = LAYER_PREVIEW;
  1358.  
  1359.   gtk_widget_queue_draw (layer_widget->layer_preview);
  1360.   gtk_widget_queue_resize (layer_widget->layer_preview->parent);
  1361. }
  1362.  
  1363. /*****************************************************/
  1364. /*  paint mode, opacity & preserve trans. functions  */
  1365. /*****************************************************/
  1366.  
  1367. static void
  1368. paint_mode_menu_callback (GtkWidget *widget,
  1369.               gpointer   data)
  1370. {
  1371.   GimpImage        *gimage;
  1372.   Layer            *layer;
  1373.   LayerModeEffects  mode;
  1374.  
  1375.   if (!(gimage = layersD->gimage) || !(layer = gimage->active_layer))
  1376.     return;
  1377.  
  1378.   /*  If the layer has an alpha channel, set the transparency and redraw  */
  1379.   if (layer_has_alpha (layer))
  1380.     {
  1381.       mode = (LayerModeEffects) gtk_object_get_user_data (GTK_OBJECT (widget));
  1382.  
  1383.       if (layer->mode != mode)
  1384.     {
  1385.       layer->mode = mode;
  1386.  
  1387.       drawable_update (GIMP_DRAWABLE (layer), 0, 0,
  1388.                GIMP_DRAWABLE (layer)->width,
  1389.                GIMP_DRAWABLE (layer)->height);
  1390.       gdisplays_flush ();
  1391.     }
  1392.     }
  1393. }
  1394.  
  1395. static void
  1396. opacity_scale_update (GtkAdjustment *adjustment,
  1397.               gpointer       data)
  1398. {
  1399.   GimpImage *gimage;
  1400.   Layer     *layer;
  1401.   gint       opacity;
  1402.  
  1403.   if (!(gimage = layersD->gimage) || !(layer = gimage->active_layer))
  1404.     return;
  1405.  
  1406.   /*  add the 0.001 to insure there are no subtle rounding errors  */
  1407.   opacity = (gint) (adjustment->value * 2.55 + 0.001);
  1408.  
  1409.   if (layer->opacity != opacity)
  1410.     {
  1411.       layer->opacity = opacity;
  1412.  
  1413.       drawable_update (GIMP_DRAWABLE (layer), 0, 0,
  1414.                GIMP_DRAWABLE (layer)->width,
  1415.                GIMP_DRAWABLE (layer)->height);
  1416.       gdisplays_flush ();
  1417.     }
  1418. }
  1419.  
  1420. static void
  1421. preserve_trans_update (GtkWidget *widget,
  1422.                gpointer   data)
  1423. {
  1424.   GimpImage *gimage;
  1425.   Layer     *layer;
  1426.  
  1427.   if (!(gimage = layersD->gimage) || !(layer = gimage->active_layer))
  1428.     return;
  1429.  
  1430.   if (GTK_TOGGLE_BUTTON (widget)->active)
  1431.     layer->preserve_trans = TRUE;
  1432.   else
  1433.     layer->preserve_trans = FALSE;
  1434. }
  1435.  
  1436.  
  1437. /********************************/
  1438. /*  layer list events callback  */
  1439. /********************************/
  1440.  
  1441. static gint
  1442. layer_list_events (GtkWidget *widget,
  1443.            GdkEvent  *event,
  1444.            gpointer   data)
  1445. {
  1446.   LayerWidget    *layer_widget;
  1447.   GdkEventButton *bevent;
  1448.   GtkWidget      *event_widget;
  1449.  
  1450.   event_widget = gtk_get_event_widget (event);    
  1451.  
  1452.   if (GTK_IS_LIST_ITEM (event_widget))
  1453.     {
  1454.       layer_widget =
  1455.     (LayerWidget *) gtk_object_get_user_data (GTK_OBJECT (event_widget));
  1456.  
  1457.       switch (event->type)
  1458.     {
  1459.     case GDK_BUTTON_PRESS:
  1460.       bevent = (GdkEventButton *) event;
  1461.       if (bevent->button == 3)
  1462.         {
  1463.           gtk_menu_popup (GTK_MENU (layersD->ops_menu),
  1464.                   NULL, NULL, NULL, NULL,
  1465.                   bevent->button, bevent->time);
  1466.           return TRUE;
  1467.         }
  1468.       break;
  1469.  
  1470.     case GDK_2BUTTON_PRESS:
  1471.       layers_dialog_edit_layer_query (layer_widget);
  1472.       return TRUE;
  1473.  
  1474.     default:
  1475.       break;
  1476.     }
  1477.     }
  1478.  
  1479.   return FALSE;
  1480. }
  1481.  
  1482. /*****************************/
  1483. /*  layers dialog callbacks  */
  1484. /*****************************/
  1485.  
  1486. static void
  1487. layers_dialog_map_callback (GtkWidget *widget,
  1488.                 gpointer   data)
  1489. {
  1490.   if (! layersD)
  1491.     return;
  1492.  
  1493.   gtk_window_add_accel_group (GTK_WINDOW (lc_dialog->shell),
  1494.                   layersD->accel_group);
  1495. }
  1496.  
  1497. static void
  1498. layers_dialog_unmap_callback (GtkWidget *widget,
  1499.                   gpointer   data)
  1500. {
  1501.   if (! layersD)
  1502.     return;
  1503.  
  1504.   gtk_window_remove_accel_group (GTK_WINDOW (lc_dialog->shell),
  1505.                  layersD->accel_group);
  1506. }
  1507.  
  1508. /***********************************/
  1509. /*  callbacks exported to menus.c  */
  1510. /***********************************/
  1511.  
  1512. void
  1513. layers_dialog_previous_layer_callback (GtkWidget *widget,
  1514.                        gpointer   data)
  1515. {
  1516.   GimpImage *gimage;
  1517.   Layer     *new_layer;
  1518.   gint       current_layer;
  1519.  
  1520.   if (!layersD || !(gimage = layersD->gimage))
  1521.     return;
  1522.  
  1523.   current_layer =
  1524.     gimp_image_get_layer_index (gimage, gimage->active_layer);
  1525.  
  1526.   /*  FIXME: don't use internal knowledge about layer lists
  1527.    *  TODO : implement gimp_image_get_layer_by_index()
  1528.    */
  1529.   new_layer =
  1530.     (Layer *) g_slist_nth_data (gimage->layers, current_layer - 1);
  1531.  
  1532.   if (new_layer)
  1533.     {
  1534.       gimp_image_set_active_layer (gimage, new_layer);
  1535.       gdisplays_flush ();
  1536.     }
  1537. }
  1538.  
  1539. void
  1540. layers_dialog_next_layer_callback (GtkWidget *widget,
  1541.                    gpointer   data)
  1542. {
  1543.   GimpImage *gimage;
  1544.   Layer     *new_layer;
  1545.   gint       current_layer;
  1546.  
  1547.   if (!layersD || !(gimage = layersD->gimage))
  1548.     return;
  1549.  
  1550.   current_layer =
  1551.     gimp_image_get_layer_index (gimage, gimage->active_layer);
  1552.  
  1553.   /*  FIXME: don't use internal knowledge about layer lists
  1554.    *  TODO : implement gimp_image_get_layer_by_index()
  1555.    */
  1556.   new_layer =
  1557.     (Layer *) g_slist_nth_data (gimage->layers, current_layer + 1);
  1558.  
  1559.   if (new_layer)
  1560.     {
  1561.       gimp_image_set_active_layer (gimage, new_layer);
  1562.       gdisplays_flush ();
  1563.     }
  1564. }
  1565.  
  1566. void
  1567. layers_dialog_raise_layer_callback (GtkWidget *widget,
  1568.                     gpointer   data)
  1569. {
  1570.   GimpImage *gimage;
  1571.  
  1572.   if (!layersD || !(gimage = layersD->gimage))
  1573.     return;
  1574.  
  1575.   gimp_image_raise_layer (gimage, gimage->active_layer);
  1576.   gdisplays_flush ();
  1577. }
  1578.  
  1579. void
  1580. layers_dialog_lower_layer_callback (GtkWidget *widget,
  1581.                     gpointer   data)
  1582. {
  1583.   GimpImage *gimage;
  1584.  
  1585.   if (!layersD || !(gimage = layersD->gimage))
  1586.     return;
  1587.  
  1588.   gimp_image_lower_layer (gimage, gimage->active_layer);
  1589.   gdisplays_flush ();
  1590. }
  1591.  
  1592. void
  1593. layers_dialog_raise_layer_to_top_callback (GtkWidget *widget,
  1594.                        gpointer   data)
  1595. {
  1596.   GimpImage *gimage;
  1597.  
  1598.   if (!layersD || !(gimage = layersD->gimage))
  1599.     return;
  1600.  
  1601.   gimp_image_raise_layer_to_top (gimage, gimage->active_layer);
  1602.   gdisplays_flush ();
  1603. }
  1604.  
  1605. void
  1606. layers_dialog_lower_layer_to_bottom_callback (GtkWidget *widget,
  1607.                           gpointer   data)
  1608. {
  1609.   GimpImage *gimage;
  1610.  
  1611.   if (!layersD || !(gimage = layersD->gimage))
  1612.     return;
  1613.  
  1614.   gimp_image_lower_layer_to_bottom (gimage, gimage->active_layer);
  1615.   gdisplays_flush ();
  1616. }
  1617.  
  1618. void
  1619. layers_dialog_new_layer_callback (GtkWidget *widget,
  1620.                   gpointer   data)
  1621. {
  1622.   GimpImage *gimage;
  1623.   Layer     *layer;
  1624.  
  1625.   if (!layersD || !(gimage = layersD->gimage))
  1626.     return;
  1627.  
  1628.   /*  If there is a floating selection, the new command transforms
  1629.    *  the current fs into a new layer
  1630.    */
  1631.   if ((layer = gimp_image_floating_sel (gimage)))
  1632.     {
  1633.       floating_sel_to_layer (layer);
  1634.  
  1635.       gdisplays_flush ();
  1636.     }
  1637.   else
  1638.     layers_dialog_new_layer_query (layersD->gimage);
  1639. }
  1640.  
  1641. void
  1642. layers_dialog_duplicate_layer_callback (GtkWidget *widget,
  1643.                     gpointer   data)
  1644. {
  1645.   GimpImage *gimage;
  1646.   Layer     *active_layer;
  1647.   Layer     *new_layer;
  1648.  
  1649.   if (!layersD || !(gimage = layersD->gimage))
  1650.     return;
  1651.  
  1652.   /*  Start a group undo  */
  1653.   undo_push_group_start (gimage, LAYER_ADD_UNDO);
  1654.  
  1655.   active_layer = gimp_image_get_active_layer (gimage);
  1656.   new_layer = layer_copy (active_layer, TRUE);
  1657.   gimp_image_add_layer (gimage, new_layer, -1);
  1658.  
  1659.   /*  End the group undo  */
  1660.   undo_push_group_end (gimage);
  1661.  
  1662.   gdisplays_flush ();
  1663. }
  1664.  
  1665. void
  1666. layers_dialog_delete_layer_callback (GtkWidget *widget,
  1667.                      gpointer   data)
  1668. {
  1669.   GimpImage *gimage;
  1670.   Layer     *layer;
  1671.  
  1672.   if (!layersD ||
  1673.       !(gimage = layersD->gimage) ||
  1674.       !(layer = gimp_image_get_active_layer (gimage)))
  1675.     return;
  1676.  
  1677.   /*  if the layer is a floating selection, take special care  */
  1678.   if (layer_is_floating_sel (layer))
  1679.     floating_sel_remove (layer);
  1680.   else
  1681.     gimp_image_remove_layer (gimage, gimage->active_layer);
  1682.  
  1683.   gdisplays_flush_now ();
  1684. }
  1685.  
  1686. void
  1687. layers_dialog_scale_layer_callback (GtkWidget *widget,
  1688.                     gpointer   data)
  1689. {
  1690.   GimpImage *gimage;
  1691.  
  1692.   if (!layersD || !(gimage = layersD->gimage))
  1693.     return;
  1694.  
  1695.   layers_dialog_scale_layer_query (gimage, gimage->active_layer);
  1696. }
  1697.  
  1698. void
  1699. layers_dialog_resize_layer_callback (GtkWidget *widget,
  1700.                      gpointer   data)
  1701. {
  1702.   GimpImage *gimage;
  1703.  
  1704.   if (!layersD || !(gimage = layersD->gimage))
  1705.     return;
  1706.  
  1707.   layers_dialog_resize_layer_query (gimage, gimage->active_layer);
  1708. }
  1709.  
  1710. void
  1711. layers_dialog_resize_to_image_callback (GtkWidget *widget,
  1712.                     gpointer   data)
  1713. {
  1714.   GimpImage *gimage;
  1715.   
  1716.   if (!layersD || !(gimage = layersD->gimage))
  1717.     return;
  1718.   
  1719.   layer_resize_to_image (gimage->active_layer);
  1720.  
  1721.   gdisplays_flush ();
  1722. }
  1723.  
  1724. void
  1725. layers_dialog_add_layer_mask_callback (GtkWidget *widget,
  1726.                        gpointer   data)
  1727. {
  1728.   GimpImage *gimage;
  1729.  
  1730.   if (!layersD || !(gimage = layersD->gimage))
  1731.     return;
  1732.  
  1733.   layers_dialog_add_mask_query (gimage->active_layer);
  1734. }
  1735.  
  1736. void
  1737. layers_dialog_apply_layer_mask_callback (GtkWidget *widget,
  1738.                      gpointer   data)
  1739. {
  1740.   GimpImage *gimage;
  1741.   Layer     *layer;
  1742.  
  1743.   if (!layersD || !(gimage = layersD->gimage))
  1744.     return;
  1745.  
  1746.   /*  Make sure there is a layer mask to apply  */
  1747.   if ((layer = gimage->active_layer) != NULL &&
  1748.       layer_get_mask (layer))
  1749.     {
  1750.       gboolean flush = !layer->apply_mask || layer->show_mask;
  1751.  
  1752.       gimp_image_remove_layer_mask (drawable_gimage (GIMP_DRAWABLE (layer)),
  1753.                     layer, APPLY);
  1754.  
  1755.       if (flush)
  1756.     {
  1757.       gdisplays_flush ();
  1758.     }
  1759.       else
  1760.     {
  1761.       LayerWidget *layer_widget = layer_widget_get_ID (layer);
  1762.  
  1763.       layer_widget_layer_flush (layer_widget->list_item, NULL);
  1764.       layers_dialog_set_menu_sensitivity ();
  1765.     }
  1766.     }
  1767. }
  1768.  
  1769. void
  1770. layers_dialog_delete_layer_mask_callback (GtkWidget *widget,
  1771.                       gpointer   data)
  1772. {
  1773.   GimpImage *gimage;
  1774.   Layer     *layer;
  1775.  
  1776.   if (!layersD || !(gimage = layersD->gimage))
  1777.     return;
  1778.  
  1779.   /*  Make sure there is a layer mask to apply  */
  1780.   if ((layer = gimage->active_layer) != NULL &&
  1781.       layer_get_mask (layer))
  1782.     {
  1783.       gboolean flush = layer->apply_mask || layer->show_mask;
  1784.  
  1785.       gimp_image_remove_layer_mask (drawable_gimage (GIMP_DRAWABLE (layer)),
  1786.                     layer, DISCARD);
  1787.  
  1788.       if (flush)
  1789.     {
  1790.       gdisplays_flush ();
  1791.     }
  1792.       else
  1793.     {
  1794.       LayerWidget *layer_widget = layer_widget_get_ID (layer);
  1795.  
  1796.       layer_widget_layer_flush (layer_widget->list_item, NULL);
  1797.       layers_dialog_set_menu_sensitivity ();
  1798.     }
  1799.     }
  1800. }
  1801.  
  1802. void
  1803. layers_dialog_anchor_layer_callback (GtkWidget *widget,
  1804.                      gpointer   data)
  1805. {
  1806.   GimpImage *gimage;
  1807.  
  1808.   if (!layersD || !(gimage = layersD->gimage))
  1809.     return;
  1810.  
  1811.   floating_sel_anchor (gimp_image_get_active_layer (gimage));
  1812.   gdisplays_flush ();
  1813. }
  1814.  
  1815. void
  1816. layers_dialog_merge_layers_callback (GtkWidget *widget,
  1817.                      gpointer   data)
  1818. {
  1819.   GimpImage *gimage;
  1820.  
  1821.   if (!layersD || !(gimage = layersD->gimage))
  1822.     return;
  1823.  
  1824.   layers_dialog_layer_merge_query (gimage, TRUE);
  1825. }
  1826.  
  1827. void
  1828. layers_dialog_merge_down_callback (GtkWidget *widget,
  1829.                    gpointer   data)
  1830. {
  1831.   GimpImage *gimage;
  1832.  
  1833.   if (!layersD || !(gimage = layersD->gimage))
  1834.     return;
  1835.   
  1836.   gimp_image_merge_down (gimage, gimage->active_layer, EXPAND_AS_NECESSARY);
  1837.   gdisplays_flush ();
  1838. }
  1839.  
  1840. void
  1841. layers_dialog_flatten_image_callback (GtkWidget *widget,
  1842.                       gpointer   data)
  1843. {
  1844.   GimpImage *gimage;
  1845.  
  1846.   if (!layersD || !(gimage = layersD->gimage))
  1847.     return;
  1848.  
  1849.   gimp_image_flatten (gimage);
  1850.   gdisplays_flush ();
  1851. }
  1852.  
  1853. void
  1854. layers_dialog_alpha_select_callback (GtkWidget *widget,
  1855.                      gpointer   data)
  1856. {
  1857.   GimpImage *gimage;
  1858.  
  1859.   if (!layersD || !(gimage = layersD->gimage))
  1860.     return;
  1861.  
  1862.   gimage_mask_layer_alpha (gimage, gimage->active_layer);
  1863.   gdisplays_flush ();
  1864. }
  1865.  
  1866. void
  1867. layers_dialog_mask_select_callback (GtkWidget *widget,
  1868.                     gpointer   data)
  1869. {
  1870.   GimpImage *gimage;
  1871.  
  1872.   if (!layersD || !(gimage = layersD->gimage))
  1873.     return;
  1874.  
  1875.   gimage_mask_layer_mask (gimage, gimage->active_layer);
  1876.   gdisplays_flush ();
  1877. }
  1878.  
  1879. void
  1880. layers_dialog_add_alpha_channel_callback (GtkWidget *widget,
  1881.                       gpointer   data)
  1882. {
  1883.   GimpImage *gimage;
  1884.   Layer     *layer;
  1885.  
  1886.   if (!layersD ||
  1887.       !(gimage = layersD->gimage) ||
  1888.       !(layer = gimp_image_get_active_layer (gimage)))
  1889.     return;
  1890.  
  1891.   layer_add_alpha (layer);
  1892.   gdisplays_flush ();
  1893. }
  1894.  
  1895. void
  1896. layers_dialog_edit_layer_attributes_callback (GtkWidget *widget,
  1897.                           gpointer   data)
  1898. {
  1899.   if (layersD && layersD->active_layer)
  1900.     {
  1901.       LayerWidget *layer_widget;
  1902.  
  1903.       layer_widget = layer_widget_get_ID (layersD->active_layer);
  1904.  
  1905.       layers_dialog_edit_layer_query (layer_widget);
  1906.     }
  1907. }
  1908.  
  1909. /*******************************/
  1910. /*  ops buttons dnd callbacks  */
  1911. /*******************************/
  1912.  
  1913. static gboolean
  1914. layers_dialog_drag_new_layer_callback (GtkWidget      *widget,
  1915.                        GdkDragContext *context,
  1916.                        gint            x,
  1917.                        gint            y,
  1918.                        guint           time)
  1919. {
  1920.   GtkWidget *src_widget;
  1921.   gboolean   return_val = FALSE;
  1922.  
  1923.   if ((src_widget = gtk_drag_get_source_widget (context)))
  1924.     {
  1925.       Layer *layer = NULL;
  1926.  
  1927.       layer = (Layer *) gtk_object_get_data (GTK_OBJECT (src_widget),
  1928.                          "gimp_layer");
  1929.  
  1930.       if (layer &&
  1931.       layer == layersD->active_layer)
  1932.     {
  1933.       Layer     *new_layer;
  1934.       GimpImage *gimage;
  1935.       gint       width, height;
  1936.       gint       off_x, off_y;
  1937.  
  1938.       gimage = layersD->gimage;
  1939.  
  1940.       width  = gimp_drawable_width  (GIMP_DRAWABLE (layer));
  1941.       height = gimp_drawable_height (GIMP_DRAWABLE (layer));
  1942.       gimp_drawable_offsets (GIMP_DRAWABLE (layer), &off_x, &off_y);
  1943.  
  1944.       /*  Start a group undo  */
  1945.       undo_push_group_start (gimage, EDIT_PASTE_UNDO);
  1946.  
  1947.       new_layer = layer_new (gimage, width, height,
  1948.                  gimp_image_base_type_with_alpha (gimage),
  1949.                  _("Empty Layer Copy"),
  1950.                  layer->opacity,
  1951.                  layer->mode);
  1952.       if (new_layer)
  1953.         {
  1954.           drawable_fill (GIMP_DRAWABLE (new_layer), TRANSPARENT_FILL);
  1955.           layer_translate (new_layer, off_x, off_y);
  1956.           gimp_image_add_layer (gimage, new_layer, -1);
  1957.  
  1958.           /*  End the group undo  */
  1959.           undo_push_group_end (gimage);
  1960.       
  1961.           gdisplays_flush ();
  1962.         } 
  1963.       else
  1964.         {
  1965.           g_message ("layers_dialog_drop_new_layer_callback():\n"
  1966.                "could not allocate new layer");
  1967.         }
  1968.  
  1969.       return_val = TRUE;
  1970.     }
  1971.     }
  1972.  
  1973.   gtk_drag_finish (context, return_val, FALSE, time);
  1974.  
  1975.   return return_val;
  1976. }
  1977.  
  1978. static gboolean
  1979. layers_dialog_drag_duplicate_layer_callback (GtkWidget      *widget,
  1980.                          GdkDragContext *context,
  1981.                          gint            x,
  1982.                          gint            y,
  1983.                          guint           time)
  1984. {
  1985.   GtkWidget *src_widget;
  1986.   gboolean   return_val = FALSE;
  1987.  
  1988.   if ((src_widget = gtk_drag_get_source_widget (context)))
  1989.     {
  1990.       Layer *layer;
  1991.  
  1992.       layer = (Layer *) gtk_object_get_data (GTK_OBJECT (src_widget),
  1993.                          "gimp_layer");
  1994.  
  1995.       if (layer &&
  1996.       layer == layersD->active_layer &&
  1997.       ! layer_is_floating_sel (layer))
  1998.     {
  1999.       layers_dialog_duplicate_layer_callback (widget, NULL);
  2000.  
  2001.       return_val = TRUE;
  2002.     }
  2003.     }
  2004.  
  2005.   gtk_drag_finish (context, return_val, FALSE, time);
  2006.  
  2007.   return return_val;
  2008. }
  2009.  
  2010. static gboolean
  2011. layers_dialog_drag_trashcan_callback (GtkWidget      *widget,
  2012.                       GdkDragContext *context,
  2013.                       gint            x,
  2014.                       gint            y,
  2015.                       guint           time)
  2016. {
  2017.   GtkWidget *src_widget;
  2018.   gboolean   return_val = FALSE;
  2019.  
  2020.   if ((src_widget = gtk_drag_get_source_widget (context)))
  2021.     {
  2022.       Layer *layer;
  2023.       LayerMask *layer_mask;
  2024.  
  2025.       layer = (Layer *) gtk_object_get_data (GTK_OBJECT (src_widget),
  2026.                          "gimp_layer");
  2027.       layer_mask = (LayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
  2028.                               "gimp_layer_mask");
  2029.  
  2030.       if (layer &&
  2031.       layer == layersD->active_layer)
  2032.     {
  2033.       layers_dialog_delete_layer_callback (widget, NULL);
  2034.  
  2035.       return_val = TRUE;
  2036.     }
  2037.       else if (layer_mask &&
  2038.            layer_mask_get_layer (layer_mask) == layersD->active_layer)
  2039.     {
  2040.       layers_dialog_delete_layer_mask_callback (widget, NULL);
  2041.  
  2042.       return_val = TRUE;
  2043.     }
  2044.     }
  2045.  
  2046.   gtk_drag_finish (context, return_val, FALSE, time);
  2047.  
  2048.   return return_val;
  2049. }
  2050.  
  2051. /****************************/
  2052. /*  layer widget functions  */
  2053. /****************************/
  2054.  
  2055. static LayerWidget *
  2056. layer_widget_get_ID (Layer *ID)
  2057. {
  2058.   LayerWidget *lw;
  2059.   GSList      *list;
  2060.  
  2061.   if (! layersD)
  2062.     return NULL;
  2063.  
  2064.   for (list = layersD->layer_widgets; list; list = g_slist_next (list))
  2065.     {
  2066.       lw = (LayerWidget *) list->data;
  2067.  
  2068.       if (lw->layer == ID)
  2069.     return lw;
  2070.     }
  2071.  
  2072.   return NULL;
  2073. }
  2074.  
  2075. static LayerWidget *
  2076. layer_widget_create (GimpImage *gimage,
  2077.              Layer     *layer)
  2078. {
  2079.   LayerWidget *layer_widget;
  2080.   GtkWidget   *list_item;
  2081.   GtkWidget   *hbox;
  2082.   GtkWidget   *vbox;
  2083.   GtkWidget   *alignment;
  2084.  
  2085.   list_item = gtk_list_item_new ();
  2086.  
  2087.   /*  create the layer widget and add it to the list  */
  2088.   layer_widget = g_new (LayerWidget, 1);
  2089.   layer_widget->gimage             = gimage;
  2090.   layer_widget->layer              = layer;
  2091.   layer_widget->list_item          = list_item;
  2092.   layer_widget->layer_preview      = NULL;
  2093.   layer_widget->mask_preview       = NULL;
  2094.   layer_widget->layer_pixmap       = NULL;
  2095.   layer_widget->mask_pixmap        = NULL;
  2096.   layer_widget->width              = -1;
  2097.   layer_widget->height             = -1;
  2098.   layer_widget->layer_mask         = (layer_get_mask (layer) != NULL);
  2099.   layer_widget->apply_mask         = layer->apply_mask;
  2100.   layer_widget->edit_mask          = layer->edit_mask;
  2101.   layer_widget->show_mask          = layer->show_mask;
  2102.   layer_widget->visited            = TRUE;
  2103.   layer_widget->drop_type          = GIMP_DROP_NONE;
  2104.   layer_widget->layer_pixmap_valid = FALSE;
  2105.  
  2106.   if (layer_get_mask (layer))
  2107.     layer_widget->active_preview =
  2108.       (layer->edit_mask) ? MASK_PREVIEW : LAYER_PREVIEW;
  2109.   else
  2110.     layer_widget->active_preview = LAYER_PREVIEW;
  2111.  
  2112.   /*  Need to let the list item know about the layer_widget  */
  2113.   gtk_object_set_user_data (GTK_OBJECT (list_item), layer_widget);
  2114.  
  2115.   /*  set up the list item observer  */
  2116.   gtk_signal_connect (GTK_OBJECT (list_item), "select",
  2117.               GTK_SIGNAL_FUNC (layer_widget_select_update),
  2118.               layer_widget);
  2119.   gtk_signal_connect (GTK_OBJECT (list_item), "deselect",
  2120.               GTK_SIGNAL_FUNC (layer_widget_select_update),
  2121.               layer_widget);
  2122.  
  2123.   vbox = gtk_vbox_new (FALSE, 1);
  2124.   gtk_container_add (GTK_CONTAINER (list_item), vbox);
  2125.  
  2126.   hbox = gtk_hbox_new (FALSE, 1);
  2127.   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 1);
  2128.  
  2129.   /* Create the visibility toggle button */
  2130.   alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
  2131.   gtk_box_pack_start (GTK_BOX (hbox), alignment, FALSE, TRUE, 2);
  2132.   layer_widget->eye_widget = gtk_drawing_area_new ();
  2133.   gtk_drawing_area_size (GTK_DRAWING_AREA (layer_widget->eye_widget),
  2134.              eye_width, eye_height);
  2135.   gtk_widget_set_events (layer_widget->eye_widget, BUTTON_EVENT_MASK);
  2136.   gtk_signal_connect (GTK_OBJECT (layer_widget->eye_widget), "event",
  2137.               GTK_SIGNAL_FUNC (layer_widget_button_events),
  2138.               layer_widget);
  2139.   gtk_object_set_user_data (GTK_OBJECT (layer_widget->eye_widget), layer_widget);
  2140.   gtk_container_add (GTK_CONTAINER (alignment), layer_widget->eye_widget);
  2141.   gtk_widget_show (layer_widget->eye_widget);
  2142.   gtk_widget_show (alignment);
  2143.  
  2144.   /* Create the link toggle button */
  2145.   alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
  2146.   gtk_box_pack_start (GTK_BOX (hbox), alignment, FALSE, TRUE, 2);
  2147.   layer_widget->linked_widget = gtk_drawing_area_new ();
  2148.   gtk_drawing_area_size (GTK_DRAWING_AREA (layer_widget->linked_widget),
  2149.              eye_width, eye_height);
  2150.   gtk_widget_set_events (layer_widget->linked_widget, BUTTON_EVENT_MASK);
  2151.   gtk_signal_connect (GTK_OBJECT (layer_widget->linked_widget), "event",
  2152.               GTK_SIGNAL_FUNC (layer_widget_button_events),
  2153.               layer_widget);
  2154.   gtk_object_set_user_data (GTK_OBJECT (layer_widget->linked_widget),
  2155.                 layer_widget);
  2156.   gtk_container_add (GTK_CONTAINER (alignment), layer_widget->linked_widget);
  2157.   gtk_widget_show (layer_widget->linked_widget);
  2158.   gtk_widget_show (alignment);
  2159.  
  2160.   /*  The layer preview  */
  2161.   alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
  2162.   gtk_box_pack_start (GTK_BOX (hbox), alignment, FALSE, FALSE, 2);
  2163.   gtk_widget_show (alignment);
  2164.  
  2165.   layer_widget->layer_preview = gtk_drawing_area_new ();
  2166.   gtk_drawing_area_size (GTK_DRAWING_AREA (layer_widget->layer_preview),
  2167.              layersD->image_width + 4, layersD->image_height + 4);
  2168.   gtk_widget_set_events (layer_widget->layer_preview, PREVIEW_EVENT_MASK);
  2169.   gtk_signal_connect_while_alive (GTK_OBJECT (layer_widget->layer_preview), 
  2170.                   "event",
  2171.                   GTK_SIGNAL_FUNC (layer_widget_preview_events),
  2172.                   layer_widget,
  2173.                   GTK_OBJECT (layer));
  2174.   gtk_object_set_user_data (GTK_OBJECT (layer_widget->layer_preview),
  2175.                 layer_widget);
  2176.   gtk_container_add (GTK_CONTAINER (alignment), layer_widget->layer_preview);
  2177.   gtk_widget_show (layer_widget->layer_preview);
  2178.  
  2179.   /*  The layer mask preview  */
  2180.   alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
  2181.   gtk_box_pack_start (GTK_BOX (hbox), alignment, FALSE, FALSE, 2);
  2182.   gtk_widget_show (alignment);
  2183.  
  2184.   layer_widget->mask_preview = gtk_drawing_area_new ();
  2185.   gtk_drawing_area_size (GTK_DRAWING_AREA (layer_widget->mask_preview),
  2186.              layersD->image_width + 4, layersD->image_height + 4);
  2187.   gtk_widget_set_events (layer_widget->mask_preview, PREVIEW_EVENT_MASK);
  2188.   gtk_signal_connect (GTK_OBJECT (layer_widget->mask_preview), "event",
  2189.               GTK_SIGNAL_FUNC (layer_widget_preview_events),
  2190.               layer_widget);
  2191.   gtk_object_set_user_data (GTK_OBJECT (layer_widget->mask_preview),
  2192.                 layer_widget);
  2193.   gtk_container_add (GTK_CONTAINER (alignment), layer_widget->mask_preview);
  2194.   if (layer_get_mask (layer) != NULL)
  2195.     {
  2196.       gtk_object_set_data (GTK_OBJECT (layer_widget->mask_preview),
  2197.                "gimp_layer_mask", layer_get_mask (layer));
  2198.       gtk_widget_show (layer_widget->mask_preview);
  2199.     }
  2200.  
  2201.   /*  dnd source  */
  2202.   gtk_drag_source_set (layer_widget->mask_preview,
  2203.                GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
  2204.                        layer_mask_target_table, n_layer_mask_targets, 
  2205.                        GDK_ACTION_MOVE | GDK_ACTION_COPY);
  2206.  
  2207.   gtk_signal_connect (GTK_OBJECT (layer_widget->mask_preview), "drag_begin",
  2208.                       GTK_SIGNAL_FUNC (layer_mask_drag_begin_callback),
  2209.               NULL);
  2210.  
  2211.   /*  the layer name label */
  2212.   if (layer_is_floating_sel (layer))
  2213.     layer_widget->label = gtk_label_new (_("Floating Selection"));
  2214.   else
  2215.     layer_widget->label = gtk_label_new (layer_get_name (layer));
  2216.  
  2217.   gtk_box_pack_start (GTK_BOX (hbox), layer_widget->label, FALSE, FALSE, 2);
  2218.   gtk_widget_show (layer_widget->label);
  2219.  
  2220.   layer_widget->clip_widget = gtk_drawing_area_new ();
  2221.   gtk_drawing_area_size (GTK_DRAWING_AREA (layer_widget->clip_widget), 1, 2);
  2222.   gtk_widget_set_events (layer_widget->clip_widget, BUTTON_EVENT_MASK);
  2223.   gtk_signal_connect (GTK_OBJECT (layer_widget->clip_widget), "event",
  2224.               GTK_SIGNAL_FUNC (layer_widget_button_events),
  2225.               layer_widget);
  2226.   gtk_object_set_user_data (GTK_OBJECT (layer_widget->clip_widget), layer_widget);
  2227.   gtk_box_pack_start (GTK_BOX (vbox), layer_widget->clip_widget,
  2228.               FALSE, FALSE, 0);
  2229.   /* gtk_widget_show (layer_widget->clip_widget); */
  2230.  
  2231.   /*  dnd destination  */
  2232.   gtk_drag_dest_set (list_item,
  2233.              GTK_DEST_DEFAULT_ALL,
  2234.                      layer_target_table, n_layer_targets,
  2235.                      GDK_ACTION_MOVE);
  2236.   gtk_signal_connect (GTK_OBJECT (list_item), "drag_leave",
  2237.                       GTK_SIGNAL_FUNC (layer_widget_drag_leave_callback),
  2238.               NULL);
  2239.   gtk_signal_connect (GTK_OBJECT (list_item), "drag_motion",
  2240.               GTK_SIGNAL_FUNC (layer_widget_drag_motion_callback),
  2241.               NULL);
  2242.   gtk_signal_connect (GTK_OBJECT (list_item), "drag_drop",
  2243.                       GTK_SIGNAL_FUNC (layer_widget_drag_drop_callback),
  2244.               NULL);
  2245.  
  2246.   /*  re-paint the drop indicator after drawing the widget  */
  2247.   gtk_signal_connect_after (GTK_OBJECT (list_item), "draw",
  2248.                 (GtkSignalFunc) layer_widget_drag_indicator_callback,
  2249.                 layer_widget);
  2250.  
  2251.   /*  dnd source  */
  2252.   gtk_drag_source_set (list_item,
  2253.                GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
  2254.                        layer_target_table, n_layer_targets, 
  2255.                        GDK_ACTION_MOVE | GDK_ACTION_COPY);
  2256.  
  2257.   gtk_signal_connect (GTK_OBJECT (list_item), "drag_begin",
  2258.                       GTK_SIGNAL_FUNC (layer_widget_drag_begin_callback),
  2259.               NULL);
  2260.  
  2261.   gtk_object_set_data (GTK_OBJECT (list_item), "gimp_layer", (gpointer) layer);
  2262.  
  2263.   gtk_widget_show (hbox);
  2264.   gtk_widget_show (vbox);
  2265.   gtk_widget_show (list_item);
  2266.  
  2267.   gtk_widget_ref (layer_widget->list_item);
  2268.  
  2269.   gtk_signal_connect_while_alive (GTK_OBJECT (layer), "invalidate_pr",
  2270.                   GTK_SIGNAL_FUNC (invalidate_preview_callback),
  2271.                   (gpointer)layer_widget,
  2272.                   GTK_OBJECT (layer_widget->list_item));
  2273.  
  2274.   return layer_widget;
  2275. }
  2276.  
  2277. static gboolean
  2278. layer_widget_drag_motion_callback (GtkWidget      *widget,
  2279.                    GdkDragContext *context,
  2280.                    gint            x,
  2281.                    gint            y,
  2282.                    guint           time)
  2283. {
  2284.   LayerWidget   *dest;
  2285.   gint           dest_index;
  2286.   GtkWidget     *src_widget;
  2287.   LayerWidget   *src;
  2288.   gint           src_index;
  2289.   gint           difference;
  2290.   GimpDropType   drop_type   = GIMP_DROP_NONE;
  2291.   GdkDragAction  drag_action = GDK_ACTION_DEFAULT;
  2292.   gboolean       return_val  = FALSE;
  2293.  
  2294.   dest = (LayerWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  2295.  
  2296.   if (dest &&
  2297.       layer_has_alpha (dest->layer) &&
  2298.       (src_widget = gtk_drag_get_source_widget (context)))
  2299.     {
  2300.       src
  2301.     = (LayerWidget *) gtk_object_get_user_data (GTK_OBJECT (src_widget));
  2302.  
  2303.       if (src &&
  2304.       layer_has_alpha (src->layer) &&
  2305.       ! layer_is_floating_sel (src->layer) &&
  2306.       src->layer == layersD->active_layer)
  2307.     {
  2308.       src_index  = gimp_image_get_layer_index (layersD->gimage, 
  2309.                            src->layer);
  2310.       dest_index = gimp_image_get_layer_index (layersD->gimage, 
  2311.                            dest->layer);
  2312.  
  2313.       difference = dest_index - src_index;
  2314.  
  2315.       drop_type = ((y < widget->allocation.height / 2) ?
  2316.                GIMP_DROP_ABOVE : GIMP_DROP_BELOW);
  2317.  
  2318.       if (difference < 0 &&
  2319.           drop_type == GIMP_DROP_BELOW)
  2320.         {
  2321.           dest_index++;
  2322.         }
  2323.       else if (difference > 0 &&
  2324.            drop_type == GIMP_DROP_ABOVE)
  2325.         {
  2326.           dest_index--;
  2327.         }
  2328.  
  2329.       if (src_index != dest_index)
  2330.         {
  2331.           drag_action = GDK_ACTION_MOVE;
  2332.           return_val = TRUE;
  2333.         }
  2334.       else
  2335.         {
  2336.           drop_type = GIMP_DROP_NONE;
  2337.         }
  2338.     }
  2339.     }
  2340.  
  2341.   gdk_drag_status (context, drag_action, time);
  2342.  
  2343.   if (dest && drop_type != dest->drop_type)
  2344.     {
  2345.       layer_widget_draw_drop_indicator (dest, dest->drop_type);
  2346.       layer_widget_draw_drop_indicator (dest, drop_type);
  2347.       dest->drop_type = drop_type;
  2348.     }
  2349.  
  2350.   return return_val;
  2351. }
  2352.  
  2353. static void
  2354. layer_widget_drag_begin_callback (GtkWidget      *widget,
  2355.                   GdkDragContext *context)
  2356. {
  2357.   LayerWidget *layer_widget;
  2358.  
  2359.   layer_widget = 
  2360.     (LayerWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  2361.  
  2362.   gimp_dnd_set_drawable_preview_icon (widget, context,
  2363.                       GIMP_DRAWABLE (layer_widget->layer));
  2364. }
  2365.  
  2366. static void
  2367. layer_mask_drag_begin_callback (GtkWidget      *widget,
  2368.                 GdkDragContext *context)
  2369. {
  2370.   LayerWidget *layer_widget;
  2371.  
  2372.   layer_widget = 
  2373.     (LayerWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  2374.  
  2375.   gimp_dnd_set_drawable_preview_icon
  2376.     (widget, context,
  2377.      GIMP_DRAWABLE (layer_get_mask (layer_widget->layer)));
  2378. }
  2379.  
  2380. typedef struct
  2381. {
  2382.   GimpImage *gimage;
  2383.   Layer     *layer;
  2384.   gint       dest_index;
  2385. } LayerDrop;
  2386.  
  2387. static gint
  2388. layer_widget_idle_drop_layer (gpointer data)
  2389. {
  2390.   LayerDrop *ld;
  2391.  
  2392.   ld = (LayerDrop *) data;
  2393.  
  2394.   gimp_image_position_layer (ld->gimage, ld->layer, ld->dest_index, TRUE);
  2395.   gdisplays_flush ();
  2396.  
  2397.   g_free (ld);
  2398.  
  2399.   return FALSE;
  2400. }
  2401.  
  2402. static gboolean
  2403. layer_widget_drag_drop_callback (GtkWidget      *widget,
  2404.                  GdkDragContext *context,
  2405.                  gint            x,
  2406.                  gint            y,
  2407.                  guint           time)
  2408. {
  2409.   LayerWidget  *dest;
  2410.   gint          dest_index;
  2411.   GtkWidget    *src_widget;
  2412.   LayerWidget  *src;
  2413.   gint          src_index;
  2414.   gint          difference;
  2415.   GimpDropType  drop_type  = GIMP_DROP_NONE;
  2416.   gboolean      return_val = FALSE;
  2417.  
  2418.   dest = (LayerWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  2419.  
  2420.   if (dest &&
  2421.       layer_has_alpha (dest->layer) &&
  2422.       (src_widget = gtk_drag_get_source_widget (context)))
  2423.     {
  2424.       src = 
  2425.     (LayerWidget *) gtk_object_get_user_data (GTK_OBJECT (src_widget));
  2426.  
  2427.       if (src &&
  2428.       layer_has_alpha (src->layer) &&
  2429.       ! layer_is_floating_sel (src->layer) &&
  2430.       src->layer == layersD->active_layer)
  2431.     {
  2432.       src_index  = 
  2433.         gimp_image_get_layer_index (layersD->gimage, src->layer);
  2434.       dest_index = 
  2435.         gimp_image_get_layer_index (layersD->gimage, dest->layer);
  2436.  
  2437.       difference = dest_index - src_index;
  2438.  
  2439.       drop_type = ((y < widget->allocation.height / 2) ?
  2440.                GIMP_DROP_ABOVE : GIMP_DROP_BELOW);
  2441.  
  2442.       if (difference < 0 &&
  2443.           drop_type == GIMP_DROP_BELOW)
  2444.         {
  2445.           dest_index++;
  2446.         }
  2447.       else if (difference > 0 &&
  2448.            drop_type == GIMP_DROP_ABOVE)
  2449.         {
  2450.           dest_index--;
  2451.         }
  2452.  
  2453.       if (src_index != dest_index)
  2454.         {
  2455.           LayerDrop *ld;
  2456.  
  2457.           ld = g_new (LayerDrop, 1);
  2458.           ld->gimage     = layersD->gimage;
  2459.           ld->layer      = src->layer;
  2460.           ld->dest_index = dest_index;
  2461.  
  2462.           /*  let dnd finish it's work before changing the widget tree  */
  2463.           gtk_idle_add ((GtkFunction) layer_widget_idle_drop_layer, ld);
  2464.           return_val = TRUE;
  2465.         }
  2466.     }
  2467.     }
  2468.  
  2469.   if (dest)
  2470.     {
  2471.       if (!return_val)
  2472.     layer_widget_draw_drop_indicator (dest, dest->drop_type);
  2473.  
  2474.       dest->drop_type = GIMP_DROP_NONE;
  2475.     }
  2476.  
  2477.   gtk_drag_finish (context, return_val, FALSE, time);
  2478.  
  2479.   return return_val;
  2480. }
  2481.  
  2482. static void
  2483. layer_widget_drag_leave_callback (GtkWidget      *widget,
  2484.                   GdkDragContext *context,
  2485.                   guint           time)
  2486. {
  2487.   LayerWidget *layer_widget;
  2488.  
  2489.   layer_widget = 
  2490.     (LayerWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  2491.  
  2492.   layer_widget->drop_type = GIMP_DROP_NONE;
  2493. }
  2494.  
  2495. static void
  2496. layer_widget_drag_indicator_callback (GtkWidget *widget,
  2497.                       gpointer   data)
  2498. {
  2499.   LayerWidget *layer_widget;
  2500.  
  2501.   layer_widget = 
  2502.     (LayerWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  2503.  
  2504.   layer_widget_draw_drop_indicator (layer_widget, layer_widget->drop_type);
  2505. }
  2506.  
  2507. static void
  2508. layer_widget_draw_drop_indicator (LayerWidget   *layer_widget,
  2509.                   GimpDropType   drop_type)
  2510. {
  2511.   static GdkGC *gc = NULL;
  2512.   gint          y  = 0;
  2513.  
  2514.   if (!gc)
  2515.     {
  2516.       GdkColor fg, bg;
  2517.  
  2518.       gc = gdk_gc_new (layer_widget->list_item->window);
  2519.  
  2520.       fg.pixel = 0xFFFFFFFF;
  2521.       bg.pixel = 0x00000000;
  2522.  
  2523.       gdk_gc_set_function (gc, GDK_INVERT);
  2524.       gdk_gc_set_foreground (gc, &fg);
  2525.       gdk_gc_set_background (gc, &bg);
  2526.       gdk_gc_set_line_attributes (gc, 5, GDK_LINE_SOLID,
  2527.                   GDK_CAP_BUTT, GDK_JOIN_MITER);
  2528.     }
  2529.  
  2530.   if (drop_type != GIMP_DROP_NONE)
  2531.     {
  2532.       y = ((drop_type == GIMP_DROP_ABOVE) ?
  2533.        3 : layer_widget->list_item->allocation.height - 4);
  2534.  
  2535.       gdk_draw_line (layer_widget->list_item->window, gc,
  2536.              2, y, layer_widget->list_item->allocation.width - 3, y);
  2537.     }
  2538. }
  2539.  
  2540. static void
  2541. layer_widget_delete (LayerWidget *layer_widget)
  2542. {
  2543.   if (layer_widget->layer_pixmap)
  2544.     gdk_pixmap_unref (layer_widget->layer_pixmap);
  2545.   if (layer_widget->mask_pixmap)
  2546.     gdk_pixmap_unref (layer_widget->mask_pixmap);
  2547.  
  2548.   /*  Remove the layer widget from the list  */
  2549.   layersD->layer_widgets = g_slist_remove (layersD->layer_widgets, layer_widget);
  2550.  
  2551.   /*  Release the widget  */
  2552.   gtk_widget_unref (layer_widget->list_item);
  2553.   g_free (layer_widget);
  2554. }
  2555.  
  2556. static void
  2557. layer_widget_select_update (GtkWidget *widget,
  2558.                 gpointer   data)
  2559. {
  2560.   LayerWidget *layer_widget;
  2561.  
  2562.   if (! (layer_widget = (LayerWidget *) data))
  2563.     return;
  2564.  
  2565.   /*  Is the list item being selected?  */
  2566.   if (widget->state != GTK_STATE_SELECTED)
  2567.     return;
  2568.  
  2569.   /*  Only notify the gimage of an active layer change if necessary  */
  2570.   if (suspend_gimage_notify == 0)
  2571.     {
  2572.       /*  set the gimage's active layer to be this layer  */
  2573.       gimp_image_set_active_layer (layer_widget->gimage, layer_widget->layer);
  2574.  
  2575.       gdisplays_flush ();
  2576.     }
  2577. }
  2578.  
  2579. static gint
  2580. layer_widget_button_events (GtkWidget *widget,
  2581.                 GdkEvent  *event,
  2582.                 gpointer   data)
  2583. {
  2584.   LayerWidget      *layer_widget;
  2585.   GtkWidget        *event_widget;
  2586.   GdkEventButton   *bevent;
  2587.   gint              return_val;
  2588.  
  2589.   static gboolean   button_down  = FALSE;
  2590.   static GtkWidget *click_widget = NULL;
  2591.   static gint       old_state;
  2592.   static gint       exclusive;
  2593.  
  2594.   layer_widget = 
  2595.     (LayerWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  2596.  
  2597.   return_val = FALSE;
  2598.  
  2599.   switch (event->type)
  2600.     {
  2601.     case GDK_EXPOSE:
  2602.       if (widget == layer_widget->eye_widget)
  2603.     layer_widget_eye_redraw (layer_widget);
  2604.       else if (widget == layer_widget->linked_widget)
  2605.     layer_widget_linked_redraw (layer_widget);
  2606.       else if (widget == layer_widget->clip_widget)
  2607.     layer_widget_clip_redraw (layer_widget);
  2608.       break;
  2609.  
  2610.     case GDK_BUTTON_PRESS:
  2611.       return_val = TRUE;
  2612.       bevent = (GdkEventButton *) event;
  2613.  
  2614.       if (bevent->button == 3)
  2615.     {
  2616.       gtk_menu_popup (GTK_MENU (layersD->ops_menu),
  2617.               NULL, NULL, NULL, NULL,
  2618.               3, bevent->time);
  2619.       return TRUE;
  2620.     }
  2621.  
  2622.       button_down = TRUE;
  2623.       click_widget = widget;
  2624.       gtk_grab_add (click_widget);
  2625.       
  2626.       if (widget == layer_widget->eye_widget)
  2627.     {
  2628.       old_state = GIMP_DRAWABLE (layer_widget->layer)->visible;
  2629.  
  2630.       /*  If this was a shift-click, make all/none visible  */
  2631.       if (event->button.state & GDK_SHIFT_MASK)
  2632.         {
  2633.           exclusive = TRUE;
  2634.           layer_widget_exclusive_visible (layer_widget);
  2635.         }
  2636.       else
  2637.         {
  2638.           exclusive = FALSE;
  2639.           GIMP_DRAWABLE (layer_widget->layer)->visible =
  2640.         !GIMP_DRAWABLE (layer_widget->layer)->visible;
  2641.           layer_widget_eye_redraw (layer_widget);
  2642.         }
  2643.     }
  2644.       else if (widget == layer_widget->linked_widget)
  2645.     {
  2646.       old_state = layer_widget->layer->linked;
  2647.       layer_widget->layer->linked = !layer_widget->layer->linked;
  2648.       layer_widget_linked_redraw (layer_widget);
  2649.     }
  2650.       break;
  2651.  
  2652.     case GDK_BUTTON_RELEASE:
  2653.       return_val = TRUE;
  2654.  
  2655.       button_down = FALSE;
  2656.       gtk_grab_remove (click_widget);
  2657.  
  2658.       if (widget == layer_widget->eye_widget)
  2659.     {
  2660.       if (exclusive)
  2661.                {
  2662.           gimp_image_invalidate_preview (layer_widget->gimage);
  2663.           gdisplays_update_area (layer_widget->gimage, 0, 0,
  2664.                      layer_widget->gimage->width,
  2665.                      layer_widget->gimage->height);
  2666.           gdisplays_flush ();
  2667.         }
  2668.       else if (old_state != GIMP_DRAWABLE (layer_widget->layer)->visible)
  2669.         {
  2670.           /*  Invalidate the gimage preview  */
  2671.           gimp_image_invalidate_preview (layer_widget->gimage);
  2672.           drawable_update (GIMP_DRAWABLE (layer_widget->layer), 0, 0,
  2673.                    GIMP_DRAWABLE (layer_widget->layer)->width,
  2674.                    GIMP_DRAWABLE (layer_widget->layer)->height);
  2675.           gdisplays_flush (); 
  2676.         }
  2677.     }
  2678.       else if ((widget == layer_widget->linked_widget) &&
  2679.            (old_state != layer_widget->layer->linked))
  2680.     {
  2681.     }
  2682.       break;
  2683.  
  2684.     case GDK_LEAVE_NOTIFY:
  2685.       event_widget = gtk_get_event_widget (event);
  2686.  
  2687.      if (button_down && (event_widget == click_widget))
  2688.     {
  2689.       /* the user moved the cursor out of the widget before
  2690.              releasing the button -> cancel the button_press */ 
  2691.       button_down = FALSE;
  2692.  
  2693.       if (widget == layer_widget->eye_widget)
  2694.         {
  2695.           if (exclusive)
  2696.         {
  2697.           layer_widget_exclusive_visible (layer_widget);
  2698.         }
  2699.           else
  2700.         {
  2701.           GIMP_DRAWABLE (layer_widget->layer)->visible =
  2702.             !GIMP_DRAWABLE (layer_widget->layer)->visible;
  2703.           layer_widget_eye_redraw (layer_widget);
  2704.         }
  2705.         }
  2706.       else if (widget == layer_widget->linked_widget)
  2707.         {
  2708.           layer_widget->layer->linked = !layer_widget->layer->linked;
  2709.           layer_widget_linked_redraw (layer_widget);
  2710.         }
  2711.     }
  2712.       break;
  2713.  
  2714.     default:
  2715.       break;
  2716.     }
  2717.  
  2718.   return return_val;
  2719. }
  2720.  
  2721. static gint
  2722. layer_widget_preview_events (GtkWidget *widget,
  2723.                  GdkEvent  *event,
  2724.                  gpointer   data)
  2725. {
  2726.   LayerWidget     *layer_widget;
  2727.   GdkEventExpose  *eevent;
  2728.   GdkEventButton  *bevent;
  2729.   GdkPixmap      **pixmap;
  2730.   gboolean         valid;
  2731.   gint             preview_type;
  2732.   gint             sx, sy, dx, dy, w, h;
  2733.  
  2734.   pixmap = NULL;
  2735.   valid  = FALSE;
  2736.  
  2737.   layer_widget = 
  2738.     (LayerWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  2739.  
  2740.   g_return_val_if_fail (layer_widget != NULL, FALSE);
  2741.   g_return_val_if_fail (layer_widget->layer != NULL, FALSE);  
  2742.  
  2743.   if (!GIMP_IS_DRAWABLE (layer_widget->layer))
  2744.     return FALSE;
  2745.  
  2746.   if (widget == layer_widget->layer_preview)
  2747.     preview_type = LAYER_PREVIEW;
  2748.   else if (widget == layer_widget->mask_preview && GTK_WIDGET_VISIBLE (widget))
  2749.     preview_type = MASK_PREVIEW;
  2750.   else
  2751.     return FALSE;
  2752.  
  2753.   switch (preview_type)
  2754.     {
  2755.     case LAYER_PREVIEW:
  2756.       pixmap = &layer_widget->layer_pixmap;
  2757.       valid  = GIMP_DRAWABLE (layer_widget->layer)->preview_valid;
  2758.       break;
  2759.     case MASK_PREVIEW:
  2760.       pixmap = &layer_widget->mask_pixmap;
  2761.       valid  = 
  2762.     GIMP_DRAWABLE (layer_get_mask (layer_widget->layer))->preview_valid;
  2763.       break;
  2764.     }
  2765.  
  2766.   if (layer_is_floating_sel (layer_widget->layer))
  2767.     preview_type = FS_PREVIEW;
  2768.  
  2769.   switch (event->type)
  2770.     {
  2771.      case GDK_BUTTON_PRESS:
  2772.       /*  Control-button press disables the application of the mask  */
  2773.       bevent = (GdkEventButton *) event;
  2774.  
  2775.       if (bevent->button == 3)
  2776.     {
  2777.       gtk_menu_popup (GTK_MENU (layersD->ops_menu),
  2778.               NULL, NULL, NULL, NULL,
  2779.               3, bevent->time);
  2780.       return TRUE;
  2781.     }
  2782.  
  2783.       if (event->button.state & GDK_CONTROL_MASK)
  2784.     {
  2785.       if (preview_type == MASK_PREVIEW)
  2786.         {
  2787.           gimage_set_layer_mask_apply (layer_widget->gimage,
  2788.                        layer_widget->layer);
  2789.           gdisplays_flush ();
  2790.         }
  2791.     }
  2792.       /*  Alt-button press makes the mask visible instead of the layer  */
  2793.       else if (event->button.state & GDK_MOD1_MASK)
  2794.     {
  2795.       if (preview_type == MASK_PREVIEW)
  2796.         {
  2797.           gimage_set_layer_mask_show (layer_widget->gimage,
  2798.                       layer_widget->layer);
  2799.           gdisplays_flush ();
  2800.         }
  2801.     }
  2802.       else if (layer_widget->active_preview != preview_type)
  2803.     {
  2804.       gimage_set_layer_mask_edit (layer_widget->gimage,
  2805.                       layer_widget->layer,
  2806.                       (preview_type == MASK_PREVIEW));
  2807.       gdisplays_flush ();
  2808.     }
  2809.       break;
  2810.  
  2811.     case GDK_EXPOSE:
  2812.       if (!preview_size && preview_type != FS_PREVIEW)
  2813.     layer_widget_no_preview_redraw (layer_widget, preview_type);
  2814.       else
  2815.     {
  2816.       if (!valid || !*pixmap)
  2817.         {
  2818.           layer_widget_preview_redraw (layer_widget, preview_type);
  2819.  
  2820.           gdk_draw_pixmap (widget->window,
  2821.                    widget->style->black_gc,
  2822.                    *pixmap,
  2823.                    0, 0, 2, 2,
  2824.                    layersD->image_width,
  2825.                    layersD->image_height);
  2826.         }
  2827.       else
  2828.         {
  2829.           eevent = (GdkEventExpose *) event;
  2830.  
  2831.           w = eevent->area.width;
  2832.           h = eevent->area.height;
  2833.  
  2834.           if (eevent->area.x < 2)
  2835.         {
  2836.           sx = eevent->area.x;
  2837.           dx = 2;
  2838.           w -= (2 - eevent->area.x);
  2839.         }
  2840.           else
  2841.         {
  2842.           sx = eevent->area.x - 2;
  2843.           dx = eevent->area.x;
  2844.         }
  2845.  
  2846.           if (eevent->area.y < 2)
  2847.         {
  2848.           sy = eevent->area.y;
  2849.           dy = 2;
  2850.           h -= (2 - eevent->area.y);
  2851.         }
  2852.           else
  2853.         {
  2854.           sy = eevent->area.y - 2;
  2855.           dy = eevent->area.y;
  2856.         }
  2857.  
  2858.           if ((sx + w) >= layersD->image_width)
  2859.         w = layersD->image_width - sx;
  2860.  
  2861.           if ((sy + h) >= layersD->image_height)
  2862.         h = layersD->image_height - sy;
  2863.  
  2864.           if ((w > 0) && (h > 0))
  2865.         {
  2866.         /* 
  2867.        Expose events are optimzed away by GTK+ if the widget is not
  2868.        visible. Therefore, previews not visible in the layers_dialog
  2869.        are not redrawn when they invalidate. Later the preview gets
  2870.        validated by the image_preview in lc_dialog but is never
  2871.        propagated to the layer_pixmap. We work around this by using an
  2872.        additional flag "layer_pixmap_valid" so that the pixmap gets
  2873.        updated once the preview scrolls into sight.
  2874.        We should probably do the same for all drawables (masks, 
  2875.        channels), but it is much more difficult to change one of these
  2876.        when it's not visible.
  2877.      */
  2878.           if (preview_type == LAYER_PREVIEW && 
  2879.               ! layer_widget->layer_pixmap_valid)
  2880.             {
  2881.               layer_widget_preview_redraw (layer_widget, preview_type);
  2882.             }
  2883.  
  2884.           gdk_draw_pixmap (widget->window,
  2885.                    widget->style->black_gc,
  2886.                    *pixmap,
  2887.                    sx, sy, dx, dy, w, h);
  2888.         }
  2889.         }
  2890.     } 
  2891.  
  2892.       /*  The boundary indicating whether layer or mask is active  */
  2893.       layer_widget_boundary_redraw (layer_widget, preview_type);
  2894.       break;
  2895.  
  2896.     default:
  2897.       break;
  2898.     }
  2899.  
  2900.   return FALSE;
  2901. }
  2902.  
  2903. static void
  2904. layer_widget_boundary_redraw (LayerWidget *layer_widget,
  2905.                   gint         preview_type)
  2906. {
  2907.   GtkWidget    *widget;
  2908.   GdkGC        *gc1;
  2909.   GdkGC        *gc2;
  2910.   GtkStateType  state;
  2911.  
  2912.   if (preview_type == LAYER_PREVIEW)
  2913.     widget = layer_widget->layer_preview;
  2914.   else if (preview_type == MASK_PREVIEW)
  2915.     widget = layer_widget->mask_preview;
  2916.   else
  2917.     return;
  2918.  
  2919.   state = layer_widget->list_item->state;
  2920.   if (state == GTK_STATE_SELECTED)
  2921.     {
  2922.       if (layer_widget->active_preview == preview_type)
  2923.     gc1 = layer_widget->layer_preview->style->white_gc;
  2924.       else
  2925.     gc1 = layer_widget->layer_preview->style->bg_gc[GTK_STATE_SELECTED];
  2926.     }
  2927.   else
  2928.     {
  2929.       if (layer_widget->active_preview == preview_type)
  2930.     gc1 = layer_widget->layer_preview->style->black_gc;
  2931.       else
  2932.     gc1 = layer_widget->layer_preview->style->white_gc;
  2933.     }
  2934.  
  2935.   gc2 = gc1;
  2936.   if (preview_type == MASK_PREVIEW)
  2937.     {
  2938.       if (layersD->green_gc == NULL)
  2939.     {
  2940.       GdkColor green;
  2941.  
  2942.       green.pixel = get_color (0, 255, 0);
  2943.       layersD->green_gc = gdk_gc_new (widget->window);
  2944.       gdk_gc_set_foreground (layersD->green_gc, &green);
  2945.     }
  2946.  
  2947.       if (layersD->red_gc == NULL)
  2948.     {
  2949.       GdkColor red;
  2950.  
  2951.       red.pixel = get_color (255, 0, 0);
  2952.       layersD->red_gc = gdk_gc_new (widget->window);
  2953.       gdk_gc_set_foreground (layersD->red_gc, &red);
  2954.     }
  2955.  
  2956.       if (layer_widget->layer->show_mask)
  2957.     gc2 = layersD->green_gc;
  2958.       else if (! layer_widget->layer->apply_mask)
  2959.     gc2 = layersD->red_gc;
  2960.     }
  2961.  
  2962.   gdk_draw_rectangle (widget->window,
  2963.               gc1, FALSE, 0, 0,
  2964.               layersD->image_width + 3,
  2965.               layersD->image_height + 3);
  2966.  
  2967.   gdk_draw_rectangle (widget->window,
  2968.               gc2, FALSE, 1, 1,
  2969.               layersD->image_width + 1,
  2970.               layersD->image_height + 1);
  2971. }
  2972.  
  2973. static void
  2974. layer_widget_preview_redraw (LayerWidget *layer_widget,
  2975.                  gint         preview_type)
  2976. {
  2977.   TempBuf    *preview_buf;
  2978.   GdkPixmap **pixmap;
  2979.   GtkWidget  *widget;
  2980.   gint        offx;
  2981.   gint        offy;
  2982.  
  2983.   preview_buf = NULL;
  2984.   pixmap = NULL;
  2985.   widget = NULL;
  2986.  
  2987.   switch (preview_type)
  2988.     {
  2989.     case LAYER_PREVIEW:
  2990.     case FS_PREVIEW:
  2991.       widget = layer_widget->layer_preview;
  2992.       pixmap = &layer_widget->layer_pixmap;
  2993.       break;
  2994.     case MASK_PREVIEW:
  2995.       widget = layer_widget->mask_preview;
  2996.       pixmap = &layer_widget->mask_pixmap;
  2997.       break;
  2998.     }
  2999.  
  3000.   /*  allocate the layer widget pixmap  */
  3001.   if (! *pixmap)
  3002.     *pixmap = gdk_pixmap_new (widget->window,
  3003.                   layersD->image_width,
  3004.                   layersD->image_height,
  3005.                   -1);
  3006.  
  3007.   /*  If this is a floating selection preview, draw the preview  */
  3008.   if (preview_type == FS_PREVIEW)
  3009.     render_fs_preview (widget, *pixmap);
  3010.   /*  otherwise, ask the layer or mask for the preview  */
  3011.   else
  3012.     {
  3013.       /*  determine width and height  */
  3014.       layer_widget->width  = 
  3015.     RINT (layersD->ratio * GIMP_DRAWABLE (layer_widget->layer)->width);
  3016.       layer_widget->height = 
  3017.     RINT (layersD->ratio * GIMP_DRAWABLE (layer_widget->layer)->height);
  3018.  
  3019.       if (layer_widget->width < 1)  
  3020.     layer_widget->width = 1;
  3021.       if (layer_widget->height < 1)  
  3022.     layer_widget->height = 1;
  3023.  
  3024.       offx = RINT (layersD->ratio *
  3025.            GIMP_DRAWABLE (layer_widget->layer)->offset_x);
  3026.       offy = RINT (layersD->ratio *
  3027.            GIMP_DRAWABLE (layer_widget->layer)->offset_y);
  3028.  
  3029.       switch (preview_type)
  3030.     {
  3031.     case LAYER_PREVIEW:
  3032.       preview_buf = layer_preview (layer_widget->layer,
  3033.                        layer_widget->width,
  3034.                        layer_widget->height);
  3035.       
  3036.       layer_widget->layer_pixmap_valid = TRUE;
  3037.       break;
  3038.  
  3039.     case MASK_PREVIEW:
  3040.       preview_buf = layer_mask_preview (layer_widget->layer,
  3041.                         layer_widget->width,
  3042.                         layer_widget->height);
  3043.       break;
  3044.     }
  3045.  
  3046.       preview_buf->x = offx;
  3047.       preview_buf->y = offy;
  3048.  
  3049.       render_preview (preview_buf,
  3050.               layersD->layer_preview,
  3051.               layersD->image_width,
  3052.               layersD->image_height,
  3053.               -1);
  3054.  
  3055.       gtk_preview_put (GTK_PREVIEW (layersD->layer_preview),
  3056.                *pixmap, widget->style->black_gc,
  3057.                0, 0, 0, 0, 
  3058.                layersD->image_width, layersD->image_height);
  3059.  
  3060.       /*  make sure the image has been transfered completely to the pixmap 
  3061.        *  before we use it again...
  3062.        */
  3063.       gdk_flush ();
  3064.     }
  3065.  
  3066.   lc_dialog_menu_preview_dirty
  3067.     (GTK_OBJECT (gimp_drawable_gimage (GIMP_DRAWABLE (layer_widget->layer))),
  3068.      NULL);
  3069. }
  3070.  
  3071. static void
  3072. layer_widget_no_preview_redraw (LayerWidget *layer_widget,
  3073.                 gint         preview_type)
  3074. {
  3075.   GdkPixmap     *pixmap;
  3076.   GdkPixmap    **pixmap_normal;
  3077.   GdkPixmap    **pixmap_selected;
  3078.   GdkPixmap    **pixmap_insensitive;
  3079.   GdkColor      *color;
  3080.   GtkWidget     *widget;
  3081.   GtkStateType   state;
  3082.   gchar         *bits;
  3083.   gint           width, height;
  3084.  
  3085.   pixmap_normal      = NULL;
  3086.   pixmap_selected    = NULL;
  3087.   pixmap_insensitive = NULL;
  3088.   widget             = NULL;
  3089.   bits               = NULL;
  3090.   width              = 0;
  3091.   height             = 0;
  3092.  
  3093.   state = layer_widget->list_item->state;
  3094.  
  3095.   switch (preview_type)
  3096.     {
  3097.     case LAYER_PREVIEW:
  3098.       widget = layer_widget->layer_preview;
  3099.       pixmap_normal = &layer_pixmap[NORMAL];
  3100.       pixmap_selected = &layer_pixmap[SELECTED];
  3101.       pixmap_insensitive = &layer_pixmap[INSENSITIVE];
  3102.       bits = (gchar *) layer_bits;
  3103.       width = layer_width;
  3104.       height = layer_height;
  3105.       break;
  3106.  
  3107.     case MASK_PREVIEW:
  3108.       widget = layer_widget->mask_preview;
  3109.       pixmap_normal = &mask_pixmap[NORMAL];
  3110.       pixmap_selected = &mask_pixmap[SELECTED];
  3111.       pixmap_insensitive = &mask_pixmap[INSENSITIVE];
  3112.       bits = (gchar *) mask_bits;
  3113.       width = mask_width;
  3114.       height = mask_height;
  3115.       break;
  3116.     }
  3117.  
  3118.   if (GTK_WIDGET_IS_SENSITIVE (layer_widget->list_item))
  3119.     {
  3120.       if (state == GTK_STATE_SELECTED)
  3121.     color = &widget->style->bg[GTK_STATE_SELECTED];
  3122.       else
  3123.     color = &widget->style->white;
  3124.     }
  3125.   else
  3126.     color = &widget->style->bg[GTK_STATE_INSENSITIVE];
  3127.  
  3128.   gdk_window_set_background (widget->window, color);
  3129.  
  3130.   if (!*pixmap_normal)
  3131.     {
  3132.       *pixmap_normal =
  3133.     gdk_pixmap_create_from_data (widget->window,
  3134.                      bits, width, height, -1,
  3135.                      &widget->style->fg[GTK_STATE_SELECTED],
  3136.                      &widget->style->bg[GTK_STATE_SELECTED]);
  3137.       *pixmap_selected =
  3138.     gdk_pixmap_create_from_data (widget->window,
  3139.                      bits, width, height, -1,
  3140.                      &widget->style->fg[GTK_STATE_NORMAL],
  3141.                      &widget->style->white);
  3142.       *pixmap_insensitive =
  3143.     gdk_pixmap_create_from_data (widget->window,
  3144.                      bits, width, height, -1,
  3145.                      &widget->style->fg[GTK_STATE_INSENSITIVE],
  3146.                      &widget->style->bg[GTK_STATE_INSENSITIVE]);
  3147.     }
  3148.  
  3149.   if (GTK_WIDGET_IS_SENSITIVE (layer_widget->list_item))
  3150.     {
  3151.       if (state == GTK_STATE_SELECTED)
  3152.     pixmap = *pixmap_selected;
  3153.       else
  3154.     pixmap = *pixmap_normal;
  3155.     }
  3156.   else
  3157.     pixmap = *pixmap_insensitive;
  3158.  
  3159.   gdk_draw_pixmap (widget->window,
  3160.            widget->style->black_gc,
  3161.            pixmap, 0, 0, 2, 2, width, height);
  3162. }
  3163.  
  3164. static void
  3165. layer_widget_eye_redraw (LayerWidget *layer_widget)
  3166. {
  3167.   GdkPixmap    *pixmap;
  3168.   GdkColor     *color;
  3169.   GtkStateType  state;
  3170.  
  3171.   state = layer_widget->list_item->state;
  3172.  
  3173.   if (GTK_WIDGET_IS_SENSITIVE (layer_widget->list_item))
  3174.     {
  3175.       if (state == GTK_STATE_SELECTED)
  3176.     color = &layer_widget->eye_widget->style->bg[GTK_STATE_SELECTED];
  3177.       else
  3178.     color = &layer_widget->eye_widget->style->white;
  3179.     }
  3180.   else
  3181.     color = &layer_widget->eye_widget->style->bg[GTK_STATE_INSENSITIVE];
  3182.  
  3183.   gdk_window_set_background (layer_widget->eye_widget->window, color);
  3184.  
  3185.   if (GIMP_DRAWABLE(layer_widget->layer)->visible)
  3186.     {
  3187.       if (!eye_pixmap[NORMAL])
  3188.     {
  3189.       eye_pixmap[NORMAL] =
  3190.         gdk_pixmap_create_from_data (layer_widget->eye_widget->window,
  3191.                      (gchar*) eye_bits,
  3192.                      eye_width, eye_height, -1,
  3193.                      &layer_widget->eye_widget->style->fg[GTK_STATE_NORMAL],
  3194.                      &layer_widget->eye_widget->style->white);
  3195.       eye_pixmap[SELECTED] =
  3196.         gdk_pixmap_create_from_data (layer_widget->eye_widget->window,
  3197.                      (gchar*) eye_bits,
  3198.                      eye_width, eye_height, -1,
  3199.                      &layer_widget->eye_widget->style->fg[GTK_STATE_SELECTED],
  3200.                      &layer_widget->eye_widget->style->bg[GTK_STATE_SELECTED]);
  3201.       eye_pixmap[INSENSITIVE] =
  3202.         gdk_pixmap_create_from_data (layer_widget->eye_widget->window,
  3203.                      (gchar*) eye_bits,
  3204.                      eye_width, eye_height, -1,
  3205.                      &layer_widget->eye_widget->style->fg[GTK_STATE_INSENSITIVE],
  3206.                      &layer_widget->eye_widget->style->bg[GTK_STATE_INSENSITIVE]);
  3207.     }
  3208.  
  3209.       if (GTK_WIDGET_IS_SENSITIVE (layer_widget->list_item))
  3210.     {
  3211.       if (state == GTK_STATE_SELECTED)
  3212.         pixmap = eye_pixmap[SELECTED];
  3213.       else
  3214.         pixmap = eye_pixmap[NORMAL];
  3215.     }
  3216.       else
  3217.     pixmap = eye_pixmap[INSENSITIVE];
  3218.  
  3219.       gdk_draw_pixmap (layer_widget->eye_widget->window,
  3220.                layer_widget->eye_widget->style->black_gc,
  3221.                pixmap, 0, 0, 0, 0, eye_width, eye_height);
  3222.     }
  3223.   else
  3224.     {
  3225.       gdk_window_clear (layer_widget->eye_widget->window);
  3226.     }
  3227. }
  3228.  
  3229. static void
  3230. layer_widget_linked_redraw (LayerWidget *layer_widget)
  3231. {
  3232.   GdkPixmap    *pixmap;
  3233.   GdkColor     *color;
  3234.   GtkStateType  state;
  3235.  
  3236.   state = layer_widget->list_item->state;
  3237.  
  3238.   if (GTK_WIDGET_IS_SENSITIVE (layer_widget->list_item))
  3239.     {
  3240.       if (state == GTK_STATE_SELECTED)
  3241.     color = &layer_widget->linked_widget->style->bg[GTK_STATE_SELECTED];
  3242.       else
  3243.     color = &layer_widget->linked_widget->style->white;
  3244.     }
  3245.   else
  3246.     color = &layer_widget->linked_widget->style->bg[GTK_STATE_INSENSITIVE];
  3247.  
  3248.   gdk_window_set_background (layer_widget->linked_widget->window, color);
  3249.  
  3250.   if (layer_widget->layer->linked)
  3251.     {
  3252.       if (!linked_pixmap[NORMAL])
  3253.     {
  3254.       linked_pixmap[NORMAL] =
  3255.         gdk_pixmap_create_from_data (layer_widget->linked_widget->window,
  3256.                      (gchar*) linked_bits, linked_width, linked_height, -1,
  3257.                      &layer_widget->linked_widget->style->fg[GTK_STATE_NORMAL],
  3258.                      &layer_widget->linked_widget->style->white);
  3259.       linked_pixmap[SELECTED] =
  3260.         gdk_pixmap_create_from_data (layer_widget->linked_widget->window,
  3261.                      (gchar*) linked_bits, linked_width, linked_height, -1,
  3262.                      &layer_widget->linked_widget->style->fg[GTK_STATE_SELECTED],
  3263.                      &layer_widget->linked_widget->style->bg[GTK_STATE_SELECTED]);
  3264.       linked_pixmap[INSENSITIVE] =
  3265.         gdk_pixmap_create_from_data (layer_widget->linked_widget->window,
  3266.                      (gchar*) linked_bits, linked_width, linked_height, -1,
  3267.                      &layer_widget->linked_widget->style->fg[GTK_STATE_INSENSITIVE],
  3268.                      &layer_widget->linked_widget->style->bg[GTK_STATE_INSENSITIVE]);
  3269.     }
  3270.  
  3271.       if (GTK_WIDGET_IS_SENSITIVE (layer_widget->list_item))
  3272.     {
  3273.       if (state == GTK_STATE_SELECTED)
  3274.         pixmap = linked_pixmap[SELECTED];
  3275.       else
  3276.         pixmap = linked_pixmap[NORMAL];
  3277.     }
  3278.       else
  3279.     pixmap = linked_pixmap[INSENSITIVE];
  3280.  
  3281.       gdk_draw_pixmap (layer_widget->linked_widget->window,
  3282.                layer_widget->linked_widget->style->black_gc,
  3283.                pixmap, 0, 0, 0, 0, linked_width, linked_height);
  3284.     }
  3285.   else
  3286.     {
  3287.       gdk_window_clear (layer_widget->linked_widget->window);
  3288.     }
  3289. }
  3290.  
  3291. static void
  3292. layer_widget_clip_redraw (LayerWidget *layer_widget)
  3293. {
  3294.   GdkColor     *color;
  3295.   GtkStateType  state;
  3296.  
  3297.   state = layer_widget->list_item->state;
  3298.   color = &layer_widget->clip_widget->style->fg[state];
  3299.  
  3300.   gdk_window_set_background (layer_widget->clip_widget->window, color);
  3301.   gdk_window_clear (layer_widget->clip_widget->window);
  3302. }
  3303.  
  3304. static void
  3305. layer_widget_exclusive_visible (LayerWidget *layer_widget)
  3306. {
  3307.   GSList      *list;
  3308.   LayerWidget *lw;
  3309.   gboolean     visible = FALSE;
  3310.  
  3311.   if (!layersD)
  3312.     return;
  3313.  
  3314.   /*  First determine if _any_ other layer widgets are set to visible  */
  3315.   for (list = layersD->layer_widgets; list;  list = g_slist_next (list))
  3316.     {
  3317.       lw = (LayerWidget *) list->data;
  3318.  
  3319.       if (lw != layer_widget)
  3320.     visible |= GIMP_DRAWABLE (lw->layer)->visible;
  3321.     }
  3322.  
  3323.   /*  Now, toggle the visibility for all layers except the specified one  */
  3324.   for (list = layersD->layer_widgets; list; list = g_slist_next (list))
  3325.     {
  3326.       lw = (LayerWidget *) list->data;
  3327.  
  3328.       if (lw != layer_widget)
  3329.     GIMP_DRAWABLE (lw->layer)->visible = !visible;
  3330.       else
  3331.     GIMP_DRAWABLE (lw->layer)->visible = TRUE;
  3332.  
  3333.       layer_widget_eye_redraw (lw);
  3334.     }
  3335. }
  3336.  
  3337. static void
  3338. layer_widget_layer_flush (GtkWidget *widget,
  3339.               gpointer   data)
  3340. {
  3341.   LayerWidget *layer_widget;
  3342.   Layer       *layer;
  3343.   gchar       *name;
  3344.   gchar       *label_name;
  3345.   gboolean     update_layer_preview = FALSE;
  3346.   gboolean     update_mask_preview  = FALSE;
  3347.  
  3348.   layer_widget = (LayerWidget *) gtk_object_get_user_data (GTK_OBJECT (widget));
  3349.   layer = layer_widget->layer;
  3350.  
  3351.   /*  Set sensitivity  */
  3352.  
  3353.   /*  to false if there is a floating selection, and this aint it  */
  3354.   if (! layer_is_floating_sel (layer_widget->layer) &&
  3355.       layersD->floating_sel != NULL)
  3356.     {
  3357.       if (GTK_WIDGET_IS_SENSITIVE (layer_widget->list_item))
  3358.     gtk_widget_set_sensitive (layer_widget->list_item, FALSE);
  3359.     }
  3360.   /*  to true if there is a floating selection, and this is it  */
  3361.   if (layer_is_floating_sel (layer_widget->layer) &&
  3362.       layersD->floating_sel != NULL)
  3363.     {
  3364.       if (! GTK_WIDGET_IS_SENSITIVE (layer_widget->list_item))
  3365.     gtk_widget_set_sensitive (layer_widget->list_item, TRUE);
  3366.     }
  3367.   /*  to true if there is not floating selection  */
  3368.   else if (layersD->floating_sel == NULL)
  3369.     {
  3370.       if (! GTK_WIDGET_IS_SENSITIVE (layer_widget->list_item))
  3371.     gtk_widget_set_sensitive (layer_widget->list_item, TRUE);
  3372.     }
  3373.  
  3374.   /*  if there is an active channel, unselect layer  */
  3375.   if (layersD->active_channel != NULL)
  3376.     layers_dialog_unset_layer (layer_widget->layer);
  3377.   /*  otherwise, if this is the active layer, set  */
  3378.   else if (layersD->active_layer == layer_widget->layer)
  3379.     {
  3380.       layers_dialog_set_active_layer (layersD->active_layer);
  3381.       /*  set the data widgets to reflect this layer's values
  3382.        *  1)  The opacity slider
  3383.        *  2)  The paint mode menu
  3384.        *  3)  The preserve trans button
  3385.        */
  3386.       gtk_adjustment_set_value (GTK_ADJUSTMENT (layersD->opacity_data),
  3387.                 (gfloat) layer_widget->layer->opacity / 2.55);
  3388.       gimp_option_menu_set_history (GTK_OPTION_MENU (layersD->mode_option_menu),
  3389.                     (gpointer) layer_widget->layer->mode);
  3390.       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (layersD->preserve_trans),
  3391.                     (layer_widget->layer->preserve_trans) ?
  3392.                     GTK_STATE_ACTIVE : GTK_STATE_NORMAL);
  3393.     }
  3394.  
  3395.   if (layer_is_floating_sel (layer_widget->layer))
  3396.     name = _("Floating Selection");
  3397.   else
  3398.     name = layer_get_name (layer_widget->layer);
  3399.  
  3400.   /*  we need to set the name label if necessary  */
  3401.   gtk_label_get (GTK_LABEL (layer_widget->label), &label_name);
  3402.   if (strcmp (name, label_name))
  3403.     gtk_label_set_text (GTK_LABEL (layer_widget->label), name);
  3404.  
  3405.   /*  show the layer mask preview if necessary  */
  3406.   if (layer_get_mask (layer_widget->layer) == NULL &&
  3407.       layer_widget->layer_mask)
  3408.     {
  3409.       layer_widget->layer_mask = FALSE;
  3410.       layers_dialog_remove_layer_mask (layer_widget->layer);
  3411.     }
  3412.   else if (layer_get_mask (layer_widget->layer) != NULL &&
  3413.        !layer_widget->layer_mask)
  3414.     {
  3415.       layer_widget->layer_mask = TRUE;
  3416.       layers_dialog_add_layer_mask (layer_widget->layer);
  3417.     }
  3418.  
  3419.   /*  Update the previews  */
  3420.   update_layer_preview = (! GIMP_DRAWABLE (layer)->preview_valid);
  3421.  
  3422.   if (layer_get_mask (layer))
  3423.     {
  3424.       update_mask_preview = 
  3425.     (! GIMP_DRAWABLE (layer_get_mask (layer))->preview_valid);
  3426.  
  3427.       if (layer->apply_mask != layer_widget->apply_mask)
  3428.     {
  3429.       layer_widget->apply_mask = layer->apply_mask;
  3430.       update_mask_preview = TRUE;
  3431.     }
  3432.       if (layer->show_mask != layer_widget->show_mask)
  3433.     {
  3434.       layer_widget->show_mask = layer->show_mask;
  3435.       update_mask_preview = TRUE;
  3436.     }
  3437.       if (layer->edit_mask != layer_widget->edit_mask)
  3438.     {
  3439.       layer_widget->edit_mask = layer->edit_mask;
  3440.  
  3441.       if (layer->edit_mask == TRUE)
  3442.         layer_widget->active_preview = MASK_PREVIEW;
  3443.       else
  3444.         layer_widget->active_preview = LAYER_PREVIEW;
  3445.  
  3446.       /*  The boundary indicating whether layer or mask is active  */
  3447.       layer_widget_boundary_redraw (layer_widget, LAYER_PREVIEW);
  3448.       layer_widget_boundary_redraw (layer_widget, MASK_PREVIEW);
  3449.     }
  3450.     }
  3451.  
  3452.   if (update_layer_preview)
  3453.     gtk_widget_queue_draw (layer_widget->layer_preview);
  3454.   if (update_mask_preview)
  3455.     gtk_widget_queue_draw (layer_widget->mask_preview);
  3456. }
  3457.  
  3458. /********************************/
  3459. /*  The new layer query dialog  */
  3460. /********************************/
  3461.  
  3462. typedef struct _NewLayerOptions NewLayerOptions;
  3463.  
  3464. struct _NewLayerOptions
  3465. {
  3466.   GtkWidget    *query_box;
  3467.   GtkWidget    *name_entry;
  3468.   GtkWidget    *size_se;
  3469.  
  3470.   GimpFillType  fill_type;
  3471.   gint          xsize;
  3472.   gint          ysize;
  3473.  
  3474.   GimpImage    *gimage;
  3475. };
  3476.  
  3477. static GimpFillType  fill_type  = TRANSPARENT_FILL;
  3478. static gchar        *layer_name = NULL;
  3479.  
  3480. static void
  3481. new_layer_query_ok_callback (GtkWidget *widget,
  3482.                  gpointer   data)
  3483. {
  3484.   NewLayerOptions *options;
  3485.   Layer           *layer;
  3486.   GimpImage       *gimage;
  3487.  
  3488.   options = (NewLayerOptions *) data;
  3489.  
  3490.   if (layer_name)
  3491.     g_free (layer_name);
  3492.   layer_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (options->name_entry)));
  3493.  
  3494.   options->xsize = 
  3495.     RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (options->size_se), 0));
  3496.   options->ysize =
  3497.     RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (options->size_se), 1));
  3498.  
  3499.   fill_type = options->fill_type;
  3500.  
  3501.   if ((gimage = options->gimage))
  3502.     {
  3503.       /*  Start a group undo  */
  3504.       undo_push_group_start (gimage, LAYER_ADD_UNDO);
  3505.  
  3506.       layer = layer_new (gimage, options->xsize, options->ysize,
  3507.              gimp_image_base_type_with_alpha (gimage),
  3508.              layer_name, OPAQUE_OPACITY, NORMAL_MODE);
  3509.       if (layer) 
  3510.     {
  3511.       drawable_fill (GIMP_DRAWABLE (layer), fill_type);
  3512.       gimp_image_add_layer (gimage, layer, -1);
  3513.       
  3514.       /*  End the group undo  */
  3515.       undo_push_group_end (gimage);
  3516.       
  3517.       gdisplays_flush ();
  3518.     } 
  3519.       else 
  3520.     {
  3521.       g_message ("new_layer_query_ok_callback():\n"
  3522.              "could not allocate new layer");
  3523.     }
  3524.     }
  3525.  
  3526.   gtk_widget_destroy (options->query_box);
  3527. }
  3528.  
  3529. static void
  3530. layers_dialog_new_layer_query (GimpImage* gimage)
  3531. {
  3532.   NewLayerOptions *options;
  3533.   GtkWidget       *vbox;
  3534.   GtkWidget       *table;
  3535.   GtkWidget       *label;
  3536.   GtkObject       *adjustment;
  3537.   GtkWidget       *spinbutton;
  3538.   GtkWidget       *frame;
  3539.  
  3540.   /*  The new options structure  */
  3541.   options = g_new (NewLayerOptions, 1);
  3542.   options->fill_type = fill_type;
  3543.   options->gimage    = gimage;
  3544.  
  3545.   /*  The dialog  */
  3546.   options->query_box =
  3547.     gimp_dialog_new (_("New Layer Options"), "new_layer_options",
  3548.              gimp_standard_help_func,
  3549.              "dialogs/layers/new_layer.html",
  3550.              GTK_WIN_POS_MOUSE,
  3551.              FALSE, TRUE, FALSE,
  3552.  
  3553.              _("OK"), new_layer_query_ok_callback,
  3554.              options, NULL, NULL, TRUE, FALSE,
  3555.              _("Cancel"), gtk_widget_destroy,
  3556.              NULL, 1, NULL, FALSE, TRUE,
  3557.  
  3558.              NULL);
  3559.  
  3560.   gtk_signal_connect_object (GTK_OBJECT (options->query_box), "destroy",
  3561.                  GTK_SIGNAL_FUNC (g_free),
  3562.                  (GtkObject *) options);
  3563.  
  3564.   /*  The main vbox  */
  3565.   vbox = gtk_vbox_new (FALSE, 2);
  3566.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  3567.   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (options->query_box)->vbox),
  3568.              vbox);
  3569.  
  3570.   table = gtk_table_new (3, 2, FALSE);
  3571.   gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4);
  3572.   gtk_table_set_row_spacing (GTK_TABLE (table), 0, 4);
  3573.   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  3574.  
  3575.   /*  The name label and entry  */
  3576.   label = gtk_label_new (_("Layer Name:"));
  3577.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
  3578.   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
  3579.             GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 1);
  3580.   gtk_widget_show (label);
  3581.  
  3582.   options->name_entry = gtk_entry_new ();
  3583.   gtk_widget_set_usize (options->name_entry, 75, 0);
  3584.   gtk_table_attach_defaults (GTK_TABLE (table), 
  3585.                  options->name_entry, 1, 2, 0, 1);
  3586.   gtk_entry_set_text (GTK_ENTRY (options->name_entry),
  3587.               (layer_name ? layer_name : _("New Layer")));
  3588.   gtk_widget_show (options->name_entry);
  3589.  
  3590.   /*  The size labels  */
  3591.   label = gtk_label_new (_("Layer Width:"));
  3592.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
  3593.   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
  3594.             GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0);
  3595.   gtk_widget_show (label);
  3596.  
  3597.   label = gtk_label_new (_("Height:"));
  3598.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
  3599.   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
  3600.             GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0);
  3601.   gtk_widget_show (label);
  3602.  
  3603.   /*  The size sizeentry  */
  3604.   adjustment = gtk_adjustment_new (1, 1, 1, 1, 10, 1);
  3605.   spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 1, 2);
  3606.   gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinbutton),
  3607.                    GTK_SHADOW_NONE);
  3608.   gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
  3609.   gtk_widget_set_usize (spinbutton, 75, 0);
  3610.   
  3611.   options->size_se = gimp_size_entry_new (1, gimage->unit, "%a",
  3612.                       TRUE, TRUE, FALSE, 75,
  3613.                       GIMP_SIZE_ENTRY_UPDATE_SIZE);
  3614.   gimp_size_entry_add_field (GIMP_SIZE_ENTRY (options->size_se),
  3615.                              GTK_SPIN_BUTTON (spinbutton), NULL);
  3616.   gtk_table_attach_defaults (GTK_TABLE (options->size_se), spinbutton,
  3617.                              1, 2, 0, 1);
  3618.   gtk_widget_show (spinbutton);
  3619.   gtk_table_attach (GTK_TABLE (table), options->size_se, 1, 2, 1, 3,
  3620.                     GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  3621.   gtk_widget_show (options->size_se);
  3622.  
  3623.   gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (options->size_se), 
  3624.                 GIMP_UNIT_PIXEL);
  3625.  
  3626.   gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (options->size_se), 0,
  3627.                                   gimage->xresolution, FALSE);
  3628.   gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (options->size_se), 1,
  3629.                                   gimage->yresolution, FALSE);
  3630.  
  3631.   gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (options->size_se), 0,
  3632.                                          GIMP_MIN_IMAGE_SIZE,
  3633.                                          GIMP_MAX_IMAGE_SIZE);
  3634.   gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (options->size_se), 1,
  3635.                                          GIMP_MIN_IMAGE_SIZE,
  3636.                                          GIMP_MAX_IMAGE_SIZE);
  3637.  
  3638.   gimp_size_entry_set_size (GIMP_SIZE_ENTRY (options->size_se), 0,
  3639.                 0, gimage->width);
  3640.   gimp_size_entry_set_size (GIMP_SIZE_ENTRY (options->size_se), 1,
  3641.                 0, gimage->height);
  3642.  
  3643.   gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (options->size_se), 0,
  3644.                   gimage->width);
  3645.   gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (options->size_se), 1,
  3646.                   gimage->height);
  3647.  
  3648.   gtk_widget_show (table);
  3649.  
  3650.   /*  The radio frame  */
  3651.   frame =
  3652.     gimp_radio_group_new2 (TRUE, _("Layer Fill Type"),
  3653.                gimp_radio_button_update,
  3654.                &options->fill_type, (gpointer) options->fill_type,
  3655.  
  3656.                _("Foreground"),  (gpointer) FOREGROUND_FILL, NULL,
  3657.                _("Background"),  (gpointer) BACKGROUND_FILL, NULL,
  3658.                _("White"),       (gpointer) WHITE_FILL, NULL,
  3659.                _("Transparent"), (gpointer) TRANSPARENT_FILL, NULL,
  3660.  
  3661.                NULL);
  3662.  
  3663.   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
  3664.   gtk_widget_show (frame);
  3665.  
  3666.   gtk_widget_show (vbox);
  3667.   gtk_widget_show (options->query_box);
  3668. }
  3669.  
  3670. /**************************************/
  3671. /*  The edit layer attributes dialog  */
  3672. /**************************************/
  3673.  
  3674. typedef struct _EditLayerOptions EditLayerOptions;
  3675.  
  3676. struct _EditLayerOptions
  3677. {
  3678.   GtkWidget *query_box;
  3679.   GtkWidget *name_entry;
  3680.   GimpLayer *layer;
  3681.   GimpImage *gimage;
  3682. };
  3683.  
  3684. static void
  3685. edit_layer_query_ok_callback (GtkWidget *widget,
  3686.                   gpointer   data)
  3687. {
  3688.   EditLayerOptions *options;
  3689.   Layer            *layer;
  3690.  
  3691.   options = (EditLayerOptions *) data;
  3692.  
  3693.   if ((layer = options->layer))
  3694.     {
  3695.       /*  Set the new layer name  */
  3696.       if (GIMP_DRAWABLE (layer)->name && layer_is_floating_sel (layer))
  3697.     {
  3698.       /*  If the layer is a floating selection, make it a layer  */
  3699.       floating_sel_to_layer (layer);
  3700.     }
  3701.       else
  3702.         {
  3703.       /* We're doing a plain rename */
  3704.           undo_push_layer_rename (options->gimage, layer);
  3705.         }
  3706.  
  3707.       layer_set_name (layer,
  3708.               gtk_entry_get_text (GTK_ENTRY (options->name_entry)));
  3709.     }
  3710.  
  3711.   gdisplays_flush ();
  3712.  
  3713.   gtk_widget_destroy (options->query_box); 
  3714. }
  3715.  
  3716. static void
  3717. layers_dialog_edit_layer_query (LayerWidget *layer_widget)
  3718. {
  3719.   EditLayerOptions *options;
  3720.   GtkWidget        *vbox;
  3721.   GtkWidget        *hbox;
  3722.   GtkWidget        *label;
  3723.  
  3724.   /*  The new options structure  */
  3725.   options = g_new (EditLayerOptions, 1);
  3726.   options->layer  = layer_widget->layer;
  3727.   options->gimage = layer_widget->gimage;
  3728.  
  3729.   /*  The dialog  */
  3730.   options->query_box =
  3731.     gimp_dialog_new (_("Edit Layer Attributes"), "edit_layer_attributes",
  3732.              gimp_standard_help_func,
  3733.              "dialogs/layers/edit_layer_attributes.html",
  3734.              GTK_WIN_POS_MOUSE,
  3735.              FALSE, TRUE, FALSE,
  3736.  
  3737.              _("OK"), edit_layer_query_ok_callback,
  3738.              options, NULL, NULL, TRUE, FALSE,
  3739.              _("Cancel"), gtk_widget_destroy,
  3740.              NULL, 1, NULL, FALSE, TRUE,
  3741.  
  3742.              NULL);
  3743.  
  3744.   gtk_signal_connect_object (GTK_OBJECT (options->query_box), "destroy",
  3745.                  GTK_SIGNAL_FUNC (g_free),
  3746.                  (GtkObject *) options);
  3747.  
  3748.   /*  The main vbox  */
  3749.   vbox = gtk_vbox_new (FALSE, 2);
  3750.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  3751.   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (options->query_box)->vbox),
  3752.              vbox);
  3753.  
  3754.   /*  The name hbox, label and entry  */
  3755.   hbox = gtk_hbox_new (FALSE, 4);
  3756.   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  3757.  
  3758.   label = gtk_label_new (_("Layer name:"));
  3759.   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
  3760.   gtk_widget_show (label);
  3761.  
  3762.   options->name_entry = gtk_entry_new ();
  3763.   gtk_box_pack_start (GTK_BOX (hbox), options->name_entry, TRUE, TRUE, 0);
  3764.   gtk_entry_set_text (GTK_ENTRY (options->name_entry),
  3765.               ((layer_is_floating_sel (layer_widget->layer) ?
  3766.             _("Floating Selection") :
  3767.             layer_get_name (layer_widget->layer))));
  3768.   gtk_signal_connect (GTK_OBJECT (options->name_entry), "activate",
  3769.               edit_layer_query_ok_callback,
  3770.               options);
  3771.   gtk_widget_show (options->name_entry);
  3772.  
  3773.   gtk_widget_show (hbox);
  3774.  
  3775.   gtk_widget_show (vbox);
  3776.   gtk_widget_show (options->query_box);
  3777. }
  3778.  
  3779. /*******************************/
  3780. /*  The add mask query dialog  */
  3781. /*******************************/
  3782.  
  3783. typedef struct _AddMaskOptions AddMaskOptions;
  3784.  
  3785. struct _AddMaskOptions
  3786. {
  3787.   GtkWidget   *query_box;
  3788.   Layer       *layer;
  3789.   AddMaskType  add_mask_type;
  3790. };
  3791.  
  3792. static void
  3793. add_mask_query_ok_callback (GtkWidget *widget,
  3794.                 gpointer   data)
  3795. {
  3796.   AddMaskOptions *options;
  3797.   GimpImage      *gimage;
  3798.   LayerMask      *mask;
  3799.   Layer          *layer;
  3800.  
  3801.   options = (AddMaskOptions *) data;
  3802.   if ((layer = (options->layer)) &&
  3803.       (gimage = GIMP_DRAWABLE (layer)->gimage))
  3804.     {
  3805.       mask = layer_create_mask (layer, options->add_mask_type);
  3806.       gimp_image_add_layer_mask (gimage, layer, mask);
  3807.       gdisplays_flush ();
  3808.     }
  3809.  
  3810.   gtk_widget_destroy (options->query_box);
  3811. }
  3812.  
  3813. static void
  3814. layers_dialog_add_mask_query (Layer *layer)
  3815. {
  3816.   AddMaskOptions *options;
  3817.   GtkWidget      *frame;
  3818.  
  3819.   /*  The new options structure  */
  3820.   options = g_new (AddMaskOptions, 1);
  3821.   options->layer         = layer;
  3822.   options->add_mask_type = ADD_WHITE_MASK;
  3823.  
  3824.   /*  The dialog  */
  3825.   options->query_box =
  3826.     gimp_dialog_new (_("Add Mask Options"), "add_mask_options",
  3827.              gimp_standard_help_func,
  3828.              "dialogs/layers/add_layer_mask.html",
  3829.              GTK_WIN_POS_MOUSE,
  3830.              FALSE, TRUE, FALSE,
  3831.  
  3832.              _("OK"), add_mask_query_ok_callback,
  3833.              options, NULL, NULL, TRUE, FALSE,
  3834.              _("Cancel"), gtk_widget_destroy,
  3835.              NULL, 1, NULL, FALSE, TRUE,
  3836.  
  3837.              NULL);
  3838.  
  3839.   gtk_signal_connect_object (GTK_OBJECT (options->query_box), "destroy",
  3840.                  GTK_SIGNAL_FUNC (g_free),
  3841.                  (GtkObject *) options);
  3842.  
  3843.   /*  The radio frame and box  */
  3844.   frame = gimp_radio_group_new2 (TRUE, _("Initialize Layer Mask to:"),
  3845.                  gimp_radio_button_update,
  3846.                  &options->add_mask_type,
  3847.                  (gpointer) options->add_mask_type,
  3848.  
  3849.                  _("White (Full Opacity)"),
  3850.                  (gpointer) ADD_WHITE_MASK, NULL,
  3851.                  _("Black (Full Transparency)"),
  3852.                  (gpointer) ADD_BLACK_MASK, NULL,
  3853.                  _("Layer's Alpha Channel"),
  3854.                  (gpointer) ADD_ALPHA_MASK, NULL,
  3855.                  NULL);
  3856.  
  3857.   gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
  3858.   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (options->query_box)->vbox),
  3859.              frame);
  3860.   gtk_widget_show (frame);
  3861.  
  3862.   gtk_widget_show (options->query_box);
  3863. }
  3864.  
  3865.  
  3866. /****************************/
  3867. /*  The scale layer dialog  */
  3868. /****************************/
  3869.  
  3870. typedef struct _ScaleLayerOptions ScaleLayerOptions;
  3871.  
  3872. struct _ScaleLayerOptions
  3873. {
  3874.   Layer  *layer;
  3875.   Resize *resize;
  3876. };
  3877.  
  3878. static void
  3879. scale_layer_query_ok_callback (GtkWidget *widget,
  3880.                    gpointer   data)
  3881. {
  3882.   ScaleLayerOptions *options;
  3883.   GimpImage         *gimage;
  3884.   Layer             *layer;
  3885.  
  3886.   options = (ScaleLayerOptions *) data;
  3887.  
  3888.   if (options->resize->width > 0 && options->resize->height > 0 &&
  3889.       (layer =  (options->layer)))
  3890.     {
  3891.       gtk_widget_set_sensitive (options->resize->resize_shell, FALSE);
  3892.  
  3893.       if ((gimage = GIMP_DRAWABLE (layer)->gimage) != NULL)
  3894.     {
  3895.       undo_push_group_start (gimage, LAYER_SCALE_UNDO);
  3896.  
  3897.       if (layer_is_floating_sel (layer))
  3898.         floating_sel_relax (layer, TRUE);
  3899.  
  3900.       layer_scale (layer, 
  3901.                options->resize->width, options->resize->height, TRUE);
  3902.  
  3903.       if (layer_is_floating_sel (layer))
  3904.         floating_sel_rigor (layer, TRUE);
  3905.  
  3906.       undo_push_group_end (gimage);
  3907.  
  3908.       gdisplays_flush ();
  3909.     }
  3910.  
  3911.       gtk_widget_destroy (options->resize->resize_shell);
  3912.     }
  3913.   else
  3914.     {
  3915.       g_message (_("Invalid width or height.\n"
  3916.            "Both must be positive."));
  3917.     }
  3918. }
  3919.  
  3920. static void
  3921. layers_dialog_scale_layer_query (GimpImage *gimage,
  3922.                  Layer     *layer)
  3923. {
  3924.   ScaleLayerOptions *options;
  3925.  
  3926.   /*  the new options structure  */
  3927.   options = g_new (ScaleLayerOptions, 1);
  3928.   options->layer  = layer;
  3929.   options->resize = resize_widget_new (ScaleWidget,
  3930.                        ResizeLayer,
  3931.                        GTK_OBJECT (layer),
  3932.                        "removed",
  3933.                        drawable_width (GIMP_DRAWABLE (layer)),
  3934.                        drawable_height (GIMP_DRAWABLE (layer)),
  3935.                        gimage->xresolution,
  3936.                        gimage->yresolution,
  3937.                        gimage->unit,
  3938.                        TRUE,
  3939.                        scale_layer_query_ok_callback,
  3940.                        NULL,
  3941.                        options);
  3942.  
  3943.   gtk_signal_connect_object (GTK_OBJECT (options->resize->resize_shell),
  3944.                  "destroy",
  3945.                  GTK_SIGNAL_FUNC (g_free),
  3946.                  (GtkObject *) options);
  3947.  
  3948.   gtk_widget_show (options->resize->resize_shell);
  3949. }
  3950.  
  3951. /*****************************/
  3952. /*  The resize layer dialog  */
  3953. /*****************************/
  3954.  
  3955. typedef struct _ResizeLayerOptions ResizeLayerOptions;
  3956.  
  3957. struct _ResizeLayerOptions
  3958. {
  3959.   Layer  *layer;
  3960.   Resize *resize;
  3961. };
  3962.  
  3963. static void
  3964. resize_layer_query_ok_callback (GtkWidget *widget,
  3965.                 gpointer   data)
  3966. {
  3967.   ResizeLayerOptions *options;
  3968.   GimpImage          *gimage;
  3969.   Layer              *layer;
  3970.  
  3971.   options = (ResizeLayerOptions *) data;
  3972.  
  3973.   if (options->resize->width > 0 && options->resize->height > 0 &&
  3974.       (layer = (options->layer)))
  3975.     {
  3976.       gtk_widget_set_sensitive (options->resize->resize_shell, FALSE);
  3977.  
  3978.       if ((gimage = GIMP_DRAWABLE (layer)->gimage) != NULL)
  3979.     {
  3980.       undo_push_group_start (gimage, LAYER_RESIZE_UNDO);
  3981.  
  3982.       if (layer_is_floating_sel (layer))
  3983.         floating_sel_relax (layer, TRUE);
  3984.  
  3985.       layer_resize (layer,
  3986.             options->resize->width, options->resize->height,
  3987.             options->resize->offset_x, options->resize->offset_y);
  3988.  
  3989.       if (layer_is_floating_sel (layer))
  3990.         floating_sel_rigor (layer, TRUE);
  3991.  
  3992.       undo_push_group_end (gimage);
  3993.  
  3994.       gdisplays_flush ();
  3995.     }
  3996.  
  3997.       gtk_widget_destroy (options->resize->resize_shell);
  3998.     }
  3999.   else
  4000.     {
  4001.       g_message (_("Invalid width or height.\n"
  4002.            "Both must be positive."));
  4003.     }
  4004. }
  4005.  
  4006. static void
  4007. layers_dialog_resize_layer_query (GimpImage *gimage,
  4008.                   Layer     *layer)
  4009. {
  4010.   ResizeLayerOptions *options;
  4011.  
  4012.   /*  the new options structure  */
  4013.   options = g_new (ResizeLayerOptions, 1);
  4014.   options->layer  = layer;
  4015.   options->resize = resize_widget_new (ResizeWidget,
  4016.                        ResizeLayer,
  4017.                        GTK_OBJECT (layer),
  4018.                        "removed",
  4019.                        drawable_width (GIMP_DRAWABLE (layer)),
  4020.                        drawable_height (GIMP_DRAWABLE (layer)),
  4021.                        gimage->xresolution,
  4022.                        gimage->yresolution,
  4023.                        gimage->unit,
  4024.                        TRUE,
  4025.                        resize_layer_query_ok_callback,
  4026.                        NULL,
  4027.                        options);
  4028.  
  4029.   gtk_signal_connect_object (GTK_OBJECT (options->resize->resize_shell),
  4030.                  "destroy",
  4031.                  GTK_SIGNAL_FUNC (g_free),
  4032.                  (GtkObject *) options);
  4033.  
  4034.   gtk_widget_show (options->resize->resize_shell);
  4035. }
  4036.  
  4037. /****************************/
  4038. /*  The layer merge dialog  */
  4039. /****************************/
  4040.  
  4041. typedef struct _LayerMergeOptions LayerMergeOptions;
  4042.  
  4043. struct _LayerMergeOptions
  4044. {
  4045.   GtkWidget *query_box;
  4046.   GimpImage *gimage;
  4047.   gboolean   merge_visible;
  4048.   MergeType  merge_type;
  4049. };
  4050.  
  4051. static void
  4052. layer_merge_query_ok_callback (GtkWidget *widget,
  4053.                    gpointer   data)
  4054. {
  4055.   LayerMergeOptions *options;
  4056.   GimpImage *gimage;
  4057.  
  4058.   options = (LayerMergeOptions *) data;
  4059.   if (! (gimage = options->gimage))
  4060.     return;
  4061.  
  4062.   if (options->merge_visible)
  4063.     gimp_image_merge_visible_layers (gimage, options->merge_type);
  4064.  
  4065.   gdisplays_flush ();
  4066.  
  4067.   gtk_widget_destroy (options->query_box);
  4068. }
  4069.  
  4070. void
  4071. layers_dialog_layer_merge_query (GimpImage   *gimage,
  4072.                  /*  if FALSE, anchor active layer  */
  4073.                  gboolean     merge_visible)
  4074. {
  4075.   LayerMergeOptions *options;
  4076.   GtkWidget         *vbox;
  4077.   GtkWidget         *frame;
  4078.  
  4079.   /*  The new options structure  */
  4080.   options = g_new (LayerMergeOptions, 1);
  4081.   options->gimage        = gimage;
  4082.   options->merge_visible = merge_visible;
  4083.   options->merge_type    = EXPAND_AS_NECESSARY;
  4084.  
  4085.   /* The dialog  */
  4086.   options->query_box =
  4087.     gimp_dialog_new (_("Layer Merge Options"), "layer_merge_options",
  4088.              gimp_standard_help_func,
  4089.              "dialogs/layers/merge_visible_layers.html",
  4090.              GTK_WIN_POS_MOUSE,
  4091.              FALSE, TRUE, FALSE,
  4092.  
  4093.              _("OK"), layer_merge_query_ok_callback,
  4094.              options, NULL, NULL, TRUE, FALSE,
  4095.              _("Cancel"), gtk_widget_destroy,
  4096.              NULL, 1, NULL, FALSE, TRUE,
  4097.  
  4098.              NULL);
  4099.  
  4100.   gtk_signal_connect_object (GTK_OBJECT (options->query_box), "destroy",
  4101.                  GTK_SIGNAL_FUNC (g_free),
  4102.                  (GtkObject *) options);
  4103.  
  4104.   /*  The main vbox  */
  4105.   vbox = gtk_vbox_new (FALSE, 2);
  4106.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  4107.   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (options->query_box)->vbox),
  4108.              vbox);
  4109.  
  4110.   frame = gimp_radio_group_new2 (TRUE,
  4111.                  merge_visible ?
  4112.                  _("Final, Merged Layer should be:") :
  4113.                  _("Final, Anchored Layer should be:"),
  4114.                  gimp_radio_button_update,
  4115.                  &options->merge_type,
  4116.                  (gpointer) options->merge_type,
  4117.  
  4118.                  _("Expanded as necessary"),
  4119.                  (gpointer) EXPAND_AS_NECESSARY, NULL,
  4120.                  _("Clipped to image"),
  4121.                  (gpointer) CLIP_TO_IMAGE, NULL,
  4122.                  _("Clipped to bottom layer"),
  4123.                  (gpointer) CLIP_TO_BOTTOM_LAYER, NULL,
  4124.  
  4125.                  NULL);
  4126.  
  4127.   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
  4128.   gtk_widget_show (frame);
  4129.  
  4130.   gtk_widget_show (vbox);
  4131.   gtk_widget_show (options->query_box);
  4132. }
  4133.