home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / app / paths_dialog.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-12-17  |  70.1 KB  |  2,732 lines
  1. /* The GIMP -- an image manipulation program
  2.  * Copyright (C) 1999 Andy Thomas alt@picnic.demon.co.uk
  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.  * Some of this code is based on the layers_dialog box code.
  18.  */
  19.  
  20. #include "config.h"
  21.  
  22. #include <stdio.h>
  23. #include <errno.h>
  24. #include <string.h>
  25.  
  26. #include <gtk/gtk.h>
  27. #include <gdk/gdkkeysyms.h>
  28.  
  29. #include "apptypes.h"
  30.  
  31. #include "appenv.h"
  32. #include "draw_core.h"
  33. #include "drawable.h"
  34. #include "floating_sel.h"
  35. #include "gimage.h"
  36. #include "gimpimage.h"
  37. #include "gimpdrawable.h"
  38. #include "gimage_mask.h"
  39. #include "gdisplay.h"
  40. #include "gimprc.h"
  41. #include "gimpset.h"
  42. #include "gimpui.h"
  43. #include "image_render.h"
  44. #include "lc_dialogP.h"
  45. #include "menus.h"
  46. #include "ops_buttons.h"
  47. #include "bezier_select.h"
  48. #include "bezier_selectP.h"
  49. #include "path.h"
  50. #include "pathP.h"
  51. #include "path_transform.h"
  52. #include "paths_dialog.h"
  53. #include "paths_dialogP.h"
  54. #include "undo.h"
  55.  
  56. #include "drawable_pvt.h"
  57.  
  58. #include "libgimp/gimpmath.h"
  59.  
  60. #include "libgimp/gimpintl.h"
  61.  
  62. #include "pixmaps/new.xpm"
  63. #include "pixmaps/duplicate.xpm"
  64. #include "pixmaps/delete.xpm"
  65. #include "pixmaps/pennorm.xpm"
  66. #include "pixmaps/penadd.xpm"
  67. #include "pixmaps/pendel.xpm"
  68. #include "pixmaps/penedit.xpm"
  69. #include "pixmaps/penstroke.xpm"
  70. #include "pixmaps/toselection.xpm"
  71. #include "pixmaps/topath.xpm"
  72. #include "pixmaps/path.xbm"
  73. #include "pixmaps/locked.xbm"
  74.  
  75. typedef struct _PathsDialog PathsDialog;
  76.  
  77. struct _PathsDialog
  78. {
  79.   GtkWidget *vbox;
  80.   GtkWidget *paths_list;
  81.  
  82.   GtkWidget     *ops_menu;
  83.   GtkAccelGroup *accel_group;
  84.  
  85.   gdouble ratio;
  86.   gint    image_width, image_height;
  87.   gint    gimage_width, gimage_height;
  88.  
  89.   /* pixmaps for the no preview bitmap */
  90.   GdkPixmap *pixmap_normal;
  91.   GdkPixmap *pixmap_selected;
  92.   GdkPixmap *pixmap_locked_normal;
  93.   GdkPixmap *pixmap_locked_selected;
  94.  
  95.   /*  state information  */
  96.   gint       selsigid;
  97.   GimpImage *gimage;
  98.   GdkGC     *gc;   
  99.   GdkColor   black;
  100.   GdkColor   white;
  101.   gint       selected_row_num;
  102.   gboolean   been_selected;
  103.   PathList  *current_path_list;
  104. };
  105.  
  106. typedef struct _PathWidget PathWidget;
  107.  
  108. struct _PathWidget
  109. {
  110.   GdkPixmap *paths_pixmap;
  111.   Path      *bzp;
  112. };
  113.  
  114. typedef struct _PathCounts PathCounts;
  115.  
  116. struct _PathCounts
  117. {
  118.   CountCurves  c_count;             /* Must be the first element */
  119.   gint         total_count;         /* Total number of curves    */
  120. };
  121.  
  122. static PathsDialog *paths_dialog = NULL;
  123. static Path        *copy_pp      = NULL;
  124.  
  125. static void     paths_dialog_realized        (GtkWidget      *widget);
  126. static void     paths_select_row             (GtkWidget      *widget,
  127.                           gint            row,
  128.                           gint            column, 
  129.                           GdkEventButton *event,
  130.                           gpointer        data);
  131. static void     paths_unselect_row           (GtkWidget      *widget,
  132.                           gint            row,
  133.                           gint            column,
  134.                           GdkEventButton *event,
  135.                           gpointer        data);
  136. static gint     paths_list_events            (GtkWidget      *widget,
  137.                           GdkEvent       *event);
  138. static void     paths_dialog_map_callback    (GtkWidget      *widget,
  139.                           gpointer        data);
  140. static void     paths_dialog_unmap_callback  (GtkWidget      *widget,
  141.                           gpointer        data);
  142. static void     paths_update_paths           (gpointer        data,
  143.                           gint            row);
  144. static void     paths_update_preview         (BezierSelect   *bezier_sel);
  145. static void     paths_dialog_preview_extents           (void);
  146. static void     paths_dialog_new_point_callback        (GtkWidget *, gpointer);
  147. static void     paths_dialog_add_point_callback        (GtkWidget *, gpointer);
  148. static void     paths_dialog_delete_point_callback     (GtkWidget *, gpointer);
  149. static void     paths_dialog_edit_point_callback       (GtkWidget *, gpointer);
  150. static void     paths_dialog_advanced_to_path_callback (GtkWidget *, gpointer);
  151. static void     paths_dialog_null_callback             (GtkWidget *, gpointer);
  152.  
  153. static void     path_close                   (Path *);
  154.  
  155. /*  the ops buttons  */
  156. static GtkSignalFunc to_path_ext_callbacks[] = 
  157. { 
  158.   paths_dialog_advanced_to_path_callback,          /* SHIFT */
  159.   paths_dialog_null_callback,                      /* CTRL  */
  160.   paths_dialog_null_callback,                      /* MOD1  */
  161.   paths_dialog_null_callback,                      /* SHIFT + CTRL */
  162. };
  163.  
  164. static OpsButton paths_ops_buttons[] =
  165. {
  166.   { new_xpm, paths_dialog_new_path_callback, NULL,
  167.     N_("New Path"),
  168.     "paths/new_path.html",
  169.     NULL, 0 },
  170.   { duplicate_xpm, paths_dialog_dup_path_callback, NULL,
  171.     N_("Duplicate Path"),
  172.     "paths/duplicate_path.html",
  173.     NULL, 0 },
  174.   { toselection_xpm, paths_dialog_path_to_sel_callback, NULL,
  175.     N_("Path to Selection"),
  176.     "paths/path_to_selection.html",
  177.     NULL, 0 },
  178.   { topath_xpm, paths_dialog_sel_to_path_callback, to_path_ext_callbacks,
  179.     N_("Selection to Path"),
  180.     "filters/sel2path.html",
  181.     NULL, 0 },
  182.   { penstroke_xpm, paths_dialog_stroke_path_callback, NULL,
  183.     N_("Stroke Path"),
  184.     "paths/stroke_path.html",
  185.     NULL, 0 },
  186.   { delete_xpm, paths_dialog_delete_path_callback, NULL,
  187.     N_("Delete Path"),
  188.     "paths/delete_path.html",
  189.     NULL, 0 },
  190.   { NULL, NULL, NULL, NULL, NULL, NULL, 0 }
  191. };
  192.  
  193. static OpsButton point_ops_buttons[] =
  194. {
  195.   { pennorm_xpm, paths_dialog_new_point_callback, NULL,
  196.     N_("New Point"),
  197.     "#new_point_button",
  198.     NULL, 0 },
  199.   { penadd_xpm, paths_dialog_add_point_callback, NULL,
  200.     N_("Add Point"),
  201.     "#add_point_button",
  202.     NULL, 0 },
  203.   { pendel_xpm, paths_dialog_delete_point_callback, NULL,
  204.     N_("Delete Point"),
  205.     "#delete_point_button",
  206.     NULL, 0 },
  207.   { penedit_xpm, paths_dialog_edit_point_callback, NULL,
  208.     N_("Edit Point"),
  209.     "#edit_point_button",
  210.     NULL, 0 },
  211.   { NULL, NULL, NULL, NULL, NULL, NULL, 0 }
  212. };
  213.  
  214. static void
  215. paths_dialog_set_menu_sensitivity (void)
  216. {
  217.   gboolean gimage = FALSE;  /*  is there a gimage  */
  218.   gboolean pp     = FALSE;  /*  paths present  */
  219.   gboolean cpp    = FALSE;  /*  is there a path in the pate buffer  */
  220.  
  221.   if (! paths_dialog)
  222.     return;
  223.  
  224.   if (paths_dialog->gimage)
  225.     gimage = TRUE;
  226.  
  227.   if (gimage && gimp_image_get_paths (paths_dialog->gimage))
  228.     pp = TRUE;
  229.  
  230.   if (copy_pp)
  231.     cpp = TRUE;
  232.  
  233. #define SET_SENSITIVE(menu,condition) \
  234.         menus_set_sensitive ("<Paths>/" menu, (condition) != 0)
  235. #define SET_OPS_SENSITIVE(button,condition) \
  236.         gtk_widget_set_sensitive (paths_ops_buttons[(button)].widget, \
  237.                                  (condition) != 0)
  238. #define SET_POINT_SENSITIVE(button,condition) \
  239.         gtk_widget_set_sensitive (point_ops_buttons[(button)].widget, \
  240.                                  (condition) != 0)
  241.  
  242.   SET_SENSITIVE ("New Path", gimage);
  243.   SET_OPS_SENSITIVE (0, gimage);
  244.  
  245.   SET_SENSITIVE ("Duplicate Path", pp);
  246.   SET_OPS_SENSITIVE (1, pp);
  247.  
  248.   SET_SENSITIVE ("Path to Selection", pp);
  249.   SET_OPS_SENSITIVE (2, pp);
  250.  
  251.   SET_SENSITIVE ("Selection to Path", gimage);
  252.   SET_OPS_SENSITIVE (3, gimage);
  253.  
  254.   SET_SENSITIVE ("Stroke Path", pp);
  255.   SET_OPS_SENSITIVE (4, pp);
  256.  
  257.   SET_SENSITIVE ("Delete Path", pp);
  258.   SET_OPS_SENSITIVE (5, pp);
  259.  
  260.   SET_SENSITIVE ("Copy Path", pp);
  261.   SET_SENSITIVE ("Paste Path", pp && cpp);
  262.  
  263.   SET_SENSITIVE ("Import Path...", gimage);
  264.   SET_SENSITIVE ("Export Path...", pp);
  265.  
  266.   SET_SENSITIVE ("Edit Path Attributes...", pp);
  267.  
  268.   /*  new point  */
  269.   SET_POINT_SENSITIVE (0, pp);
  270.  
  271.   /*  add point  */
  272.   SET_POINT_SENSITIVE (1, pp);
  273.  
  274.   /*  selete point  */
  275.   SET_POINT_SENSITIVE (2, pp);
  276.  
  277.   /*  edit point  */
  278.   SET_POINT_SENSITIVE (3, pp);
  279.  
  280. #undef SET_POINT_SENSITIVE
  281. #undef SET_OPS_SENSITIVE
  282. #undef SET_SENSITIVE
  283. }
  284.  
  285. void
  286. paths_dialog_set_default_op (void)
  287. {
  288.   if(paths_dialog != NULL) /* Bug #5049: Clients may call this because it is possible */
  289.                            /* to create a path before the L&C dialog exists.          */
  290.  
  291.     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (point_ops_buttons[0].widget),
  292.                    TRUE);
  293. }
  294.  
  295. GtkWidget *
  296. paths_dialog_create (void)
  297. {
  298.   GtkWidget *vbox;
  299.   GtkWidget *paths_list;
  300.   GtkWidget *scrolled_win;  
  301.   GtkWidget *button_box;  
  302.  
  303.   if (paths_dialog)
  304.     return paths_dialog->vbox;
  305.  
  306.   paths_dialog = g_new0 (PathsDialog, 1);
  307.  
  308.   /*  The paths box  */
  309.   paths_dialog->vbox = gtk_event_box_new ();
  310.  
  311.   gimp_help_set_help_data (paths_dialog->vbox, NULL,
  312.                "dialogs/paths/paths.html");
  313.  
  314.   vbox = gtk_vbox_new (FALSE, 1);
  315.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
  316.   gtk_container_add (GTK_CONTAINER (paths_dialog->vbox), vbox);
  317.  
  318.   /* The point operations */
  319.   button_box = ops_button_box_new (point_ops_buttons, OPS_BUTTON_RADIO);
  320.   gtk_box_pack_start (GTK_BOX (vbox), button_box, FALSE, TRUE, 2);
  321.   gtk_widget_show (button_box);
  322.  
  323.   scrolled_win = gtk_scrolled_window_new (NULL, NULL);
  324.   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
  325.                   GTK_POLICY_AUTOMATIC,
  326.                   GTK_POLICY_ALWAYS);
  327.   gtk_widget_set_usize (scrolled_win, LIST_WIDTH, LIST_HEIGHT);
  328.   gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 2);
  329.  
  330.   paths_dialog->paths_list = paths_list = gtk_clist_new (2);
  331.   gtk_signal_connect (GTK_OBJECT (vbox), "destroy",
  332.               GTK_SIGNAL_FUNC (gtk_widget_destroyed),
  333.               &paths_dialog);
  334.  
  335.   gtk_clist_set_selection_mode (GTK_CLIST (paths_list), GTK_SELECTION_BROWSE);
  336.   gtk_clist_set_reorderable (GTK_CLIST (paths_list), FALSE);
  337.   gtk_clist_set_column_width (GTK_CLIST (paths_list), 0, locked_width);
  338.   gtk_clist_set_column_min_width (GTK_CLIST (paths_list), 1, 
  339.                   LIST_WIDTH - locked_width - 4);
  340.   gtk_clist_set_column_auto_resize (GTK_CLIST (paths_list), 1, TRUE);
  341.  
  342.   gtk_container_add (GTK_CONTAINER (scrolled_win), paths_list);
  343.   gtk_signal_connect (GTK_OBJECT (paths_list), "event",
  344.               (GtkSignalFunc) paths_list_events,
  345.               paths_dialog);
  346.   gtk_container_set_focus_vadjustment (GTK_CONTAINER (paths_list), 
  347.                        gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_win))); 
  348.   GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (scrolled_win)->vscrollbar,
  349.               GTK_CAN_FOCUS); 
  350.  
  351.   paths_dialog->selsigid =
  352.     gtk_signal_connect (GTK_OBJECT (paths_list), "select_row",
  353.             GTK_SIGNAL_FUNC (paths_select_row),
  354.             NULL);
  355.  
  356.   gtk_signal_connect (GTK_OBJECT (paths_list), "unselect_row",
  357.               GTK_SIGNAL_FUNC (paths_unselect_row),
  358.               NULL);
  359.       
  360.   gtk_widget_show (scrolled_win);
  361.   gtk_widget_show (paths_list);
  362.  
  363.   gtk_signal_connect (GTK_OBJECT (paths_dialog->vbox), "realize",
  364.               GTK_SIGNAL_FUNC (paths_dialog_realized),
  365.               NULL);
  366.  
  367.   gtk_widget_show (vbox);
  368.   gtk_widget_show (paths_dialog->vbox);
  369.  
  370.   /*  The ops buttons  */
  371.   button_box = ops_button_box_new (paths_ops_buttons, OPS_BUTTON_NORMAL);
  372.   gtk_box_pack_start (GTK_BOX (vbox), button_box, FALSE, FALSE, 2);
  373.   gtk_widget_show (button_box);
  374.  
  375.   menus_get_paths_menu (&paths_dialog->ops_menu,
  376.             &paths_dialog->accel_group);
  377.  
  378.   /*  Set up signals for map/unmap for the accelerators  */
  379.   gtk_signal_connect (GTK_OBJECT (vbox), "map",
  380.               (GtkSignalFunc) paths_dialog_map_callback,
  381.               NULL);
  382.   gtk_signal_connect (GTK_OBJECT (vbox), "unmap",
  383.               (GtkSignalFunc) paths_dialog_unmap_callback,
  384.               NULL);
  385.  
  386.   paths_dialog_set_menu_sensitivity ();
  387.  
  388.   paths_dialog_set_default_op ();
  389.   
  390.   return paths_dialog->vbox;
  391. }
  392.  
  393. static void 
  394. paths_dialog_realized (GtkWidget *widget)
  395. {
  396.   GdkColormap *colormap;
  397.   gchar dash_list[2]= {3,3};
  398.  
  399.   /* Help out small displays */
  400.   if (preview_size < 64)
  401.     dash_list[1] = 1;
  402.  
  403.   paths_dialog->gc = gdk_gc_new (widget->window);
  404.   gdk_gc_set_dashes (paths_dialog->gc, 2, dash_list, 2);
  405.   colormap = gtk_widget_get_colormap (paths_dialog->paths_list);
  406.   gdk_color_parse ("black", &paths_dialog->black);
  407.   gdk_color_alloc (colormap, &paths_dialog->black);
  408.   gdk_color_parse ("white", &paths_dialog->white);
  409.   gdk_color_alloc (colormap, &paths_dialog->white);
  410. }
  411.  
  412. /* Clears out row when list element is deleted/destroyed */
  413. static void
  414. clear_pathwidget (gpointer data)
  415. {
  416.   PathWidget *pwidget = data;
  417.  
  418.   if (pwidget)
  419.     {
  420.       if (pwidget->paths_pixmap)
  421.     gdk_pixmap_unref (pwidget->paths_pixmap);
  422.  
  423.       g_free (pwidget);
  424.     }
  425. }
  426.  
  427.  
  428. static Path*
  429. path_dialog_new (GimpImage *gimage,
  430.          gint       name_seed, 
  431.          gpointer   data)
  432. {
  433.   Path  *bzp;
  434.   gchar *s;
  435.  
  436.   s = g_strdup_printf (_("Path %d"), name_seed);
  437.   bzp = path_new (gimage, BEZIER, (GSList *) data, 0, 0, 0, 0, s);
  438.  
  439.   return bzp;
  440. }
  441.  
  442. static PathPoint*
  443. path_start_last_seg (GSList *plist)
  444. {
  445.   PathPoint *retp = plist->data;
  446.   while (plist)
  447.     {
  448.       if (((PathPoint*) (plist->data))->type == BEZIER_MOVE &&
  449.       g_slist_next (plist))
  450.     {
  451.       plist = g_slist_next (plist);
  452.       retp = plist->data;
  453.     }
  454.       plist = g_slist_next (plist);
  455.     }  
  456.   return retp;
  457. }
  458.  
  459. static void
  460. path_close (Path *bzp)
  461. {
  462.   PathPoint *pdata;
  463.   PathPoint *pathpoint;
  464.  
  465.   /* bzpaths are only really closed when converted to the BezierSelect ones */
  466.   bzp->closed = 1;
  467.   /* first point */
  468.   pdata = (PathPoint*)bzp->path_details->data;
  469.  
  470.   if (g_slist_length (bzp->path_details) < 5)
  471.     {
  472.       int i;
  473.       for (i = 0 ; i < 2 ; i++)
  474.     {
  475.       pathpoint = g_new0 (PathPoint, 1);
  476.       pathpoint->type = (i & 1) ? BEZIER_ANCHOR : BEZIER_CONTROL;
  477.       pathpoint->x = pdata->x+i;
  478.       pathpoint->y = pdata->y+i;
  479.  
  480.       bzp->path_details = g_slist_append (bzp->path_details, pathpoint);
  481.     }
  482.     }
  483.   pathpoint = g_new0 (PathPoint, 1);
  484.   pdata = path_start_last_seg (bzp->path_details);
  485.   pathpoint->type = BEZIER_CONTROL;
  486.   pathpoint->x = pdata->x;
  487.   pathpoint->y = pdata->y;
  488.   /* printf("Closing to x,y %d,%d\n",(gint)pdata->x,(gint)pdata->y); */
  489.   bzp->path_details = g_slist_append (bzp->path_details, pathpoint);
  490.   bzp->state = BEZIER_EDIT;
  491. }
  492.  
  493. static void 
  494. bz_change_name_row_to (gint   row,
  495.                gchar *text)
  496. {
  497.   PathWidget *pwidget;
  498.  
  499.   pwidget = (PathWidget *)
  500.     gtk_clist_get_row_data (GTK_CLIST (paths_dialog->paths_list), row);
  501.  
  502.   if (!pwidget)
  503.     return;
  504.  
  505.   g_free (pwidget->bzp->name);
  506.  
  507.   pwidget->bzp->name = g_strdup (text);
  508. }
  509.  
  510. static void 
  511. paths_set_dash_line (GdkGC    *gc,
  512.              gboolean  state)
  513. {
  514.   gdk_gc_set_foreground (paths_dialog->gc, &paths_dialog->black);
  515.  
  516.   if (state)
  517.     {
  518.       gdk_gc_set_line_attributes (gc, 0, GDK_LINE_ON_OFF_DASH,
  519.                   GDK_CAP_BUTT, GDK_JOIN_ROUND);
  520.     }
  521.   else
  522.     {
  523.       gdk_gc_set_line_attributes (gc, 0, GDK_LINE_SOLID,
  524.                   GDK_CAP_BUTT, GDK_JOIN_ROUND);
  525.     }
  526. }
  527.  
  528. static void 
  529. clear_pixmap_preview (PathWidget *pwidget)
  530. {
  531.   guchar *rgb_buf;
  532.  
  533.   rgb_buf = g_new0 (guchar,
  534.             (paths_dialog->image_width + 4)
  535.             *(paths_dialog->image_height + 4) * 3);
  536.  
  537.   memset (rgb_buf,0xFF,(paths_dialog->image_width + 4)
  538.       *(paths_dialog->image_height + 4) * 3);
  539.  
  540.   gdk_draw_rgb_image (pwidget->paths_pixmap,
  541.               paths_dialog->gc,
  542.               0,
  543.               0,
  544.               paths_dialog->image_width + 4,
  545.               paths_dialog->image_height + 4,
  546.               GDK_RGB_DITHER_NORMAL,
  547.               rgb_buf,
  548.               (paths_dialog->image_width + 4)*3);
  549.  
  550.   paths_set_dash_line (paths_dialog->gc,FALSE);
  551.  
  552.   gdk_draw_rectangle (pwidget->paths_pixmap, 
  553.               paths_dialog->gc, FALSE, 0, 0, 
  554.               paths_dialog->image_width+3,
  555.               paths_dialog->image_height+3);
  556.  
  557.   gdk_draw_rectangle (pwidget->paths_pixmap, 
  558.               paths_dialog->gc, FALSE, 1, 1, 
  559.               paths_dialog->image_width+1,
  560.               paths_dialog->image_height+1);
  561.  
  562.   g_free (rgb_buf);
  563. }
  564.  
  565. /* insrow == -1 -> append else insert at insrow */
  566. void 
  567. paths_add_path (Path *bzp,
  568.         gint  insrow)
  569. {
  570.   /* Create a new entry in the list */
  571.   PathWidget *pwidget;
  572.   gint row;
  573.   gchar *row_data[2];
  574.  
  575.   pwidget = g_new0 (PathWidget, 1);
  576.  
  577.   if (!GTK_WIDGET_REALIZED (paths_dialog->vbox))
  578.     gtk_widget_realize (paths_dialog->vbox);
  579.  
  580.   paths_dialog_preview_extents ();
  581.  
  582.   if (preview_size)
  583.     {
  584.       /* Need to add this to the list */
  585.       pwidget->paths_pixmap =  gdk_pixmap_new (paths_dialog->vbox->window,
  586.                            paths_dialog->image_width + 4,  
  587.                            paths_dialog->image_height + 4,
  588.                            -1);
  589.       clear_pixmap_preview (pwidget);
  590.     }
  591.   else
  592.     {
  593.       if (!paths_dialog->pixmap_normal)
  594.     {
  595.       paths_dialog->pixmap_normal =
  596.         gdk_pixmap_create_from_data (paths_dialog->vbox->window,
  597.                      path_bits, 
  598.                      paths_dialog->image_width,
  599.                      paths_dialog->image_height,
  600.                      -1,
  601.                      &paths_dialog->vbox->style->fg[GTK_STATE_SELECTED],
  602.                      &paths_dialog->vbox->style->bg[GTK_STATE_SELECTED]);
  603.       paths_dialog->pixmap_selected =
  604.         gdk_pixmap_create_from_data (paths_dialog->vbox->window,
  605.                      path_bits, 
  606.                      paths_dialog->image_width,
  607.                      paths_dialog->image_height,
  608.                      -1,
  609.                      &paths_dialog->vbox->style->fg[GTK_STATE_NORMAL],
  610.                      &paths_dialog->vbox->style->bg[GTK_STATE_SELECTED]);
  611.     }
  612.        pwidget->paths_pixmap = paths_dialog->pixmap_normal;
  613.     }
  614.  
  615.   if (!paths_dialog->pixmap_locked_normal)
  616.     {
  617.       paths_dialog->pixmap_locked_normal = 
  618.     gdk_pixmap_create_from_data (paths_dialog->vbox->window,
  619.                      locked_bits, locked_width, locked_height, -1,
  620.                      &paths_dialog->vbox->style->fg[GTK_STATE_NORMAL],
  621.                      &paths_dialog->vbox->style->white);
  622.       paths_dialog->pixmap_locked_selected = 
  623.     gdk_pixmap_create_from_data (paths_dialog->vbox->window,
  624.                      locked_bits, locked_width, locked_height, -1,
  625.                      &paths_dialog->vbox->style->fg[GTK_STATE_SELECTED],
  626.                      &paths_dialog->vbox->style->bg[GTK_STATE_SELECTED]);
  627.     }
  628.  
  629.   gtk_clist_set_row_height (GTK_CLIST (paths_dialog->paths_list),
  630.                 paths_dialog->image_height + 6);
  631.  
  632.   row_data[0] = "";
  633.   row_data[1] = "";
  634.  
  635.   if (insrow == -1)
  636.     row = gtk_clist_append (GTK_CLIST (paths_dialog->paths_list),
  637.                 row_data);
  638.   else
  639.     row = gtk_clist_insert (GTK_CLIST (paths_dialog->paths_list),
  640.                 insrow,
  641.                 row_data);
  642.  
  643.   gtk_clist_set_pixtext (GTK_CLIST (paths_dialog->paths_list),
  644.              row,
  645.              1,
  646.              bzp->name,
  647.              2,
  648.              pwidget->paths_pixmap,
  649.              NULL);
  650.  
  651.   gtk_clist_set_row_data_full (GTK_CLIST (paths_dialog->paths_list),
  652.                    row,
  653.                    (gpointer) pwidget,
  654.                    clear_pathwidget);
  655.  
  656.   gtk_signal_handler_block (GTK_OBJECT (paths_dialog->paths_list),
  657.                 paths_dialog->selsigid);
  658.   gtk_clist_select_row (GTK_CLIST (paths_dialog->paths_list),
  659.             paths_dialog->current_path_list->last_selected_row,
  660.             1);
  661.   gtk_signal_handler_unblock (GTK_OBJECT (paths_dialog->paths_list),
  662.                   paths_dialog->selsigid);
  663.  
  664.   pwidget->bzp = bzp;
  665. }
  666.  
  667. static void
  668. paths_dialog_preview_extents (void)
  669. {
  670.   GimpImage *gimage;
  671.  
  672.   if (!paths_dialog)
  673.     return;
  674.  
  675.  if (! (gimage = paths_dialog->gimage))
  676.     return;
  677.  
  678.   paths_dialog->gimage_width  = gimage->width;
  679.   paths_dialog->gimage_height = gimage->height;
  680.  
  681.   /*  Get the image width and height variables, based on the gimage  */
  682.   if (gimage->width > gimage->height)
  683.     paths_dialog->ratio = (double) preview_size / (double) gimage->width;
  684.   else
  685.     paths_dialog->ratio = (double) preview_size / (double) gimage->height;
  686.  
  687.   if (preview_size)
  688.     {
  689.       paths_dialog->image_width = (int) (paths_dialog->ratio * gimage->width);
  690.       paths_dialog->image_height = (int) (paths_dialog->ratio * gimage->height);
  691.       if (paths_dialog->image_width < 1) paths_dialog->image_width = 1;
  692.       if (paths_dialog->image_height < 1) paths_dialog->image_height = 1;
  693.     }
  694.   else
  695.     {
  696.       paths_dialog->image_width  = path_width;
  697.       paths_dialog->image_height = path_height;
  698.     }
  699. }
  700.  
  701. static void
  702. paths_select_row (GtkWidget      *widget, 
  703.           gint            row,
  704.           gint            column,
  705.           GdkEventButton *event,
  706.           gpointer        data)
  707. {
  708.   PathWidget *pwidget;
  709.   Path* bzp;
  710.   BezierSelect * bsel;
  711.   GDisplay *gdisp;
  712.   gint last_row;
  713.  
  714.   pwidget = (PathWidget *) gtk_clist_get_row_data (GTK_CLIST (widget), row);
  715.  
  716.   if (!pwidget ||
  717.       (paths_dialog->current_path_list->last_selected_row == row &&
  718.        paths_dialog->been_selected == TRUE))
  719.     {
  720.       if (column)
  721.     return;
  722.     }
  723.  
  724.   last_row = paths_dialog->current_path_list->last_selected_row;
  725.  
  726.   bzp = (Path*)g_slist_nth_data(paths_dialog->current_path_list->bz_paths,row);
  727.  
  728.   g_return_if_fail(bzp != NULL);
  729.  
  730.   if(column == 0)
  731.     {
  732.       if(bzp->locked == 0)
  733.     {
  734.       bzp->locked = 1;
  735.       if (paths_dialog->selected_row_num == row)
  736.         gtk_clist_set_pixmap (GTK_CLIST (paths_dialog->paths_list),
  737.                   row,
  738.                   0,
  739.                   paths_dialog->pixmap_locked_selected,
  740.                   NULL);
  741.       else
  742.         gtk_clist_set_pixmap (GTK_CLIST (paths_dialog->paths_list),
  743.                   row,
  744.                   0,
  745.                   paths_dialog->pixmap_locked_normal,
  746.                   NULL);
  747.           }
  748.       else
  749.     {
  750.       gint tmprow;
  751.  
  752.       bzp->locked = 0;
  753.       gtk_clist_set_text (GTK_CLIST (paths_dialog->paths_list),
  754.                   row,
  755.                   0,
  756.                   "");
  757.       /* There should be an easier way of updating the preview! */
  758.       bsel = path_to_beziersel (bzp);
  759.       tmprow = paths_dialog->current_path_list->last_selected_row;
  760.       paths_dialog->current_path_list->last_selected_row = row;
  761.       paths_update_preview (bsel);
  762.       bezier_select_free (bsel);
  763.       paths_dialog->current_path_list->last_selected_row = tmprow;
  764.       paths_dialog->selected_row_num = tmprow;
  765.     }
  766.  
  767.       /* Put hightlight back on the old original selection */
  768.       gtk_signal_handler_block (GTK_OBJECT (paths_dialog->paths_list),
  769.                 paths_dialog->selsigid);
  770.  
  771.       gtk_clist_select_row (GTK_CLIST (paths_dialog->paths_list),
  772.                 last_row,
  773.                 1);
  774.  
  775.       gtk_signal_handler_unblock (GTK_OBJECT (paths_dialog->paths_list),
  776.                   paths_dialog->selsigid);
  777.  
  778.       return;
  779.     }
  780.  
  781.   paths_dialog->selected_row_num = row;
  782.   paths_dialog->current_path_list->last_selected_row = row;
  783.   paths_dialog->been_selected = TRUE;
  784.  
  785.   if(bzp->locked)
  786.     gtk_clist_set_pixmap (GTK_CLIST (paths_dialog->paths_list),
  787.               row,
  788.               0,
  789.               paths_dialog->pixmap_locked_selected,
  790.               NULL);
  791.  
  792.   bsel = path_to_beziersel (bzp);
  793.   gdisp = gdisplays_check_valid (paths_dialog->current_path_list->gdisp,
  794.                  paths_dialog->gimage);
  795.   if (!gdisp)
  796.     {
  797.       /*g_warning("Lost image which bezier curve belonged to");*/
  798.       return;
  799.     }
  800.   bezier_paste_bezierselect_to_current (gdisp, bsel);
  801.   paths_update_preview (bsel);
  802.   bezier_select_free (bsel);
  803. }
  804.  
  805. static void
  806. paths_unselect_row (GtkWidget      *widget, 
  807.             gint            row,
  808.             gint            column,
  809.             GdkEventButton *event,
  810.             gpointer        data)
  811. {
  812.   PathWidget *pwidget;
  813.   Path* bzp;
  814.  
  815.   pwidget = (PathWidget *) gtk_clist_get_row_data (GTK_CLIST (widget), row);
  816.  
  817.   if (!pwidget)
  818.     return;
  819.  
  820.   bzp = pwidget->bzp;
  821.  
  822.   g_return_if_fail (bzp != NULL);
  823.  
  824.   if (column && bzp->locked)
  825.     {
  826.       gtk_clist_set_pixmap (GTK_CLIST (paths_dialog->paths_list),
  827.                 row,
  828.                 0,
  829.                 paths_dialog->pixmap_locked_normal,
  830.                 NULL);
  831.     }
  832. }
  833.  
  834. void
  835. paths_dialog_update (GimpImage* gimage)
  836. {
  837.   PathList* new_path_list;
  838.   GSList *plist;
  839.   gint loop;
  840.   gint tmprow;
  841.  
  842.   if (!paths_dialog || !gimage)
  843.     return;
  844.  
  845.   if (paths_dialog->gimage == gimage &&
  846.       paths_dialog->current_path_list ==
  847.       (PathList*) gimp_image_get_paths (gimage))
  848.     return;
  849.  
  850.   paths_dialog->gimage = gimage;
  851.  
  852.   paths_dialog_preview_extents ();
  853.  
  854.   /*  clear clist out  */
  855.   gtk_clist_freeze (GTK_CLIST (paths_dialog->paths_list));
  856.   gtk_clist_clear (GTK_CLIST (paths_dialog->paths_list));
  857.   gtk_clist_thaw (GTK_CLIST (paths_dialog->paths_list));
  858.  
  859.   /*  Find bz list  */
  860.   new_path_list = (PathList*) gimp_image_get_paths (gimage);
  861.  
  862.   paths_dialog->current_path_list = new_path_list;
  863.   paths_dialog->been_selected = FALSE;
  864.  
  865.   paths_dialog_set_menu_sensitivity ();
  866.  
  867.   paths_dialog_set_default_op ();
  868.  
  869.   if (!new_path_list)
  870.     return;
  871.  
  872.   /* update the clist to reflect this images bz list */
  873.   /* go around the image list populating the clist */
  874.  
  875.   if (gimage != new_path_list->gimage)
  876.     {
  877.       g_warning("paths list: internal list error");
  878.     }
  879.  
  880.   plist = new_path_list->bz_paths;
  881.   loop = 0;
  882.  
  883.   tmprow = paths_dialog->current_path_list->last_selected_row;
  884.   while (plist)
  885.     {
  886.       paths_update_paths (plist->data,loop);
  887.       loop++;
  888.       plist = g_slist_next (plist);
  889.     }
  890.   paths_dialog->current_path_list->last_selected_row = tmprow;
  891.   paths_dialog->selected_row_num = tmprow;
  892.  
  893.   /* select last one */
  894.  
  895.   gtk_signal_handler_block (GTK_OBJECT (paths_dialog->paths_list),
  896.                 paths_dialog->selsigid);
  897.   gtk_clist_select_row (GTK_CLIST (paths_dialog->paths_list),
  898.             paths_dialog->current_path_list->last_selected_row,
  899.             1);
  900.   gtk_signal_handler_unblock (GTK_OBJECT (paths_dialog->paths_list),
  901.                   paths_dialog->selsigid);
  902.  
  903.   gtk_clist_moveto (GTK_CLIST (paths_dialog->paths_list),
  904.             paths_dialog->current_path_list->last_selected_row,
  905.             0,
  906.             0.5,
  907.             0.0);
  908. }
  909.  
  910. static void
  911. paths_update_paths (gpointer data,
  912.             gint     row)
  913. {
  914.   Path* bzp;
  915.   BezierSelect *bezier_sel;
  916.  
  917.   paths_add_path ((bzp = (Path*) data), -1);
  918.   /* Now fudge the drawing....*/
  919.   bezier_sel = path_to_beziersel (bzp);
  920.   paths_dialog->current_path_list->last_selected_row = row;
  921.   paths_update_preview (bezier_sel);
  922.   bezier_select_free (bezier_sel);
  923.  
  924.   if (bzp->locked)
  925.     {
  926.       if (paths_dialog->selected_row_num == row)
  927.     gtk_clist_set_pixmap (GTK_CLIST (paths_dialog->paths_list),
  928.                   row,
  929.                   0,
  930.                   paths_dialog->pixmap_locked_selected,
  931.                   NULL);
  932.       else
  933.     gtk_clist_set_pixmap (GTK_CLIST (paths_dialog->paths_list),
  934.                   row,
  935.                   0,
  936.                   paths_dialog->pixmap_locked_normal,
  937.                   NULL);
  938.     }
  939. }
  940.  
  941. static void
  942. do_rename_paths_callback (GtkWidget *widget, 
  943.               gchar     *text,
  944.               gpointer   data)
  945. {
  946.   GdkBitmap *mask;
  947.   guint8     spacing;
  948.   GdkPixmap *pixmap;
  949.  
  950.   if (!(GTK_CLIST (data)->selection))
  951.     return;
  952.  
  953.   gtk_clist_get_pixtext (GTK_CLIST (paths_dialog->paths_list),
  954.              paths_dialog->selected_row_num,
  955.              1,
  956.              NULL,
  957.              &spacing,
  958.              &pixmap,
  959.              &mask);
  960.  
  961.   gtk_clist_set_pixtext (GTK_CLIST (data),
  962.              paths_dialog->selected_row_num,
  963.              1,
  964.              text,
  965.              spacing,
  966.              pixmap,
  967.              mask);
  968.  
  969.   bz_change_name_row_to (paths_dialog->selected_row_num, text);
  970. }
  971.  
  972. static void
  973. paths_dialog_edit_path_query (GtkWidget *widget)
  974. {
  975.   GtkWidget *qbox;
  976.   GdkBitmap *mask;
  977.   gchar *text;
  978.   gint   ret;
  979.  
  980.   /* Get the current name */
  981.   ret = gtk_clist_get_pixtext (GTK_CLIST (paths_dialog->paths_list),
  982.                    paths_dialog->selected_row_num,
  983.                    1,
  984.                    &text,
  985.                    NULL,
  986.                    NULL,
  987.                    &mask);
  988.  
  989.   qbox = gimp_query_string_box (_("Edit Path Attributes"),
  990.                 gimp_standard_help_func,
  991.                 "paths/dialogs/edit_path_attributes.html",
  992.                 _("Enter a new name for the path"),
  993.                 text,
  994.                 NULL, NULL,
  995.                 do_rename_paths_callback, widget);
  996.   gtk_widget_show (qbox);
  997. }
  998.  
  999. static gint
  1000. paths_list_events (GtkWidget *widget,
  1001.            GdkEvent  *event)
  1002. {
  1003.   GdkEventButton *bevent;
  1004.   static gint     last_row = -1;
  1005.   gint            this_column;
  1006.  
  1007.   switch (event->type)
  1008.     {
  1009.     case GDK_BUTTON_PRESS:
  1010.       bevent = (GdkEventButton *) event;
  1011.       if (!gtk_clist_get_selection_info (GTK_CLIST (paths_dialog->paths_list),
  1012.                      bevent->x,
  1013.                      bevent->y,
  1014.                      &last_row, &this_column))
  1015.     last_row = -1;
  1016.       else if (paths_dialog->selected_row_num != last_row)
  1017.     last_row = -1;
  1018.  
  1019.       if (bevent->button == 3)
  1020.     gtk_menu_popup (GTK_MENU (paths_dialog->ops_menu), 
  1021.             NULL, NULL, NULL, NULL, bevent->button, bevent->time);
  1022.       break;
  1023.  
  1024.     case GDK_2BUTTON_PRESS:
  1025.       bevent = (GdkEventButton *) event;
  1026.  
  1027.       if (last_row != -1 && 
  1028.       gtk_clist_get_selection_info (GTK_CLIST (paths_dialog->paths_list),
  1029.                     bevent->x,
  1030.                     bevent->y,
  1031.                     NULL, &this_column))
  1032.     {
  1033.       if (this_column == 1)
  1034.         {
  1035.           paths_dialog_edit_path_query (widget);
  1036.           return TRUE;
  1037.         }
  1038.       else
  1039.         return FALSE;
  1040.     }
  1041.       else
  1042.     return FALSE;
  1043.       
  1044.     default:
  1045.       break;
  1046.     }
  1047.   return FALSE;
  1048. }
  1049.  
  1050. static PathList *
  1051. path_add_to_current (PathList  *pip,
  1052.              Path      *bzp,
  1053.              GimpImage *gimage,
  1054.              gint       pos)
  1055. {
  1056.   /* add bzp to current list */
  1057.   if (!pip)
  1058.     {
  1059.       /* This image does not have a list */
  1060.       pip = path_list_new (gimage, 0, NULL);
  1061.  
  1062.       /* add to gimage */
  1063.       gimp_image_set_paths (gimage, pip);
  1064.     }
  1065.  
  1066.   if (pos < 0)
  1067.     pip->bz_paths = g_slist_append (pip->bz_paths,bzp);
  1068.   else
  1069.     pip->bz_paths = g_slist_insert (pip->bz_paths,bzp,pos);
  1070.  
  1071.   return pip;
  1072. }
  1073.  
  1074. static Path*
  1075. paths_dialog_new_path (PathList  **plp,
  1076.                gpointer    points,
  1077.                GimpImage  *gimage,
  1078.                gint        pos)
  1079. {
  1080.   static gint nseed = 0;
  1081.   Path* bzp;
  1082.  
  1083.   bzp  = path_dialog_new (gimage, nseed++, points);
  1084.   *plp = path_add_to_current (*plp, bzp, gimage, pos);
  1085.  
  1086.   return (bzp);
  1087. }
  1088.  
  1089. void 
  1090. paths_dialog_new_path_callback (GtkWidget *widget, 
  1091.                 gpointer   data)
  1092. {
  1093.   BezierSelect * bsel;
  1094.   GDisplay *gdisp;
  1095.   Path* bzp;
  1096.  
  1097.   bzp = paths_dialog_new_path (&paths_dialog->current_path_list,
  1098.                    NULL,
  1099.                    paths_dialog->gimage,
  1100.                    paths_dialog->selected_row_num);
  1101.  
  1102.   paths_add_path (bzp, paths_dialog->selected_row_num);
  1103.  
  1104.   paths_dialog_set_menu_sensitivity ();
  1105.  
  1106.   paths_dialog_set_default_op ();
  1107.  
  1108.   /* Clear the path display out */
  1109.   bsel = path_to_beziersel (bzp);
  1110.   gdisp = gdisplays_check_valid (paths_dialog->current_path_list->gdisp,
  1111.                  paths_dialog->gimage);
  1112.   bezier_paste_bezierselect_to_current (gdisp, bsel);
  1113.   bezier_select_free (bsel);
  1114. }
  1115.  
  1116. void 
  1117. paths_dialog_delete_path_callback (GtkWidget *widget, 
  1118.                    gpointer   udata)
  1119. {
  1120.   Path* bzp;
  1121.   PathList* plp;
  1122.   gboolean new_sz;
  1123.   gint row = paths_dialog->selected_row_num;
  1124.   BezierSelect *bsel  = NULL;
  1125.   GDisplay     *gdisp = NULL;
  1126.  
  1127.   g_return_if_fail (paths_dialog->current_path_list != NULL);
  1128.  
  1129.   /* Get current selection... ignore if none */
  1130.   if (paths_dialog->selected_row_num < 0)
  1131.     return;
  1132.   
  1133.   /* Get bzpath structure & delete its content */
  1134.   plp = paths_dialog->current_path_list;
  1135.   bzp = (Path*) g_slist_nth_data (plp->bz_paths, row); 
  1136.  
  1137.   /* Remove from list */
  1138.   plp->bz_paths = g_slist_remove (plp->bz_paths, bzp);
  1139.   new_sz = (g_slist_length (plp->bz_paths) > 0);
  1140.   path_free (bzp);
  1141.  
  1142.   /* Remove from the clist ... */ 
  1143.   gtk_signal_handler_block_by_data (GTK_OBJECT (paths_dialog->paths_list), 
  1144.                     paths_dialog);
  1145.   gtk_clist_remove (GTK_CLIST (paths_dialog->paths_list), row);
  1146.   gtk_signal_handler_unblock_by_data (GTK_OBJECT (paths_dialog->paths_list), 
  1147.                       paths_dialog);
  1148.  
  1149.   /* If now empty free everything up */
  1150.   if (!plp->bz_paths || g_slist_length (plp->bz_paths) == 0)
  1151.     {
  1152.       gtk_signal_disconnect (GTK_OBJECT (plp->gimage),
  1153.                  plp->sig_id);
  1154.  
  1155.       gimp_image_set_paths (plp->gimage, NULL);
  1156.       path_list_free (plp);
  1157.  
  1158.       /* Paste an empty BezierSelect to the current display to emulate an empty path list */
  1159.  
  1160.       bsel = g_new0 (BezierSelect, 1);
  1161.       bezier_select_reset (bsel);
  1162.       gdisp = gdisplays_check_valid (paths_dialog->current_path_list->gdisp,
  1163.                      paths_dialog->gimage);
  1164.  
  1165.       bezier_paste_bezierselect_to_current (gdisp, bsel);
  1166.       bezier_select_free (bsel);
  1167.  
  1168.       paths_dialog->current_path_list = NULL;
  1169.  
  1170.       paths_dialog_set_menu_sensitivity ();
  1171.     }
  1172.  
  1173.   if (!new_sz)
  1174.     paths_dialog_set_default_op ();
  1175. }
  1176.  
  1177. void 
  1178. paths_dialog_paste_path_callback (GtkWidget *widget, 
  1179.                   gpointer   data)
  1180. {
  1181.   Path* bzp;
  1182.   PathList* plp;
  1183.   PathPoint* pp;
  1184.   BezierSelect * bezier_sel;
  1185.   gint tmprow;
  1186.   GDisplay *gdisp;
  1187.  
  1188.   gint row = paths_dialog->selected_row_num;
  1189.  
  1190.   g_return_if_fail (paths_dialog->current_path_list != NULL);
  1191.  
  1192.   if (!copy_pp)
  1193.     return;
  1194.  
  1195.   /* Get current selection... ignore if none */
  1196.   if (paths_dialog->selected_row_num < 0)
  1197.     return;
  1198.   
  1199.   /* Get bzpath structure  */
  1200.   plp = paths_dialog->current_path_list;
  1201.   if (!plp)
  1202.     return;
  1203.  
  1204.   bzp = (Path*) g_slist_nth_data (plp->bz_paths, row); 
  1205.  
  1206.   if (bzp->path_details)
  1207.     {
  1208.       pp = bzp->path_details->data;
  1209.       pp->type = BEZIER_MOVE;
  1210.       bzp->path_details = g_slist_concat (copy_pp->path_details,
  1211.                       bzp->path_details);
  1212.     }
  1213.   else
  1214.     {
  1215.       bzp->closed = TRUE;
  1216.       bzp->path_details = copy_pp->path_details;
  1217.       bzp->state = copy_pp->state;
  1218.     }
  1219.  
  1220.   /* First point on new curve is a moveto */
  1221.   copy_pp->path_details = NULL;
  1222.   path_free (copy_pp);
  1223.   copy_pp = NULL;
  1224.  
  1225.   paths_dialog_set_menu_sensitivity ();
  1226.  
  1227.   /* Now fudge the drawing....*/
  1228.   bezier_sel = path_to_beziersel (bzp);
  1229.   tmprow = paths_dialog->current_path_list->last_selected_row;
  1230.   paths_dialog->current_path_list->last_selected_row = row;
  1231.   gdisp = gdisplays_check_valid (paths_dialog->current_path_list->gdisp,
  1232.                  paths_dialog->gimage);
  1233.   bezier_paste_bezierselect_to_current (gdisp, bezier_sel);
  1234.   paths_update_preview (bezier_sel);
  1235.   bezier_select_free (bezier_sel);
  1236.   paths_dialog->current_path_list->last_selected_row = tmprow;
  1237. }
  1238.  
  1239. void 
  1240. paths_dialog_copy_path_callback (GtkWidget *widget,
  1241.                  gpointer   data)
  1242. {
  1243.   Path* bzp;
  1244.   PathList* plp;
  1245.   gint row = paths_dialog->selected_row_num;
  1246.  
  1247.   g_return_if_fail (paths_dialog->current_path_list != NULL);
  1248.  
  1249.   /* Get current selection... ignore if none */
  1250.   if (paths_dialog->selected_row_num < 0)
  1251.     return;
  1252.   
  1253.   /* Get bzpath structure  */
  1254.   plp = paths_dialog->current_path_list;
  1255.   bzp = (Path*) g_slist_nth_data (plp->bz_paths, row);
  1256.  
  1257.   if (!bzp->path_details || g_slist_length (bzp->path_details) <= 5)
  1258.     return;
  1259.  
  1260.   /* And store in static array */
  1261.   copy_pp = path_copy (paths_dialog->gimage, bzp);
  1262.  
  1263.   /* All paths that are in the cut buffer must be closed */
  1264.   if (!copy_pp->closed)
  1265.     path_close (copy_pp);
  1266.  
  1267.   paths_dialog_set_menu_sensitivity ();
  1268. }
  1269.  
  1270. void 
  1271. paths_dialog_dup_path_callback (GtkWidget *widget, 
  1272.                 gpointer   data)
  1273. {
  1274.   Path* bzp;
  1275.   PathList* plp;
  1276.   BezierSelect * bezier_sel;
  1277.   gint row;
  1278.   gint tmprow;
  1279.  
  1280.   g_return_if_fail (paths_dialog->current_path_list != NULL);
  1281.  
  1282.   /* Get current selection... ignore if none */
  1283.   if (paths_dialog->selected_row_num < 0)
  1284.     return;
  1285.   
  1286.   row = paths_dialog->current_path_list->last_selected_row;
  1287.   /* Get bzpath structure  */
  1288.   plp = paths_dialog->current_path_list;
  1289.   bzp = (Path*) g_slist_nth_data (plp->bz_paths, row); 
  1290.  
  1291.   /* Insert at the current position */
  1292.   bzp = path_copy (paths_dialog->gimage, bzp);
  1293.   plp->bz_paths = g_slist_insert (plp->bz_paths, bzp, row);
  1294.   paths_add_path (bzp, row);
  1295.  
  1296.   /* Now fudge the drawing....*/
  1297.   bezier_sel = path_to_beziersel (bzp);
  1298.   tmprow = paths_dialog->current_path_list->last_selected_row;
  1299.   paths_dialog->current_path_list->last_selected_row = row;
  1300.   paths_update_preview (bezier_sel);
  1301.   bezier_select_free (bezier_sel);
  1302.   paths_dialog->current_path_list->last_selected_row = tmprow;
  1303. }
  1304.  
  1305. static void 
  1306. paths_dialog_advanced_to_path_callback (GtkWidget *widget, 
  1307.                     gpointer   data)
  1308. {
  1309.   ProcRecord *proc_rec;
  1310.   Argument   *args;
  1311.   GimpImage *gimage;
  1312.  
  1313.   /*  find the sel2path PDB record  */
  1314.   if ((proc_rec = procedural_db_lookup ("plug_in_sel2path_advanced")) == NULL)
  1315.     {
  1316.       g_message ("paths_dialog_adavanced_to_path_callback(): selection to path (advanced) procedure lookup failed");
  1317.       return;
  1318.     }
  1319.  
  1320.   gimage = paths_dialog->gimage;
  1321.  
  1322.   /*  plug-in arguments as if called by <Image>/Filters/...  */
  1323.   args = g_new (Argument, 3);
  1324.   args[0].arg_type = PDB_INT32;
  1325.   args[0].value.pdb_int = RUN_INTERACTIVE;
  1326.   args[1].arg_type = PDB_IMAGE;
  1327.   args[1].value.pdb_int = (gint32) pdb_image_to_id (gimage);
  1328.   args[2].arg_type = PDB_DRAWABLE;
  1329.   args[2].value.pdb_int = (gint32) (gimage_active_drawable (gimage))->ID;
  1330.  
  1331.   plug_in_run (proc_rec, args, 3, FALSE, TRUE,
  1332.            (gimage_active_drawable (gimage))->ID);
  1333.  
  1334.   g_free (args);
  1335.  
  1336. }
  1337.  
  1338. static void 
  1339. paths_dialog_null_callback (GtkWidget *widget, 
  1340.                 gpointer   data)
  1341. {
  1342.   /* Maybe some more here later? */
  1343. }
  1344.  
  1345. void 
  1346. paths_dialog_sel_to_path_callback (GtkWidget *widget, 
  1347.                    gpointer   data)
  1348. {
  1349.   ProcRecord *proc_rec;
  1350.   Argument   *args;
  1351.   GimpImage  *gimage;
  1352.   GDisplay   *gdisp;
  1353.  
  1354.   /*  find the sel2path PDB record  */
  1355.   if ((proc_rec = procedural_db_lookup ("plug_in_sel2path")) == NULL)
  1356.     {
  1357.       g_message ("paths_dialog_sel_to_path_callback(): selection to path procedure lookup failed");
  1358.       return;
  1359.     }
  1360.  
  1361.   gimage = paths_dialog->gimage;
  1362.  
  1363.   /*  plug-in arguments as if called by <Image>/Filters/...  */
  1364.   args = g_new (Argument, 3);
  1365.   args[0].arg_type = PDB_INT32;
  1366.   args[0].value.pdb_int = RUN_INTERACTIVE;
  1367.   args[1].arg_type = PDB_IMAGE;
  1368.   args[1].value.pdb_int = (gint32) pdb_image_to_id (gimage);
  1369.   args[2].arg_type = PDB_DRAWABLE;
  1370.   args[2].value.pdb_int = (gint32) (gimage_active_drawable (gimage))->ID;
  1371.  
  1372.   /* get the display by asking the current context */
  1373.   gdisp = gimp_context_get_display (gimp_context_get_user ());
  1374.   plug_in_run (proc_rec, args, 3, FALSE, TRUE,
  1375.            gdisp? gdisp->ID : 0);
  1376.  
  1377.   g_free (args);
  1378. }
  1379.  
  1380.  
  1381. void 
  1382. paths_dialog_path_to_sel_callback (GtkWidget *widget, 
  1383.                    gpointer   data)
  1384. {
  1385.   Path* bzp;
  1386.   PathList* plp;
  1387.   BezierSelect * bezier_sel;
  1388.   GDisplay  * gdisp;
  1389.   gint row = paths_dialog->selected_row_num;
  1390.  
  1391.   g_return_if_fail (paths_dialog->current_path_list != NULL);
  1392.  
  1393.   /* Get current selection... ignore if none */
  1394.   if (paths_dialog->selected_row_num < 0)
  1395.     return;
  1396.   
  1397.   /* Get bzpath structure  */
  1398.   plp = paths_dialog->current_path_list;
  1399.   bzp = (Path*) g_slist_nth_data (plp->bz_paths, row); 
  1400.  
  1401.   /* Return if no point list */
  1402.   if (!bzp->path_details)
  1403.     return;
  1404.  
  1405.   /* Now do the selection....*/
  1406.   gdisp = gdisplays_check_valid (paths_dialog->current_path_list->gdisp,
  1407.                  paths_dialog->gimage);
  1408.  
  1409.   if (!bzp->closed)
  1410.     {
  1411.       Path* bzpcopy = path_copy (paths_dialog->gimage,bzp);
  1412.       /* Close it */
  1413.       path_close (bzpcopy);
  1414.       bezier_sel = path_to_beziersel (bzpcopy);
  1415.       path_free (bzpcopy);
  1416.       bezier_to_selection (bezier_sel, gdisp);
  1417.       bezier_select_free (bezier_sel);
  1418.  
  1419.       /* Force display to show no closed curve */
  1420.       bezier_sel = path_to_beziersel (bzp);
  1421.       bezier_paste_bezierselect_to_current (gdisp, bezier_sel);
  1422.       bezier_select_free (bezier_sel);
  1423.     }
  1424.   else
  1425.     {
  1426.       bezier_sel = path_to_beziersel (bzp);
  1427.       bezier_to_selection (bezier_sel, gdisp);
  1428.       bezier_select_free (bezier_sel);
  1429.     }
  1430. }
  1431.  
  1432. void 
  1433. paths_dialog_stroke_path_callback (GtkWidget *widget, 
  1434.                    gpointer   data)
  1435. {
  1436.   Path* bzp;
  1437.   PathList* plp;
  1438.   gint row = paths_dialog->selected_row_num;
  1439.  
  1440.   g_return_if_fail (paths_dialog->current_path_list != NULL);
  1441.  
  1442.   /* Get current selection... ignore if none */
  1443.   if (paths_dialog->selected_row_num < 0)
  1444.     return;
  1445.   
  1446.   /* Get bzpath structure  */
  1447.   plp = paths_dialog->current_path_list;
  1448.   bzp = (Path*) g_slist_nth_data (plp->bz_paths, row); 
  1449.  
  1450.   /* Now do the stroke....*/
  1451.   path_stroke (paths_dialog->gimage, paths_dialog->current_path_list, bzp);
  1452. }
  1453.  
  1454. void
  1455. paths_dialog_edit_path_attributes_callback (GtkWidget *widget,
  1456.                         gpointer   data)
  1457. {
  1458.   if (paths_dialog && paths_dialog->paths_list)
  1459.     paths_dialog_edit_path_query (paths_dialog->paths_list);
  1460. }
  1461.  
  1462. static void
  1463. paths_dialog_map_callback (GtkWidget *widget,
  1464.                gpointer   data)
  1465. {
  1466.   if (!paths_dialog)
  1467.     return;
  1468.  
  1469.   gtk_window_add_accel_group (GTK_WINDOW (lc_dialog->shell),
  1470.                   paths_dialog->accel_group);
  1471.  
  1472.   paths_dialog_preview_extents ();
  1473. }
  1474.  
  1475. static void
  1476. paths_dialog_unmap_callback (GtkWidget *widget,
  1477.                  gpointer   data)
  1478. {
  1479.   if (!paths_dialog)
  1480.     return;
  1481.   
  1482.   gtk_window_remove_accel_group (GTK_WINDOW (lc_dialog->shell),
  1483.                  paths_dialog->accel_group);
  1484. }
  1485.  
  1486. void
  1487. paths_dialog_destroy_cb (GtkObject *object,
  1488.              gpointer   data)
  1489. {
  1490.   GimpImage *gimage = (GimpImage *)object;
  1491.   PathList* new_path_list;
  1492.  
  1493.   if (!paths_dialog)
  1494.     return;
  1495.  
  1496.   if (paths_dialog->current_path_list && 
  1497.       gimage == paths_dialog->current_path_list->gimage)
  1498.     {
  1499.       /* showing could be last so remove here.. might get 
  1500.      done again if not the last one
  1501.       */
  1502.       paths_dialog->current_path_list = NULL;
  1503.       paths_dialog->been_selected = FALSE;
  1504.  
  1505.       gtk_clist_freeze (GTK_CLIST (paths_dialog->paths_list));
  1506.       gtk_clist_clear (GTK_CLIST (paths_dialog->paths_list));
  1507.       gtk_clist_thaw (GTK_CLIST (paths_dialog->paths_list));
  1508.     }
  1509.  
  1510.   /* Find bz list */  
  1511.   new_path_list = (PathList*) gimp_image_get_paths (gimage);
  1512.  
  1513.   if (!new_path_list)
  1514.     return; /* Already removed - signal handler just left in the air */
  1515.  
  1516.   path_list_free (new_path_list);
  1517.  
  1518.   gimp_image_set_paths (gimage, NULL);
  1519. }
  1520.  
  1521. /* Functions used from the bezier code .. tie in with this code */
  1522. static GSList *
  1523. pathpoints_create (BezierSelect *sel)
  1524. {
  1525.   gint i;
  1526.   GSList *list = NULL;
  1527.   PathPoint *pathpoint;
  1528.   BezierPoint *pts = (BezierPoint *) sel->points;
  1529.   BezierPoint *start_pnt = pts;
  1530.   gint need_move = 0;
  1531.  
  1532.   for (i=0; i< sel->num_points; i++)
  1533.     {
  1534.       pathpoint = path_point_new ((need_move)?BEZIER_MOVE:pts->type,
  1535.                   (gdouble)pts->x,(gdouble)pts->y);
  1536.       need_move = 0;
  1537.       list = g_slist_append (list, pathpoint);
  1538.       if(pts->next_curve)
  1539.     {
  1540.       /* The curve must loop back on itself */
  1541.       if(start_pnt != pts->next)
  1542.         g_warning("Curve of of sync");
  1543.       
  1544.       need_move = 1;
  1545.       pts = pts->next_curve;
  1546.       start_pnt = pts;
  1547.     }
  1548.       else
  1549.     {
  1550.       pts = pts->next;
  1551.     }
  1552.     }
  1553.   return (list);
  1554. }
  1555.  
  1556. GSList *
  1557. pathpoints_copy (GSList *list)
  1558. {
  1559.   GSList *slcopy = NULL;
  1560.   PathPoint* pdata;
  1561.   PathPoint* pathpoint;
  1562.   while(list)
  1563.     {
  1564.       pathpoint = g_new0(PathPoint,1);
  1565.       pdata = (PathPoint*)list->data;
  1566.       pathpoint->type = pdata->type;
  1567.       pathpoint->x = pdata->x;
  1568.       pathpoint->y = pdata->y;
  1569.       slcopy = g_slist_append(slcopy,pathpoint);
  1570.       list = g_slist_next(list);
  1571.     }
  1572.   return slcopy;
  1573. }
  1574.  
  1575. void
  1576. pathpoints_free (GSList *list)
  1577. {
  1578.   if (!list)
  1579.     return;
  1580.  
  1581.   g_slist_foreach (list, (GFunc)path_point_free, NULL);
  1582.   g_slist_free (list);
  1583. }
  1584.  
  1585. static void
  1586. paths_update_bzpath (PathList     *plp,
  1587.              BezierSelect *bezier_sel)
  1588. {
  1589.   Path* p;
  1590.  
  1591.   p = (Path*)g_slist_nth_data(plp->bz_paths,plp->last_selected_row);
  1592.   
  1593.   if(p->path_details) 
  1594.     pathpoints_free (p->path_details); 
  1595.   
  1596.   p->path_details = pathpoints_create(bezier_sel);
  1597.   p->closed = bezier_sel->closed;
  1598.   p->state  = bezier_sel->state;
  1599. }
  1600.  
  1601. static gboolean
  1602. paths_replaced_current (PathList     *plp,
  1603.             BezierSelect *bezier_sel)
  1604. {
  1605.   /* Is there a currently selected path in this image? */
  1606.   /* ALT if(paths_dialog && plp &&  */
  1607.   if(plp && 
  1608.      plp->last_selected_row >= 0)
  1609.     {  
  1610.       paths_update_bzpath(plp,bezier_sel);
  1611.       return TRUE;
  1612.     }
  1613.   return FALSE;
  1614. }
  1615.  
  1616. static gint 
  1617. number_curves_in_path (GSList *plist)
  1618. {
  1619.   gint count = 0;
  1620.   while(plist)
  1621.     {
  1622.       if(((PathPoint*)(plist->data))->type == BEZIER_MOVE &&
  1623.      g_slist_next(plist))
  1624.     {
  1625.       count++;
  1626.     }
  1627.       plist = g_slist_next(plist);
  1628.     }  
  1629.   return count;
  1630. }
  1631.  
  1632. static void 
  1633. paths_draw_segment_points (BezierSelect *bezier_sel, 
  1634.                GdkPoint     *pnt, 
  1635.                int           npoints,
  1636.                gpointer      udata)
  1637. {
  1638.   /* 
  1639.    * hopefully the image points are already in image space co-ords.
  1640.    * so just scale by ratio factor and draw 'em
  1641.    */
  1642.   gint loop;
  1643.   gint pcount = 0;
  1644.   GdkPoint * copy_pnt = g_new(GdkPoint,npoints);
  1645.   GdkPoint * cur_pnt  = copy_pnt;
  1646.   GdkPoint * last_pnt  = NULL;
  1647.   PathWidget *pwidget;
  1648.   gint row;
  1649.   PathCounts *curve_count = (PathCounts *) udata;
  1650.  
  1651.   /* we could remove duplicate points here */
  1652.  
  1653.   for(loop = 0; loop < npoints; loop++)
  1654.     {
  1655.       /* The "2" is because we have a boarder */
  1656.       cur_pnt->x = 2+(int) (paths_dialog->ratio * pnt->x);
  1657.       cur_pnt->y = 2+(int) (paths_dialog->ratio * pnt->y);
  1658.       pnt++;
  1659.       if(last_pnt &&
  1660.      last_pnt->x == cur_pnt->x &&
  1661.      last_pnt->y == cur_pnt->y)
  1662.     {
  1663.       /* same as last ... don't need this one */
  1664.       continue;
  1665.     }
  1666.  
  1667. /*       printf("converting %d [%d,%d] => [%d,%d]\n", */
  1668. /*          pcount,(int)pnt->x,(int)pnt->y,(int)cur_pnt->x,(int)cur_pnt->y); */
  1669.       last_pnt = cur_pnt;
  1670.       pcount++;
  1671.       cur_pnt++;
  1672.     }
  1673.  
  1674.   row = paths_dialog->current_path_list->last_selected_row;
  1675.  
  1676.   pwidget = (PathWidget *)
  1677.     gtk_clist_get_row_data (GTK_CLIST (paths_dialog->paths_list), row);
  1678.   
  1679.   if(pcount < 2)
  1680.     return;
  1681.  
  1682.   g_return_if_fail(pwidget != NULL);
  1683.  
  1684.   if(curve_count->c_count.count < curve_count->total_count || 
  1685.      bezier_sel->closed)
  1686.     paths_set_dash_line(paths_dialog->gc,FALSE);
  1687.   else
  1688.     paths_set_dash_line(paths_dialog->gc,TRUE);
  1689.   
  1690.   gdk_draw_lines (pwidget->paths_pixmap,
  1691.            paths_dialog->gc, copy_pnt, pcount);
  1692.  
  1693.   g_free(copy_pnt);
  1694. }
  1695.  
  1696. static void
  1697. paths_update_preview (BezierSelect *bezier_sel)
  1698. {
  1699.   gint row;
  1700.   PathCounts curve_count;
  1701.  
  1702.   if(paths_dialog &&
  1703.      paths_dialog->current_path_list &&
  1704.      (row = paths_dialog->current_path_list->last_selected_row) >= 0 &&
  1705.      preview_size)
  1706.     {
  1707.       PathWidget *pwidget;
  1708.  
  1709.       pwidget = (PathWidget *)
  1710.     gtk_clist_get_row_data (GTK_CLIST (paths_dialog->paths_list), row);
  1711.  
  1712.       /* Clear pixmap */
  1713.       clear_pixmap_preview (pwidget);
  1714.  
  1715.       curve_count.total_count =
  1716.     number_curves_in_path (pwidget->bzp->path_details);
  1717.  
  1718.       /* update .. */
  1719.       bezier_draw_curve (bezier_sel, paths_draw_segment_points,
  1720.              IMAGE_COORDS, &curve_count);
  1721.  
  1722.       /* update the pixmap */
  1723.       gtk_clist_set_pixtext (GTK_CLIST (paths_dialog->paths_list),
  1724.                  row,
  1725.                  1,
  1726.                  pwidget->bzp->name,
  1727.                  2,
  1728.                  pwidget->paths_pixmap,
  1729.                  NULL);
  1730.     }
  1731. }
  1732.  
  1733. static void 
  1734. paths_dialog_new_point_callback (GtkWidget *widget, 
  1735.                  gpointer   udata)
  1736. {
  1737.   bezier_select_mode (EXTEND_NEW);
  1738. }
  1739.  
  1740. static void 
  1741. paths_dialog_add_point_callback (GtkWidget *widget, 
  1742.                  gpointer   udata)
  1743. {
  1744.   bezier_select_mode (EXTEND_ADD);
  1745. }
  1746.  
  1747. static void 
  1748. paths_dialog_delete_point_callback (GtkWidget *widget, 
  1749.                     gpointer   udata)
  1750. {
  1751.   bezier_select_mode (EXTEND_REMOVE);
  1752. }
  1753.  
  1754. static void 
  1755. paths_dialog_edit_point_callback (GtkWidget *widget, 
  1756.                   gpointer   udata)
  1757. {
  1758.   bezier_select_mode (EXTEND_EDIT);
  1759. }
  1760.  
  1761. void
  1762. paths_dialog_flush (void)
  1763. {
  1764.   GimpImage *gimage;
  1765.  
  1766.   if (!paths_dialog)
  1767.     return;
  1768.  
  1769.  if (!(gimage = paths_dialog->gimage))
  1770.     return;
  1771.  
  1772.   gimage = paths_dialog->gimage;
  1773.  
  1774.   /* Check current_path_list since we might not have a valid preview.
  1775.    * which means it should be removed.. Or if we have one
  1776.    * created it!
  1777.    */
  1778.   if ((paths_dialog->current_path_list == NULL) ||
  1779.       (gimage->width != paths_dialog->gimage_width) ||
  1780.       (gimage->height != paths_dialog->gimage_height))
  1781.     {
  1782.       paths_dialog->gimage = NULL;
  1783.       paths_dialog_update (gimage);
  1784.     }
  1785. }
  1786.  
  1787. void 
  1788. paths_first_button_press (BezierSelect *bezier_sel,
  1789.               GDisplay     *gdisp)
  1790. {
  1791.   /* First time a button is pressed in this display */
  1792.   /* We have two choices here 
  1793.      Either:-
  1794.      1) We already have a paths item in the list. 
  1795.         => In this case the new one replaces the current entry. We
  1796.     need a callback into the bezier code to free things up.
  1797.      2) We don't have an entry. 
  1798.         => Create a new one and add this curve.
  1799.  
  1800.      In either case we need to update the preview widget..
  1801.  
  1802.      All this of course depends on the fact that gdisp is the same
  1803.      as before. 
  1804.   */
  1805.   Path* bzp; 
  1806.   PathList* plp;
  1807.  
  1808.   if(paths_dialog)
  1809.     {
  1810.       paths_dialog->been_selected = FALSE;
  1811.       /*ALT return;*/
  1812.     }
  1813.  
  1814.   /* Button not pressed in this image...
  1815.    * find which one it was pressed in if any.
  1816.    */
  1817.   plp = (PathList*)gimp_image_get_paths(gdisp->gimage);      
  1818.  
  1819.   /* Since beziers are part of the save format.. make the image dirty */
  1820. /*   undo_push_cantundo(gdisp->gimage, _("path modification")); */
  1821.   
  1822.   if(!paths_replaced_current(plp,bezier_sel))
  1823.     {
  1824.       bzp = paths_dialog_new_path (&plp, pathpoints_create(bezier_sel),gdisp->gimage,-1);
  1825.       bzp->closed = bezier_sel->closed;
  1826.       bzp->state  = bezier_sel->state;
  1827.       if(paths_dialog && paths_dialog->gimage == gdisp->gimage)
  1828.     {
  1829.       paths_dialog->current_path_list = plp;
  1830.       paths_add_path(bzp,-1);
  1831.     }
  1832.     }
  1833. }
  1834.  
  1835. void
  1836. paths_newpoint_current (BezierSelect *bezier_sel,
  1837.             GDisplay     *gdisp)
  1838. {
  1839.   /*  Check if currently showing the paths we are updating  */
  1840.   if (paths_dialog &&
  1841.       gdisp->gimage == paths_dialog->gimage)
  1842.     {
  1843.       paths_dialog_set_menu_sensitivity ();
  1844.  
  1845.       paths_update_preview (bezier_sel);
  1846.     }
  1847.  
  1848.   paths_first_button_press (bezier_sel, gdisp);
  1849. }
  1850.  
  1851. void 
  1852. paths_new_bezier_select_tool (void)
  1853. {
  1854.   if (paths_dialog)
  1855.     paths_dialog->been_selected = FALSE;
  1856. }
  1857.  
  1858.  
  1859. /**************************************************************/
  1860. /* Code to save/load from filesystem                          */
  1861. /**************************************************************/
  1862.  
  1863. static GtkWidget *file_dlg = 0;
  1864. static int load_store;
  1865.  
  1866. static void
  1867. path_write_current_to_file (FILE  *f,
  1868.                 Path*  bzp)
  1869. {
  1870.   GSList *list = bzp->path_details;
  1871.   PathPoint* pdata;
  1872.  
  1873.   fprintf(f, "Name: %s\n", bzp->name);
  1874.   fprintf(f, "#POINTS: %d\n", g_slist_length(bzp->path_details));
  1875.   fprintf(f, "CLOSED: %d\n", bzp->closed==1?1:0);
  1876.   fprintf(f, "DRAW: %d\n", 0);
  1877.   fprintf(f, "STATE: %d\n", bzp->state);
  1878.  
  1879.   while (list)
  1880.     {
  1881.       pdata = (PathPoint*)list->data;
  1882.       fprintf(f,"TYPE: %d X: %d Y: %d\n", pdata->type, (gint)pdata->x, (gint)pdata->y);
  1883.       list = g_slist_next(list);
  1884.     }
  1885. }
  1886.  
  1887. static void
  1888. file_ok_callback (GtkWidget *widget,
  1889.           gpointer   client_data) 
  1890. {
  1891.   GtkFileSelection *fs;
  1892.   FILE *f; 
  1893.   char* filename;
  1894.   Path* bzpath;
  1895.   PathList* plp;
  1896.   gint row = paths_dialog->selected_row_num;
  1897.   gint this_path_count = 0;
  1898.  
  1899.   fs = GTK_FILE_SELECTION (file_dlg);
  1900.   filename = gtk_file_selection_get_filename (fs);
  1901.  
  1902.   if (load_store) 
  1903.     {
  1904.       f = fopen(filename, "rb");
  1905.  
  1906.       if(!f)
  1907.     {
  1908.       g_message(_("Unable to open file %s"),filename);
  1909.       return;
  1910.     }
  1911.       
  1912.       while(!feof(f))
  1913.     {
  1914.       GSList * pts_list = NULL;
  1915.       gchar *txt = g_new(gchar,512);
  1916.       gchar *txtstart = txt;
  1917.       gint readfields = 0;
  1918.       int val, type, closed, i, draw, state;
  1919.       double x,y;
  1920.  
  1921.       if(!fgets(txt,512,f) || strlen(txt) < 7)
  1922.         {
  1923.           g_message(_("Failed to read from %s"),filename);
  1924.           gtk_widget_hide (file_dlg);  
  1925.           return;
  1926.         }
  1927.  
  1928.       txt += 6; /* Miss out 'Name: ' bit */
  1929.       txt[strlen(txt)-1] = '\0';
  1930.  
  1931.       readfields += fscanf(f, "#POINTS: %d\n", &val);
  1932.        readfields += fscanf(f, "CLOSED: %d\n", &closed);
  1933.       readfields += fscanf(f, "DRAW: %d\n", &draw);
  1934.       readfields += fscanf(f, "STATE: %d\n", &state);
  1935.  
  1936.       if(readfields != 4)
  1937.         {
  1938.           g_message(_("Failed to read path from %s"),filename);
  1939.           gtk_widget_hide (file_dlg);  
  1940.           return;
  1941.         }
  1942.  
  1943.       if(val <= 0)
  1944.         {
  1945.           g_message(_("No points specified in path file %s"),filename);
  1946.           gtk_widget_hide (file_dlg);  
  1947.           return;
  1948.         }
  1949.  
  1950.       for(i=0; i< val; i++)
  1951.         {
  1952.           PathPoint* bpt;
  1953.           readfields = fscanf(f,"TYPE: %d X: %lg Y: %lg\n", &type, &x, &y);
  1954.           if(readfields != 3)
  1955.         {
  1956.           g_message(_("Failed to read path points from %s"),filename);
  1957.           gtk_widget_hide (file_dlg);  
  1958.           return;
  1959.         }
  1960.           this_path_count++;
  1961.           switch(type)
  1962.         {
  1963.         case BEZIER_ANCHOR:
  1964.         case BEZIER_CONTROL:
  1965.           break;
  1966.         case BEZIER_MOVE:
  1967.           if(this_path_count < 6)
  1968.             {
  1969.               g_warning("Invalid single point in path\n");
  1970.               gtk_widget_hide (file_dlg);  
  1971.               return;
  1972.             }
  1973.           this_path_count = 0;
  1974.           break;
  1975.         default:
  1976.           g_warning("Invalid point type passed\n");
  1977.           gtk_widget_hide (file_dlg);  
  1978.           return;
  1979.         }
  1980.  
  1981.           bpt = path_point_new (type, (gdouble)x, (gdouble)y);
  1982.           pts_list = g_slist_append(pts_list,bpt);
  1983.         }
  1984.  
  1985.       bzpath = path_new(paths_dialog->gimage,
  1986.                 BEZIER,
  1987.                 pts_list,
  1988.                 closed,
  1989.                 state,
  1990.                 0, /* Can't be locked */
  1991.                 0, /* No tattoo assigned */
  1992.                 txt);
  1993.       
  1994.       g_free(txtstart);
  1995.  
  1996.       paths_dialog->current_path_list = 
  1997.         path_add_to_current(paths_dialog->current_path_list,
  1998.                   bzpath,
  1999.                   paths_dialog->gimage,
  2000.                   row);
  2001.       paths_add_path (bzpath, row);
  2002.  
  2003.       gtk_clist_select_row(GTK_CLIST(paths_dialog->paths_list),
  2004.                    paths_dialog->current_path_list->last_selected_row,
  2005.                    1);
  2006.  
  2007.       paths_dialog_set_menu_sensitivity ();
  2008.  
  2009.       if (!val)
  2010.         paths_dialog_set_default_op ();
  2011.     }
  2012.       fclose (f);
  2013.     } 
  2014.   else 
  2015.     {
  2016.       Path* bzp;
  2017.  
  2018.       /* Get current selection... ignore if none */
  2019.       if(paths_dialog->selected_row_num < 0)
  2020.     return;
  2021.       
  2022.       /* Get bzpath structure  */
  2023.       plp = paths_dialog->current_path_list;
  2024.       bzp = (Path*)g_slist_nth_data(plp->bz_paths,row); 
  2025.  
  2026.       f = fopen(filename, "wb");
  2027.       if (NULL == f) 
  2028.     {
  2029.       g_message (_("open failed on %s: %s\n"), filename, g_strerror(errno));
  2030.       return;
  2031.     }
  2032.  
  2033.       /* Write the current selection out. */
  2034.       path_write_current_to_file (f,bzp);
  2035.  
  2036.       fclose (f);
  2037.     }
  2038.   gtk_widget_hide (file_dlg);  
  2039. }
  2040.  
  2041. static void
  2042. file_cancel_callback (GtkWidget *widget,
  2043.               gpointer   data) 
  2044. {
  2045.   gtk_widget_hide (file_dlg);
  2046. }
  2047.  
  2048. static void
  2049. make_file_dlg (gpointer data) 
  2050. {
  2051.   file_dlg = gtk_file_selection_new (_("Load/Store Bezier Curves"));
  2052.   gtk_window_set_wmclass (GTK_WINDOW (file_dlg), "load_save_path", "Gimp");
  2053.   gtk_window_set_position (GTK_WINDOW (file_dlg), GTK_WIN_POS_MOUSE);
  2054.  
  2055.   gtk_container_set_border_width (GTK_CONTAINER (file_dlg), 2);
  2056.   gtk_container_set_border_width (GTK_CONTAINER (GTK_FILE_SELECTION (file_dlg)->button_area), 2);
  2057.  
  2058.   gtk_signal_connect
  2059.     (GTK_OBJECT (GTK_FILE_SELECTION (file_dlg)->cancel_button), "clicked",
  2060.      GTK_SIGNAL_FUNC (file_cancel_callback),
  2061.      data);
  2062.   gtk_signal_connect
  2063.     (GTK_OBJECT (GTK_FILE_SELECTION (file_dlg)->ok_button), "clicked",
  2064.      GTK_SIGNAL_FUNC (file_ok_callback),
  2065.      data);
  2066.   gtk_signal_connect (GTK_OBJECT (file_dlg), "delete_event",
  2067.               GTK_SIGNAL_FUNC (gtk_widget_hide),
  2068.               NULL);
  2069.  
  2070.   /*  Connect the "F1" help key  */
  2071.   gimp_help_connect_help_accel (file_dlg, gimp_standard_help_func, NULL);
  2072. }
  2073.  
  2074. void 
  2075. paths_dialog_import_path_callback (GtkWidget *widget,
  2076.                    gpointer   data)
  2077. {
  2078.   /* Read and add at current position */
  2079.   if (!file_dlg) 
  2080.     {
  2081.       make_file_dlg (NULL);
  2082.     } 
  2083.   else 
  2084.     {
  2085.       if (GTK_WIDGET_VISIBLE (file_dlg))
  2086.     return;
  2087.     }
  2088.  
  2089.   gimp_help_set_help_data (file_dlg, NULL, "paths/dialogs/import_path.html");
  2090.  
  2091.   gtk_window_set_title (GTK_WINDOW (file_dlg), _("Load Path"));
  2092.   load_store = 1;
  2093.   gtk_widget_show (file_dlg);
  2094. }
  2095.  
  2096. void 
  2097. paths_dialog_export_path_callback (GtkWidget *widget,
  2098.                    gpointer   data)
  2099. {
  2100.   /* Export the path to a file */
  2101.   if (!file_dlg) 
  2102.     {
  2103.       make_file_dlg (NULL);
  2104.     } 
  2105.   else 
  2106.     {
  2107.       if (GTK_WIDGET_VISIBLE (file_dlg))
  2108.     return;
  2109.     }
  2110.  
  2111.   gimp_help_set_help_data (file_dlg, NULL, "paths/dialogs/export_path.html");
  2112.  
  2113.   gtk_window_set_title (GTK_WINDOW (file_dlg), _("Store Path"));
  2114.   load_store = 0;
  2115.   gtk_widget_show (file_dlg);
  2116. }
  2117.  
  2118. /*************************************/
  2119. /* Function for transforming paths   */
  2120. /*************************************/
  2121.  
  2122. /* These functions are the undo functions for the paths
  2123.  * that have undergone transformations. 
  2124.  *
  2125.  * Generally speaking paths do not belong with the undo 
  2126.  * structures. However when a path undergoes a transformation 
  2127.  * then THIS path transformation should be part of the undo.
  2128.  * We do have a problem here since a point could have been
  2129.  * added to the path after the transformation. This 
  2130.  * point will be lost if the undo stuff is performed. It would 
  2131.  * then appear that this point is part of the undo structure.
  2132.  * I think it is fair that this happens since the user is telling
  2133.  * us to restore the state before the transformation took place.
  2134.  * Note tattoos are used to find which paths have been stored in the
  2135.  * undo buffer. So deleted paths will not suddenly reappear. (I did say
  2136.  * generally paths are not part of the undo structures).
  2137.  */
  2138. PathUndo *
  2139. path_transform_start_undo (GimpImage *gimage)
  2140. {
  2141.   /* Save only the locked paths away */
  2142.   PathList *plp;
  2143.   GSList   *plist;
  2144.   Path*     p;
  2145.   Path*     p_copy;
  2146.   GSList   *undo_list = NULL;
  2147.  
  2148.   /* Get bzpath structure  */
  2149.   plp = (PathList*) gimp_image_get_paths (gimage);
  2150.   
  2151.   if (!plp)
  2152.     return NULL;
  2153.   
  2154.   plist = plp->bz_paths;
  2155.  
  2156.   for (plist = plp->bz_paths; plist; plist = g_slist_next (plist))
  2157.     {
  2158.       p = (Path*)plist->data;
  2159.       if (p->locked)
  2160.     {
  2161.       /* save away for a rainy day */
  2162.       p_copy = path_copy (NULL, p); /* NULL means dont want new tattoo */
  2163.       undo_list = g_slist_append (undo_list, p_copy);
  2164.     }
  2165.     }
  2166.  
  2167.   return (PathUndo *) undo_list;
  2168. }
  2169.  
  2170. void
  2171. path_transform_free_undo (PathUndo *pundo)
  2172. {
  2173.   GSList *pundolist = (GSList*)pundo;
  2174.   Path   *p;
  2175.   /* free data associated with the transform path undo */
  2176.  
  2177.   while (pundolist)
  2178.     {
  2179.       p = (Path*)pundolist->data;
  2180.       path_free (p);
  2181.       pundolist = g_slist_next (pundolist);
  2182.     }
  2183.  
  2184.   g_slist_free (pundolist);
  2185. }
  2186.  
  2187. void
  2188. path_transform_do_undo (GimpImage *gimage,
  2189.             PathUndo  *pundo)
  2190. {
  2191.   GSList *pundolist;
  2192.   /* Restore the paths as they were before this transform took place. */
  2193.   Path *p_undo;
  2194.   Path *p;
  2195.   BezierSelect *bezier_sel;
  2196.   gint tmprow;
  2197.   gint loop;
  2198.   gboolean preview_update = FALSE;
  2199.   PathList *plp;
  2200.   GSList *plist;
  2201.  
  2202.   /* free data associated with the transform path undo */
  2203.  
  2204.   for (pundolist = pundo; pundolist; pundolist = g_slist_next(pundolist))
  2205.     {
  2206.       p_undo = (Path*)pundolist->data;
  2207.       /* Find the old path and replace it */
  2208.       p = path_get_path_by_tattoo (gimage, p_undo->tattoo);
  2209.       if (p)
  2210.     {
  2211.       /* Path is still around... undo the transform stuff */
  2212.       pathpoints_free (p->path_details);
  2213.       p->closed = p_undo->closed;
  2214.       p->state = p_undo->state;
  2215.       p->pathtype = p_undo->pathtype;
  2216.       p->path_details = pathpoints_copy (p_undo->path_details);
  2217.       preview_update = TRUE;
  2218.     }
  2219.     }
  2220.  
  2221.   if (preview_update && paths_dialog)
  2222.     {
  2223.       /* Heck the previews need updating...*/
  2224.       plp = (PathList *) gimp_image_get_paths (gimage);
  2225.       plist = plp->bz_paths;
  2226.       loop = 0;
  2227.       
  2228.       while (plist && 
  2229.          g_slist_length (plist) &&
  2230.          paths_dialog->current_path_list)
  2231.     {
  2232.       bezier_sel = path_to_beziersel (plist->data);
  2233.       tmprow = paths_dialog->current_path_list->last_selected_row;
  2234.       paths_dialog->current_path_list->last_selected_row = loop;
  2235.       paths_update_preview (bezier_sel);
  2236.       bezier_select_free (bezier_sel);
  2237.       paths_dialog->current_path_list->last_selected_row = tmprow;
  2238.       paths_dialog->selected_row_num = tmprow;
  2239.       loop++;
  2240.       plist = g_slist_next (plist);
  2241.     }
  2242.  
  2243.       /* Force selection .. it may have changed */
  2244.       if (bezier_tool_selected () && paths_dialog->current_path_list)
  2245.     {
  2246.       gtk_clist_select_row (GTK_CLIST (paths_dialog->paths_list),
  2247.                 paths_dialog->current_path_list->last_selected_row,
  2248.                 1);
  2249.     }
  2250.     }
  2251. }
  2252.  
  2253. static void
  2254. transform_func (GimpImage  *gimage, 
  2255.         int         flip, 
  2256.         gdouble     x, 
  2257.         gdouble     y)
  2258. {
  2259.   PathList      *plp;
  2260.   Path          *p;
  2261.   Path          *p_copy;
  2262.   GSList        *points_list;
  2263.   BezierSelect  *bezier_sel;
  2264.   GSList        *plist;
  2265.   gint           loop;
  2266.   gint           tmprow;
  2267.  
  2268.   /* As a first off lets just translate the current path */
  2269.  
  2270.   /* Get bzpath structure  */
  2271.   plp = (PathList *) gimp_image_get_paths (gimage);
  2272.  
  2273.   if (!plp)
  2274.     return;
  2275.  
  2276.   loop = 0;
  2277.   for (plist = plp->bz_paths; plist; plist = g_slist_next (plist))
  2278.     {
  2279.       p = (Path *) plist->data;
  2280.  
  2281.       if (p->locked)
  2282.     {
  2283.       p_copy = p;
  2284.       
  2285.       for (points_list = p_copy->path_details; points_list;
  2286.            points_list = g_slist_next (points_list))
  2287.         {
  2288.           PathPoint *ppoint = points_list->data;
  2289.  
  2290.           if (flip)
  2291.         {
  2292.           if (x > 0.0)
  2293.             {
  2294.               ppoint->y = gimage->height - ppoint->y;
  2295.             }
  2296.           else
  2297.             {
  2298.               ppoint->x = gimage->width - ppoint->x;
  2299.             }
  2300.         }
  2301.           else
  2302.         {
  2303.           ppoint->y += y;
  2304.           ppoint->x += x;
  2305.         }
  2306.         }
  2307.       
  2308.       /* Only update if we have a dialog, we have a currently 
  2309.        * selected path and its the showing the same image.
  2310.        */
  2311.  
  2312.       if(paths_dialog && 
  2313.          paths_dialog->current_path_list &&
  2314.          paths_dialog->gimage == gimage)
  2315.         {
  2316.           /* Now fudge the drawing....*/
  2317.           bezier_sel = path_to_beziersel(p_copy);
  2318.           tmprow = paths_dialog->current_path_list->last_selected_row;
  2319.           paths_dialog->current_path_list->last_selected_row = loop;
  2320.           paths_update_preview(bezier_sel);
  2321.           bezier_select_free(bezier_sel);
  2322.           paths_dialog->current_path_list->last_selected_row = tmprow;
  2323.           paths_dialog->selected_row_num = tmprow;
  2324.         }
  2325.     }
  2326.       loop++;
  2327.     }
  2328. }
  2329.  
  2330. void
  2331. path_transform_flip_horz (GimpImage  *gimage)
  2332. {
  2333.   transform_func (gimage, TRUE, 0.0, 0);
  2334. }
  2335.  
  2336. void
  2337. path_transform_flip_vert (GimpImage  *gimage)
  2338. {
  2339.   transform_func (gimage, TRUE, 1.0, 0);
  2340. }
  2341.  
  2342. void 
  2343. path_transform_xy (GimpImage *gimage,
  2344.             gint       x,
  2345.             gint       y)
  2346. {
  2347.   transform_func (gimage, FALSE, (gdouble) x, (gdouble) y);
  2348. }
  2349.  
  2350. void
  2351. path_transform_current_path (GimpImage   *gimage,
  2352.                  GimpMatrix3  transform,
  2353.                  gboolean     forpreview)
  2354. {
  2355.   PathList      *plp;
  2356.   Path          *p;
  2357.   Path          *p_copy;
  2358.   GSList        *points_list;
  2359.   BezierSelect  *bezier_sel;
  2360.   GSList        *plist;
  2361.   gint           loop;
  2362.   gint           tmprow;
  2363.  
  2364.   /* As a first off lets just translate the current path */
  2365.  
  2366.   /* Get bzpath structure  */
  2367.   plp = (PathList *) gimp_image_get_paths (gimage);
  2368.  
  2369.   if (!plp)
  2370.     return;
  2371.  
  2372.   loop = 0;
  2373.   for (plist = plp->bz_paths; plist; plist = g_slist_next (plist))
  2374.     {
  2375.       p = (Path *) plist->data;
  2376.  
  2377.       if (p->locked)
  2378.     {
  2379.       if (forpreview)
  2380.         p_copy = path_copy (NULL, p); /* NULL means dont want new tattoo */
  2381.       else
  2382.         p_copy = p;
  2383.  
  2384.       for (points_list = p_copy->path_details; points_list;
  2385.            points_list = g_slist_next (points_list))
  2386.         {
  2387.           gdouble newx,newy;
  2388.           PathPoint *ppoint = points_list->data;
  2389.  
  2390.           /*       printf("[x,y] = [%g,%g]\n",ppoint->x, ppoint->y); */
  2391.  
  2392.           gimp_matrix3_transform_point (transform,
  2393.                         ppoint->x,
  2394.                         ppoint->y,
  2395.                         &newx,&newy);
  2396.  
  2397.           /*       printf("->[x,y] = [%g,%g]\n", newx, newy); */
  2398.  
  2399.           ppoint->x = newx;
  2400.           ppoint->y = newy;
  2401.         }
  2402.       
  2403.       /* Only update if we have a dialog, we have a currently 
  2404.        * selected path and its the showing the same image.
  2405.        */
  2406.  
  2407.       if (paths_dialog && 
  2408.           paths_dialog->current_path_list &&
  2409.           paths_dialog->gimage == gimage)
  2410.         {
  2411.           /* Now fudge the drawing....*/
  2412.           bezier_sel = path_to_beziersel (p_copy);
  2413.           tmprow = paths_dialog->current_path_list->last_selected_row;
  2414.           paths_dialog->current_path_list->last_selected_row = loop;
  2415.           paths_update_preview (bezier_sel);
  2416.           bezier_select_free (bezier_sel);
  2417.           paths_dialog->current_path_list->last_selected_row = tmprow;
  2418.           paths_dialog->selected_row_num = tmprow;
  2419.         }
  2420.  
  2421.       if (forpreview)
  2422.         path_free (p_copy);
  2423.     }
  2424.       loop++;
  2425.     }
  2426. }
  2427.  
  2428. void
  2429. path_transform_draw_current (GDisplay    *gdisp, 
  2430.                  DrawCore    *core,
  2431.                  GimpMatrix3  transform)
  2432. {
  2433.   PathList     *plp;
  2434.   Path         *bzp;
  2435.   BezierSelect *bezier_sel;
  2436.   Path         *p_copy;
  2437.   GSList       *points_list;
  2438.   GSList       *plist;
  2439.  
  2440.   /* Get bzpath structure  */
  2441.   plp = (PathList *) gimp_image_get_paths (gdisp->gimage);
  2442.  
  2443.   if (!plp)
  2444.     return;
  2445.  
  2446.   for (plist = plp->bz_paths; plist; plist = g_slist_next (plist))
  2447.     {
  2448.       bzp = (Path *) plist->data;
  2449.       /* This image path is locked */
  2450.       if (bzp->locked)
  2451.     {
  2452.       p_copy = path_copy (NULL, bzp); /* NULL means dont want new tattoo */
  2453.       
  2454.       for (points_list = p_copy->path_details; points_list;
  2455.            points_list = g_slist_next (points_list))
  2456.         {
  2457.           gdouble newx,newy;
  2458.           PathPoint *ppoint = points_list->data;
  2459.  
  2460.           /*       printf("[x,y] = [%g,%g]\n",ppoint->x, ppoint->y); */
  2461.  
  2462.           gimp_matrix3_transform_point (transform,
  2463.                         ppoint->x,
  2464.                         ppoint->y,
  2465.                         &newx,&newy);
  2466.  
  2467.           /*       printf("->[x,y] = [%g,%g]\n", newx, newy); */
  2468.  
  2469.           ppoint->x = newx;
  2470.           ppoint->y = newy;
  2471.         }
  2472.  
  2473.       bezier_sel = path_to_beziersel (p_copy);
  2474.       bezier_sel->core = core; /* A bit hacky */
  2475.       bezier_draw (gdisp, bezier_sel);
  2476.       bezier_select_free (bezier_sel);
  2477.       path_free (p_copy);
  2478.     }
  2479.     }
  2480. }
  2481.  
  2482.  
  2483. /*************************************/
  2484. /* PDB function aids                 */
  2485. /*************************************/
  2486.  
  2487. /* Return TRUE if setting the path worked, else false */
  2488.  
  2489. gboolean
  2490. path_set_path (GimpImage *gimage,
  2491.            gchar     *pname)
  2492. {
  2493.   gint      row = 0;
  2494.   gboolean  found = FALSE;
  2495.   GSList   *tlist;
  2496.   PathList *plp;
  2497.  
  2498.   /* Get bzpath structure  */
  2499.   plp = (PathList *) gimp_image_get_paths (gimage);
  2500.  
  2501.   if(!plp)
  2502.     return FALSE;
  2503.  
  2504.   for (tlist = plp->bz_paths; tlist; tlist = g_slist_next (tlist))
  2505.     {
  2506.       gchar *test_str = ((Path*)(tlist->data))->name;
  2507.       if (strcmp (pname, test_str) == 0)
  2508.     {
  2509.       found = TRUE;
  2510.       break;
  2511.     }
  2512.       row++;
  2513.     }
  2514.  
  2515.   if(!found)
  2516.     return FALSE;
  2517.  
  2518.   if(paths_dialog)
  2519.     {
  2520.       gtk_clist_select_row(GTK_CLIST(paths_dialog->paths_list),
  2521.                row,
  2522.                1);
  2523.     }
  2524.   else
  2525.     {
  2526.       plp->last_selected_row = row;
  2527.     }
  2528.  
  2529.   return TRUE;
  2530. }
  2531.  
  2532. /* Set a path with the given set of points. */
  2533. /* We assume that there are enough points */
  2534. /* Return TRUE if path created OK. */
  2535.  
  2536. gboolean
  2537. path_set_path_points (GimpImage *gimage,
  2538.               gchar     *pname,
  2539.               gint       ptype,
  2540.               gint       pclosed,
  2541.               gint       num_pnts,
  2542.               gdouble   *pnts)
  2543. {
  2544.   PathList     *plist    = gimp_image_get_paths(gimage);
  2545.   GSList       *pts_list = NULL;
  2546.   Path         *bzpath;
  2547.   BezierSelect *bezier_sel;
  2548.   gint          pcount   = 0;
  2549.   gint          this_path_count = 0;
  2550.  
  2551.   if (num_pnts < 6 ||
  2552.       (pclosed && ((num_pnts/3) % 3)) ||
  2553.       (!pclosed && ((num_pnts/3) % 3) != 2))
  2554.     {
  2555.       g_warning ("wrong number of points\n");
  2556.       return FALSE;
  2557.     }
  2558.  
  2559.   if (ptype != BEZIER)
  2560.     ptype = BEZIER;
  2561.  
  2562.   while (num_pnts)
  2563.     {
  2564.       PathPoint *bpt;
  2565.       gint type;
  2566.       gdouble x; 
  2567.       gdouble y;
  2568.       
  2569. /*       if((pcount/2)%3) */
  2570. /*     type = BEZIER_CONTROL; */
  2571. /*       else */
  2572. /*     type = BEZIER_ANCHOR; */
  2573.  
  2574.       x = pnts[pcount++];
  2575.       y = pnts[pcount++];
  2576.       type = (gint)pnts[pcount++];
  2577.       this_path_count++;
  2578.  
  2579.       switch (type)
  2580.     {
  2581.     case BEZIER_ANCHOR:
  2582.     case BEZIER_CONTROL:
  2583.       break;
  2584.     case BEZIER_MOVE:
  2585.       if (this_path_count < 6)
  2586.         {
  2587.           g_warning ("Invalid single point in path\n");
  2588.           return FALSE;
  2589.         }
  2590.       this_path_count = 0;
  2591.       break;
  2592.     default:
  2593.       g_warning ("Invalid point type passed\n");
  2594.       return FALSE;
  2595.     }
  2596.  
  2597.       
  2598. /*       printf("New point type = %s, x = %d y= %d\n", */
  2599. /*          (type==BEZIER_CONTROL)?"CNTL":"ANCH", */
  2600. /*          (int)x, */
  2601. /*          (int)y); */
  2602.       
  2603.       bpt = path_point_new (type, (gdouble)x, (gdouble)y);
  2604.       pts_list = g_slist_append(pts_list,bpt);
  2605.  
  2606.       num_pnts -= 3;
  2607.     }
  2608.   
  2609.   bzpath = path_new (gimage,
  2610.              ptype,
  2611.              pts_list,
  2612.              pclosed,
  2613.              (pclosed) ? BEZIER_EDIT : BEZIER_ADD, /* state */
  2614.              0, /* Can't be locked */
  2615.              0, /* No tattoo assigned */
  2616.              pname);
  2617.  
  2618.   bezier_sel = path_to_beziersel(bzpath);
  2619.  
  2620.   /* Only add if paths dialog showing this window */
  2621.   if (paths_dialog && paths_dialog->gimage == gimage)
  2622.     { 
  2623.       paths_dialog->current_path_list =  
  2624.     path_add_to_current (paths_dialog->current_path_list, 
  2625.                  bzpath, 
  2626.                  paths_dialog->gimage, 
  2627.                  0); 
  2628.  
  2629.       paths_add_path (bzpath, 0); 
  2630.  
  2631.       /* Update the preview */
  2632.       paths_dialog->current_path_list->last_selected_row = 0;
  2633.       paths_update_preview (bezier_sel);
  2634.  
  2635.       gtk_clist_select_row (GTK_CLIST (paths_dialog->paths_list),
  2636.                 paths_dialog->current_path_list->last_selected_row,
  2637.                 1);
  2638.  
  2639.       paths_dialog_set_menu_sensitivity ();
  2640.     }
  2641.   else
  2642.     {
  2643.       GDisplay *gdisp;
  2644.  
  2645.       if (!plist)
  2646.     {
  2647.       /* If we haven't got a paths dialog */
  2648.       GSList *bzp_list = NULL;
  2649.  
  2650.       bzp_list = g_slist_append (bzp_list, bzpath);
  2651.       plist = path_list_new (gimage, 0, bzp_list);
  2652.       gimp_image_set_paths (gimage, plist);
  2653.     }
  2654.       else
  2655.     {
  2656.       path_add_to_current (plist, bzpath, gimage, 0);
  2657.     }
  2658.  
  2659.       /* This is a little HACK.. we need to find a display
  2660.        * to put the path image on.
  2661.        */
  2662.  
  2663.       gdisp = gdisplays_check_valid (NULL, gimage);
  2664.  
  2665.       /* Mark this path as selected */
  2666.       plist->last_selected_row = 0;
  2667.  
  2668.       /* Only paste if we have an image to paste to! */
  2669.       if (gdisp)
  2670.     bezier_paste_bezierselect_to_current (gdisp, bezier_sel);
  2671.     }
  2672.  
  2673.   bezier_select_free (bezier_sel);
  2674.  
  2675.   return TRUE;
  2676. }
  2677.  
  2678. gboolean
  2679. path_delete_path (GimpImage *gimage,
  2680.           gchar     *pname)
  2681. {
  2682.   gint      row = 0;
  2683.   gboolean  found = FALSE;
  2684.   GSList   *tlist;
  2685.   PathList *plp;
  2686.  
  2687.   if (!pname || !gimage)
  2688.     {
  2689.       g_warning ("paths_delete_path: invalid path");
  2690.       return FALSE;
  2691.     }
  2692.  
  2693.   /* Removed the named path ... */
  2694.   /* Get bzpath structure  */
  2695.   plp = (PathList *) gimp_image_get_paths (gimage);
  2696.  
  2697.   if(!plp)
  2698.     return FALSE;
  2699.  
  2700.   for (tlist = plp->bz_paths; tlist; tlist = g_slist_next (tlist))
  2701.     {
  2702.       gchar *test_str = ((Path *) (tlist->data))->name;
  2703.       if (strcmp (pname, test_str) == 0)
  2704.     {
  2705.       found = TRUE;
  2706.       break;
  2707.     }
  2708.       row++;
  2709.     }
  2710.  
  2711.   if (!found)
  2712.     return FALSE;
  2713.  
  2714.   plp->bz_paths = g_slist_remove (plp->bz_paths, tlist->data);
  2715.   /* If now empty free everything up */
  2716.   if (!plp->bz_paths || g_slist_length (plp->bz_paths) == 0)
  2717.     {
  2718.       gtk_signal_disconnect (GTK_OBJECT (plp->gimage), plp->sig_id);
  2719.       gimp_image_set_paths (plp->gimage, NULL);
  2720.       path_list_free (plp);
  2721.     }
  2722.  
  2723.   /* Redisplay if required */
  2724.   if (paths_dialog && paths_dialog->gimage == gimage)
  2725.     {
  2726.       paths_dialog->current_path_list = NULL;
  2727.       paths_dialog_flush ();
  2728.     }
  2729.  
  2730.   return TRUE;
  2731. }
  2732.