home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / plug-ins / gfig / gfig.c next >
Encoding:
C/C++ Source or Header  |  2000-09-29  |  271.1 KB  |  11,276 lines
  1. /*
  2.  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  3.  *
  4.  * This is a plug-in for the GIMP.
  5.  *
  6.  * Generates images containing vector type drawings.
  7.  *
  8.  * Copyright (C) 1997 Andy Thomas  alt@picnic.demon.co.uk
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23.  * 
  24.  * Some of this code was taken from the Whirl plug-in
  25.  * which was copyrighted by Federico Mena Quintero (as below).
  26.  * 
  27.  * Whirl plug-in --- distort an image into a whirlpool
  28.  * Copyright (C) 1997 Federico Mena Quintero           
  29.  *
  30.  */
  31.  
  32. /* Change log:
  33.  * 0.9 First public release. 
  34.  * 0.95 Second release.
  35.  * 
  36.  * 0.96 Added patch from  Rob Saunders that introduces a isometric type grid
  37.  *      Removed use of gtk_idle* stuff on position update. Not required.
  38.  *
  39.  * 1.0  Fixed to work with the new gtk+-0.99.4 (tooltips stuff has changed).  
  40.  * 
  41.  * 1.1  Fixed crashes when objects not fully defined
  42.  * 
  43.  * 1.2  More bug fixes and prevent gtk warning when creating new figs
  44.  * 
  45.  * 1.3  Portability fixes and fixed bug reports 257 and 258 from and 81 & 101 & 133
  46.  *      http://www.wilberworks.com/bugs.cgi
  47.  */
  48.  
  49. #include "config.h"
  50.  
  51. #include <glib.h>
  52.  
  53. #include <stdio.h>
  54. #include <stdlib.h>
  55. #include <sys/types.h>
  56. #include <sys/stat.h>
  57. #ifdef HAVE_UNISTD_H
  58. #include <unistd.h>
  59. #endif
  60. #include <string.h>
  61. #ifdef HAVE_DIRENT_H
  62. #include <dirent.h>
  63. #endif
  64. #include <ctype.h>
  65. #include <gtk/gtk.h>
  66.  
  67. #ifdef G_OS_WIN32
  68. #  include <io.h>
  69. #  ifndef W_OK
  70. #    define W_OK 2
  71. #  endif
  72. #  ifndef S_ISDIR
  73. #    define S_ISDIR(m) ((m) & _S_IFDIR)
  74. #  endif
  75. #  ifndef S_ISREG
  76. #    define S_ISREG(m) ((m) & _S_IFREG)
  77. #  endif
  78. #endif
  79.  
  80. #if defined (GTK_CHECK_VERSION) && GTK_CHECK_VERSION (1,3,0)
  81. #define gdk_root_parent (*gdk_parent_root)
  82. #endif
  83.  
  84. #ifdef G_OS_WIN32
  85. extern __declspec(dllimport) void *gdk_root_parent;
  86. #else
  87. extern void * gdk_root_parent;
  88. #endif
  89.  
  90. #include <libgimp/gimp.h>
  91. #include <libgimp/gimpui.h>
  92.  
  93. #include "libgimp/stdplugins-intl.h"
  94.  
  95. #include "pix_data.h"
  96.  
  97. /***** Magic numbers *****/
  98.  
  99. #define PREVIEW_SIZE 400
  100. #define SCALE_WIDTH  120
  101.  
  102. #define MIN_GRID 10
  103. #define MAX_GRID 50
  104. #define MAX_UNDO 10
  105. #define MIN_UNDO 1
  106. #define MAX_LOAD_LINE 256
  107. #define SMALL_PREVIEW_SZ 48
  108. #define BRUSH_PREVIEW_SZ 32
  109. #define GFIG_HEADER "GFIG Version 0.1\n"
  110.  
  111. #define PREVIEW_MASK   GDK_EXPOSURE_MASK | \
  112.                        GDK_MOTION_NOTIFY | \
  113.                GDK_POINTER_MOTION_MASK | \
  114.                        GDK_BUTTON_PRESS_MASK | \
  115.                GDK_BUTTON_RELEASE_MASK | \
  116.                GDK_BUTTON_MOTION_MASK | \
  117.                GDK_KEY_PRESS_MASK | \
  118.                GDK_KEY_RELEASE_MASK 
  119.  
  120. static GimpDrawable *gfig_select_drawable;
  121. static GtkWidget *gfig_preview;
  122. static GtkWidget *pic_preview;
  123. static GtkWidget *gfig_gtk_list;
  124. static gint       gfig_preview_exp_id;
  125. static gint32     gfig_image;
  126. static gint32     gfig_drawable;
  127. static GtkWidget *brush_page_pw;
  128. static GtkWidget *brush_sel_button;
  129.  
  130. static gint   tile_width, tile_height;
  131. static gint   img_width, img_height, img_bpp, real_img_bpp;
  132.  
  133. static void      query  (void);
  134. static void      run    (gchar    *name,
  135.              gint      nparams,
  136.              GimpParam   *param,
  137.              gint     *nreturn_vals,
  138.              GimpParam  **return_vals);
  139.  
  140. static gint      gfig_dialog               (void);
  141. static void      gfig_ok_callback          (GtkWidget *widget,
  142.                         gpointer   data);
  143. static void      gfig_paint_callback       (GtkWidget *widget,
  144.                         gpointer   data);
  145. static void      gfig_clear_callback       (GtkWidget *widget,
  146.                         gpointer   data);
  147. static void      gfig_undo_callback        (GtkWidget *widget,
  148.                         gpointer   data);
  149. static gint      gfig_preview_expose       (GtkWidget *widget,
  150.                         GdkEvent  *event);
  151. static gint      pic_preview_expose        (GtkWidget *widget,
  152.                         GdkEvent  *event);
  153. static gint      gfig_preview_events       (GtkWidget *widget,
  154.                         GdkEvent  *event);
  155. static gint      gfig_brush_preview_events (GtkWidget *widget,
  156.                         GdkEvent  *event);
  157.  
  158. static void      gfig_scale_update_scale   (GtkAdjustment *adjustment,
  159.                         gdouble       *value);
  160.  
  161. static void      gfig_scale2img_update     (GtkWidget *widget,
  162.                         gpointer   data);
  163.  
  164. static gint      gfig_scale_x              (gint       x);
  165. static gint      gfig_scale_y              (gint       y);
  166. static gint      gfig_invscale_x           (gint       x);
  167. static gint      gfig_invscale_y           (gint       y);
  168. static GdkGC *   gfig_get_grid_gc          (GtkWidget *widget,
  169.                         gint       gctype);
  170. static void      gfig_pos_enable           (GtkWidget *widget,
  171.                         gpointer   data);
  172.  
  173. static gint      list_button_press         (GtkWidget      *widget,
  174.                         GdkEventButton *event,
  175.                         gpointer        data);
  176.  
  177. static void      rescan_button_callback    (GtkWidget *widget,
  178.                         gpointer   data);
  179. static void      load_button_callback      (GtkWidget *widget,
  180.                         gpointer   data);
  181. static void      save_button_callback      (GtkWidget *widget,
  182.                         gpointer   data);
  183. static void      new_button_callback       (GtkWidget *widget,
  184.                         gpointer   data);
  185. static void   gfig_do_delete_gfig_callback (GtkWidget *widget,
  186.                         gboolean   delete,
  187.                         gpointer   data);
  188. static void      gfig_delete_gfig_callback (GtkWidget *widget,
  189.                         gpointer   data);
  190. static void      edit_button_callback      (GtkWidget *widget,
  191.                         gpointer   data);
  192. static void      merge_button_callback     (GtkWidget *widget,
  193.                         gpointer   data);
  194. static void      about_button_callback     (GtkWidget *widget,
  195.                         gpointer   data);
  196. static void      reload_button_callback    (GtkWidget *widget,
  197.                         gpointer   data);
  198.  
  199. static void      do_gfig                   (void);
  200. static void      dialog_update_preview     (void);
  201.  
  202. static void      draw_grid_clear           (GtkWidget *widget,
  203.                         gpointer   data);
  204. static void      toggle_show_image         (GtkWidget *widget,
  205.                         gpointer   data);
  206. static void      toggle_tooltips           (GtkWidget *widget,
  207.                         gpointer   data);
  208. static void      toggle_obj_type           (GtkWidget *widget,
  209.                         gpointer   data);
  210. static void      draw_grid                 (GtkWidget *widget,
  211.                         gpointer   data);
  212.  
  213. static void      gfig_new_gc               (void);
  214. static void      find_grid_pos             (GdkPoint  *p,
  215.                         GdkPoint  *gp,
  216.                         guint      state);
  217.  
  218. static void      brush_list_button_callback (GtkWidget *widget,
  219.                          gpointer   data);
  220. static gint      calculate_point_to_line_distance (GdkPoint *p,
  221.                            GdkPoint *A,
  222.                            GdkPoint *B,
  223.                            GdkPoint *I);
  224.  
  225. GimpPlugInInfo PLUG_IN_INFO =
  226. {
  227.   NULL,  /* init_proc  */
  228.   NULL,  /* quit_proc  */
  229.   query, /* query_proc */
  230.   run,   /* run_proc   */
  231. };
  232.  
  233. /* The types of an object */
  234. /* Also includes actions that can be performed on objects */
  235.  
  236. typedef enum
  237. {
  238.   LINE,
  239.   CIRCLE,
  240.   ELLIPSE,
  241.   ARC,
  242.   POLY,
  243.   STAR,
  244.   SPIRAL,
  245.   BEZIER,
  246.   MOVE_OBJ,
  247.   MOVE_POINT,
  248.   COPY_OBJ,
  249.   MOVE_COPY_OBJ,
  250.   DEL_OBJ,
  251.   NULL_OPER
  252. } DobjType;
  253.  
  254. typedef enum
  255. {
  256.   RECT_GRID = 0,
  257.   POLAR_GRID,
  258.   ISO_GRID
  259. } GridType;
  260.  
  261. typedef enum
  262. {
  263.   ORIGINAL_LAYER = 0,
  264.   SINGLE_LAYER,
  265.   MULTI_LAYER
  266. } DrawonLayers;
  267.  
  268. typedef enum
  269. {
  270.   LAYER_TRANS_BG = 0,
  271.   LAYER_BG_BG,
  272.   LAYER_FG_BG,
  273.   LAYER_WHITE_BG,
  274.   LAYER_COPY_BG
  275. } LayersBGType;
  276.  
  277. typedef enum
  278. {
  279.   PAINT_BRUSH_TYPE = 0,
  280.   PAINT_SELECTION_TYPE,
  281.   PAINT_SELECTION_FILL_TYPE
  282. } PaintType;
  283.  
  284. typedef enum
  285. {
  286.   BRUSH_BRUSH_TYPE = 0,
  287.   BRUSH_PENCIL_TYPE,
  288.   BRUSH_AIRBRUSH_TYPE,
  289.   BRUSH_PATTERN_TYPE
  290. } BrushType;
  291.  
  292.  
  293. #define GRID_TYPE_MENU 1
  294. #define GRID_RENDER_MENU 2
  295. #define GRID_IGNORE 0 
  296. #define GRID_HIGHTLIGHT 1
  297. #define GRID_RESTORE 2
  298.  
  299. #define GFIG_BLACK_GC -2
  300. #define GFIG_WHITE_GC -3
  301. #define GFIG_GREY_GC -4
  302.  
  303. #define PAINT_LAYERS_MENU 1
  304. #define PAINT_BGS_MENU 2
  305. #define PAINT_TYPE_MENU 3
  306.  
  307. #define SELECT_TYPE_MENU 1
  308. #define SELECT_ARCTYPE_MENU 2
  309. #define SELECT_TYPE_MENU_FILL 3
  310. #define SELECT_TYPE_MENU_WHEN 4
  311.  
  312. #define OBJ_SELECT_GT 1
  313. #define OBJ_SELECT_LT 2
  314. #define OBJ_SELECT_EQ 4
  315.  
  316.  
  317. typedef struct
  318. {
  319.   gint     gridspacing;
  320.   GridType gridtype;
  321.   gint     drawgrid;
  322.   gint     snap2grid;
  323.   gint     lockongrid;
  324.   gint     showcontrol;
  325. } GfigOpts;
  326.  
  327. /* Must keep in step with the above */
  328. typedef struct
  329. {
  330.   void      *gridspacing;
  331.   GtkWidget *gridtypemenu;
  332.   GtkWidget *drawgrid;
  333.   GtkWidget *snap2grid;
  334.   GtkWidget *lockongrid;
  335.   GtkWidget *showcontrol;
  336. } GfigOptWidgets;
  337.  
  338. static GfigOptWidgets gfig_opt_widget;
  339.  
  340. typedef struct
  341. {
  342.   GfigOpts      opts;
  343.   gint          showimage;
  344.   gint          maxundo;
  345.   gint          showpos;
  346.   gdouble       brushfade;
  347.   gdouble       brushgradient;
  348.   gdouble       airbrushpressure;
  349.   gint          showtooltips;
  350.   DrawonLayers  onlayers;
  351.   LayersBGType  onlayerbg;
  352.   PaintType     painttype;
  353.   gint          reverselines;
  354.   gint          scaletoimage;
  355.   gdouble       scaletoimagefp;
  356.   gint          approxcircles;
  357.   BrushType    brshtype;
  358.   DobjType      otype;
  359. } SelectItVals;
  360.  
  361. /* Values when first invoked */
  362. static SelectItVals selvals =
  363. {
  364.   {
  365.     MIN_GRID + (MAX_GRID - MIN_GRID)/2, /* Gridspacing */
  366.     RECT_GRID, /* Default to rectangle type */
  367.     0,  /* drawgrid */
  368.     0,  /* snap2grid */
  369.     0,  /* lockongrid */
  370.     1,  /* show control points */
  371.   },
  372.   0,  /* show image */
  373.   MIN_UNDO + (MAX_UNDO - MIN_UNDO)/2,  /* Max level of undos */
  374.   FALSE, /* Show pos updates */
  375.   0.0, /* Brush fade */
  376.   0.0, /* Brush gradient */
  377.   20.0, /* Air bursh pressure */
  378.   TRUE,  /* show Tool tips */
  379.   ORIGINAL_LAYER, /* Draw all objects on one layer */
  380.   LAYER_TRANS_BG, /* New layers background */
  381.   PAINT_BRUSH_TYPE, /* Default to use brushes */
  382.   FALSE, /* reverse lines */
  383.   TRUE, /* Scale to image when painting */
  384.   1.0, /* Scale to image fp */
  385.   FALSE, /* Approx circles by drawing lines */
  386.   BRUSH_BRUSH_TYPE, /* Default to use a brush */
  387.   LINE /* Initial object type */
  388. };
  389.  
  390. typedef enum
  391. {
  392.   ADD=0,
  393.   SUBTRACT=1,
  394.   REPLACE=2,
  395.   INTERSECT=3
  396. } SelectionType;
  397.     
  398.  
  399. typedef enum
  400. {
  401.   ARC_SEGMENT,
  402.   ARC_SECTOR
  403. } ArcType;
  404.  
  405. typedef enum
  406. {
  407.   FILL_FOREGROUND = 0,
  408.   FILL_BACKGROUND = 1,
  409.   FILL_PATTERN = 2
  410. } FillType;
  411.  
  412. typedef enum
  413. {
  414.   FILL_EACH = 0,
  415.   FILL_AFTER
  416. } FillWhen;
  417.  
  418. struct selection_option
  419. {
  420.   SelectionType type; /* ADD etc .. */
  421.   gint antia; /* Boolean for Antia */
  422.   gint feather; /* Feather it ? */
  423.   gdouble feather_radius; /* Radius to feather */
  424.   ArcType as_pie; /* Arc type selection segment/sector */
  425.   FillType fill_type; /* Fill type for selection */
  426.   FillWhen fill_when; /* Fill on each selection or after all? */
  427.   gdouble fill_opacity; /* You can guess this one */
  428. } selopt =
  429. {
  430.   ADD, /* type */
  431.   FALSE, /* Antia */
  432.   FALSE, /* Feather */
  433.   10.0, /* feather radius */
  434.   ARC_SEGMENT,  /* Arc as a segment */
  435.   FILL_PATTERN, /* Fill as pattern */
  436.   FILL_EACH, /* Fill after each selection */
  437.   100.0, /* Max opacity */
  438. };
  439.  
  440.  
  441. static GList *gfig_path_list = NULL;
  442. static GList *gfig_list      = NULL;
  443. static gint   line_no;
  444.  
  445. static gint poly_num_sides    = 3; /* Default to three sided object */
  446. static gint star_num_sides    = 3; /* Default to three sided object */
  447. static gint spiral_num_turns  = 4; /* Default to 4 turns */
  448. static gint spiral_toggle     = 0; /* 0 = clockwise -1 = anti-clockwise */
  449. static gint bezier_closed     = 0; /* Closed curve 0 = false 1 = true */
  450. static gint bezier_line_frame = 0; /* Show frame = false 1 = true */
  451.  
  452. static gint obj_show_single = -1; /* -1 all >= 0 object number */
  453.  
  454. /* Structures etc for the objects */
  455. /* Points used to draw the object  */
  456.  
  457. typedef struct DobjPoints
  458. {
  459.   struct DobjPoints * next;
  460.   GdkPoint pnt;
  461.   gint found_me;
  462. } DobjPoints;
  463.  
  464.  
  465. struct Dobject; /* fwd declaration for DobjFunc */
  466.  
  467. typedef void            (*DobjFunc) (struct Dobject *);
  468. typedef struct Dobject *(*DobjGenFunc) (struct Dobject *);
  469. typedef struct Dobject *(*DobjLoadFunc) (FILE *);
  470. typedef void            (*DobjSaveFunc) (struct Dobject *, FILE *);
  471.  
  472. /* The object itself */
  473. typedef struct Dobject
  474. {
  475.   DobjType      type; /* What is the type? */
  476.   gpointer      type_data; /* Extra data needed by the object */
  477.   DobjPoints   *points; /* List of points */
  478.   DobjFunc      drawfunc; /* How do I draw myself */
  479.   DobjFunc      paintfunc; /* Draw me on canvas */
  480.   DobjGenFunc   copyfunc;  /* copy */
  481.   DobjLoadFunc  loadfunc;  /* Load this type of object */
  482.   DobjSaveFunc  savefunc;  /* Save me out */
  483. } Dobject;
  484.  
  485.  
  486. static Dobject *obj_creating; /* Object we are creating */
  487. static Dobject *tmp_line; /* Needed when drawing lines */
  488. static Dobject *tmp_bezier; /* Neeed when drawing bezier curves */
  489.  
  490. typedef struct DAllObjs
  491. {
  492.   struct DAllObjs *next; 
  493.   Dobject         *obj; /* Object on list */
  494. } DAllObjs;
  495.  
  496. /* States of the object */
  497. #define GFIG_OK       0x0
  498. #define GFIG_MODIFIED 0x1
  499. #define GFIG_READONLY 0x2
  500.  
  501. typedef struct DFigObj
  502. {
  503.   gchar     *name;     /* Trailing name of file  */
  504.   gchar     *filename; /* Filename itself */
  505.   gchar     *draw_name;/* Name of the drawing */
  506.   gfloat     version;     /* Version number of data file */
  507.   GfigOpts   opts;    /* Options enforced when fig saved */
  508.   DAllObjs  *obj_list; /* Objects that make up this list */
  509.   gint       obj_status;    /* See above for possible values */
  510.   GtkWidget *list_item;
  511.   GtkWidget *label_widget;
  512.   GtkWidget *pixmap_widget;
  513. } GFigObj;  
  514.  
  515.  
  516. typedef struct BrushDesc
  517. {
  518.   gchar  *bname; /* name of the brush */
  519.   gint32  width;  /* Width of brush */
  520.   gint32  height;  /* Height of brush */
  521.   guchar *pv_buf; /* Buffer where brush placed */
  522.   gint16  x_off;
  523.   gint16  y_off;
  524.   gint    bpp; /* Depth - should ALWAYS be the same for all BrushDesc */
  525. } BrushDesc;
  526.  
  527. static GFigObj  *current_obj;
  528. static Dobject  *operation_obj;
  529. static GdkPoint *move_all_pnt; /* Point moving all from */
  530. static GFigObj  *pic_obj;
  531. static DAllObjs *undo_table[MAX_UNDO];
  532. static gint      need_to_scale;
  533. static gint32    brush_image_ID = -1;
  534.  
  535. static GtkWidget *undo_widget;
  536. static GtkWidget *gfig_op_menu; /* Popup menu in the list box */
  537. static GtkWidget *delete_frame_to_freeze; /* Top preview frame window */
  538. static GtkWidget *fade_out_hbox;   /* Fade out widget in brush page */
  539. static GtkWidget *gradient_hbox;   /* Gradient widget in brush page */
  540. static GtkWidget *pressure_hbox;   /* Pressure widget in brush page */
  541. static GtkWidget *pencil_hbox;     /* Dummy widget in brush page */
  542. static GtkWidget *pos_label;       /* XY pos marker */
  543. static GtkWidget *brush_page_widget; /* Widget for the brush part of notebook */
  544. static GtkWidget *select_page_widget; /* Widget for the selection part
  545.                        * of notebook */
  546.  
  547. static gint undo_water_mark = -1; /* Last slot filled in -1 = no undo */
  548. static gint drawing_pic = FALSE;  /* If true drawing to the small preview */
  549. static GtkWidget *status_label_dname;
  550. static GtkWidget *status_label_fname;
  551. static GFigObj   *gfig_obj_for_menu; /* More static data -
  552.                       * need to know which object was selected*/
  553. static GtkWidget *save_menu_item;  
  554. static GtkWidget *save_button;
  555.  
  556.  
  557. /* Don't up just like BIGGG source files? */
  558.  
  559. static void       object_start            (GdkPoint *pnt, gint);
  560. static void       object_operation        (GdkPoint *pnt, gint);
  561. static void       object_operation_start  (GdkPoint *pnt, gint shift_down);
  562. static void       object_operation_end    (GdkPoint *pnt, gint);
  563. static void       object_end              (GdkPoint *pnt, gint shift_down);
  564. static void       object_update           (GdkPoint * pnt);
  565. static void       add_to_all_obj          (GFigObj * fobj, Dobject *obj);
  566. static void       d_delete_dobjpoints     (DobjPoints *);
  567. static Dobject  * d_new_line              (gint x, gint y);
  568. static Dobject  * d_new_circle            (gint x, gint y);
  569. static DAllObjs * copy_all_objs           (DAllObjs *objs);
  570. static void       setup_undo              (void);
  571. static void       d_pnt_add_line          (Dobject *obj,
  572.                        gint x, gint y, gint pos);
  573. static GFigObj  * gfig_load               (gchar *filename, gchar *name);
  574. static void       free_all_objs           (DAllObjs * objs);
  575. static void       draw_objects            (DAllObjs *objs, gint show_single);
  576. static Dobject  * d_load_line             (FILE *from);
  577. static Dobject  * d_load_circle           (FILE *from);
  578. static gchar    * get_line                (gchar *buf, gint s,
  579.                        FILE * from, gint init);
  580. static GFigObj  * gfig_new                (void);
  581. static void       clear_undo              (void);
  582. static void       list_button_update      (GFigObj *obj);
  583. static void       prepend_to_all_obj      (GFigObj *fobj, DAllObjs *nobj);
  584. static void       gfig_update_stat_labels (void);
  585. static void       gfig_obj_modified       (GFigObj *obj, gint stat_type);
  586. static void       gfig_op_menu_create     (GtkWidget *window);
  587. static void       gridtype_menu_callback  (GtkWidget *widget, gpointer data);
  588. static void       draw_one_obj            (Dobject * obj);
  589. static void       d_save_poly             (Dobject * obj, FILE *to);
  590. static Dobject  * d_load_poly             (FILE *from);
  591. static void       d_draw_poly             (Dobject *obj);
  592. static void       d_paint_poly            (Dobject *obj);
  593. static Dobject  * d_copy_poly             (Dobject * obj);
  594. static Dobject  * d_new_poly              (gint x, gint y);
  595. static void       d_update_poly           (GdkPoint *pnt);
  596. static void       d_poly_start            (GdkPoint *pnt, gint shift_down);
  597. static void       d_poly_end              (GdkPoint *pnt, gint shift_down);
  598. static void       d_save_star             (Dobject * obj, FILE *to);
  599. static Dobject  * d_load_star             (FILE *from);
  600. static void       d_draw_star             (Dobject *obj);
  601. static void       d_paint_star            (Dobject *obj);
  602. static Dobject  * d_copy_star             (Dobject * obj);
  603. static Dobject  * d_new_star              (gint x, gint y);
  604. static void       d_update_star           (GdkPoint *pnt);
  605. static void       d_star_start            (GdkPoint *pnt, gint shift_down);
  606. static void       d_star_end              (GdkPoint *pnt, gint shift_down);
  607. static Dobject  * d_load_spiral           (FILE *from);
  608. static void       d_draw_spiral           (Dobject *obj);
  609. static void       d_paint_spiral          (Dobject *obj);
  610. static Dobject  * d_copy_spiral           (Dobject * obj);
  611. static Dobject  * d_new_spiral            (gint x, gint y);
  612. static void       d_update_spiral         (GdkPoint *pnt);
  613. static void       d_spiral_start          (GdkPoint *pnt, gint shift_down);
  614. static void       d_spiral_end            (GdkPoint *pnt, gint shift_down);
  615.  
  616. static Dobject  * d_load_bezier           (FILE *from);
  617. static void       d_draw_bezier           (Dobject *obj);
  618. static void       d_paint_bezier          (Dobject *obj);
  619. static Dobject  * d_copy_bezier           (Dobject * obj);
  620. static Dobject  * d_new_bezier            (gint x, gint y);
  621. static void       d_update_bezier         (GdkPoint *pnt);
  622. static void       d_bezier_start          (GdkPoint *pnt, gint shift_down);
  623. static void       d_bezier_end            (GdkPoint *pnt, gint shift_down);
  624.  
  625. static void       new_obj_2edit           (GFigObj *obj);
  626. static Dobject  * d_new_ellipse           (gint x, gint y);
  627. static Dobject  * d_load_ellipse          (FILE *from);
  628. static Dobject  * d_new_arc               (gint x, gint y);
  629. static Dobject  * d_load_arc              (FILE *from);
  630. static gint       load_options            (GFigObj *gfig, FILE *fp);
  631. static gint       gfig_obj_counts         (DAllObjs * objs);
  632.  
  633. static void    gfig_brush_fill_preview_xy (GtkWidget *pw, gint x , gint y);
  634.  
  635.  
  636. /* globals */
  637.  
  638. static gint    gfig_run;
  639. static GdkGC  *gfig_gc;
  640. static GdkGC  *grid_hightlight_drawgc;
  641. static gint    grid_gc_type = GTK_STATE_NORMAL;
  642. static guchar *pv_cache = NULL;
  643. static guchar  preview_row[PREVIEW_SIZE*4];
  644.  
  645. /* Stuff for the preview bit */
  646. static gint    sel_x1, sel_y1, sel_x2, sel_y2;
  647. static gint    sel_width, sel_height;
  648. static gint    preview_width, preview_height;
  649. static gint    has_alpha;
  650. static gdouble scale_x_factor, scale_y_factor;
  651. static gdouble org_scale_x_factor, org_scale_y_factor;
  652.  
  653. MAIN ()
  654.  
  655. static void
  656. query (void)
  657. {
  658.   static GimpParamDef args[] =
  659.   {
  660.     { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
  661.     { GIMP_PDB_IMAGE, "image", "Input image (unused)" },
  662.     { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
  663.     { GIMP_PDB_INT32, "dummy", "dummy" } 
  664.   };
  665.   static gint nargs = sizeof (args) / sizeof (args[0]);
  666.  
  667.   gimp_install_procedure ("plug_in_gfig",
  668.               "Create Geometrical shapes with the Gimp",
  669.               "More here later",
  670.               "Andy Thomas",
  671.               "Andy Thomas",
  672.               "1997",
  673.               N_("<Image>/Filters/Render/Gfig..."),
  674.               "RGB*, GRAY*",
  675.               GIMP_PLUGIN,
  676.               nargs, 0,
  677.               args, NULL);
  678. }
  679.  
  680. static void
  681. run (gchar    *name,
  682.      gint      nparams,
  683.      GimpParam   *param,
  684.      gint     *nreturn_vals,
  685.      GimpParam  **return_vals)
  686. {
  687.   GimpParam * values = g_new (GimpParam, 1);
  688.   GimpDrawable *drawable;
  689.   GimpRunModeType run_mode;
  690.   GimpPDBStatusType status = GIMP_PDB_SUCCESS;
  691.  
  692.   gint pwidth, pheight;
  693.  
  694.   /*kill (getpid (), 19);*/
  695.  
  696.   run_mode = param[0].data.d_int32;
  697.   gfig_image = param[1].data.d_image;
  698.   gfig_drawable = param[2].data.d_drawable;
  699.  
  700.   *nreturn_vals = 1;
  701.   *return_vals = values;
  702.  
  703.   values[0].type = GIMP_PDB_STATUS;
  704.   values[0].data.d_status = status;
  705.  
  706.   gfig_select_drawable = drawable =
  707.     gimp_drawable_get (param[2].data.d_drawable);
  708.  
  709.   tile_width  = gimp_tile_width ();
  710.   tile_height = gimp_tile_height ();
  711.  
  712.   /* TMP Hack - clear any selections */
  713.   gimp_selection_clear (gfig_image);
  714.  
  715.   gimp_drawable_mask_bounds (drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
  716.  
  717.   sel_width  = sel_x2 - sel_x1;
  718.   sel_height = sel_y2 - sel_y1;
  719.  
  720.   /* Calculate preview size */
  721.   
  722.   if (sel_width > sel_height)
  723.     {
  724.       pwidth  = MIN (sel_width, PREVIEW_SIZE);
  725.       pheight = sel_height * pwidth / sel_width;
  726.     }
  727.   else
  728.     {
  729.       pheight = MIN (sel_height, PREVIEW_SIZE);
  730.       pwidth  = sel_width * pheight / sel_height;
  731.   }
  732.   
  733.   preview_width  = MAX (pwidth, 2);  /* Min size is 2 */
  734.   preview_height = MAX (pheight, 2); 
  735.  
  736.   org_scale_x_factor = scale_x_factor =
  737.     (gdouble) sel_width / (gdouble) preview_width;
  738.   org_scale_y_factor = scale_y_factor =
  739.     (gdouble) sel_height / (gdouble) preview_height;
  740.   
  741.   switch (run_mode)
  742.     {
  743.     case GIMP_RUN_INTERACTIVE:
  744.       /*gimp_get_data ("plug_in_gfig", &selvals);*/
  745.       INIT_I18N_UI ();
  746.       if (!gfig_dialog ())
  747.     {
  748.       gimp_drawable_detach (drawable);
  749.       return;
  750.     }
  751.       break;
  752.  
  753.     case GIMP_RUN_NONINTERACTIVE:
  754.       status = GIMP_PDB_CALLING_ERROR;
  755.       break;
  756.  
  757.     case GIMP_RUN_WITH_LAST_VALS:
  758.       /*gimp_get_data ("plug_in_gfig", &selvals);*/
  759.       break;
  760.  
  761.     default:
  762.       break;
  763.     }
  764.  
  765.   if (gimp_drawable_is_rgb (drawable->id) ||
  766.       gimp_drawable_is_gray (drawable->id))
  767.     {
  768.       /* Set the tile cache size */
  769.       gimp_tile_cache_ntiles ((drawable->width + gimp_tile_width () - 1) /
  770.                   gimp_tile_width ());
  771.  
  772.       do_gfig ();
  773.  
  774.       if (run_mode != GIMP_RUN_NONINTERACTIVE)
  775.     gimp_displays_flush ();
  776.  
  777. #if 0
  778.       if (run_mode == GIMP_RUN_INTERACTIVE)
  779.     gimp_set_data ("plug_in_gfig", &selvals, sizeof (SelectItVals));
  780. #endif /* 0 */
  781.     }
  782.   else
  783.     {
  784.       status = GIMP_PDB_EXECUTION_ERROR;
  785.     }
  786.  
  787.   values[0].data.d_status = status;
  788.  
  789.   gimp_drawable_detach (drawable);
  790. }
  791.  
  792. /*
  793.  *  Query gimprc for gfig-path, and parse it.
  794.  */
  795.  
  796. static void
  797. plug_in_parse_gfig_path (void)
  798. {
  799.   GList *fail_list = NULL;
  800.   GList *list;
  801.   gchar *gfig_path;
  802.  
  803.   if (gfig_path_list)
  804.     gimp_path_free (gfig_path_list);
  805.   
  806.   gfig_path_list = NULL;
  807.   
  808.   gfig_path = gimp_gimprc_query ("gfig-path");
  809.  
  810.   if (!gfig_path)
  811.     {
  812.       gchar *gimprc = gimp_personal_rc_file ("gimprc");
  813.       gchar *path = gimp_strescape
  814.     ("${gimp_dir}" G_DIR_SEPARATOR_S "gfig"
  815.      G_SEARCHPATH_SEPARATOR_S
  816.      "${gimp_data_dir}" G_DIR_SEPARATOR_S "gfig",
  817.      NULL);
  818.       g_message (_("No gfig-path in gimprc:\n"
  819.            "You need to add an entry like\n"
  820.            "(gfig-path \"%s\")\n"
  821.            "to your %s file."),
  822.            path, gimprc);
  823.       g_free (gimprc);
  824.       g_free (path);
  825.       return;
  826.     }
  827.   
  828.   gfig_path_list = gimp_path_parse (gfig_path, 16, TRUE, &fail_list);
  829.  
  830.   g_free (gfig_path);
  831.  
  832.   if (fail_list)
  833.     {
  834.       GString *err =
  835.     g_string_new (_("gfig-path misconfigured - "
  836.             "the following directories were not found"));
  837.  
  838.       for (list = fail_list; list; list = g_list_next (list))
  839.     {
  840.       g_string_append_c (err, '\n');
  841.       g_string_append (err, (gchar *) list->data);
  842.     }
  843.  
  844.       g_message (err->str);
  845.  
  846.       g_string_free (err, TRUE);
  847.       gimp_path_free (fail_list);
  848.     }
  849. }
  850.  
  851.  
  852. /*
  853.   Translate SPACE to "\\040", etc.
  854.   Taken from gflare plugin
  855.  */
  856. static void
  857. gfig_name_encode (gchar *dest,
  858.           gchar *src)
  859. {
  860.   gint cnt = MAX_LOAD_LINE - 1;
  861.  
  862.   while (*src && cnt--)
  863.     {
  864.       if (iscntrl (*src) || isspace (*src) || *src == '\\')
  865.     {
  866.       sprintf (dest, "\\%03o", *src++);
  867.       dest += 4;
  868.     }
  869.       else
  870.     *dest++ = *src++;
  871.     }
  872.   *dest = '\0';
  873. }
  874.  
  875. /*
  876.   Translate "\\040" to SPACE, etc.
  877.  */
  878. static void
  879. gfig_name_decode (gchar *dest,
  880.           gchar *src)
  881. {
  882.   gint cnt = MAX_LOAD_LINE - 1;
  883.   gint tmp;
  884.  
  885.   while (*src && cnt--)
  886.     {
  887.       if (*src == '\\' && *(src+1) && *(src+2) && *(src+3))
  888.     {
  889.       sscanf (src+1, "%3o", &tmp);
  890.       *dest++ = tmp;
  891.       src += 4;
  892.     }
  893.       else
  894.     *dest++ = *src++;
  895.     }
  896.   *dest = '\0';
  897. }
  898.  
  899.  
  900. /*
  901.  * Load all gfig, which are founded in gfig-path-list, into gfig_list.
  902.  * gfig-path-list must be initialized first. (plug_in_parse_gfig_path ())
  903.  * based on code from Gflare.
  904.  */
  905.  
  906. static gint
  907. gfig_list_pos (GFigObj *gfig)
  908. {
  909.   GFigObj *g;
  910.   gint n;
  911.   GList *tmp;
  912.  
  913.   n = 0;
  914.  
  915.   for (tmp = gfig_list; tmp; tmp = g_list_next (tmp)) 
  916.     {
  917.       g = tmp->data;
  918.       
  919.       if (strcmp (gfig->draw_name, g->draw_name) <= 0)
  920.     break;
  921.  
  922.       n++;
  923.     }
  924.  
  925.   return n;
  926. }
  927.  
  928. static gint
  929. gfig_list_insert (GFigObj *gfig)
  930. {
  931.   gint n;
  932.  
  933.   /*
  934.    *    Insert gfigs in alphabetical order
  935.    */
  936.  
  937.   n = gfig_list_pos (gfig);
  938.  
  939.   gfig_list = g_list_insert (gfig_list, gfig, n);
  940.  
  941. #ifdef DEBUG
  942.   printf ("gfig_list_insert %s => %d\n", gfig->draw_name, n);
  943. #endif /* DEBUG */
  944.  
  945.   return n;
  946. }
  947.  
  948. static void
  949. gfig_free (GFigObj *gfig)
  950. {
  951.   g_assert (gfig != NULL);
  952.  
  953.   if (gfig->obj_list)
  954.     free_all_objs (gfig->obj_list);
  955.  
  956.   g_free (gfig->name);
  957.   g_free (gfig->filename);
  958.   g_free (gfig->draw_name);
  959.  
  960.   g_free (gfig);
  961. }
  962.  
  963. static void
  964. gfig_free_everything (GFigObj *gfig)
  965. {
  966.   g_assert (gfig != NULL);
  967.  
  968.   if (gfig->filename)
  969.     {
  970. #ifdef DEBUG
  971.       printf ("Removing filename '%s'\n", gfig->filename);
  972. #endif /* DEBUG */
  973.       remove (gfig->filename);
  974.     }
  975.  
  976.   gfig_free (gfig);
  977. }
  978.  
  979. static void
  980. gfig_list_free_all (void)
  981. {
  982.   GList   *list;
  983.   GFigObj *gfig;
  984.  
  985.   for (list = gfig_list; list; list = g_list_next (list))
  986.     {
  987.       gfig = (GFigObj *) list->data;
  988.       gfig_free (gfig);
  989.     }
  990.  
  991.   g_list_free (gfig_list);
  992.   gfig_list = NULL;
  993. }
  994.  
  995.  
  996. static void
  997. gfig_list_load_all (GList *plist)
  998. {
  999.   GFigObj *gfig;
  1000.   GList   *list;
  1001.   gchar      *path;
  1002.   gchar      *filename;
  1003.   DIR      *dir;
  1004.   struct dirent *dir_ent;
  1005.   struct stat    filestat;
  1006.   gint err;
  1007.  
  1008.   /*  Make sure to clear any existing gfigs  */
  1009.   current_obj = pic_obj = NULL;
  1010.   gfig_list_free_all ();
  1011.  
  1012.   list = plist;
  1013.   while (list)
  1014.     {
  1015.       path = list->data;
  1016.       list = list->next;
  1017.  
  1018.       /* Open directory */
  1019.       dir = opendir (path);
  1020.  
  1021.       if (!dir)
  1022.     g_warning ("Error reading GFig directory \"%s\"", path);
  1023.       else
  1024.     {
  1025.       while ((dir_ent = readdir (dir)))
  1026.         {
  1027.           filename = g_malloc (strlen (path) + strlen (dir_ent->d_name) + 1);
  1028.  
  1029.           sprintf (filename, "%s%s", path, dir_ent->d_name);
  1030.  
  1031.           /* Check the file and see that it is not a sub-directory */
  1032.           err = stat (filename, &filestat);
  1033.  
  1034.           if (!err && S_ISREG (filestat.st_mode))
  1035.         {
  1036.           gfig = gfig_load (filename, dir_ent->d_name);
  1037.           
  1038.           if (gfig)
  1039.             {
  1040.               /* Read only ?*/
  1041.               if (access (filename, W_OK))
  1042.             gfig->obj_status |= GFIG_READONLY;
  1043.  
  1044.               gfig_list_insert (gfig);
  1045.             }
  1046.         }
  1047.  
  1048.           g_free (filename);
  1049.         } /* while */
  1050.       closedir (dir);
  1051.     } /* else */
  1052.     }
  1053.  
  1054.   if (!gfig_list)
  1055.     {
  1056.       /* lets have at least one! */
  1057.       gfig = gfig_new ();
  1058.       gfig->draw_name = g_strdup (_("First Gfig"));
  1059.       gfig_list_insert (gfig);
  1060.     }
  1061.   pic_obj = current_obj = gfig_list->data;  /* set to first entry */
  1062.  
  1063. }
  1064.  
  1065. static GFigObj *
  1066. gfig_new (void)
  1067. {
  1068.   GFigObj * new;
  1069.  
  1070.   new = g_new0 (GFigObj, 1);
  1071.  
  1072.   return new;
  1073. }
  1074.  
  1075. static void
  1076. gfig_load_objs (GFigObj *gfig,
  1077.         gint     load_count,
  1078.         FILE    *fp)
  1079. {
  1080.   Dobject *obj;
  1081.   gchar load_buf[MAX_LOAD_LINE];
  1082.  
  1083.   /* Loading object */
  1084.   /*kill (getpid (), 19);*/
  1085.   /* Read first line */
  1086.   while (load_count-- > 0)
  1087.     {
  1088.       obj = NULL;
  1089.       get_line (load_buf, MAX_LOAD_LINE, fp, 0);
  1090.  
  1091.       if (!strcmp (load_buf, "<LINE>"))
  1092.     {
  1093.       obj = d_load_line (fp);
  1094.     }
  1095.       else if (!strcmp (load_buf, "<CIRCLE>"))
  1096.     {
  1097.       obj = d_load_circle (fp);
  1098.     }
  1099.       else if (!strcmp (load_buf, "<ELLIPSE>"))
  1100.     {
  1101.       obj = d_load_ellipse (fp);
  1102.     }
  1103.       else if (!strcmp (load_buf, "<POLY>"))
  1104.     {
  1105.       obj = d_load_poly (fp);
  1106.     }
  1107.       else if (!strcmp (load_buf, "<STAR>"))
  1108.     {
  1109.       obj = d_load_star (fp);
  1110.     }
  1111.       else if (!strcmp (load_buf, "<SPIRAL>"))
  1112.     {
  1113.       obj = d_load_spiral (fp);
  1114.     }
  1115.       else if (!strcmp (load_buf, "<BEZIER>"))
  1116.     {
  1117.       obj = d_load_bezier (fp);
  1118.     }
  1119.       else if (!strcmp (load_buf, "<ARC>"))
  1120.     {
  1121.       obj = d_load_arc (fp);
  1122.     }
  1123.       else
  1124.     {
  1125.       g_warning ("Unknown obj type file %s line %d\n", gfig->filename, line_no);
  1126.     }
  1127.       
  1128.       if (obj)
  1129.     {
  1130.       add_to_all_obj (gfig, obj);
  1131.     }
  1132.     }
  1133. }
  1134.  
  1135. static GFigObj *
  1136. gfig_load (gchar *filename, gchar *name)
  1137. {
  1138.   GFigObj * gfig;
  1139.   FILE * fp;
  1140.   gchar load_buf[MAX_LOAD_LINE];
  1141.   gchar str_buf[MAX_LOAD_LINE];
  1142.   gint chk_count;
  1143.   gint load_count = 0;
  1144.   
  1145.   g_assert (filename != NULL);
  1146.  
  1147. #ifdef DEBUG
  1148.   printf ("Loading %s (%s)\n", filename, name);
  1149. #endif /* DEBUG */
  1150.  
  1151.   fp = fopen (filename, "r");
  1152.   if (!fp)
  1153.     {
  1154.       g_warning ("Error opening: %s", filename);
  1155.       return NULL;
  1156.     }
  1157.  
  1158.   gfig = gfig_new ();
  1159.  
  1160.   gfig->name = g_strdup (name);
  1161.   gfig->filename = g_strdup (filename);
  1162.  
  1163.  
  1164.   /* HEADER
  1165.    * draw_name
  1166.    * version
  1167.    * obj_list
  1168.    */
  1169.  
  1170.   get_line (load_buf, MAX_LOAD_LINE, fp, 1);
  1171.  
  1172.   if (strncmp (GFIG_HEADER, load_buf, strlen (load_buf)))
  1173.     {
  1174.       g_message ("File '%s' is not a gfig file", gfig->filename);
  1175.       return NULL;
  1176.     }
  1177.   
  1178.   get_line (load_buf, MAX_LOAD_LINE, fp, 0);
  1179.   sscanf (load_buf, "Name: %100s", str_buf);
  1180.   gfig_name_decode (load_buf, str_buf);
  1181.   gfig->draw_name = g_strdup (load_buf);
  1182.  
  1183.   get_line (load_buf, MAX_LOAD_LINE, fp, 0);
  1184.   sscanf (load_buf, "Version: %f", &gfig->version);
  1185.  
  1186.   get_line (load_buf, MAX_LOAD_LINE, fp, 0);
  1187.   sscanf (load_buf, "ObjCount: %d", &load_count);
  1188.  
  1189.   if (load_options (gfig, fp))
  1190.     {
  1191.       g_message ("File '%s' corrupt file - Line %d Option section incorrect",
  1192.          filename, line_no);
  1193.       return NULL;
  1194.     }
  1195.  
  1196.   /*return (NULL);*/
  1197.  
  1198.   gfig_load_objs (gfig, load_count, fp);
  1199.  
  1200.   /* Check count ? */
  1201.   
  1202.   chk_count = gfig_obj_counts (gfig->obj_list);
  1203.  
  1204.   if (chk_count != load_count)
  1205.     {
  1206.       g_message ("File '%s' corrupt file - Line %d Object count to small",
  1207.          filename, line_no);
  1208.       return NULL;
  1209.     }
  1210.  
  1211.   fclose (fp);
  1212.  
  1213.   if (!pic_obj)
  1214.     pic_obj = gfig;
  1215.  
  1216.   gfig->obj_status = GFIG_OK;
  1217.  
  1218.   return gfig;
  1219. }
  1220.  
  1221. static void
  1222. save_options (FILE *fp)
  1223. {
  1224.   /* Save options */
  1225.   fprintf (fp, "<OPTIONS>\n");
  1226.   fprintf (fp, "GridSpacing: %d\n", selvals.opts.gridspacing);
  1227.   if (selvals.opts.gridtype == RECT_GRID)
  1228.     fprintf (fp, "GridType: RECT_GRID\n");
  1229.   else if (selvals.opts.gridtype == POLAR_GRID)
  1230.     fprintf (fp, "GridType: POLAR_GRID\n");
  1231.   else if (selvals.opts.gridtype == ISO_GRID)
  1232.     fprintf (fp, "GridType: ISO_GRID\n");
  1233.   else fprintf (fp, "GridType: RECT_GRID\n"); /* If in doubt, default to RECT_GRID */
  1234.   fprintf (fp, "DrawGrid: %s\n", (selvals.opts.drawgrid)?"TRUE":"FALSE");
  1235.   fprintf (fp, "Snap2Grid: %s\n", (selvals.opts.snap2grid)?"TRUE":"FALSE");
  1236.   fprintf (fp, "LockOnGrid: %s\n", (selvals.opts.lockongrid)?"TRUE":"FALSE");
  1237.   /*  fprintf (fp, "ShowImage: %s\n", (selvals.opts.showimage)?"TRUE":"FALSE");*/
  1238.   fprintf (fp, "ShowControl: %s\n", (selvals.opts.showcontrol)?"TRUE":"FALSE");
  1239.   fprintf (fp, "</OPTIONS>\n");
  1240. }
  1241.  
  1242. static gint
  1243. load_bool (gchar *opt_buf,
  1244.        gint  *toset)
  1245. {
  1246.   if (!strcmp (opt_buf, "TRUE"))
  1247.     *toset = 1;
  1248.   else if (!strcmp (opt_buf, "FALSE"))
  1249.     *toset = 0;
  1250.   else
  1251.     return (-1);
  1252.  
  1253.   return (0);
  1254. }
  1255.  
  1256. static void
  1257. update_options (GFigObj *old_obj)
  1258. {
  1259.   /* Save old vals */
  1260.   if (selvals.opts.gridspacing != old_obj->opts.gridspacing)
  1261.     {
  1262.       old_obj->opts.gridspacing = selvals.opts.gridspacing;
  1263.     }
  1264.   if (selvals.opts.gridtype != old_obj->opts.gridtype)
  1265.     {
  1266.       old_obj->opts.gridtype = selvals.opts.gridtype;
  1267.     }
  1268.   if (selvals.opts.drawgrid != old_obj->opts.drawgrid)
  1269.     {
  1270.       old_obj->opts.drawgrid = selvals.opts.drawgrid;
  1271.     }
  1272.   if (selvals.opts.snap2grid != old_obj->opts.snap2grid)
  1273.     {
  1274.       old_obj->opts.snap2grid = selvals.opts.snap2grid;
  1275.     }
  1276.   if (selvals.opts.lockongrid != old_obj->opts.lockongrid)
  1277.     {
  1278.       old_obj->opts.lockongrid = selvals.opts.lockongrid;
  1279.     }
  1280.   if (selvals.opts.showcontrol != old_obj->opts.showcontrol)
  1281.     {
  1282.       old_obj->opts.showcontrol = selvals.opts.showcontrol;
  1283.     }
  1284.  
  1285.   /* New vals */
  1286.   if (selvals.opts.gridspacing != current_obj->opts.gridspacing)
  1287.     {
  1288.       gtk_adjustment_set_value
  1289.     (GTK_ADJUSTMENT (gfig_opt_widget.gridspacing),
  1290.      current_obj->opts.gridspacing);
  1291.     }
  1292.   if (selvals.opts.drawgrid != current_obj->opts.drawgrid)
  1293.     {
  1294.       gtk_toggle_button_set_active
  1295.     (GTK_TOGGLE_BUTTON (gfig_opt_widget.drawgrid),
  1296.      current_obj->opts.drawgrid);
  1297.     }
  1298.   if (selvals.opts.snap2grid != current_obj->opts.snap2grid)
  1299.     {
  1300.       gtk_toggle_button_set_active
  1301.     (GTK_TOGGLE_BUTTON (gfig_opt_widget.snap2grid),
  1302.      current_obj->opts.snap2grid);
  1303.     }
  1304.   if (selvals.opts.lockongrid != current_obj->opts.lockongrid)
  1305.     {
  1306.       gtk_toggle_button_set_active
  1307.     (GTK_TOGGLE_BUTTON (gfig_opt_widget.lockongrid),
  1308.      current_obj->opts.lockongrid);
  1309.     }
  1310.   if (selvals.opts.showcontrol != current_obj->opts.showcontrol)
  1311.     {
  1312.       gtk_toggle_button_set_active
  1313.     (GTK_TOGGLE_BUTTON (gfig_opt_widget.showcontrol),
  1314.      current_obj->opts.showcontrol);
  1315.     }
  1316.   if (selvals.opts.gridtype != current_obj->opts.gridtype)
  1317.     {
  1318.       gtk_option_menu_set_history
  1319.     (GTK_OPTION_MENU (gfig_opt_widget.gridtypemenu),
  1320.      current_obj->opts.gridtype); 
  1321.  
  1322.       gridtype_menu_callback
  1323.     (gtk_menu_get_active
  1324.      (GTK_MENU (gtk_option_menu_get_menu
  1325.             (GTK_OPTION_MENU (gfig_opt_widget.gridtypemenu)))),
  1326.      (gpointer) GRID_TYPE_MENU);
  1327. #ifdef DEBUG
  1328.       printf ("Gridtype set in options to ");
  1329.       if (current_obj->opts.gridtype == RECT_GRID)
  1330.     printf ("RECT_GRID\n");
  1331.       else if (current_obj->opts.gridtype == POLAR_GRID)
  1332.     printf ("POLAR_GRID\n");
  1333.       else if (current_obj->opts.gridtype == ISO_GRID)
  1334.     printf ("ISO_GRID\n");
  1335.       else printf ("NONE\n");
  1336. #endif /* DEBUG */
  1337.     }
  1338. }
  1339.  
  1340. static gint
  1341. load_options (GFigObj *gfig,
  1342.           FILE    *fp)
  1343. {
  1344.   gchar load_buf[MAX_LOAD_LINE];
  1345.   gchar str_buf[MAX_LOAD_LINE];
  1346.   gchar opt_buf[MAX_LOAD_LINE];
  1347.  
  1348.   get_line (load_buf, MAX_LOAD_LINE, fp, 0);
  1349.  
  1350. #ifdef DEBUG
  1351.   printf ("load '%s'\n", load_buf);
  1352. #endif /* DEBUG */
  1353.  
  1354.   if (strcmp (load_buf, "<OPTIONS>"))
  1355.     return (-1);
  1356.   
  1357.   get_line (load_buf, MAX_LOAD_LINE, fp, 0);
  1358.  
  1359. #ifdef DEBUG
  1360.   printf ("opt line '%s'\n", load_buf);
  1361. #endif /* DEBUG */
  1362.  
  1363.   while (strcmp (load_buf, "</OPTIONS>"))
  1364.     {
  1365.       /* Get option name */
  1366. #ifdef DEBUG
  1367.       printf ("num = %d\n", sscanf (load_buf, "%s %s", str_buf, opt_buf));
  1368.  
  1369.       printf ("option %s val %s\n", str_buf, opt_buf);
  1370. #else
  1371.       sscanf (load_buf, "%s %s", str_buf, opt_buf);
  1372. #endif /* DEBUG */
  1373.  
  1374.       if (!strcmp (str_buf, "GridSpacing:"))
  1375.     {
  1376.       /* Value is decimal */
  1377.       int sp = 0;
  1378.       sp = atoi (opt_buf);
  1379.       if (sp <= 0)
  1380.         return (-1);
  1381.       gfig->opts.gridspacing = sp;
  1382.     }
  1383.       else if (!strcmp (str_buf, "DrawGrid:"))
  1384.     {
  1385.       /* Value is bool */
  1386.       if (load_bool (opt_buf, &gfig->opts.drawgrid))
  1387.         return (-1);
  1388.     }
  1389.       else if (!strcmp (str_buf, "Snap2Grid:"))
  1390.     {
  1391.       /* Value is bool */
  1392.       if (load_bool (opt_buf, &gfig->opts.snap2grid))
  1393.         return (-1);
  1394.     }
  1395.       else if (!strcmp (str_buf, "LockOnGrid:"))
  1396.     {
  1397.       /* Value is bool */
  1398.       if (load_bool (opt_buf, &gfig->opts.lockongrid))
  1399.         return (-1);
  1400.     }
  1401.       else if (!strcmp (str_buf, "ShowControl:"))
  1402.     {
  1403.       /* Value is bool */
  1404.       if (load_bool (opt_buf, &gfig->opts.showcontrol))
  1405.         return (-1);
  1406.     }
  1407.       else if (!strcmp (str_buf, "GridType:"))
  1408.     {
  1409.       /* Value is string */
  1410.       if (!strcmp (opt_buf, "RECT_GRID"))
  1411.         gfig->opts.gridtype = RECT_GRID;
  1412.       else if (!strcmp (opt_buf, "POLAR_GRID"))
  1413.         gfig->opts.gridtype = POLAR_GRID;
  1414.       else if (!strcmp (opt_buf, "ISO_GRID"))
  1415.         gfig->opts.gridtype = ISO_GRID;
  1416.       else
  1417.         return (-1);
  1418.     }
  1419.  
  1420.       get_line (load_buf, MAX_LOAD_LINE, fp, 0);
  1421. #ifdef DEBUG
  1422.       printf ("opt line '%s'\n", load_buf);
  1423. #endif /* DEBUG */
  1424.     }  
  1425.   return (0);
  1426. }
  1427.  
  1428. static gint
  1429. gfig_obj_counts (DAllObjs *objs)
  1430. {
  1431.   gint count = 0;
  1432.  
  1433.   while (objs)
  1434.     {
  1435.       count++;
  1436.       objs = objs->next;
  1437.     }
  1438.  
  1439.   return (count);
  1440. }
  1441.  
  1442. static void
  1443. gfig_save_callbk (void)
  1444. {
  1445.   FILE *fp;
  1446.   DAllObjs * objs;
  1447.   gint count = 0;
  1448.   gchar *savename;
  1449.   gchar *message;
  1450.   gchar conv_buf[MAX_LOAD_LINE*3 +1];
  1451.  
  1452.   savename = current_obj->filename;
  1453.  
  1454.   fp = fopen (savename, "w+");
  1455.   
  1456.   if (!fp)
  1457.     {
  1458.       message = g_strconcat (_("Error opening: %s"), 
  1459.                  "\n",
  1460.                  _("Could not save."), 
  1461.                  savename);
  1462.       g_message (message);
  1463.       g_free (message);
  1464.       return;
  1465.     }
  1466.  
  1467.   /* Write header out */
  1468.   fputs (GFIG_HEADER, fp);
  1469.   
  1470.   /* 
  1471.    * draw_name 
  1472.    * version
  1473.    * obj_list
  1474.    *
  1475.    */
  1476.  
  1477.   gfig_name_encode (conv_buf, current_obj->draw_name);
  1478.   fprintf (fp, "Name: %s\n", conv_buf);
  1479.   fprintf (fp, "Version: %f\n", current_obj->version);
  1480.   objs = current_obj->obj_list;
  1481.  
  1482.   count = gfig_obj_counts (objs);
  1483.  
  1484.   fprintf (fp, "ObjCount: %d\n", count);
  1485.  
  1486.   save_options (fp);
  1487.  
  1488.   objs = current_obj->obj_list;
  1489.   while (objs)
  1490.     {
  1491.       objs->obj->savefunc (objs->obj, fp);
  1492.       objs = objs->next;
  1493.     }
  1494.  
  1495.   if (ferror (fp))
  1496.     g_message ("Failed to write file\n");
  1497.   else
  1498.     {
  1499.       gfig_obj_modified (current_obj, GFIG_OK);
  1500.       current_obj->obj_status &= ~(GFIG_MODIFIED | GFIG_READONLY);
  1501.     }
  1502.  
  1503.   fclose (fp);
  1504.  
  1505.   gfig_update_stat_labels ();
  1506. }
  1507.  
  1508. static void
  1509. file_selection_ok (GtkWidget        *w,
  1510.            GtkFileSelection *fs,
  1511.            gpointer data)
  1512. {
  1513.   gchar *filenamebuf;
  1514.   struct stat filestat;
  1515.   gint    err;
  1516.   GFigObj *obj = (GFigObj *)gtk_object_get_user_data (GTK_OBJECT (fs));
  1517.   GFigObj *real_current;
  1518.  
  1519.   filenamebuf = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
  1520. #ifdef DEBUG
  1521.   g_print ("name selected '%s'\n", filenamebuf);
  1522. #endif /* DEBUG */
  1523.  
  1524.   /* Get the name */
  1525.   if (strlen (filenamebuf) == 0)
  1526.     {
  1527.       g_message ("Save: No filename given");
  1528.       return;
  1529.     }
  1530.  
  1531.   /* Check if directory exists */
  1532.   err = stat (filenamebuf, &filestat);
  1533.   
  1534.   if (!err && S_ISDIR (filestat.st_mode))
  1535.     {
  1536.       g_message ("Save: Can't save to a directory");
  1537.       return;
  1538.     }
  1539.   
  1540.   obj->filename = g_strdup (filenamebuf);
  1541.  
  1542.   real_current = current_obj;
  1543.   current_obj = obj;
  1544.   gfig_save_callbk ();
  1545.   current_obj = current_obj;
  1546.  
  1547.   gtk_widget_destroy (GTK_WIDGET (fs));
  1548.  
  1549. }
  1550.  
  1551. static void
  1552. create_file_selection (GFigObj *obj,
  1553.                gchar   *tpath)
  1554. {
  1555.   static GtkWidget *window = NULL;
  1556.  
  1557.   if (!window)
  1558.     {
  1559.       window = gtk_file_selection_new ("Save gfig drawing");
  1560.       gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
  1561.  
  1562.       gtk_signal_connect (GTK_OBJECT (window), "destroy",
  1563.               GTK_SIGNAL_FUNC (gtk_widget_destroyed),
  1564.               &window);
  1565.  
  1566.       gtk_object_set_user_data (GTK_OBJECT (window), obj);
  1567.       gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
  1568.               "clicked",
  1569.               GTK_SIGNAL_FUNC (file_selection_ok),
  1570.               (gpointer) window);
  1571.       gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
  1572.                  "clicked",
  1573.                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
  1574.                  GTK_OBJECT (window));
  1575.     }
  1576.  
  1577.   if (tpath)
  1578.     {
  1579.       gtk_file_selection_set_filename (GTK_FILE_SELECTION (window), tpath);
  1580.     }
  1581.   else if (gfig_path_list)
  1582.     {
  1583.       gchar *dir;
  1584.  
  1585.       dir = gimp_path_get_user_writable_dir (gfig_path_list);
  1586.  
  1587.       if (!dir)
  1588.     dir = g_strdup (gimp_directory ());
  1589.  
  1590.       gtk_file_selection_set_filename (GTK_FILE_SELECTION (window), dir);
  1591.  
  1592.       g_free (dir);
  1593.     }
  1594.   else
  1595.     {
  1596.       gchar *tmp = g_get_tmp_dir ();
  1597.  
  1598.       gtk_file_selection_set_filename (GTK_FILE_SELECTION (window), tmp);
  1599.       g_free (tmp);
  1600.     }
  1601.  
  1602.   if (!GTK_WIDGET_VISIBLE (window))
  1603.     gtk_widget_show (window);
  1604. }
  1605.  
  1606. static void
  1607. gfig_save (void)
  1608. {
  1609.   /* Save the current object */
  1610.   if (!current_obj->filename)
  1611.    {
  1612.      create_file_selection (current_obj, NULL);
  1613.      return;
  1614.    }
  1615.   gfig_save_callbk ();
  1616. }
  1617.  
  1618. /* HACK WARNING */
  1619. void * xxx;
  1620. void * yyy;
  1621.  
  1622. /* Cache the preview image - updates are a lot faster. */
  1623. /* The preview_cache will contain the small image */
  1624.  
  1625. static void
  1626. cache_preview (void)
  1627. {
  1628.   GimpPixelRgn src_rgn;
  1629.   int y, x;
  1630.   guchar *src_rows;
  1631.   guchar *p;
  1632.   int isgrey = 0;
  1633.  
  1634.   gimp_pixel_rgn_init (&src_rgn, gfig_select_drawable,
  1635.                sel_x1, sel_y1, sel_width, sel_height, FALSE, FALSE);
  1636.  
  1637.   src_rows = g_new (guchar , sel_width * 4); 
  1638.   p = pv_cache = g_new (guchar , preview_width * preview_height * 4);
  1639.  
  1640.   real_img_bpp = gimp_drawable_bpp (gfig_select_drawable->id);
  1641.  
  1642.   has_alpha = gimp_drawable_has_alpha (gfig_select_drawable->id);
  1643.  
  1644.   if (real_img_bpp < 3)
  1645.     {
  1646.       img_bpp = 3 + has_alpha;
  1647.     }
  1648.   else
  1649.     {
  1650.       img_bpp = real_img_bpp;
  1651.     }
  1652.  
  1653.   switch (gimp_drawable_type (gfig_select_drawable->id))
  1654.     {
  1655.     case GIMP_GRAYA_IMAGE:
  1656.     case GIMP_GRAY_IMAGE:
  1657.       isgrey = 1;
  1658.     default:
  1659.       break;
  1660.     }
  1661.  
  1662.   /*memset (p,-1, preview_width*preview_height*4); return;*/
  1663.  
  1664.   for (y = 0; y < preview_height; y++)
  1665.     {
  1666.       gimp_pixel_rgn_get_row (&src_rgn,
  1667.                   src_rows,
  1668.                   sel_x1,
  1669.                   sel_y1 + (y*sel_height)/preview_height,
  1670.                   sel_width);
  1671.  
  1672.     for (x = 0; x < (preview_width); x ++)
  1673.       {
  1674.     /* Get the pixels of each col */
  1675.     int i;
  1676.     for (i = 0 ; i < 3; i++)
  1677.       p[x*img_bpp+i] =
  1678.         src_rows[((x*sel_width)/preview_width)*src_rgn.bpp +((isgrey)?0:i)]; 
  1679.     if (has_alpha)
  1680.       p[x*img_bpp+3] =
  1681.         src_rows[((x*sel_width)/preview_width)*src_rgn.bpp + ((isgrey)?1:3)];
  1682.       }
  1683.     p += (preview_width*img_bpp);
  1684.     }
  1685.   g_free (src_rows);
  1686. }
  1687.  
  1688. static void
  1689. refill_cache (void)
  1690. {
  1691.   GdkCursorType ctype1 = GDK_WATCH;
  1692.   GdkCursorType ctype2 = GDK_TOP_LEFT_ARROW;
  1693.   static GdkCursor *preview_cursor1;  
  1694.   static GdkCursor *preview_cursor2;  
  1695.  
  1696.   if (!preview_cursor1)
  1697.     preview_cursor1 = gdk_cursor_new (ctype1);
  1698.  
  1699.   if (!preview_cursor2)
  1700.     preview_cursor2 = gdk_cursor_new (ctype2);
  1701.  
  1702.   gdk_window_set_cursor
  1703.     (gtk_widget_get_toplevel (GTK_WIDGET (gfig_preview))->window,
  1704.      preview_cursor1);
  1705.  
  1706.   gdk_window_set_cursor (gfig_preview->window, preview_cursor1);
  1707.  
  1708.   gdk_flush ();
  1709.  
  1710.   cache_preview ();
  1711.  
  1712.   gdk_window_set_cursor
  1713.     (gtk_widget_get_toplevel (GTK_WIDGET (gfig_preview))->window,
  1714.      preview_cursor2);
  1715.  
  1716.   toggle_obj_type (NULL, (gpointer) selvals.otype);
  1717. }
  1718.  
  1719. static GtkWidget *
  1720. gfig_list_item_new_with_label_and_pixmap (GFigObj   *obj,
  1721.                       gchar     *label,
  1722.                       GtkWidget *pix_widget)
  1723. {
  1724.   GtkWidget *list_item;
  1725.   GtkWidget *label_widget;
  1726.   GtkWidget *hbox;
  1727.  
  1728.   list_item = gtk_list_item_new ();
  1729.  
  1730.   hbox = gtk_hbox_new (FALSE, 1);
  1731.   gtk_container_add (GTK_CONTAINER (list_item), hbox);
  1732.   gtk_widget_show (hbox);
  1733.  
  1734.   gtk_box_pack_start (GTK_BOX (hbox), pix_widget, FALSE, FALSE, 0);
  1735.  
  1736.   label_widget = gtk_label_new (label);
  1737.   gtk_misc_set_alignment (GTK_MISC (label_widget), 0.0, 0.5);
  1738.   gtk_container_add (GTK_CONTAINER (hbox), label_widget);
  1739.  
  1740.   gtk_widget_show (obj->label_widget = label_widget);
  1741.   gtk_widget_show (obj->pixmap_widget = pix_widget);
  1742.   gtk_widget_show (obj->list_item = list_item);
  1743.  
  1744.   return list_item;
  1745. }
  1746.  
  1747. static void
  1748. gfig_obj_modified (GFigObj *obj,
  1749.            gint     stat_type)
  1750. {
  1751.   g_assert (obj != NULL);
  1752.  
  1753.   if (obj->obj_status == stat_type)
  1754.     return;
  1755.  
  1756.   /* Set the new one up */
  1757.   if (stat_type == GFIG_MODIFIED)
  1758.     gimp_pixmap_set (GIMP_PIXMAP (obj->pixmap_widget), Floppy6_xpm);
  1759.   else 
  1760.     gimp_pixmap_set (GIMP_PIXMAP (obj->pixmap_widget), blank_xpm);
  1761. }
  1762.  
  1763. static gint
  1764. select_button_press (GtkWidget      *widget,
  1765.              GdkEventButton *event,
  1766.              gpointer        data)
  1767. {
  1768.   gint type = (gint) data;
  1769.   gint count = 0;
  1770.   DAllObjs * objs;
  1771.  
  1772.   if (current_obj)
  1773.     {
  1774.       objs = current_obj->obj_list;
  1775.  
  1776.       while (objs)
  1777.     {
  1778.       objs = objs->next;
  1779.       count++;
  1780.     }
  1781.     }
  1782.  
  1783.   switch (type)
  1784.     {
  1785.     case OBJ_SELECT_LT:
  1786.       obj_show_single--;
  1787.       if (obj_show_single < 0)
  1788.     obj_show_single = count - 1;
  1789.       break;
  1790.     case OBJ_SELECT_GT:
  1791.       obj_show_single++;
  1792.       if (obj_show_single >= count)
  1793.     obj_show_single = 0;
  1794.       break;
  1795.     case OBJ_SELECT_EQ:
  1796.       obj_show_single = -1; /* Reset to show all */
  1797.       break;
  1798.     default:
  1799.       break;
  1800.     }
  1801.  
  1802.   draw_grid_clear (widget, data);
  1803.  
  1804.   return FALSE;
  1805. }
  1806.  
  1807. static GtkWidget *
  1808. obj_select_buttons (void)
  1809. {
  1810.   GtkWidget *button;
  1811.   GtkWidget *hbox, *vbox;
  1812.  
  1813.   vbox = gtk_vbox_new (FALSE, 0);
  1814.   gtk_widget_show (vbox);
  1815.  
  1816.   hbox = gtk_hbox_new (FALSE, 0);
  1817.   gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
  1818.   gtk_widget_show (hbox);
  1819.  
  1820.   button = gtk_button_new_with_label ("<");
  1821.   gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
  1822.   gtk_signal_connect (GTK_OBJECT (button), "button_press_event",
  1823.               GTK_SIGNAL_FUNC (select_button_press),
  1824.               (gpointer) OBJ_SELECT_LT);
  1825.   gtk_widget_show (button);
  1826.  
  1827.   button = gtk_button_new_with_label (">");
  1828.   gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
  1829.   gtk_signal_connect (GTK_OBJECT (button), "button_press_event",
  1830.               GTK_SIGNAL_FUNC (select_button_press),
  1831.               (gpointer) OBJ_SELECT_GT);
  1832.   gtk_widget_show (button);
  1833.  
  1834.   button = gtk_button_new_with_label ("==");
  1835.   gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
  1836.   gtk_signal_connect (GTK_OBJECT (button), "button_press_event",
  1837.               GTK_SIGNAL_FUNC (select_button_press),
  1838.               (gpointer) OBJ_SELECT_EQ);
  1839.   gtk_widget_show (button);
  1840.  
  1841.   return vbox;
  1842. }
  1843.  
  1844. static GtkWidget *
  1845. but_with_pix (gchar  **pixdata,
  1846.           GSList **group,
  1847.           gint     baction)
  1848. {
  1849.   GtkWidget *button;
  1850.   GtkWidget *alignment;
  1851.   GtkWidget *pixmap_widget;
  1852.  
  1853.   button = gtk_radio_button_new (*group);
  1854.   gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE); 
  1855.   gtk_signal_connect (GTK_OBJECT (button), "toggled",
  1856.               GTK_SIGNAL_FUNC (toggle_obj_type),
  1857.               (gpointer) baction);
  1858.   gtk_widget_show (button);
  1859.  
  1860.   *group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
  1861.  
  1862.   alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
  1863.   gtk_container_add (GTK_CONTAINER (button), alignment);
  1864.   gtk_widget_show (alignment);
  1865.  
  1866.   pixmap_widget = gimp_pixmap_new (pixdata);
  1867.   gtk_container_add (GTK_CONTAINER (alignment), pixmap_widget);
  1868.   gtk_widget_show (pixmap_widget);
  1869.  
  1870.   return button;
  1871. }
  1872.  
  1873. static GtkWidget *
  1874. small_preview (GtkWidget *list)
  1875. {
  1876.   GtkWidget *label;
  1877.   GtkWidget *frame;
  1878.   GtkWidget *button;
  1879.   GtkWidget *vbox;
  1880.   gint y;
  1881.  
  1882.   vbox = gtk_vbox_new (FALSE, 0);
  1883.   gtk_widget_show (vbox);
  1884.  
  1885.   label = gtk_label_new (_("Prev"));
  1886.   gtk_container_add (GTK_CONTAINER (vbox), label);
  1887.   gtk_widget_show (label);
  1888.  
  1889.   frame = gtk_frame_new (NULL);
  1890.   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
  1891.   gtk_container_add (GTK_CONTAINER (vbox), frame);
  1892.   gtk_widget_show (frame);
  1893.  
  1894.   pic_preview = gtk_preview_new (GTK_PREVIEW_COLOR);
  1895.   gtk_preview_size (GTK_PREVIEW (pic_preview),
  1896.             SMALL_PREVIEW_SZ, SMALL_PREVIEW_SZ);
  1897.   gtk_container_add (GTK_CONTAINER (frame), pic_preview);
  1898.   gtk_widget_show (pic_preview);
  1899.  
  1900.   /* Fill with white */
  1901.   for (y = 0; y < SMALL_PREVIEW_SZ; y++)
  1902.     {
  1903.       guchar prow[SMALL_PREVIEW_SZ*3];
  1904.       memset (prow, -1, SMALL_PREVIEW_SZ * 3);
  1905.       gtk_preview_draw_row (GTK_PREVIEW (pic_preview), prow,
  1906.                 0, y, SMALL_PREVIEW_SZ);
  1907.     }
  1908.  
  1909.   gtk_signal_connect_after (GTK_OBJECT (pic_preview), "expose_event",
  1910.                 GTK_SIGNAL_FUNC (pic_preview_expose),
  1911.                 NULL);
  1912.  
  1913.   /* More Buttons */
  1914.   button = gtk_button_new_with_label (_("Edit"));
  1915.   gtk_container_add (GTK_CONTAINER (vbox), button);
  1916.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  1917.               GTK_SIGNAL_FUNC (edit_button_callback),
  1918.               (gpointer) list);
  1919.   gimp_help_set_help_data (button, _("Edit Gfig object collection"), NULL); 
  1920.   gtk_widget_show (button);
  1921.  
  1922.   button = gtk_button_new_with_label (_("Merge"));
  1923.   gtk_container_add (GTK_CONTAINER (vbox), button);
  1924.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  1925.               GTK_SIGNAL_FUNC (merge_button_callback),
  1926.               (gpointer) list);
  1927.   gimp_help_set_help_data (button, _("Merge Gfig Object collection into the "
  1928.                      "current edit session"), NULL); 
  1929.   gtk_widget_show (button);
  1930.  
  1931.   return vbox;
  1932. }
  1933.  
  1934. /* Special case for now - options on poly/star/spiral button */
  1935.  
  1936. static void
  1937. num_sides_dialog (gchar *d_title,
  1938.           gint  *num_sides,
  1939.           gint  *which_way,
  1940.           gint   adj_min,
  1941.           gint   adj_max)
  1942. {
  1943.   GtkWidget *window;
  1944.   GtkWidget *table;
  1945.   GtkObject *size_data;
  1946.  
  1947.   window = gimp_dialog_new (d_title, "gfig",
  1948.                 gimp_standard_help_func, "filters/gfig.html",
  1949.                 GTK_WIN_POS_MOUSE,
  1950.                 FALSE, TRUE, FALSE,
  1951.  
  1952.                 _("Close"), gtk_widget_destroy,
  1953.                 NULL, 1, NULL, TRUE, TRUE,
  1954.  
  1955.                 NULL);
  1956.  
  1957.   table = gtk_table_new (which_way ? 2 : 1, 3, FALSE);
  1958.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  1959.   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  1960.   gtk_container_set_border_width (GTK_CONTAINER (table), 6);
  1961.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), table,
  1962.               FALSE, FALSE, 0);
  1963.   gtk_widget_show (table);
  1964.  
  1965.   size_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
  1966.                     _("Number of Sides/Points/Turns:"), 0, 0,
  1967.                     *num_sides, adj_min, adj_max, 1, 10, 0,
  1968.                     TRUE, 0, 0,
  1969.                     NULL, NULL);
  1970.   gtk_signal_connect (GTK_OBJECT (size_data), "value_changed",
  1971.               GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
  1972.               num_sides);
  1973.  
  1974.   if (which_way)
  1975.     {
  1976.       GtkWidget *option_menu;
  1977.  
  1978.       option_menu =
  1979.     gimp_option_menu_new2 (FALSE, gimp_menu_item_update,
  1980.                    which_way, (gpointer) *which_way,
  1981.  
  1982.                    _("Clockwise"),      (gpointer) 0, NULL,
  1983.                    _("Anti-Clockwise"), (gpointer) 1, NULL,
  1984.  
  1985.                    NULL);
  1986.       gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
  1987.                  _("Orientation:"), 1.0, 0.5,
  1988.                  option_menu, 1, TRUE);
  1989.     }
  1990.  
  1991.   gtk_widget_show (window);
  1992. }
  1993.  
  1994. static void
  1995. bezier_dialog (void)
  1996. {
  1997.   static GtkWidget *window = NULL;
  1998.   GtkWidget *vbox;
  1999.   GtkWidget *toggle;
  2000.  
  2001.   if (window)
  2002.     {
  2003.       gdk_window_raise (window->window);
  2004.       return;
  2005.     }
  2006.  
  2007.   window = gimp_dialog_new (_("Bezier Settings"), "gfig",
  2008.                 gimp_standard_help_func, "filters/gfig.html",
  2009.                 GTK_WIN_POS_MOUSE,
  2010.                 FALSE, FALSE, FALSE,
  2011.  
  2012.                 _("Close"), gtk_widget_destroy,
  2013.                 NULL, 1, NULL, TRUE, TRUE,
  2014.  
  2015.                 NULL);
  2016.  
  2017.   gtk_signal_connect (GTK_OBJECT (window), "destroy",
  2018.               GTK_SIGNAL_FUNC (gtk_widget_destroyed),
  2019.               &window);
  2020.  
  2021.   vbox = gtk_vbox_new (FALSE, 2);
  2022.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  2023.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
  2024.               FALSE, FALSE, 0);
  2025.   gtk_widget_show (vbox);
  2026.  
  2027.   toggle = gtk_check_button_new_with_label (_("Closed"));
  2028.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  2029.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  2030.               &bezier_closed);
  2031.   gimp_help_set_help_data (toggle,
  2032.             _("Close curve on completion"), NULL);
  2033.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bezier_closed);
  2034.   gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
  2035.   gtk_widget_show (toggle);
  2036.  
  2037.   toggle = gtk_check_button_new_with_label (_("Show Line Frame"));
  2038.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  2039.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  2040.               &bezier_line_frame);
  2041.   gimp_help_set_help_data (toggle,
  2042.             _("Draws lines between the control points. "
  2043.               "Only during curve creation"), NULL);
  2044.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bezier_line_frame);
  2045.   gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
  2046.   gtk_widget_show (toggle);
  2047.  
  2048.   gtk_widget_show (window);
  2049. }
  2050.  
  2051. static gint
  2052. poly_button_press (GtkWidget      *widget,
  2053.            GdkEventButton *event,
  2054.            gpointer        data)
  2055. {
  2056.   if ((event->type == GDK_2BUTTON_PRESS) &&
  2057.       (event->button == 1))
  2058.     num_sides_dialog (_("Regular Polygon Number of Sides"),
  2059.               &poly_num_sides, NULL, 3, 200);
  2060.   return FALSE;
  2061. }
  2062.  
  2063. static gint
  2064. star_button_press (GtkWidget      *widget,
  2065.            GdkEventButton *event,
  2066.            gpointer        data)
  2067. {
  2068.   if ((event->type == GDK_2BUTTON_PRESS) &&
  2069.       (event->button == 1))
  2070.     num_sides_dialog (_("Star Number of Points"),
  2071.               &star_num_sides, NULL, 3, 200);
  2072.   return FALSE;
  2073. }
  2074.  
  2075. static gint
  2076. spiral_button_press (GtkWidget      *widget,
  2077.              GdkEventButton *event,
  2078.              gpointer        data)
  2079. {
  2080.   if ((event->type == GDK_2BUTTON_PRESS) &&
  2081.       (event->button == 1))
  2082.     num_sides_dialog (_("Spiral Number of Points"),
  2083.               &spiral_num_turns, &spiral_toggle, 1, 20);
  2084.   return FALSE;
  2085. }
  2086.  
  2087. static gint
  2088. bezier_button_press (GtkWidget      *widget,
  2089.              GdkEventButton *event,
  2090.              gpointer        data)
  2091. {
  2092.   if ((event->type == GDK_2BUTTON_PRESS) &&
  2093.       (event->button == 1))
  2094.     bezier_dialog ();
  2095.   return FALSE;
  2096. }              
  2097.  
  2098. static GtkWidget *
  2099. draw_buttons (GtkWidget *ww)
  2100. {
  2101.   GtkWidget *frame;
  2102.   GtkWidget *button;
  2103.   GtkWidget *vbox;
  2104.   GSList    *group;
  2105.  
  2106.   frame = gtk_frame_new (_("Ops"));
  2107.   gtk_container_set_border_width (GTK_CONTAINER (frame), 1);
  2108.   
  2109.   /* Create group */
  2110.   group = NULL;
  2111.   vbox = gtk_vbox_new (FALSE, 0);
  2112.   gtk_container_add (GTK_CONTAINER (frame), vbox); 
  2113.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
  2114.  
  2115.   /* Put buttons in */
  2116.   button = but_with_pix (line_xpm, &group, LINE);
  2117.   gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
  2118.   gtk_widget_show (button);
  2119.   gimp_help_set_help_data (button, _("Create line"), NULL); 
  2120.  
  2121.   button = but_with_pix (circle_xpm, &group, CIRCLE);
  2122.   gtk_container_add (GTK_CONTAINER (vbox), button);
  2123.   gtk_widget_show (button);
  2124.   gimp_help_set_help_data (button, _("Create circle"), NULL); 
  2125.  
  2126.   button = but_with_pix (ellipse_xpm, &group, ELLIPSE);
  2127.   gtk_container_add (GTK_CONTAINER (vbox), button);
  2128.   gtk_widget_show (button);
  2129.   gimp_help_set_help_data (button, _("Create ellipse"), NULL); 
  2130.  
  2131.   button = but_with_pix (curve_xpm, &group, ARC);
  2132.   gtk_container_add (GTK_CONTAINER (vbox), button);
  2133.   gtk_widget_show (button);
  2134.   gimp_help_set_help_data (button, _("Create arch"), NULL); 
  2135.  
  2136.   button = but_with_pix (poly_xpm, &group, POLY);
  2137.   gtk_container_add (GTK_CONTAINER (vbox), button);
  2138.   gtk_widget_show (button);
  2139.  
  2140.   gtk_signal_connect (GTK_OBJECT (button), "button_press_event",
  2141.               GTK_SIGNAL_FUNC (poly_button_press),
  2142.               NULL);
  2143.   gimp_help_set_help_data (button, _("Create reg polygon"), NULL); 
  2144.  
  2145.   button = but_with_pix (star_xpm, &group, STAR);
  2146.   gtk_container_add (GTK_CONTAINER (vbox), button);
  2147.   gtk_widget_show (button);
  2148.   gtk_signal_connect (GTK_OBJECT (button), "button_press_event",
  2149.               GTK_SIGNAL_FUNC (star_button_press),
  2150.               NULL);
  2151.   gimp_help_set_help_data (button, "Create star", NULL); 
  2152.  
  2153.   button = but_with_pix (spiral_xpm, &group, SPIRAL);
  2154.   gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
  2155.   gtk_widget_show (button);
  2156.  
  2157.   gtk_signal_connect (GTK_OBJECT (button), "button_press_event",
  2158.               GTK_SIGNAL_FUNC (spiral_button_press),
  2159.               NULL);
  2160.   gimp_help_set_help_data (button, _("Create spiral"), NULL); 
  2161.  
  2162.   button = but_with_pix (bezier_xpm, &group, BEZIER);
  2163.   gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
  2164.   gtk_widget_show (button);
  2165.   gtk_signal_connect (GTK_OBJECT (button), "button_press_event",
  2166.               GTK_SIGNAL_FUNC (bezier_button_press),
  2167.               NULL);
  2168.  
  2169.   gimp_help_set_help_data (button,
  2170.             _("Create bezier curve. "
  2171.               "Shift + Button ends object creation."), NULL); 
  2172.  
  2173.   button = but_with_pix (move_obj_xpm, &group, MOVE_OBJ);
  2174.   gtk_container_add (GTK_CONTAINER (vbox), button);
  2175.   gtk_widget_show (button);
  2176.   gimp_help_set_help_data (button, _("Move an object"), NULL); 
  2177.  
  2178.   button = but_with_pix (move_point_xpm, &group, MOVE_POINT);
  2179.   gtk_container_add (GTK_CONTAINER (vbox), button);
  2180.   gtk_widget_show (button);
  2181.   gimp_help_set_help_data (button, _("Move a single point"), NULL); 
  2182.  
  2183.   button = but_with_pix (copy_obj_xpm, &group, COPY_OBJ);
  2184.   gtk_container_add (GTK_CONTAINER (vbox), button);
  2185.   gtk_widget_show (button);
  2186.   gimp_help_set_help_data (button, _("Copy an object"), NULL); 
  2187.  
  2188.   button = but_with_pix (delete_xpm, &group, DEL_OBJ);
  2189.   gtk_container_add (GTK_CONTAINER (vbox), button);
  2190.   gtk_widget_show (button);
  2191.   gimp_help_set_help_data (button, _("Delete an object"), NULL); 
  2192.  
  2193.   button = obj_select_buttons ();
  2194.   gtk_container_add (GTK_CONTAINER (vbox), button);
  2195.   gtk_widget_show (button);
  2196.  
  2197. #if 0
  2198.   button = but_with_pix (blank_xpm, &group, NULL_OPER);
  2199.   gtk_container_add (GTK_CONTAINER (vbox), button);
  2200.   gtk_widget_set_sensitive (button, FALSE);
  2201.   gtk_widget_show (button);
  2202. #endif /* 0 */
  2203.  
  2204.   gtk_widget_show (vbox);
  2205.   gtk_widget_show (frame);
  2206.  
  2207.   return frame;
  2208. }
  2209.  
  2210. /* Brush preview stuff */
  2211. static gint
  2212. gfig_brush_preview_events (GtkWidget *widget,
  2213.                GdkEvent  *event)
  2214. {
  2215.   GdkEventButton *bevent;
  2216.   GdkEventMotion *mevent;
  2217.   static GdkPoint point;
  2218.   static int have_start = 0;
  2219.  
  2220.   switch (event->type)
  2221.     {
  2222.     case GDK_EXPOSE:
  2223.       break;
  2224.  
  2225.     case GDK_BUTTON_PRESS:
  2226.       bevent = (GdkEventButton *) event;
  2227.       point.x = bevent->x;
  2228.       point.y = bevent->y;
  2229.       have_start = 1;
  2230.  
  2231.       break;
  2232.     case GDK_BUTTON_RELEASE:
  2233.       bevent = (GdkEventButton *) event;
  2234.       have_start = 0;
  2235.  
  2236.       break;
  2237.     case GDK_MOTION_NOTIFY:
  2238.       mevent = (GdkEventMotion *) event;
  2239.  
  2240.       if (!have_start || !(mevent->state & GDK_BUTTON1_MASK))
  2241.     break;
  2242.  
  2243.       gfig_brush_fill_preview_xy (widget,
  2244.                   point.x - mevent->x,
  2245.                   point.y - mevent->y);
  2246.       gtk_widget_draw (widget, NULL);
  2247.       point.x = mevent->x;
  2248.       point.y = mevent->y;
  2249.       break;
  2250.     default:
  2251.       break;
  2252.     }
  2253.   return FALSE;
  2254. }
  2255.  
  2256. static void
  2257. gfig_brush_update_preview (GtkWidget *widget,
  2258.                gpointer   data)
  2259. {
  2260.   GtkWidget *pw = (GtkWidget *) data;
  2261.   BrushDesc *bdesc;
  2262.  
  2263.   /* Must update the dialog area */
  2264.   /* Use the same brush as already set in the dialog */
  2265.   bdesc = gtk_object_get_user_data (GTK_OBJECT (pw));
  2266.   brush_list_button_callback (NULL, bdesc);
  2267. }
  2268.  
  2269. static void
  2270. gfig_brush_menu_callback (GtkWidget *widget,
  2271.               gpointer   data)
  2272. {
  2273.   gimp_menu_item_update (widget, &selvals.brshtype);
  2274.  
  2275.   switch (selvals.brshtype)
  2276.     {
  2277.     case BRUSH_BRUSH_TYPE:
  2278.       gtk_widget_hide (pressure_hbox);
  2279.       gtk_widget_hide (pencil_hbox);
  2280.       gtk_widget_show (fade_out_hbox);
  2281.       gtk_widget_show (gradient_hbox);
  2282.       break;
  2283.     case BRUSH_PENCIL_TYPE:
  2284.       gtk_widget_hide (fade_out_hbox);
  2285.       gtk_widget_hide (gradient_hbox);
  2286.       gtk_widget_hide (pressure_hbox);
  2287.       gtk_widget_show (pencil_hbox);
  2288.       break;
  2289.     case BRUSH_AIRBRUSH_TYPE:
  2290.       gtk_widget_hide (fade_out_hbox);
  2291.       gtk_widget_hide (gradient_hbox);
  2292.       gtk_widget_hide (pencil_hbox);
  2293.       gtk_widget_show (pressure_hbox);
  2294.       break;
  2295.     case BRUSH_PATTERN_TYPE:
  2296.       gtk_widget_hide (fade_out_hbox);
  2297.       gtk_widget_hide (gradient_hbox);
  2298.       gtk_widget_hide (pressure_hbox);
  2299.       gtk_widget_show (pencil_hbox);
  2300.       break;
  2301.     default:
  2302.       g_warning ("Internal error - invalid brush type");
  2303.       break;
  2304.     }
  2305.  
  2306.   gfig_brush_update_preview (widget, data);
  2307. }
  2308.  
  2309.  
  2310. static GtkWidget *
  2311. gfig_brush_preview (GtkWidget **pv)
  2312. {
  2313.   GtkWidget *option_menu;
  2314.   GtkWidget *frame;
  2315.   GtkWidget *hbox;
  2316.   GtkWidget *vbox;
  2317.   gint y;
  2318.  
  2319.   hbox = gtk_hbox_new (FALSE, 0);
  2320.   gtk_container_set_border_width (GTK_CONTAINER (hbox), 4);
  2321.   gtk_widget_show (hbox);
  2322.  
  2323.   frame = gtk_frame_new (NULL);
  2324.   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
  2325.   gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
  2326.   gtk_widget_show (frame);
  2327.  
  2328.   *pv = gtk_preview_new (GTK_PREVIEW_COLOR);
  2329.   gtk_widget_show (*pv);
  2330.   gtk_widget_set_events (GTK_WIDGET (*pv), PREVIEW_MASK);
  2331.   gtk_signal_connect (GTK_OBJECT (*pv), "event",
  2332.               GTK_SIGNAL_FUNC (gfig_brush_preview_events),
  2333.               NULL);
  2334.   gtk_preview_size (GTK_PREVIEW (*pv), BRUSH_PREVIEW_SZ, BRUSH_PREVIEW_SZ);
  2335.   gtk_container_add (GTK_CONTAINER (frame), *pv);
  2336.  
  2337.   /* Fill with white */
  2338.   for (y = 0; y < BRUSH_PREVIEW_SZ; y++)
  2339.     {
  2340.       guchar prow[BRUSH_PREVIEW_SZ*3];
  2341.       memset (prow, -1, BRUSH_PREVIEW_SZ * 3);
  2342.       gtk_preview_draw_row (GTK_PREVIEW (*pv), prow, 0, y, BRUSH_PREVIEW_SZ);
  2343.     }
  2344.  
  2345.   /* Now the buttons */
  2346.   vbox = gtk_vbox_new (FALSE, 0);
  2347.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  2348.   gtk_widget_show (vbox);
  2349.  
  2350.   option_menu =
  2351.     gimp_option_menu_new2 (FALSE, gfig_brush_menu_callback,
  2352.                *pv, (gpointer) selvals.brshtype,
  2353.  
  2354.                _("Brush"),    (gpointer) BRUSH_BRUSH_TYPE, NULL,
  2355.                _("Airbrush"), (gpointer) BRUSH_AIRBRUSH_TYPE, NULL,
  2356.                _("Pencil"),   (gpointer) BRUSH_PENCIL_TYPE, NULL,
  2357.                _("Pattern"),  (gpointer) BRUSH_PATTERN_TYPE, NULL,
  2358.  
  2359.                NULL);
  2360.   gtk_widget_show (option_menu);
  2361.  
  2362.   gtk_container_add (GTK_CONTAINER (vbox), option_menu);
  2363.   gimp_help_set_help_data (option_menu,
  2364.             _("Use the brush/pencil or the airbrush when drawing "
  2365.               "on the image. Pattern paints with currently "
  2366.               "selected brush with a pattern. Only applies to "
  2367.               "circles/ellipses if Approx. Circles/Ellipses "
  2368.               "toggle is set."), NULL);
  2369.  
  2370.   gtk_container_add (GTK_CONTAINER (hbox), vbox);
  2371.   gtk_container_add (GTK_CONTAINER (hbox), frame);
  2372.  
  2373.   return hbox;
  2374. }
  2375.  
  2376. static void
  2377. gfig_brush_fill_preview_xy (GtkWidget *pw,
  2378.                 gint       x1,
  2379.                 gint       y1)
  2380. {
  2381.   gint row_count;
  2382.   BrushDesc *bdesc = (BrushDesc*) gtk_object_get_user_data (GTK_OBJECT (pw));
  2383.  
  2384.   /* Adjust start position */
  2385.   bdesc->x_off += x1;
  2386.   bdesc->y_off += y1;
  2387.  
  2388.   if (bdesc->y_off < 0)
  2389.     bdesc->y_off = 0;
  2390.   if (bdesc->y_off > (bdesc->height - BRUSH_PREVIEW_SZ))
  2391.     bdesc->y_off = bdesc->height - BRUSH_PREVIEW_SZ;
  2392.  
  2393.   if (bdesc->x_off < 0)
  2394.     bdesc->x_off = 0;
  2395.   if (bdesc->x_off > (bdesc->width - BRUSH_PREVIEW_SZ))
  2396.     bdesc->x_off = bdesc->width - BRUSH_PREVIEW_SZ;
  2397.  
  2398.   /* Given an x and y fill preview in correctly offsetted */
  2399.   for (row_count = 0; row_count < BRUSH_PREVIEW_SZ; row_count++)
  2400.     gtk_preview_draw_row (GTK_PREVIEW (pw),
  2401.               &bdesc->pv_buf[bdesc->x_off*bdesc->bpp 
  2402.                     + (bdesc->width
  2403.                        *bdesc->bpp
  2404.                        *(row_count + bdesc->y_off))],
  2405.               0,
  2406.               row_count,
  2407.               BRUSH_PREVIEW_SZ);
  2408. }
  2409.  
  2410. static void
  2411. gfig_brush_fill_preview (GtkWidget *pw,
  2412.              gint32     layer_ID,
  2413.              BrushDesc *bdesc)
  2414. {
  2415.   GimpPixelRgn src_rgn;
  2416.   GimpDrawable *brushdrawable;
  2417.   gint bcount = 3;
  2418.  
  2419.   if (bdesc->pv_buf)
  2420.     {
  2421.       g_free (bdesc->pv_buf); /* Free old area */
  2422.     }
  2423.  
  2424.   brushdrawable = gimp_drawable_get (layer_ID);
  2425.  
  2426.   bdesc->bpp = bcount;
  2427.  
  2428.   /* Fill the preview with the current brush name */
  2429.   gimp_pixel_rgn_init (&src_rgn, brushdrawable,
  2430.                0, 0, bdesc->width, bdesc->height, FALSE, FALSE);
  2431.  
  2432.   bdesc->pv_buf = g_new (guchar, bdesc->width * bdesc->height * bcount);
  2433.   bdesc->x_off = bdesc->y_off = 0; /* Start from top left */
  2434.  
  2435.   gimp_pixel_rgn_get_rect (&src_rgn, bdesc->pv_buf,
  2436.                0, 0, bdesc->width, bdesc->height);
  2437.  
  2438.   /* Dump the pv_buf into the preview area */
  2439.   gfig_brush_fill_preview_xy (pw, 0, 0);
  2440. }
  2441.  
  2442. static void
  2443. mygimp_brush_set (gchar *bname)
  2444. {
  2445.   GimpParam *return_vals;
  2446.   int nreturn_vals;
  2447.  
  2448.   return_vals = gimp_run_procedure ("gimp_brushes_set_brush",
  2449.                     &nreturn_vals,
  2450.                     GIMP_PDB_STRING, bname,
  2451.                     GIMP_PDB_END);
  2452.  
  2453.   if (return_vals[0].data.d_status != GIMP_PDB_SUCCESS)
  2454.     {
  2455.       g_message ("Can't set brush...(1)");
  2456.     }
  2457.  
  2458.   gimp_destroy_params (return_vals, nreturn_vals);
  2459. }
  2460.  
  2461. static gchar *
  2462. mygimp_brush_get (void)
  2463. {
  2464.   GimpParam *return_vals;
  2465.   int nreturn_vals;
  2466.   static gchar saved_bname[1024]; /* required to be static - returned from proc */
  2467.  
  2468.   return_vals = gimp_run_procedure ("gimp_brushes_get_brush",
  2469.                                     &nreturn_vals,
  2470.                     GIMP_PDB_END);
  2471.  
  2472.   if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
  2473.     {
  2474.       strncpy (saved_bname, return_vals[1].data.d_string, sizeof (saved_bname));
  2475.     }
  2476.   else
  2477.     {
  2478.       saved_bname[0] = '\0';
  2479.     }
  2480.  
  2481.   gimp_destroy_params (return_vals, nreturn_vals);
  2482.  
  2483.   return (saved_bname);
  2484. }
  2485.  
  2486. static void
  2487. mygimp_brush_info (gint32 *width,
  2488.            gint32 *height)
  2489. {
  2490.   GimpParam *return_vals;
  2491.   int nreturn_vals;
  2492.  
  2493.   return_vals = gimp_run_procedure ("gimp_brushes_get_brush",
  2494.                                     &nreturn_vals,
  2495.                     GIMP_PDB_END);
  2496.  
  2497.   if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
  2498.     {
  2499.       *width  = MAX (return_vals[2].data.d_int32, 32);
  2500.       *height = MAX (return_vals[3].data.d_int32, 32);
  2501.     }
  2502.   else
  2503.     {
  2504.       g_message ("Failed to get brush info");
  2505.       *width = *height = 48;
  2506.     }
  2507.  
  2508.   gimp_destroy_params (return_vals, nreturn_vals);
  2509. }          
  2510.  
  2511. static void
  2512. gfig_paint (BrushType brush_type,
  2513.         gint32    drawable_ID,
  2514.         gint      seg_count,
  2515.         gdouble   line_pnts[])
  2516. {
  2517.   switch (brush_type)
  2518.     {
  2519.     case BRUSH_BRUSH_TYPE:
  2520.       gimp_paintbrush (drawable_ID,
  2521.                selvals.brushfade,
  2522.                seg_count, line_pnts,
  2523.                GIMP_HARD,
  2524.                selvals.brushgradient);
  2525.       break;
  2526.  
  2527.     case BRUSH_PENCIL_TYPE:
  2528.       gimp_pencil (drawable_ID,
  2529.            seg_count, line_pnts);
  2530.       break;
  2531.  
  2532.     case BRUSH_AIRBRUSH_TYPE:
  2533.       gimp_airbrush (drawable_ID,
  2534.              selvals.airbrushpressure,
  2535.              seg_count, line_pnts); 
  2536.       break;
  2537.  
  2538.     case BRUSH_PATTERN_TYPE:
  2539.       gimp_clone (drawable_ID,
  2540.           drawable_ID,
  2541.           GIMP_PATTERN_CLONE,
  2542.           0.0, 0.0,
  2543.           seg_count, line_pnts);
  2544.       break;
  2545.     }
  2546. }
  2547.  
  2548. static gint32
  2549. gfig_gen_brush_preview (BrushDesc *bdesc)
  2550. {
  2551.   /* Given the name of a brush then paint it and return the ID of the image 
  2552.    * the preview can be got from
  2553.    */
  2554.   static gint32 layer_ID = -1;
  2555.   guchar fR, fG, fB;
  2556.   guchar bR, bG, bB;
  2557.   gchar *saved_bname;
  2558.   gint32 width, height;
  2559.   gdouble line_pnts[2];
  2560.  
  2561.   if (brush_image_ID == -1)
  2562.     {
  2563.       /* Create a new image */
  2564.       brush_image_ID = gimp_image_new (48, 48, 0);
  2565.       if (brush_image_ID < 0)
  2566.     {
  2567.       g_message ("Failed to generate brush preview");
  2568.       return -1;
  2569.     }
  2570.       if ((layer_ID = gimp_layer_new (brush_image_ID,
  2571.                       "Brush preview",
  2572.                       48,
  2573.                       48,
  2574.                       0, /* RGB type */
  2575.                       100.0, /* opacity */
  2576.                       0 /* mode */)) < 0)
  2577.     {
  2578.       g_message ("Error in creating layer for brush preview");
  2579.       return -1;
  2580.     }
  2581.       gimp_image_add_layer (brush_image_ID, layer_ID, -1);
  2582.     }
  2583.  
  2584.   /* Need this later to delete it */
  2585.  
  2586.   /* Store foreground & backgroud colours set to black/white
  2587.    * paint with brush
  2588.    * restore colours
  2589.    */
  2590.  
  2591.   gimp_palette_get_foreground (&fR, &fG, &fB);
  2592.   gimp_palette_get_background (&bR, &bG, &bB);
  2593.   saved_bname = mygimp_brush_get ();
  2594.  
  2595.   gimp_palette_set_background ((guchar) -1, (guchar) -1, (guchar) -1);
  2596.   gimp_palette_set_foreground (0, 0, 0);
  2597.   mygimp_brush_set (bdesc->bname);
  2598.  
  2599.   mygimp_brush_info (&width, &height);
  2600.   bdesc->width = width;
  2601.   bdesc->height = height;
  2602.   line_pnts[0] = (gdouble) width / 2;
  2603.   line_pnts[1] = (gdouble) height / 2;
  2604.  
  2605.   gimp_layer_resize (layer_ID, width, height, 0, 0);
  2606.   gimp_image_resize (brush_image_ID, width, height, 0, 0);
  2607.  
  2608.   gimp_drawable_fill (layer_ID, 1); /* Clear... Fill with white ... */
  2609.  
  2610.   /* Blob of paint */
  2611.   gfig_paint (selvals.brshtype,
  2612.           layer_ID,
  2613.           2, line_pnts);
  2614.  
  2615.   gimp_palette_set_background (bR, bG, bB);  
  2616.   gimp_palette_set_foreground (fR, fG, fB);
  2617.   mygimp_brush_set (saved_bname);
  2618.  
  2619.   return layer_ID;
  2620. }
  2621.  
  2622. static void
  2623. brush_list_button_callback (GtkWidget *widget,
  2624.                 gpointer   data)
  2625. {
  2626.   gint32 layer_ID;
  2627.  
  2628.   BrushDesc *bdesc = (BrushDesc *) data;
  2629.   if ((layer_ID = gfig_gen_brush_preview (bdesc)) != -1)
  2630.     {
  2631.       gtk_object_set_user_data (GTK_OBJECT (brush_page_pw), (gpointer) bdesc);
  2632.       gfig_brush_fill_preview (brush_page_pw, layer_ID, bdesc);
  2633.       gtk_widget_draw (brush_page_pw, NULL);
  2634.     }
  2635. }
  2636.  
  2637. /* Build the dialog up. This was the hard part! */
  2638.  
  2639. static GtkWidget *page_menu_bg;
  2640. static GtkWidget *page_menu_layers;
  2641.  
  2642. static void
  2643. gfig_brush_pane_activate (GtkWidget *widget,
  2644.               gpointer   data)
  2645. {
  2646.   gint flag = (gint) data;
  2647.  
  2648.   if (flag)
  2649.     {
  2650.       gtk_widget_show (brush_page_widget);
  2651.     }
  2652.   else
  2653.     {
  2654.       gtk_widget_hide (brush_page_widget);
  2655.     }
  2656.  
  2657.   gtk_widget_set_sensitive (brush_page_widget, flag);
  2658. }
  2659.  
  2660. static void
  2661. gfig_select_pane_activate (GtkWidget *widget,
  2662.                gpointer   data)
  2663. {
  2664.   gint flag = (gint) data;
  2665.  
  2666.   if (flag)
  2667.     {
  2668.       gtk_widget_show (select_page_widget);
  2669.     }
  2670.   else
  2671.     {
  2672.       gtk_widget_hide (select_page_widget);
  2673.     }
  2674.  
  2675.   gtk_widget_set_sensitive (select_page_widget, flag);
  2676. }
  2677.  
  2678.  
  2679. static void
  2680. paint_menu_callback (GtkWidget *widget,
  2681.              gpointer   data)
  2682. {
  2683.   gint mtype = (gint)data;
  2684.  
  2685.   if (mtype == PAINT_LAYERS_MENU)
  2686.     {
  2687. #ifdef DEBUG
  2688.       printf ("layer type set to %s\n",
  2689.          ((DrawonLayers)gtk_object_get_user_data (GTK_OBJECT (widget)) == SINGLE_LAYER)?"SINGLE_LAYER":"MULTI_LAYER");
  2690. #endif /* DEBUG */
  2691.       selvals.onlayers = (DrawonLayers)gtk_object_get_user_data (GTK_OBJECT (widget));
  2692.       /* Type only meaningful if creating new layers */
  2693.       if (selvals.onlayers == ORIGINAL_LAYER)
  2694.     gtk_widget_set_sensitive (page_menu_bg, FALSE);
  2695.       else
  2696.     gtk_widget_set_sensitive (page_menu_bg, TRUE);
  2697.     }
  2698.   else if (mtype == PAINT_BGS_MENU)
  2699.     {
  2700. #ifdef DEBUG
  2701.       printf ("BG type = %d\n",
  2702.          ((LayersBGType)gtk_object_get_user_data (GTK_OBJECT (widget))));
  2703. #endif /* DEBUG */
  2704.       selvals.onlayerbg = (LayersBGType)gtk_object_get_user_data (GTK_OBJECT (widget));
  2705.     }
  2706.   else if (mtype == PAINT_TYPE_MENU)
  2707.     {
  2708. #ifdef DEBUG
  2709.       printf ("Got type menu = %d\n", (PaintType)gtk_object_get_user_data (GTK_OBJECT (widget)));
  2710. #endif /* DEBUG */
  2711.       selvals.painttype = (PaintType)gtk_object_get_user_data (GTK_OBJECT (widget));
  2712.       switch (selvals.painttype)
  2713.     {
  2714.     case PAINT_BRUSH_TYPE:
  2715.       gtk_widget_set_sensitive (select_page_widget, FALSE);
  2716.       gtk_widget_set_sensitive (brush_page_widget, TRUE);
  2717.       gtk_widget_set_sensitive (page_menu_layers, TRUE);
  2718.       if (selvals.onlayers == ORIGINAL_LAYER)
  2719.         gtk_widget_set_sensitive (page_menu_bg, FALSE);
  2720.       else
  2721.         gtk_widget_set_sensitive (page_menu_bg, TRUE);
  2722.       break;
  2723.     case PAINT_SELECTION_TYPE:
  2724.       gtk_widget_set_sensitive (select_page_widget, TRUE);
  2725.       gtk_widget_set_sensitive (brush_page_widget, FALSE);
  2726.       gtk_widget_set_sensitive (page_menu_layers, FALSE);
  2727.       gtk_widget_set_sensitive (page_menu_bg, FALSE);
  2728.       break;
  2729.     case PAINT_SELECTION_FILL_TYPE:
  2730.       gtk_widget_set_sensitive (select_page_widget, TRUE);
  2731.       gtk_widget_set_sensitive (brush_page_widget, FALSE);
  2732.       gtk_widget_set_sensitive (page_menu_layers, TRUE);
  2733.       if (selvals.onlayers == ORIGINAL_LAYER)
  2734.         gtk_widget_set_sensitive (page_menu_bg, FALSE);
  2735.       else
  2736.         gtk_widget_set_sensitive (page_menu_bg, TRUE);
  2737.       break;
  2738.     default:
  2739.       break;
  2740.     }
  2741.     }
  2742. }
  2743.  
  2744. static GtkWidget *
  2745. paint_page (void)
  2746. {
  2747.   GtkWidget *table;
  2748.   GtkWidget *vbox;
  2749.   GtkWidget *vbox2;
  2750.   GtkWidget *hbox;
  2751.   GtkWidget *toggle;
  2752.   GtkWidget *page_menu_type;
  2753.   GtkWidget *scale_scale;
  2754.   GtkObject *scale_scale_data;
  2755.   GtkWidget *item1, *item2, *item3;
  2756.  
  2757.   vbox = gtk_vbox_new (FALSE, 0);
  2758.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  2759.  
  2760.   table = gtk_table_new (5, 2, FALSE); 
  2761.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  2762.   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  2763.   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  2764.   gtk_widget_show (table);
  2765.  
  2766.   page_menu_layers =
  2767.     gimp_option_menu_new2 (FALSE, paint_menu_callback,
  2768.                (gpointer) PAINT_LAYERS_MENU, 0,
  2769.  
  2770.                _("Original"), (gpointer) ORIGINAL_LAYER, NULL,
  2771.                _("New"),      (gpointer) SINGLE_LAYER, NULL,
  2772.                _("Multiple"), (gpointer) MULTI_LAYER, NULL,
  2773.  
  2774.                NULL);
  2775.  
  2776.   gimp_help_set_help_data (page_menu_layers,
  2777.             _("Draw all objects on one layer (original or new) "
  2778.               "or one object per layer"), NULL);
  2779.   if (gimp_drawable_is_channel (gfig_drawable))
  2780.       gtk_widget_set_sensitive (page_menu_layers, FALSE);
  2781.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
  2782.                  _("Draw on:"), 1.0, 0.5,
  2783.                  page_menu_layers, 1, TRUE);
  2784.  
  2785.   page_menu_type =
  2786.     gimp_option_menu_new2 (FALSE, paint_menu_callback,
  2787.                (gpointer) PAINT_TYPE_MENU, 0,
  2788.  
  2789.                _("Brush"),
  2790.                (gpointer) PAINT_BRUSH_TYPE, &item1,
  2791.                _("Selection"),
  2792.                (gpointer) PAINT_SELECTION_TYPE, &item2,
  2793.                _("Selection+Fill"),
  2794.                (gpointer) PAINT_SELECTION_FILL_TYPE, &item3,
  2795.  
  2796.                NULL);
  2797.  
  2798.   gtk_signal_connect (GTK_OBJECT (item1), "activate",
  2799.               GTK_SIGNAL_FUNC (gfig_brush_pane_activate),
  2800.               (gpointer) 1);
  2801.   gtk_signal_connect (GTK_OBJECT (item1), "activate",
  2802.               GTK_SIGNAL_FUNC (gfig_select_pane_activate),
  2803.               (gpointer) 0);
  2804.  
  2805.   gtk_signal_connect (GTK_OBJECT (item2), "activate",
  2806.               GTK_SIGNAL_FUNC (gfig_brush_pane_activate),
  2807.               (gpointer) 0);
  2808.   gtk_signal_connect (GTK_OBJECT (item2), "activate",
  2809.               GTK_SIGNAL_FUNC (gfig_select_pane_activate),
  2810.               (gpointer) 1);
  2811.  
  2812.   gtk_signal_connect (GTK_OBJECT (item3), "activate",
  2813.               GTK_SIGNAL_FUNC (gfig_brush_pane_activate),
  2814.               (gpointer) 0);
  2815.   gtk_signal_connect (GTK_OBJECT (item3), "activate",
  2816.               GTK_SIGNAL_FUNC (gfig_select_pane_activate),
  2817.               (gpointer) 1);
  2818.  
  2819.   gimp_help_set_help_data (page_menu_type,
  2820.             _("Draw type. Either a brush or a selection. "
  2821.               "See brush page or selection page for more options"),
  2822.             NULL);
  2823.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
  2824.                  _("Using:"), 1.0, 0.5,
  2825.                  page_menu_type, 1, TRUE);
  2826.  
  2827.   page_menu_bg =
  2828.     gimp_option_menu_new2 (FALSE, paint_menu_callback,
  2829.                (gpointer) PAINT_BGS_MENU, 0,
  2830.  
  2831.                _("Transparent"), (gpointer) LAYER_TRANS_BG, NULL,
  2832.                _("Background"),  (gpointer) LAYER_BG_BG, NULL,
  2833.                _("Foreground"),  (gpointer) LAYER_FG_BG, NULL,
  2834.                _("White"),       (gpointer) LAYER_WHITE_BG, NULL,
  2835.                _("Copy"),        (gpointer) LAYER_COPY_BG, NULL,
  2836.  
  2837.                NULL);
  2838.   gimp_help_set_help_data (page_menu_bg,
  2839.             _("Layer background type. Copy causes previous "
  2840.               "layer to be copied before the draw is performed"),
  2841.             NULL);
  2842.   gtk_widget_set_sensitive (page_menu_bg, FALSE);
  2843.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
  2844.                  _("With BG of:"), 1.0, 0.5,
  2845.                  page_menu_bg, 1, TRUE);
  2846.  
  2847.   toggle = gtk_check_button_new_with_label (_("Reverse Line"));
  2848.   gtk_table_attach (GTK_TABLE (table), toggle, 0, 1, 4, 5,
  2849.             GTK_FILL, GTK_FILL, 0, 0);
  2850.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  2851.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  2852.               (gpointer)&selvals.reverselines);
  2853.   gimp_help_set_help_data (toggle,
  2854.             _("Draw lines in reverse order"), NULL);
  2855.   gtk_widget_show (toggle);
  2856.  
  2857.   vbox2 = gtk_vbox_new (FALSE, 0);
  2858.   gtk_table_attach (GTK_TABLE (table), vbox2, 0, 1, 3, 4,
  2859.             GTK_FILL, GTK_FILL, 0, 0);
  2860.   gtk_widget_show (vbox2);
  2861.  
  2862.   toggle = gtk_check_button_new_with_label (_("Scale to Image"));
  2863.   gtk_box_pack_end (GTK_BOX (vbox2), toggle, FALSE, FALSE, 0);
  2864.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
  2865.                 selvals.scaletoimage);
  2866.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  2867.               GTK_SIGNAL_FUNC (gfig_scale2img_update),
  2868.               &selvals.scaletoimage);
  2869.   gimp_help_set_help_data (toggle,
  2870.             _("Scale drawings to images size"), NULL);
  2871.   gtk_widget_show (toggle);
  2872.  
  2873.   hbox = gtk_hbox_new (FALSE, 1);
  2874.   scale_scale_data = gtk_adjustment_new (1.0, 0.1, 5.0, 0.01, 0.01, 0.0);
  2875.   scale_scale = gtk_hscale_new (GTK_ADJUSTMENT (scale_scale_data));
  2876.   gtk_box_pack_start (GTK_BOX (hbox), scale_scale, TRUE, TRUE, 0);
  2877.   gtk_scale_set_value_pos (GTK_SCALE (scale_scale), GTK_POS_TOP);
  2878.   gtk_scale_set_digits (GTK_SCALE (scale_scale), 2);
  2879.   gtk_range_set_update_policy (GTK_RANGE (scale_scale), GTK_UPDATE_CONTINUOUS);
  2880.   gtk_signal_connect (GTK_OBJECT (scale_scale_data), "value_changed",
  2881.                       GTK_SIGNAL_FUNC (gfig_scale_update_scale),
  2882.                       &selvals.scaletoimagefp);
  2883.   gtk_widget_show (scale_scale);
  2884.   gtk_widget_show (hbox);   
  2885.   gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 3, 4,
  2886.             GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
  2887.  
  2888.   gtk_widget_set_sensitive (GTK_WIDGET (scale_scale), FALSE);
  2889.   gtk_object_set_data (GTK_OBJECT (toggle), "inverse_sensitive", scale_scale);
  2890.   gtk_object_set_user_data (GTK_OBJECT (toggle), scale_scale_data);
  2891.  
  2892.   toggle = gtk_check_button_new_with_label (_("Approx. Circles/Ellipses"));
  2893.   gtk_table_attach (GTK_TABLE (table), toggle, 1, 2, 4, 5,
  2894.             GTK_FILL, GTK_FILL, 0, 0);
  2895.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  2896.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  2897.               &selvals.approxcircles);
  2898.   gimp_help_set_help_data (toggle,
  2899.             _("Approx. circles & ellipses using lines. Allows "
  2900.               "the use of brush fading with these types of "
  2901.               "objects."), NULL); 
  2902.   gtk_widget_show (toggle);
  2903.  
  2904.   return vbox;
  2905. }
  2906.  
  2907. static void
  2908. gfig_brush_invoker (gchar    *name,
  2909.             gdouble  opacity,
  2910.             gint     spacing,
  2911.             gint     paint_mode,
  2912.             gint     width,
  2913.             gint     height,
  2914.             gchar   *mask_data,
  2915.             gint     closing,
  2916.             gpointer udata)
  2917. {
  2918.   BrushDesc *bdesc = g_new0 (BrushDesc, 1); /* Mem leak */
  2919.  
  2920.   bdesc->bpp = 3;
  2921.   bdesc->width = width;
  2922.   bdesc->height = height;
  2923.   bdesc->bname = g_strdup (name);
  2924.  
  2925.   brush_list_button_callback (NULL, bdesc);
  2926. }
  2927.  
  2928. static void
  2929. select_brush_callback (GtkWidget *widget,
  2930.                gpointer   data)
  2931. {
  2932.   BrushDesc *bdesc = g_new0 (BrushDesc, 1);
  2933.  
  2934.   gimp_interactive_selection_brush ("Gfig brush selection",
  2935.                     mygimp_brush_get (),
  2936.                     1.0, /* Opacity */
  2937.                     -1,  /* spacing (default)*/
  2938.                     1,   /* Paint mode */
  2939.                     gfig_brush_invoker,
  2940.                     NULL);
  2941.  
  2942.    bdesc->bpp = 3; 
  2943.    bdesc->bname = mygimp_brush_get ();
  2944.    
  2945.    brush_list_button_callback (NULL, bdesc); 
  2946. }
  2947.  
  2948. static GtkWidget *
  2949. brush_page (void)
  2950. {
  2951.   GtkWidget *table;
  2952.   GtkWidget *label;
  2953.   GtkWidget *pw;
  2954.   GtkWidget *scale;
  2955.   GtkObject *fade_out_scale_data;
  2956.   GtkObject *gradient_scale_data;
  2957.   GtkObject *pressure_scale_data;
  2958.   GtkWidget *vbox;
  2959.   GtkWidget *button;
  2960.   BrushDesc *bdesc = g_new0 (BrushDesc, 1); /* Initial brush settings */
  2961.  
  2962.   vbox = gtk_vbox_new (FALSE, 0);
  2963.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  2964.  
  2965.   table = gtk_table_new (2, 3, FALSE); 
  2966.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  2967.   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  2968.   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  2969.   gtk_widget_show (table);
  2970.  
  2971.   /* Fade option */
  2972.   /*  the fade-out scale  From GIMP itself*/
  2973.   fade_out_hbox = gtk_hbox_new (FALSE, 4);
  2974.  
  2975.   label = gtk_label_new (_("Fade out:"));
  2976.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
  2977.   gtk_box_pack_start (GTK_BOX (fade_out_hbox), label, FALSE, FALSE, 0);
  2978.   gtk_widget_show (label);
  2979.  
  2980.   fade_out_scale_data = gtk_adjustment_new (0.0, 0.0, 3000.0, 1.0, 1.0, 0.0);
  2981.   scale = gtk_hscale_new (GTK_ADJUSTMENT (fade_out_scale_data));
  2982.   gtk_box_pack_start (GTK_BOX (fade_out_hbox), scale, TRUE, TRUE, 0);
  2983.   gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
  2984.   gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
  2985.   gtk_signal_connect (GTK_OBJECT (fade_out_scale_data), "value_changed",
  2986.                       GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  2987.                       &selvals.brushfade);
  2988.   gtk_widget_show (scale);
  2989.  
  2990.   gtk_table_attach (GTK_TABLE (table), fade_out_hbox, 0, 2, 1, 2,
  2991.             GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
  2992.   gtk_widget_show (fade_out_hbox);   
  2993.  
  2994.  
  2995.   /* Gradient drawing */
  2996.   gradient_hbox = gtk_hbox_new (FALSE, 4);
  2997.  
  2998.   label = gtk_label_new (_("Gradient:"));
  2999.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
  3000.   gtk_box_pack_start (GTK_BOX (gradient_hbox), label, FALSE, FALSE, 0);
  3001.   gtk_widget_show (label);
  3002.  
  3003.   gradient_scale_data = gtk_adjustment_new (0.0, 0.0, 3000.0, 1.0, 1.0, 0.0);
  3004.   scale = gtk_hscale_new (GTK_ADJUSTMENT (gradient_scale_data));
  3005.   gtk_box_pack_start (GTK_BOX (gradient_hbox), scale, TRUE, TRUE, 0);
  3006.   gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
  3007.   gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
  3008.   gtk_signal_connect (GTK_OBJECT (gradient_scale_data), "value_changed",
  3009.                       GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  3010.                       &selvals.brushgradient);
  3011.   gtk_widget_show (scale);
  3012.   gtk_table_attach (GTK_TABLE (table), gradient_hbox, 0, 2, 2, 3,
  3013.             GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
  3014.   gtk_widget_show (gradient_hbox);   
  3015.  
  3016.  
  3017.   pressure_hbox = gtk_hbox_new (FALSE, 4);
  3018.   label = gtk_label_new (_("Pressure:"));
  3019.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
  3020.   gtk_box_pack_start (GTK_BOX (pressure_hbox), label, FALSE, FALSE, 0);
  3021.   gtk_widget_show (label);
  3022.  
  3023.   pressure_scale_data = gtk_adjustment_new (20.0, 0.0, 100.0, 1.0, 1.0, 0.0);
  3024.   scale = gtk_hscale_new (GTK_ADJUSTMENT (pressure_scale_data));
  3025.   gtk_box_pack_start (GTK_BOX (pressure_hbox), scale, TRUE, TRUE, 0);
  3026.   gtk_widget_show (scale);
  3027.   gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
  3028.   gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
  3029.   gtk_signal_connect (GTK_OBJECT (pressure_scale_data), "value_changed",
  3030.                       GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  3031.                       &selvals.airbrushpressure);
  3032.   gtk_table_attach (GTK_TABLE (table), pressure_hbox, 0, 2, 1, 2,
  3033.             GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
  3034.  
  3035.   pencil_hbox = gtk_hbox_new (FALSE, 4);
  3036.   label = gtk_label_new (_("No Options..."));
  3037.   gtk_box_pack_start (GTK_BOX (pencil_hbox), label, FALSE, FALSE, 0);
  3038.   gtk_widget_show (label);
  3039.   gtk_table_attach (GTK_TABLE (table), pencil_hbox, 0, 2, 1, 2,
  3040.             GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
  3041.  
  3042.   /* Preview widget */
  3043.   pw = gfig_brush_preview (&brush_page_pw);
  3044.   gtk_table_attach (GTK_TABLE (table), pw, 0, 1, 0, 1, 0, 0, 0, 0);
  3045.  
  3046.   gtk_signal_connect (GTK_OBJECT (pressure_scale_data), "value_changed",
  3047.                       GTK_SIGNAL_FUNC (gfig_brush_update_preview),
  3048.                       (gpointer)brush_page_pw);
  3049.  
  3050.   /* Start of new brush selection code */
  3051.   brush_sel_button = button = gtk_button_new_with_label ("Set Brush...");
  3052.   gtk_misc_set_padding (GTK_MISC (GTK_BIN (brush_sel_button)->child), 2, 0);
  3053.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  3054.               GTK_SIGNAL_FUNC (select_brush_callback),
  3055.               NULL);
  3056.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
  3057.                  NULL, 0, 0,
  3058.                  button, 1,  TRUE);
  3059.  
  3060.   /* Setup initial brush settings */
  3061.   bdesc->bpp   = 3;
  3062.   bdesc->bname = mygimp_brush_get ();
  3063.   brush_list_button_callback (NULL, bdesc);
  3064.  
  3065.   return vbox;
  3066. }
  3067.  
  3068. static void
  3069. select_menu_callback (GtkWidget *widget,
  3070.               gpointer   data)
  3071. {
  3072.   gint mtype = (gint) data;
  3073.  
  3074.   if (mtype == SELECT_TYPE_MENU)
  3075.     {
  3076.       SelectionType type = 
  3077.     (SelectionType) gtk_object_get_user_data (GTK_OBJECT (widget));
  3078.  
  3079.       selopt.type = type;
  3080.     }
  3081.   else if (mtype == SELECT_ARCTYPE_MENU)
  3082.     {
  3083.       ArcType type = 
  3084.     (ArcType) gtk_object_get_user_data (GTK_OBJECT (widget));
  3085.  
  3086.       selopt.as_pie = type;
  3087.     }
  3088.   else if (mtype == SELECT_TYPE_MENU_FILL)
  3089.     {
  3090.       FillType type =
  3091.     (FillType) gtk_object_get_user_data (GTK_OBJECT (widget));
  3092.  
  3093.       selopt.fill_type = type;
  3094.     }
  3095.   else if (mtype == SELECT_TYPE_MENU_WHEN)
  3096.     {
  3097.       FillWhen type = 
  3098.     (FillWhen) gtk_object_get_user_data (GTK_OBJECT (widget));
  3099.       selopt.fill_when = type;
  3100.     }
  3101. }
  3102.  
  3103. static GtkWidget *
  3104. select_page (void)
  3105. {
  3106.   GtkWidget *menu;
  3107.   GtkWidget *toggle;
  3108.   GtkWidget *scale;
  3109.   GtkObject *scale_data;
  3110.   GtkWidget *table;
  3111.   GtkWidget *vbox;
  3112.  
  3113.   vbox = gtk_vbox_new (FALSE, 0);
  3114.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  3115.  
  3116.   table = gtk_table_new (4, 4, FALSE); 
  3117.   gtk_table_set_row_spacings (GTK_TABLE (table), 4);
  3118.   gtk_table_set_col_spacings (GTK_TABLE (table), 2);
  3119.   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  3120.   gtk_widget_show (table);
  3121.  
  3122.   /* The secltion settings - 
  3123.    * 1) Type (option menu)
  3124.    * 2) Anti A (toggle)
  3125.    * 3) Feather (toggle)
  3126.    * 4) F radius (slider)
  3127.    * 5) Fill type (option menu) 
  3128.    * 6) Opacity (slider)
  3129.    * 7) When to fill (toggle)
  3130.    * 8) Arc as segment/sector 
  3131.    */
  3132.  
  3133.   /* 1 */
  3134.   menu = gimp_option_menu_new2 (FALSE, select_menu_callback,
  3135.                 (gpointer) SELECT_TYPE_MENU, 0,
  3136.  
  3137.                 _("Add"),       (gpointer) ADD, NULL,
  3138.                 _("Subtract"),  (gpointer) SUBTRACT, NULL,
  3139.                 _("Replace"),   (gpointer) REPLACE, NULL,
  3140.                 _("Intersect"), (gpointer) INTERSECT, NULL,
  3141.  
  3142.                 NULL);
  3143.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
  3144.                  _("Selection Type:"), 1.0, 0.5,
  3145.                  menu, 1, FALSE);
  3146.  
  3147.   /* 2 */
  3148.   toggle = gtk_check_button_new_with_label (_("Antialiasing"));
  3149.   gtk_table_attach (GTK_TABLE (table), toggle, 2, 4, 0, 1,
  3150.             GTK_FILL, GTK_FILL, 0, 0);
  3151.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  3152.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  3153.               &selopt.antia);
  3154.   gtk_widget_show (toggle); 
  3155.  
  3156.   /* 3 */
  3157.   toggle = gtk_check_button_new_with_label (_("Feather"));
  3158.   gtk_table_attach (GTK_TABLE (table), toggle, 2, 4, 2, 3,
  3159.             GTK_FILL, GTK_FILL, 0, 0);
  3160.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  3161.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  3162.               &selopt.feather);
  3163.   gtk_widget_show (toggle); 
  3164.  
  3165.   /* 4 */
  3166.   scale_data =
  3167.     gtk_adjustment_new (selopt.feather_radius, 0.0, 100.0, 1.0, 1.0, 0.0);
  3168.   scale = gtk_hscale_new (GTK_ADJUSTMENT (scale_data));
  3169.   gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
  3170.   gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
  3171.   gtk_signal_connect (GTK_OBJECT (scale_data), "value_changed",
  3172.                       GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  3173.                       &selopt.feather_radius);
  3174.   gimp_table_attach_aligned (GTK_TABLE (table), 2, 3,
  3175.                  _("Radius:"), 1.0, 1.0,
  3176.                  scale, 1, FALSE);
  3177.  
  3178.   /* 5 */
  3179.   menu =
  3180.     gimp_option_menu_new2 (FALSE, select_menu_callback,
  3181.                (gpointer) SELECT_TYPE_MENU_FILL, 0,
  3182.  
  3183.                _("Pattern"),    (gpointer) FILL_PATTERN, NULL,
  3184.                _("Foreground"), (gpointer) FILL_FOREGROUND, NULL,
  3185.                _("Background"), (gpointer) FILL_BACKGROUND, NULL,
  3186.  
  3187.                NULL);
  3188.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
  3189.                  _("Fill Type:"), 1.0, 0.5,
  3190.                  menu, 1, FALSE);
  3191.  
  3192.   /* 6 */
  3193.   scale_data =
  3194.     gtk_adjustment_new (selopt.fill_opacity, 0.0, 100.0, 1.0, 1.0, 0.0);
  3195.   scale = gtk_hscale_new (GTK_ADJUSTMENT (scale_data));
  3196.   gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
  3197.   gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
  3198.   gtk_signal_connect (GTK_OBJECT (scale_data), "value_changed",
  3199.                       GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
  3200.                       &selopt.fill_opacity);
  3201.   gimp_table_attach_aligned (GTK_TABLE (table), 2, 1,
  3202.                  _("Fill Opacity:"), 1.0, 1.0,
  3203.                  scale, 1, FALSE);
  3204.  
  3205.   /* 7 */
  3206.   menu =
  3207.     gimp_option_menu_new2 (FALSE, select_menu_callback,
  3208.                (gpointer) SELECT_TYPE_MENU_WHEN, 0,
  3209.  
  3210.                _("Each Selection"), (gpointer) FILL_EACH, NULL,
  3211.                _("All Selections"), (gpointer) FILL_AFTER, NULL,
  3212.  
  3213.                NULL);
  3214.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
  3215.                  _("Fill after:"), 1.0, 0.5,
  3216.                  menu, 1, FALSE);
  3217.  
  3218.   /* 8 */
  3219.   menu = gimp_option_menu_new2 (FALSE, select_menu_callback,
  3220.                 (gpointer) SELECT_ARCTYPE_MENU, 0,
  3221.  
  3222.                 _("Segment"), (gpointer) ARC_SEGMENT, NULL,
  3223.                 _("Sector"),  (gpointer) ARC_SECTOR, NULL,
  3224.  
  3225.                 NULL);
  3226.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 3,
  3227.                  _("Arc as:"), 1.0, 0.5,
  3228.                  menu, 1, FALSE);
  3229.  
  3230.   return vbox;
  3231. }
  3232.  
  3233. static void
  3234. gridtype_menu_callback (GtkWidget *widget,
  3235.             gpointer   data)
  3236. {
  3237.   gint mtype = (gint)data;
  3238.  
  3239.   if (mtype == GRID_TYPE_MENU)
  3240.     {
  3241. #ifdef DEBUG
  3242.       printf ("Gridtype set to ");
  3243.       if (current_obj->opts.gridtype == RECT_GRID)
  3244.     printf ("RECT_GRID\n");
  3245.       else if (current_obj->opts.gridtype == POLAR_GRID)
  3246.     printf ("POLAR_GRID\n");
  3247.       else if (current_obj->opts.gridtype == ISO_GRID)
  3248.     printf ("ISO_GRID\n");
  3249.       else printf ("NONE\n");
  3250. #endif /* DEBUG */
  3251.       selvals.opts.gridtype = (GridType)gtk_object_get_user_data (GTK_OBJECT (widget));
  3252.     }
  3253.   else
  3254.     {
  3255.       grid_gc_type = (gint) gtk_object_get_user_data (GTK_OBJECT (widget));
  3256.     }
  3257.  
  3258.   draw_grid_clear (widget, 0);
  3259. }
  3260.  
  3261. static GtkWidget *
  3262. options_page (void)
  3263. {
  3264.   GtkWidget *table;
  3265.   GtkWidget *menu;
  3266.   GtkWidget *toggle;
  3267.   GtkWidget *button;
  3268.   GtkWidget *vbox;
  3269.   GtkObject *size_data;
  3270.  
  3271.   vbox = gtk_vbox_new (FALSE, 0);
  3272.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  3273.  
  3274.   table = gtk_table_new (6, 3, FALSE);
  3275.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  3276.   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  3277.   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  3278.   gtk_widget_show (table);
  3279.  
  3280.   /* Put buttons in */
  3281.   toggle = gtk_check_button_new_with_label (_("Show Image"));
  3282.   gtk_table_attach (GTK_TABLE (table), toggle, 0, 1, 0, 1,
  3283.             GTK_FILL, GTK_FILL, 0, 0);
  3284.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  3285.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  3286.               &selvals.showimage);
  3287.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  3288.               (GtkSignalFunc) toggle_show_image,
  3289.               (gpointer) 1);
  3290.   gtk_widget_show (toggle);
  3291.  
  3292.   button = gtk_button_new_with_label (_("Reload Image"));
  3293.   gtk_misc_set_padding (GTK_MISC (GTK_BIN (button)->child), 2, 0);
  3294.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  3295.               GTK_SIGNAL_FUNC (reload_button_callback),
  3296.               NULL);
  3297.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
  3298.                  NULL, 0, 0,
  3299.                  button, 1, TRUE);
  3300.  
  3301.   menu = gimp_option_menu_new2 (FALSE, gridtype_menu_callback,
  3302.                 (gpointer) GRID_TYPE_MENU, 0,
  3303.  
  3304.                 _("Rectangle"), (gpointer) RECT_GRID, NULL,
  3305.                 _("Polar"),     (gpointer) POLAR_GRID, NULL,
  3306.                 _("Isometric"), (gpointer) ISO_GRID, NULL,
  3307.  
  3308.                 NULL);
  3309.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
  3310.                  _("Grid Type:"), 1.0, 0.5,
  3311.                  menu, 1, TRUE);
  3312.  
  3313.   gfig_opt_widget.gridtypemenu = menu;
  3314.  
  3315.   menu =
  3316.     gimp_option_menu_new2 (FALSE, gridtype_menu_callback,
  3317.                (gpointer) GRID_RENDER_MENU, 0,
  3318.  
  3319.                _("Normal"),     (gpointer) GTK_STATE_NORMAL, NULL,
  3320.                _("Black"),      (gpointer) GFIG_BLACK_GC, NULL,
  3321.                _("White"),      (gpointer) GFIG_WHITE_GC, NULL,
  3322.                _("Grey"),       (gpointer) GFIG_GREY_GC, NULL,
  3323.                _("Darker"),     (gpointer) GTK_STATE_ACTIVE, NULL,
  3324.                _("Lighter"),    (gpointer) GTK_STATE_PRELIGHT, NULL,
  3325.                _("Very Dark"),  (gpointer) GTK_STATE_SELECTED, NULL,
  3326.  
  3327.                NULL);
  3328.   gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
  3329.                  _("Grid Color:"), 1.0, 0.5,
  3330.                  menu, 1, TRUE);
  3331.  
  3332.   size_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 3,
  3333.                     _("Max Undo:"), 0, 50,
  3334.                     selvals.maxundo, MIN_UNDO, MAX_UNDO, 1, 2, 0,
  3335.                     TRUE, 0, 0,
  3336.                     NULL, NULL);
  3337.   gtk_signal_connect (GTK_OBJECT (size_data), "value_changed",
  3338.               GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
  3339.               &selvals.maxundo);
  3340.  
  3341.   toggle = gtk_check_button_new_with_label (_("Show Position"));
  3342.   gtk_table_attach (GTK_TABLE (table), toggle, 0, 1, 4, 5,
  3343.             GTK_FILL, GTK_FILL, 0, 0);
  3344.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  3345.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  3346.               &selvals.showpos);
  3347.   gtk_signal_connect_after (GTK_OBJECT (toggle), "toggled",
  3348.               (GtkSignalFunc) gfig_pos_enable,
  3349.               (gpointer) 1);
  3350.   gtk_widget_show (toggle); 
  3351.  
  3352.   toggle = gtk_check_button_new_with_label (_("Hide Control Points"));
  3353.   gtk_table_attach (GTK_TABLE (table), toggle, 1, 3, 4, 5,
  3354.             GTK_FILL, GTK_FILL, 0, 0);
  3355.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  3356.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  3357.               &selvals.opts.showcontrol);
  3358.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  3359.               GTK_SIGNAL_FUNC (toggle_show_image),
  3360.               (gpointer) 1);
  3361.   gtk_widget_show (toggle); 
  3362.   gfig_opt_widget.showcontrol = toggle;
  3363.  
  3364.   toggle = gtk_check_button_new_with_label (_("Show Tooltips"));
  3365.   gtk_table_attach (GTK_TABLE (table), toggle, 0, 1, 5, 6,
  3366.             GTK_FILL, GTK_FILL, 0, 0);
  3367.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  3368.               GTK_SIGNAL_FUNC (toggle_tooltips),
  3369.               &selvals.showtooltips);
  3370.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
  3371.                 selvals.showtooltips);
  3372.   gtk_widget_show (toggle); 
  3373.  
  3374.   button = gtk_button_new_with_label (_("About"));
  3375.   gtk_misc_set_padding (GTK_MISC (GTK_BIN (button)->child), 8, 0);
  3376.   gtk_table_attach (GTK_TABLE (table), button, 1, 3, 5, 6,
  3377.             0, 0, 0, 0);
  3378.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  3379.               GTK_SIGNAL_FUNC (about_button_callback),
  3380.               NULL);
  3381.   gtk_widget_show (button);
  3382.  
  3383.   return vbox;
  3384. }
  3385.  
  3386. static GtkWidget *
  3387. grid_frame (void)
  3388. {
  3389.   GtkWidget *frame;
  3390.   GtkWidget *vbox;
  3391.   GtkWidget *hbox;
  3392.   GtkWidget *table;
  3393.   GtkWidget *toggle;
  3394.   GtkObject *size_data;
  3395.  
  3396.   frame = gtk_frame_new (_("Grid"));
  3397.  
  3398.   vbox = gtk_vbox_new (FALSE, 2);
  3399.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
  3400.   gtk_container_add (GTK_CONTAINER (frame), vbox);
  3401.   gtk_widget_show (vbox);
  3402.  
  3403.   hbox = gtk_hbox_new (FALSE, 4);
  3404.   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); 
  3405.   gtk_widget_show (hbox);
  3406.  
  3407.   toggle = gtk_check_button_new_with_label (_("Snap to Grid"));
  3408.   gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0); 
  3409.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  3410.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  3411.               &selvals.opts.snap2grid);
  3412.   gtk_widget_show (toggle);
  3413.   gfig_opt_widget.snap2grid = toggle;
  3414.  
  3415.   toggle = gtk_check_button_new_with_label (_("Display Grid"));
  3416.   gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0); 
  3417.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  3418.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  3419.               &selvals.opts.drawgrid);
  3420.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  3421.               GTK_SIGNAL_FUNC (draw_grid_clear),
  3422.               (gpointer) 1);
  3423.   gtk_widget_show (toggle);
  3424.   gfig_opt_widget.drawgrid = toggle;
  3425.  
  3426.   toggle = gtk_check_button_new_with_label (_("Lock on Grid"));
  3427.   gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0); 
  3428.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  3429.               GTK_SIGNAL_FUNC (gimp_toggle_button_update),
  3430.               &selvals.opts.lockongrid);
  3431.   gtk_widget_show (toggle);
  3432.   gfig_opt_widget.lockongrid = toggle;
  3433.  
  3434.   table = gtk_table_new (1, 3, FALSE);
  3435.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  3436.   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  3437.   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); 
  3438.   gtk_widget_show (table);
  3439.  
  3440.   size_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
  3441.                     _("Grid Spacing:"), 0, 50,
  3442.                     selvals.opts.gridspacing,
  3443.                     MIN_GRID, MAX_GRID, 1, 10, 0,
  3444.                     TRUE, 0, 0,
  3445.                     NULL, NULL);
  3446.   gtk_signal_connect (GTK_OBJECT (size_data), "value_changed",
  3447.               GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
  3448.               &selvals.opts.gridspacing);
  3449.   gtk_signal_connect (GTK_OBJECT (size_data), "value_changed",
  3450.               GTK_SIGNAL_FUNC (draw_grid_clear),
  3451.               (gpointer) 0);
  3452.   gfig_opt_widget.gridspacing = size_data;
  3453.  
  3454.   gtk_widget_show (frame);
  3455.  
  3456.   return frame;
  3457. }
  3458.  
  3459. static void 
  3460. clear_list_items (GtkList *list)
  3461. {
  3462.   gtk_list_clear_items (list, 0, -1);
  3463. }
  3464.  
  3465. static void
  3466. build_list_items (GtkWidget *list)
  3467. {
  3468.   GList     *tmp;
  3469.   GtkWidget *list_item;
  3470.   GtkWidget *list_pix;
  3471.   GFigObj   *g;
  3472.  
  3473.   for (tmp = gfig_list; tmp; tmp = g_list_next (tmp))
  3474.     {
  3475.       g = tmp->data;
  3476.  
  3477.       if (g->obj_status & GFIG_READONLY)
  3478.     list_pix = gimp_pixmap_new (mini_cross_xpm);
  3479.       else
  3480.     list_pix = gimp_pixmap_new (blank_xpm);
  3481.  
  3482.       list_item =
  3483.     gfig_list_item_new_with_label_and_pixmap (g, g->draw_name, list_pix);
  3484.  
  3485.       gtk_object_set_user_data (GTK_OBJECT (list_item), (gpointer) g);
  3486.       gtk_list_append_items (GTK_LIST (list), g_list_append (NULL, list_item));
  3487.  
  3488.       gtk_signal_connect (GTK_OBJECT (list_item), "button_press_event",
  3489.               GTK_SIGNAL_FUNC (list_button_press),
  3490.               (gpointer) g);
  3491.       gtk_widget_show (list_item);
  3492.     }
  3493. }
  3494.  
  3495. static GtkWidget *
  3496. add_objects_list (void)
  3497. {
  3498.   GtkWidget *vbox;
  3499.   GtkWidget *table;
  3500.   GtkWidget *frame;
  3501.   GtkWidget *list_frame;
  3502.   GtkWidget *scrolled_win;
  3503.   GtkWidget *list;
  3504.   GtkWidget *button;
  3505.  
  3506.   frame = gtk_frame_new (_("Object"));
  3507.   gtk_widget_show (frame);
  3508.  
  3509.   table = gtk_table_new (4, 3, FALSE);
  3510.   gtk_table_set_col_spacings (GTK_TABLE (table), 2);
  3511.   gtk_container_set_border_width (GTK_CONTAINER (table), 2);
  3512.   gtk_widget_show (table);
  3513.  
  3514.   delete_frame_to_freeze = list_frame = gtk_frame_new (NULL);
  3515.   gtk_widget_show (list_frame);
  3516.  
  3517.   scrolled_win = gtk_scrolled_window_new (NULL, NULL);
  3518.   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
  3519.                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  3520.   gtk_container_add (GTK_CONTAINER (list_frame), scrolled_win);
  3521.   gtk_widget_show (scrolled_win);
  3522.  
  3523.   gfig_gtk_list = list = gtk_list_new ();
  3524.   /* gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_MULTIPLE); */
  3525.   gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
  3526.   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win),
  3527.                      list);
  3528.   gtk_widget_show (list);
  3529.  
  3530.   /* Load saved objects */
  3531.   gfig_list_load_all (gfig_path_list);
  3532.  
  3533.   /* Put list in */
  3534.   build_list_items (list);
  3535.  
  3536.   /* Put buttons in */
  3537.   button = gtk_button_new_with_label (_("Rescan"));
  3538.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  3539.               GTK_SIGNAL_FUNC (rescan_button_callback),
  3540.               NULL);
  3541.   gimp_help_set_help_data (button,
  3542.             _("Select directory and rescan Gfig object "
  3543.               "collection"), NULL); 
  3544.   gtk_table_attach (GTK_TABLE (table), button, 2, 3, 0, 1,
  3545.             GTK_FILL, GTK_FILL, 0, 0);
  3546.   gtk_widget_show (button);
  3547.  
  3548.   button = gtk_button_new_with_label (_("Load"));
  3549.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  3550.               GTK_SIGNAL_FUNC (load_button_callback),
  3551.               list);
  3552.   gimp_help_set_help_data (button,
  3553.                _("Load a single Gfig object collection"), NULL); 
  3554.   gtk_table_attach (GTK_TABLE (table), button, 2, 3, 1, 2,
  3555.             GTK_FILL, GTK_FILL, 0, 0);
  3556.   gtk_widget_show (button);
  3557.  
  3558.   button = gtk_button_new_with_label (_("New"));
  3559.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  3560.               GTK_SIGNAL_FUNC (new_button_callback),
  3561.               "New gfig obj");
  3562.   gimp_help_set_help_data (button, _("Create a new Gfig object collection "
  3563.                      "for editing"), NULL); 
  3564.   gtk_table_attach (GTK_TABLE (table), button, 2, 3, 2, 3,
  3565.             GTK_FILL, GTK_FILL, 0, 0);
  3566.   gtk_widget_show (button);
  3567.  
  3568.   button = gtk_button_new_with_label (_("Delete"));
  3569.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  3570.               GTK_SIGNAL_FUNC (gfig_delete_gfig_callback),
  3571.               (gpointer) list);
  3572.   gimp_help_set_help_data (button, _("Delete currently selected Gfig Object "
  3573.                      "collection"), NULL); 
  3574.   gtk_table_attach (GTK_TABLE (table), button, 2, 3, 3, 4,
  3575.             GTK_FILL, GTK_FILL, 0, 0);
  3576.   gtk_widget_show (button);
  3577.  
  3578.   /* Attach the frame for the list Show the widgets */
  3579.  
  3580.   gtk_table_attach (GTK_TABLE (table), list_frame, 1, 2, 0, 4,
  3581.             GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0);
  3582.  
  3583.   vbox = small_preview (list);
  3584.   gtk_table_attach (GTK_TABLE (table), vbox, 0, 1, 0, 4, 0, 0, 0, 0);
  3585.  
  3586.   gtk_container_add (GTK_CONTAINER (frame), table);
  3587.  
  3588.   return frame;
  3589. }
  3590.  
  3591. static gint x_pos_val;
  3592. static gint y_pos_val;
  3593. static gint pos_tag = -1;
  3594.  
  3595. static void
  3596. gfig_pos_enable (GtkWidget *widget,
  3597.          gpointer   data)
  3598. {
  3599.   gint enable = selvals.showpos;
  3600.   gtk_widget_set_sensitive (GTK_WIDGET (pos_label), enable);
  3601. }
  3602.  
  3603. static void
  3604. gfig_pos_update_labels (gpointer data)
  3605. {
  3606.   static gchar buf[256];
  3607.  
  3608.   /*gtk_idle_remove (pos_tag);*/
  3609.   pos_tag = -1;
  3610.  
  3611.   g_snprintf (buf, sizeof (buf), "%d, %d", x_pos_val, y_pos_val);
  3612.   gtk_label_set_text (GTK_LABEL (pos_label), buf);
  3613. }
  3614.  
  3615. static void
  3616. gfig_pos_update (gint x,
  3617.          gint y)
  3618. {
  3619.   gint update;
  3620.  
  3621.   if (x_pos_val != x || y_pos_val != y)
  3622.     update = 1;
  3623.   else
  3624.     update = 0;
  3625.  
  3626.   x_pos_val = x;
  3627.   y_pos_val = y;
  3628.  
  3629.   if (update && pos_tag == -1 && selvals.showpos)
  3630.     {
  3631.       /*pos_tag = gtk_idle_add ((GtkFunction)gfig_pos_update_labels, NULL);*/
  3632.       gfig_pos_update_labels (NULL);
  3633.     }
  3634. }
  3635.  
  3636. #if 0 /* NOT USED */
  3637. static void
  3638. gfig_obj_size_update (gint sz)
  3639. {
  3640.   static gchar buf[256];
  3641.   
  3642.   sprintf (buf, "%6d", sz);
  3643.   gtk_label_set_text (GTK_LABEL (obj_size_label), buf);
  3644. }  
  3645.  
  3646. static GtkWidget *
  3647. gfig_obj_size_label (void)
  3648. {
  3649.   GtkWidget *label;
  3650.   GtkWidget *hbox;
  3651.   gchar buf[256];
  3652.  
  3653.   hbox = gtk_hbox_new (TRUE, 6);
  3654.  
  3655.   /* Position labels */
  3656.   label = gtk_label_new ("Size: ");
  3657.   gtk_widget_show (label);
  3658.   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
  3659.  
  3660.   obj_size_label = gtk_label_new ("");
  3661.   gtk_misc_set_alignment (GTK_MISC (obj_size_label), 0.5, 0.5);    
  3662.   gtk_widget_show (obj_size_label);
  3663.   gtk_box_pack_start (GTK_BOX (hbox), obj_size_label, FALSE, FALSE, 0);
  3664.  
  3665.   gtk_widget_show (hbox);
  3666.  
  3667.   sprintf (buf, "%6d", 0);
  3668.   gtk_label_set_text (GTK_LABEL (obj_size_label), buf);
  3669.  
  3670.   return (hbox);
  3671. }
  3672.  
  3673. #endif /* NOT USED */
  3674.  
  3675. static GtkWidget *
  3676. gfig_pos_labels (void)
  3677. {
  3678.   GtkWidget *label;
  3679.   GtkWidget *hbox;
  3680.   gchar      buf[256];
  3681.  
  3682.   hbox = gtk_hbox_new (FALSE, 6);
  3683.   gtk_widget_show (hbox);
  3684.  
  3685.   /* Position labels */
  3686.   label = gtk_label_new (_("XY Position:"));
  3687.   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
  3688.   gtk_widget_show (label);
  3689.  
  3690.   pos_label = gtk_label_new ("");
  3691.   gtk_box_pack_start (GTK_BOX (hbox), pos_label, FALSE, FALSE, 0);
  3692.   gtk_widget_show (pos_label);
  3693.  
  3694.   g_snprintf (buf, sizeof (buf), "%d, %d", 0, 0);
  3695.   gtk_label_set_text (GTK_LABEL (pos_label), buf);
  3696.  
  3697.   return hbox;
  3698. }
  3699.  
  3700. static GtkWidget *
  3701. make_pos_info (void)
  3702. {
  3703.   GtkWidget *xframe;
  3704.   GtkWidget *hbox;
  3705.   GtkWidget *label;
  3706.  
  3707.   xframe = gtk_frame_new (_("Object Details"));
  3708.  
  3709.   hbox = gtk_hbox_new (TRUE, 6);
  3710.   gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
  3711.   gtk_container_add (GTK_CONTAINER (xframe), hbox);  
  3712.  
  3713.   /* Add labels */
  3714.   label = gfig_pos_labels ();
  3715.   gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
  3716.   gfig_pos_enable (NULL, NULL);
  3717.  
  3718. #if 0
  3719.   label = gfig_obj_size_label ();
  3720.   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
  3721. #endif /* 0 */
  3722.  
  3723.   gtk_widget_show (hbox);
  3724.   gtk_widget_show (xframe);
  3725.  
  3726.   return xframe;
  3727. }
  3728.  
  3729. static GtkWidget *
  3730. make_status (void)
  3731. {
  3732.   GtkWidget *xframe;
  3733.   GtkWidget *table;
  3734.   GtkWidget *label;
  3735.  
  3736.   xframe = gtk_frame_new (_("Collection Details"));
  3737.  
  3738.   gtk_frame_set_shadow_type (GTK_FRAME (xframe), GTK_SHADOW_ETCHED_IN);
  3739.   table = gtk_table_new (6, 6, FALSE);
  3740.   gtk_table_set_col_spacing (GTK_TABLE (table), 1, 6);
  3741.   gtk_container_set_border_width (GTK_CONTAINER (table), 2);
  3742.  
  3743.   label = gtk_label_new (_("Draw Name:"));
  3744.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
  3745.   gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1,
  3746.             GTK_FILL, GTK_FILL, 0, 0);
  3747.   gtk_widget_show (label);
  3748.  
  3749.   label = gtk_label_new (_("Filename:"));
  3750.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
  3751.   gtk_table_attach (GTK_TABLE (table), label, 1, 2, 1, 2,
  3752.             GTK_FILL, GTK_FILL, 0, 0);
  3753.   gtk_widget_show (label);
  3754.  
  3755.   status_label_dname = gtk_label_new (_("(none)"));
  3756.   gtk_misc_set_alignment (GTK_MISC (status_label_dname), 0.0, 0.5);
  3757.   gtk_table_attach (GTK_TABLE (table), status_label_dname, 2, 4, 0, 1,
  3758.             GTK_FILL | GTK_EXPAND, 0, 0, 0);
  3759.   gtk_widget_show (status_label_dname);
  3760.  
  3761.   status_label_fname = gtk_label_new (_("(none)"));
  3762.   gtk_misc_set_alignment (GTK_MISC (status_label_fname), 0.0, 0.5);
  3763.   gtk_table_attach (GTK_TABLE (table), status_label_fname, 2, 4, 1, 2,
  3764.             GTK_FILL | GTK_EXPAND, 0, 0, 0);
  3765.   gtk_widget_show (status_label_fname);
  3766.  
  3767.   gtk_container_add (GTK_CONTAINER (xframe), table);  
  3768.  
  3769.   gtk_widget_show (table);
  3770.   gtk_widget_show (xframe);
  3771.  
  3772.   return xframe;
  3773. }
  3774.  
  3775. static GtkWidget *
  3776. make_preview (void)
  3777. {
  3778.   GtkWidget *xframe;
  3779.   GtkWidget *vbox;
  3780.   GtkWidget *hbox;
  3781.   GtkWidget *table;
  3782.   GtkWidget *ruler;
  3783.   
  3784.   gfig_preview = gtk_preview_new (GTK_PREVIEW_COLOR);
  3785.   gtk_widget_set_events (GTK_WIDGET (gfig_preview), PREVIEW_MASK);
  3786.   gfig_preview_exp_id = 
  3787.     gtk_signal_connect_after (GTK_OBJECT (gfig_preview), "expose_event",
  3788.                   GTK_SIGNAL_FUNC (gfig_preview_expose),
  3789.                   NULL);
  3790.  
  3791.   gtk_signal_connect (GTK_OBJECT (gfig_preview), "event",
  3792.               GTK_SIGNAL_FUNC (gfig_preview_events),
  3793.               NULL);
  3794.  
  3795.   gtk_preview_size (GTK_PREVIEW (gfig_preview), preview_width, preview_height);
  3796.  
  3797.   xframe = gtk_frame_new (NULL);
  3798.  
  3799.   gtk_frame_set_shadow_type (GTK_FRAME (xframe), GTK_SHADOW_IN);
  3800.  
  3801.   table = gtk_table_new (3, 3, FALSE);
  3802.   gtk_table_attach (GTK_TABLE (table), gfig_preview, 1, 2, 1, 2,
  3803.             GTK_FILL , GTK_FILL , 0, 0);
  3804.   gtk_container_add (GTK_CONTAINER (xframe), table); 
  3805.  
  3806.   ruler = gtk_hruler_new ();
  3807.   gtk_ruler_set_range (GTK_RULER (ruler), 0, preview_width, 0, PREVIEW_SIZE);
  3808.   gtk_signal_connect_object (GTK_OBJECT (gfig_preview), "motion_notify_event",
  3809.                  (GtkSignalFunc) GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event,
  3810.                  GTK_OBJECT (ruler));
  3811.   gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
  3812.             GTK_FILL, GTK_FILL, 0, 0);
  3813.   gtk_widget_show (ruler);
  3814.  
  3815.   ruler = gtk_vruler_new ();
  3816.   gtk_ruler_set_range (GTK_RULER (ruler), 0, preview_height, 0, PREVIEW_SIZE);
  3817.   gtk_signal_connect_object (GTK_OBJECT (gfig_preview), "motion_notify_event",
  3818.                  (GtkSignalFunc) GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event,
  3819.                  GTK_OBJECT (ruler));
  3820.   gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
  3821.             GTK_FILL, GTK_FILL, 0, 0);
  3822.   gtk_widget_show (ruler);
  3823.  
  3824.   gtk_widget_show (xframe);
  3825.   gtk_widget_show (table);
  3826.  
  3827.   vbox = gtk_vbox_new (FALSE, 0);
  3828.   hbox = gtk_hbox_new (FALSE, 0);
  3829.   gtk_box_pack_start (GTK_BOX (hbox), xframe, FALSE, FALSE, 0);
  3830.  
  3831.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
  3832.   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  3833.  
  3834.   xframe = make_pos_info ();
  3835.   gtk_box_pack_start (GTK_BOX (vbox), xframe, TRUE, TRUE, 0);
  3836.  
  3837.   xframe = make_status ();
  3838.   gtk_box_pack_start (GTK_BOX (vbox), xframe, TRUE, TRUE, 0);
  3839.  
  3840.   gtk_widget_show (vbox);
  3841.   gtk_widget_show (hbox);
  3842.  
  3843.   return vbox;
  3844. }
  3845.  
  3846. #if 0
  3847. scatch ()
  3848. {
  3849.  
  3850.   pause ();
  3851.  
  3852. }
  3853. #endif /* 0 */
  3854.  
  3855. static void
  3856. gfig_grid_colours (GtkWidget   *widget,
  3857.            GdkColormap *cmap)
  3858. {
  3859.   GdkGCValues values;
  3860.   GdkColor new_col1;
  3861.   GdkColor new_col2;
  3862.   guchar stipple[8] =
  3863.   {
  3864.     0xAA,    /*  ####----  */
  3865.     0x55,    /*  ###----#  */
  3866.     0xAA,    /*  ##----##  */
  3867.     0x55,    /*  #----###  */
  3868.     0xAA,    /*  ----####  */
  3869.     0x55,    /*  ---####-  */
  3870.     0xAA,    /*  --####--  */
  3871.     0x55,    /*  -####---  */
  3872.   };
  3873.  
  3874.   gdk_color_parse ("gray50", &new_col1);
  3875.   gdk_color_alloc (xxx, &new_col1);
  3876.   gdk_color_parse ("gray80", &new_col2);
  3877.   gdk_color_alloc (xxx, &new_col2);
  3878.   values.background.pixel = new_col1.pixel;
  3879.   values.foreground.pixel = new_col2.pixel;
  3880.   values.fill    = GDK_OPAQUE_STIPPLED;
  3881.   values.stipple = gdk_bitmap_create_from_data (widget->window,
  3882.                         (gchar *) stipple,
  3883.                         4, 4);
  3884.   grid_hightlight_drawgc = gdk_gc_new_with_values (widget->window,
  3885.                            &values,
  3886.                            GDK_GC_FOREGROUND |
  3887.                            GDK_GC_BACKGROUND |
  3888.                            GDK_GC_FILL |
  3889.                            GDK_GC_STIPPLE);
  3890. }
  3891.  
  3892.  
  3893. static gint
  3894. gfig_dialog (void)
  3895. {
  3896.   GtkWidget *main_hbox;
  3897.   GtkWidget *frame;
  3898.   GtkWidget *vbox;
  3899.   GtkWidget *xframe;
  3900.   GtkWidget *oframe;
  3901.   GtkWidget *notebook;
  3902.   GtkWidget *page;
  3903.   GtkWidget *top_level_dlg;
  3904.  
  3905.   gimp_ui_init ("gfig", TRUE);
  3906.  
  3907.   yyy = gdk_rgb_get_visual ();
  3908.   xxx = gdk_rgb_get_cmap ();
  3909.  
  3910.   plug_in_parse_gfig_path ();
  3911.  
  3912.   /*cache_preview (); Get the preview image and store it also set has_alpha */
  3913.  
  3914.   img_width  = gimp_drawable_width (gfig_select_drawable->id);
  3915.   img_height = gimp_drawable_height (gfig_select_drawable->id);
  3916.  
  3917.   /* Start buildng the dialog up */
  3918.   top_level_dlg = gimp_dialog_new (_("GFig"), "gfig",
  3919.                    gimp_standard_help_func, "filters/gfig.html",
  3920.                    GTK_WIN_POS_MOUSE,
  3921.                    FALSE, FALSE, FALSE,
  3922.  
  3923.                    _("Done"), gfig_ok_callback,
  3924.                    NULL, NULL, NULL, TRUE, FALSE,
  3925.                    _("Paint"), gfig_paint_callback,
  3926.                    NULL, NULL, NULL, FALSE, FALSE,
  3927.                    _("Save"), save_button_callback,
  3928.                    NULL, NULL, &save_button, FALSE, FALSE,
  3929.                    _("Clear"), gfig_clear_callback,
  3930.                    NULL, NULL, NULL, FALSE, FALSE,
  3931.                    _("Undo"), gfig_undo_callback,
  3932.                    NULL, NULL, &undo_widget, FALSE, FALSE,
  3933.                    _("Cancel"), gtk_widget_destroy,
  3934.                    NULL, 1, NULL, FALSE, TRUE,
  3935.  
  3936.                    NULL);
  3937.  
  3938.   gtk_signal_connect (GTK_OBJECT (top_level_dlg), "destroy",
  3939.               GTK_SIGNAL_FUNC (gtk_main_quit),
  3940.               NULL);
  3941.  
  3942.   /* Tooltips bis */
  3943.   gimp_help_init ();
  3944.  
  3945.   main_hbox = gtk_hbox_new (FALSE, 4);
  3946.   gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 4);
  3947.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (top_level_dlg)->vbox), main_hbox,
  3948.               TRUE, TRUE, 0);
  3949.  
  3950.   /* Add buttons beside the preview frame */
  3951.   xframe = draw_buttons (top_level_dlg);
  3952.   gtk_box_pack_start (GTK_BOX (main_hbox), xframe, FALSE, FALSE, 0);
  3953.   /*gtk_widget_show (xframe);*/
  3954.  
  3955.   /* Start building the frame for the preview area */
  3956.   frame = gtk_frame_new (_("Preview"));
  3957.   gtk_box_pack_start (GTK_BOX (main_hbox), frame, FALSE, FALSE, 0);
  3958.   gtk_widget_show (frame); 
  3959.  
  3960.   /* Preview itself */
  3961.   xframe = make_preview ();
  3962.   gtk_container_add (GTK_CONTAINER (frame), xframe);
  3963.   /* gtk_widget_show (xframe); */
  3964.  
  3965.   gtk_widget_show (gfig_preview);
  3966.  
  3967.   frame = gtk_frame_new (_("Settings"));
  3968.   gtk_box_pack_start (GTK_BOX (main_hbox), frame, FALSE, FALSE, 0);
  3969.   gtk_widget_show (frame); 
  3970.  
  3971.   vbox = gtk_vbox_new (FALSE, 2);
  3972.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
  3973.   gtk_container_add (GTK_CONTAINER (frame), vbox);
  3974.   gtk_widget_show (vbox);
  3975.  
  3976.   /* listbox + entry */
  3977.   oframe = add_objects_list ();
  3978.   gtk_box_pack_start (GTK_BOX (vbox), oframe, FALSE, FALSE, 0);
  3979.  
  3980.   /* Grid entry */
  3981.   xframe = grid_frame ();
  3982.   gtk_box_pack_start (GTK_BOX (vbox), xframe, FALSE, FALSE, 0);
  3983.  
  3984.   /* The notebook */
  3985.   notebook = gtk_notebook_new ();
  3986.   gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
  3987.   gtk_box_pack_start (GTK_BOX (vbox), notebook, FALSE, FALSE, 0);
  3988.   gtk_widget_show (notebook);
  3989.   
  3990.   page = paint_page ();
  3991.   gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page,
  3992.                 gtk_label_new (_("Paint")));
  3993.   gtk_widget_show (page);
  3994.  
  3995.   brush_page_widget = brush_page ();
  3996.   gtk_notebook_append_page (GTK_NOTEBOOK (notebook), brush_page_widget,
  3997.                 gtk_label_new (_("Brush")));
  3998.   gtk_widget_show (brush_page_widget);
  3999.  
  4000.   /* Sometime maybe allow all objects to be done by selections - this
  4001.    * would adjust the selection options.
  4002.    */
  4003.   select_page_widget = select_page ();
  4004.   gtk_notebook_append_page (GTK_NOTEBOOK (notebook), select_page_widget,
  4005.                 gtk_label_new (_("Select")));
  4006.   gtk_widget_set_sensitive (select_page_widget, FALSE);
  4007.  
  4008.   page = options_page ();
  4009.   gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page,
  4010.                 gtk_label_new (_("Options")));
  4011.   gtk_widget_show (page);
  4012.  
  4013.   gtk_widget_show (main_hbox);
  4014.  
  4015.   gtk_widget_show (top_level_dlg);
  4016.  
  4017.   dialog_update_preview ();
  4018.   gfig_new_gc (); /* Need this for drawing */
  4019.   gfig_update_stat_labels ();
  4020.  
  4021.   gfig_grid_colours (gfig_preview, xxx);
  4022.   /* Popup for list area */
  4023.   gfig_op_menu_create (top_level_dlg);
  4024.  
  4025.   /* signal (11, scatch); For debugging */
  4026.  
  4027.   gtk_main ();
  4028.  
  4029.   gimp_image_delete (brush_image_ID);
  4030.   brush_image_ID = -1;
  4031.  
  4032.   gimp_help_free ();
  4033.  
  4034.   gdk_flush ();
  4035.  
  4036.   return gfig_run;
  4037. }
  4038.  
  4039. static void
  4040. gfig_really_ok_callback (GtkWidget *widget,
  4041.              gboolean   doit,
  4042.              gpointer   data)
  4043. {
  4044.   if (doit)
  4045.     {
  4046.       gfig_run = TRUE;
  4047.       gtk_widget_destroy (GTK_WIDGET (data));
  4048.     }
  4049. }
  4050.  
  4051. static void
  4052. gfig_ok_callback (GtkWidget *widget,
  4053.           gpointer   data)
  4054. {
  4055.   /* Check if outstanding saves */
  4056.   GList   *list;
  4057.   GFigObj *gfig;
  4058.   gint     count = 0;
  4059.  
  4060.   for (list = gfig_list; list; list = g_list_next (list))
  4061.     {
  4062.       gfig = (GFigObj *) list->data;
  4063.       if (gfig->obj_status & GFIG_MODIFIED)
  4064.     count++;
  4065.     }
  4066.  
  4067.   if (count)
  4068.     {
  4069.       GtkWidget *dialog;
  4070.       gchar     *message;
  4071.  
  4072.       message =
  4073.     g_strdup_printf (_("%d unsaved Gfig objects.\nContinue with exiting?"), count);
  4074.  
  4075.       dialog = gimp_query_boolean_box (_("Warning"),
  4076.                        gimp_standard_help_func,
  4077.                        "filters/gfig.html",
  4078.                        FALSE,
  4079.                        message,
  4080.                        _("OK"), _("Cancel"),
  4081.                        NULL, NULL,
  4082.                        gfig_really_ok_callback,
  4083.                        data);
  4084.       g_free (message);
  4085.  
  4086.       gtk_widget_show (dialog);
  4087.     }
  4088.   else
  4089.     {
  4090.       gfig_run = TRUE;
  4091.       gtk_widget_destroy (GTK_WIDGET (data));
  4092.     }
  4093. }
  4094.  
  4095. /* Update the bits we put on the screen */
  4096. static void
  4097. update_draw_area (GtkWidget *widget,
  4098.           GdkEvent  *event)
  4099. {
  4100.   if (!GTK_WIDGET_DRAWABLE (widget))
  4101.     return;
  4102.  
  4103.   gtk_signal_handler_block (GTK_OBJECT (widget), gfig_preview_exp_id);
  4104.   gtk_widget_draw (widget, NULL);
  4105.   gtk_signal_handler_unblock (GTK_OBJECT (widget), gfig_preview_exp_id);
  4106.  
  4107.   draw_grid (widget, 0);
  4108.   draw_objects (current_obj->obj_list, TRUE);
  4109. }
  4110.  
  4111. static gint
  4112. gfig_preview_expose (GtkWidget *widget,
  4113.              GdkEvent  *event)
  4114. {
  4115.   GdkCursor *preview_cursor;
  4116.   static gint changed_cursor = 0;
  4117.  
  4118.   if (!changed_cursor && gfig_preview->window)
  4119.     {
  4120.       changed_cursor = 1;
  4121.       preview_cursor = gdk_cursor_new (GDK_CROSSHAIR);
  4122.       gdk_window_set_cursor (gfig_preview->window, preview_cursor);
  4123.     }
  4124.   update_draw_area (widget, event);
  4125.   return FALSE;
  4126. }
  4127.  
  4128. static gint
  4129. pic_preview_expose (GtkWidget *widget,
  4130.             GdkEvent  *event)
  4131. {
  4132.   if (pic_obj)
  4133.     {
  4134.       drawing_pic = TRUE;
  4135.       draw_objects (pic_obj->obj_list, FALSE);
  4136.       drawing_pic = FALSE;
  4137.     }
  4138.   return FALSE;
  4139. }
  4140.  
  4141. static gint
  4142. adjust_pic_coords (gint coord,
  4143.            gint ratio)
  4144. {
  4145.   /*return ((SMALL_PREVIEW_SZ * coord)/PREVIEW_SIZE);*/
  4146.   static gint pratio = -1;
  4147.  
  4148.   if (pratio == -1)
  4149.     {
  4150.       pratio = MAX (preview_width, preview_height);
  4151.     }
  4152.  
  4153.   return (SMALL_PREVIEW_SZ * coord) / pratio;
  4154. }
  4155.  
  4156. static gint
  4157. gfig_preview_events (GtkWidget *widget,
  4158.              GdkEvent  *event)
  4159. {
  4160.   GdkEventButton *bevent;
  4161.   GdkEventMotion *mevent;
  4162.   GdkPoint point;
  4163.   static gint tmp_show_single = 0;
  4164.  
  4165.   switch (event->type)
  4166.     {
  4167.     case GDK_EXPOSE:
  4168.       break;
  4169.  
  4170.     case GDK_BUTTON_PRESS:
  4171.       bevent = (GdkEventButton *) event;
  4172.       point.x = bevent->x;
  4173.       point.y = bevent->y;
  4174.  
  4175.       g_assert (need_to_scale == 0); /* If not out of step some how */
  4176.  
  4177.       /* Start drawing of object */
  4178.       if (selvals.otype >= MOVE_OBJ)
  4179.     {
  4180.       if (!selvals.scaletoimage)
  4181.         {
  4182.           point.x = gfig_invscale_x (point.x);
  4183.           point.y = gfig_invscale_y (point.y);
  4184.         }
  4185.       object_operation_start (&point, bevent->state & GDK_SHIFT_MASK);
  4186.  
  4187.       /* If constraining save start pnt */
  4188.       if (selvals.opts.snap2grid)
  4189.         {
  4190.           /* Save point to constained point ... if button 3 down */
  4191.           if (bevent->button == 3)
  4192.         {
  4193.           find_grid_pos (&point, &point, FALSE);
  4194.         }
  4195.         }
  4196.     }
  4197.       else
  4198.     {
  4199.       if (selvals.opts.snap2grid)
  4200.         {
  4201.           if (bevent->button == 3)
  4202.         {
  4203.           find_grid_pos (&point, &point, FALSE);
  4204.         }
  4205.           else
  4206.         {
  4207.           find_grid_pos (&point, &point, FALSE);
  4208.         }
  4209.         }
  4210.       object_start (&point, bevent->state & GDK_SHIFT_MASK);
  4211.     }
  4212.  
  4213.       break;
  4214.     case GDK_BUTTON_RELEASE:
  4215.       bevent = (GdkEventButton *) event;
  4216.       point.x = bevent->x;
  4217.       point.y = bevent->y;
  4218.  
  4219.       if (selvals.opts.snap2grid)
  4220.     find_grid_pos (&point, &point, bevent->button == 3);
  4221.  
  4222.       /* Still got shift down ?*/
  4223.       if (selvals.otype >= MOVE_OBJ)
  4224.     {
  4225.       if (!selvals.scaletoimage)
  4226.         {
  4227.           point.x = gfig_invscale_x (point.x);
  4228.           point.y = gfig_invscale_y (point.y);
  4229.         }
  4230.       object_operation_end (&point, bevent->state & GDK_SHIFT_MASK);
  4231.     }
  4232.       else
  4233.     {
  4234.       if (obj_creating)
  4235.         {
  4236.           object_end (&point, bevent->state & GDK_SHIFT_MASK);
  4237.         }
  4238.       else
  4239.         break;
  4240.     }
  4241.  
  4242.       /* make small preview reflect changes ?*/
  4243.       list_button_update (current_obj);
  4244.       break;
  4245.     case GDK_MOTION_NOTIFY:
  4246.  
  4247.       mevent = (GdkEventMotion *) event;
  4248.       point.x = mevent->x;
  4249.       point.y = mevent->y;
  4250.  
  4251.       if (selvals.opts.snap2grid)
  4252.     find_grid_pos (&point, &point, mevent->state & GDK_BUTTON3_MASK);
  4253.  
  4254.       if (selvals.otype >= MOVE_OBJ)
  4255.     {
  4256.       /* Moving objects around */
  4257.       if (!selvals.scaletoimage)
  4258.         {
  4259.           point.x = gfig_invscale_x (point.x);
  4260.           point.y = gfig_invscale_y (point.y);
  4261.         }
  4262.       object_operation (&point, mevent->state & GDK_SHIFT_MASK);
  4263.       gfig_pos_update (point.x, point.y);
  4264.       return FALSE;
  4265.     }
  4266.  
  4267.       if (obj_creating)
  4268.     {
  4269.       object_update (&point);
  4270.     }
  4271.       gfig_pos_update (point.x, point.y);
  4272.       break;
  4273.     case GDK_KEY_PRESS:
  4274.       if ((tmp_show_single = obj_show_single) != -1)
  4275.     {
  4276.       obj_show_single = -1;
  4277.       draw_grid_clear (NULL, NULL); /*Args not used */
  4278.     }
  4279.       break;
  4280.     case GDK_KEY_RELEASE:
  4281.       if (tmp_show_single != -1)
  4282.     {
  4283.       obj_show_single = tmp_show_single;
  4284.       draw_grid_clear (NULL, NULL); /*Args not used */
  4285.     }
  4286.       break;
  4287.     default:
  4288.       break;
  4289.     }
  4290.   return FALSE;
  4291. }
  4292.  
  4293.  
  4294. /*
  4295.  *  The edit gfig name attributes dialog
  4296.  *  Modified from Gimp source - layer edit.
  4297.  */
  4298.  
  4299. typedef struct _GfigListOptions
  4300. {
  4301.   GtkWidget *query_box;
  4302.   GtkWidget *name_entry;
  4303.   GtkWidget *list_entry;
  4304.   GFigObj   *obj;
  4305.   gint       created;
  4306. } GfigListOptions;
  4307.  
  4308. static GtkWidget *
  4309. gfig_list_add (GFigObj *obj)
  4310. {
  4311.   GList     *list;
  4312.   gint       pos;
  4313.   GtkWidget *list_item;
  4314.   GtkWidget *list_pix;
  4315.  
  4316.   list_pix  = gimp_pixmap_new (Floppy6_xpm);
  4317.   list_item =
  4318.     gfig_list_item_new_with_label_and_pixmap (obj, obj->draw_name, list_pix);
  4319.  
  4320.   gtk_object_set_user_data (GTK_OBJECT (list_item), (gpointer) obj);
  4321.  
  4322.   pos = gfig_list_insert (obj);
  4323.  
  4324.   list = g_list_append (NULL, list_item);
  4325.   gtk_list_insert_items (GTK_LIST (gfig_gtk_list), list, pos);
  4326.   gtk_widget_show (list_item);
  4327.   gtk_list_select_item (GTK_LIST (gfig_gtk_list), pos);  
  4328.  
  4329.   gtk_signal_connect (GTK_OBJECT (list_item), "button_press_event",
  4330.               GTK_SIGNAL_FUNC (list_button_press),
  4331.               (gpointer) obj);
  4332.  
  4333.   return list_item;
  4334. }
  4335.  
  4336. static void
  4337. gfig_list_ok_callback (GtkWidget *widget,
  4338.                gpointer   data)
  4339. {
  4340.   GfigListOptions *options;
  4341.   GtkWidget *list;
  4342.   gint pos;
  4343.  
  4344.   options = (GfigListOptions *) data;
  4345.   list = options->list_entry;
  4346.  
  4347.   /*  Set the new layer name  */
  4348. #ifdef DEBUG
  4349.   printf ("Found obj %s\n", options->obj->draw_name);
  4350. #endif /* DEBUG */
  4351.   if (options->obj->draw_name)
  4352.     {
  4353.       g_free (options->obj->draw_name);
  4354.     }
  4355.   options->obj->draw_name =
  4356.     g_strdup (gtk_entry_get_text (GTK_ENTRY (options->name_entry)));
  4357. #ifdef DEBUG
  4358.   printf ("NEW name %s\n", options->obj->draw_name);
  4359. #endif /* DEBUG */
  4360.  
  4361.   /* Need to reorder the list */
  4362. /* gtk_label_set_text (GTK_LABEL (options->layer_widget->label), layer->name);*/
  4363.  
  4364.   pos = gtk_list_child_position (GTK_LIST (gfig_gtk_list), list);
  4365. #ifdef DEBUG
  4366.   printf ("pos = %d\n", pos);
  4367. #endif /* DEBUG */
  4368.  
  4369.   gtk_list_clear_items (GTK_LIST (gfig_gtk_list), pos, pos + 1);
  4370.  
  4371.   /* remove/Add again */
  4372.   gfig_list = g_list_remove (gfig_list, options->obj);
  4373.   gfig_list_add (options->obj);
  4374.  
  4375.   options->obj->obj_status |= GFIG_MODIFIED;
  4376.  
  4377.   gtk_widget_destroy (options->query_box);
  4378.   g_free (options);
  4379.  
  4380.   gfig_update_stat_labels ();
  4381. }
  4382.  
  4383. static void
  4384. gfig_list_cancel_callback (GtkWidget *widget,
  4385.                gpointer   data)
  4386. {
  4387.   GfigListOptions *options;
  4388.  
  4389.   options = (GfigListOptions *) data;
  4390.   if (options->created)
  4391.     {
  4392.       /* We are creating an entry so if cancelled
  4393.        * must del the list item as well
  4394.        */
  4395.       gfig_do_delete_gfig_callback (widget, TRUE, gfig_gtk_list);
  4396.     }
  4397.  
  4398.   gtk_widget_destroy (options->query_box);
  4399.   g_free (options);
  4400. }
  4401.  
  4402. static void
  4403. gfig_dialog_edit_list (GtkWidget *lwidget,
  4404.                GFigObj   *obj,
  4405.                gint       created)
  4406. {
  4407.   GfigListOptions *options;
  4408.   GtkWidget *vbox;
  4409.   GtkWidget *hbox;
  4410.   GtkWidget *label;
  4411.  
  4412.   /*  the new options structure  */
  4413.   options = g_new (GfigListOptions, 1);
  4414.   options->list_entry = lwidget;
  4415.   options->obj        = obj;
  4416.   options->created    = created;
  4417.  
  4418.   /*  the dialog  */
  4419.   options->query_box =
  4420.     gimp_dialog_new (_("Enter Gfig Entry Name"), "gfig",
  4421.              gimp_standard_help_func, "filters/gfig.html",
  4422.              GTK_WIN_POS_MOUSE,
  4423.              FALSE, TRUE, FALSE,
  4424.  
  4425.              _("OK"), gfig_list_ok_callback,
  4426.              options, NULL, NULL, TRUE, FALSE,
  4427.              _("Cancel"), gfig_list_cancel_callback,
  4428.              options, NULL, NULL, FALSE, TRUE,
  4429.  
  4430.              NULL);
  4431.  
  4432.   /*  the main vbox  */
  4433.   vbox = gtk_vbox_new (FALSE, 2);
  4434.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
  4435.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (options->query_box)->vbox), vbox,
  4436.               FALSE, FALSE, 0);
  4437.   gtk_widget_show (vbox);
  4438.  
  4439.   /*  the name entry hbox, label and entry  */
  4440.   hbox = gtk_hbox_new (FALSE, 4);
  4441.   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  4442.   gtk_widget_show (hbox);
  4443.  
  4444.   label = gtk_label_new (_("Gfig Object Name:"));
  4445.   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
  4446.   gtk_widget_show (label);
  4447.  
  4448.   options->name_entry = gtk_entry_new ();
  4449.   gtk_box_pack_start (GTK_BOX (hbox), options->name_entry, TRUE, TRUE, 0);
  4450.   gtk_entry_set_text (GTK_ENTRY (options->name_entry), obj->draw_name);
  4451.   gtk_widget_show (options->name_entry);
  4452.  
  4453.   gtk_widget_show (options->query_box);
  4454. }
  4455.  
  4456. static void
  4457. gfig_rescan_ok_callback (GtkWidget *widget,
  4458.              gpointer   data)
  4459. {
  4460.   GtkWidget *patheditor;
  4461.   gchar     *raw_path;
  4462.  
  4463.   gtk_widget_set_sensitive (GTK_WIDGET (data), FALSE);
  4464.  
  4465.   gimp_path_free (gfig_path_list);
  4466.   gfig_path_list = NULL;
  4467.  
  4468.   patheditor = GTK_WIDGET (gtk_object_get_data (GTK_OBJECT (data),
  4469.                         "patheditor"));
  4470.  
  4471.   raw_path = gimp_path_editor_get_path (GIMP_PATH_EDITOR (patheditor));
  4472.  
  4473.   gfig_path_list = gimp_path_parse (raw_path, 16, FALSE, NULL);
  4474.  
  4475.   g_free (raw_path);
  4476.  
  4477.   if (gfig_path_list)
  4478.     {
  4479.       clear_list_items (GTK_LIST (gfig_gtk_list));
  4480.       gfig_list_load_all (gfig_path_list);
  4481.       build_list_items (gfig_gtk_list);
  4482.       list_button_update (current_obj);
  4483.     }
  4484.  
  4485.   gtk_widget_destroy (GTK_WIDGET (data));
  4486. }
  4487.  
  4488. static void
  4489. gfig_rescan_list (void)
  4490. {
  4491.   static GtkWidget *dlg = NULL;
  4492.  
  4493.   GtkWidget *patheditor;
  4494.   gchar     *path;
  4495.  
  4496.   if (dlg)
  4497.     {
  4498.       gdk_window_raise (dlg->window);
  4499.       return;
  4500.     }
  4501.  
  4502.   /*  the dialog  */
  4503.   dlg = gimp_dialog_new (_("Rescan for Gfig Objects"), "gfig",
  4504.              gimp_standard_help_func, "filters/gfig.html",
  4505.              GTK_WIN_POS_MOUSE,
  4506.              FALSE, TRUE, FALSE,
  4507.  
  4508.              _("OK"), gfig_rescan_ok_callback,
  4509.              NULL, NULL, NULL, TRUE, FALSE,
  4510.              _("Cancel"), gtk_widget_destroy,
  4511.              NULL, 1, NULL, FALSE, TRUE,
  4512.  
  4513.              NULL);
  4514.  
  4515.   gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
  4516.               GTK_SIGNAL_FUNC (gtk_widget_destroyed),
  4517.               &dlg);
  4518.  
  4519.   path = gimp_path_to_str (gfig_path_list);
  4520.  
  4521.   patheditor = gimp_path_editor_new (_("Add Gfig Path"), path);
  4522.   gtk_container_set_border_width (GTK_CONTAINER (patheditor), 6);
  4523.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), patheditor,
  4524.               TRUE, TRUE, 0);
  4525.   gtk_widget_show (patheditor);
  4526.  
  4527.   g_free (path);
  4528.  
  4529.   gtk_object_set_data (GTK_OBJECT (dlg), "patheditor", patheditor);
  4530.  
  4531.   gtk_widget_show (dlg);
  4532. }
  4533.  
  4534. static void
  4535. list_button_update (GFigObj *obj)
  4536. {
  4537.   g_return_if_fail (obj != NULL);
  4538.  
  4539.   pic_obj = (GFigObj *) obj;
  4540.  
  4541.   gtk_widget_draw (pic_preview, NULL);
  4542.  
  4543.   drawing_pic = TRUE;
  4544.   draw_objects (pic_obj->obj_list, FALSE);
  4545.   drawing_pic = FALSE;
  4546. }
  4547.  
  4548.  
  4549. static void
  4550. gfig_load_file_selection_ok (GtkWidget        *widget,
  4551.                      GtkFileSelection *fs,
  4552.                      gpointer          data)
  4553. {
  4554.   gchar       *filename;
  4555.   struct stat  filestat;
  4556.   gint         err;
  4557.   GFigObj     *gfig;
  4558.   GFigObj     *current_saved;
  4559.  
  4560.   filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
  4561.  
  4562. #ifdef DEBUG
  4563.   printf ("Loading file '%s'\n", filename);
  4564. #endif /* DEBUG */
  4565.  
  4566.   err = stat (filename, &filestat);
  4567.  
  4568.   if (!err && S_ISREG (filestat.st_mode))
  4569.     {
  4570.       /* Hack - current object MUST be NULL to prevent setup_undo ()
  4571.        * from kicking in.
  4572.        */
  4573.       current_saved = current_obj;
  4574.       current_obj = NULL;
  4575.       gfig = gfig_load (filename, filename);
  4576.       current_obj = current_saved;
  4577.       
  4578.       if (gfig)
  4579.     {
  4580.       /* Read only ?*/
  4581.       if (access (filename, W_OK))
  4582.         gfig->obj_status |= GFIG_READONLY;
  4583.  
  4584.       gfig_list_add (gfig);
  4585.       new_obj_2edit (gfig);
  4586.     }
  4587.     }
  4588.  
  4589.   gtk_widget_destroy (GTK_WIDGET (fs));
  4590. }
  4591.  
  4592. static void
  4593. load_button_callback (GtkWidget *widget,
  4594.               gpointer   data)
  4595. {
  4596.   static GtkWidget *window = NULL;
  4597.  
  4598.   /* Load a single object */
  4599.   window = gtk_file_selection_new (_("Load Gfig obj"));
  4600.   gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
  4601.  
  4602.   gtk_signal_connect (GTK_OBJECT (window), "destroy",
  4603.               GTK_SIGNAL_FUNC (gtk_widget_destroyed),
  4604.               &window);
  4605.  
  4606.   gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
  4607.               "clicked",
  4608.               GTK_SIGNAL_FUNC (gfig_load_file_selection_ok),
  4609.               (gpointer) window);
  4610.  
  4611.   gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
  4612.                  "clicked",
  4613.                  GTK_SIGNAL_FUNC (gtk_widget_destroy),
  4614.                  GTK_OBJECT (window));
  4615.   gtk_widget_show (window);
  4616. }
  4617.  
  4618. static void
  4619. paint_layer_copy (gchar *new_name)
  4620. {
  4621.   gint32 old_drawable = gfig_drawable;
  4622.   if ((gfig_drawable = gimp_layer_copy (gfig_drawable)) < 0)
  4623.     {
  4624.       g_warning (_("Error in copy layer for onlayers"));
  4625.       gfig_drawable = old_drawable;
  4626.       return;
  4627.     }
  4628.  
  4629.   gimp_layer_set_name (gfig_drawable, new_name);
  4630.   gimp_image_add_layer (gfig_image, gfig_drawable, -1);
  4631. }
  4632.  
  4633. static void
  4634. paint_layer_new (gchar *new_name)
  4635. {
  4636.   gint32 layer_id;
  4637.   gint32 fill_type;
  4638.   int isgrey = 0;
  4639.  
  4640.   switch (gimp_drawable_type (gfig_select_drawable->id))
  4641.     {
  4642.     case GIMP_GRAYA_IMAGE:
  4643.     case GIMP_GRAY_IMAGE:
  4644.       isgrey = 2;
  4645.     default:
  4646.       break;
  4647.     }
  4648.  
  4649.   if ((layer_id = gimp_layer_new (gfig_image,
  4650.                   new_name,
  4651.                   img_width,
  4652.                   img_height,
  4653.                   1 + isgrey, /* RGBA or GRAYA type */
  4654.                   100.0, /* opacity */
  4655.                   0 /* mode */)) < 0)
  4656.     g_warning (_("Error in creating layer"));
  4657.   else
  4658.     {
  4659.       gimp_image_add_layer (gfig_image, layer_id, -1);
  4660.       gimp_drawable_fill (layer_id, 1);
  4661.     }
  4662.   
  4663.   gfig_drawable = layer_id;
  4664.   
  4665.   switch (selvals.onlayerbg)
  4666.     {
  4667.     case LAYER_TRANS_BG:
  4668.       fill_type = 3;
  4669.       break;
  4670.     case LAYER_BG_BG:
  4671.       fill_type = 1;
  4672.       break;
  4673.     case LAYER_FG_BG:
  4674.       fill_type = 0;
  4675.       break;
  4676.     case LAYER_WHITE_BG:
  4677.       fill_type = 2;
  4678.       break;
  4679.     case LAYER_COPY_BG:
  4680.     default:
  4681.       fill_type = 1;
  4682.       g_warning ("Paint layer new internal error %d\n", selvals.onlayerbg);
  4683.       break;
  4684.     }
  4685.   /* Have to clear layer out since creating transparent layer
  4686.    * seems to leave rubbish in it.
  4687.    */
  4688.  
  4689.   gimp_drawable_fill (layer_id, fill_type);
  4690.  
  4691. }
  4692.  
  4693. static void
  4694. paint_layer_fill ()
  4695. {
  4696.   gimp_bucket_fill (gfig_drawable,
  4697.             selopt.fill_type,    /* Fill mode */
  4698.             GIMP_NORMAL_MODE,
  4699.             selopt.fill_opacity, /* Fill opacity */
  4700.             0.0,                 /* threshold - ignored */
  4701.             FALSE,               /* Sample merged - ignored */
  4702.             0.0,                 /* x - ignored */
  4703.             0.0);                /* y - ignored */
  4704. }
  4705.        
  4706. static void
  4707. gfig_paint_callback (GtkWidget *widget,
  4708.              gpointer   data)
  4709. {
  4710.   DAllObjs * objs;
  4711.   gint layer_count = 0;
  4712.   gchar buf[128];
  4713.   gint count;
  4714.   gint ccount = 0;
  4715.   BrushDesc *bdesc;
  4716.  
  4717.   objs = current_obj->obj_list;
  4718.  
  4719.   count = gfig_obj_counts (objs);
  4720. #if 0
  4721.   gtk_progress_bar_update (GTK_PROGRESS_BAR (progress_widget), (gfloat) 0.0);
  4722. #endif /* 0 */
  4723.  
  4724.   /* Set the brush up */
  4725.   bdesc = gtk_object_get_user_data (GTK_OBJECT (brush_page_pw));
  4726.  
  4727.   if (bdesc)
  4728.     mygimp_brush_set (bdesc->bname);
  4729.  
  4730.   while (objs)
  4731.     {
  4732.  
  4733.       if (ccount == obj_show_single || obj_show_single == -1)
  4734.     {
  4735.       sprintf (buf, _("Gfig Layer %d"), layer_count++);
  4736.       
  4737.       if (selvals.painttype != PAINT_SELECTION_TYPE)
  4738.         {
  4739.           switch (selvals.onlayers)
  4740.         {
  4741.         case SINGLE_LAYER:
  4742.           if (layer_count == 1)
  4743.             {
  4744.               if (selvals.onlayerbg == LAYER_COPY_BG)
  4745.             paint_layer_copy (buf);
  4746.               else
  4747.             paint_layer_new (buf);
  4748.             }
  4749.           break;
  4750.         case MULTI_LAYER:
  4751.           if (selvals.onlayerbg == LAYER_COPY_BG)
  4752.             paint_layer_copy (buf);
  4753.           else
  4754.             paint_layer_new (buf);
  4755.           break;
  4756.         case ORIGINAL_LAYER:
  4757.           /* Just use the given layer */
  4758.           break;
  4759.         default:
  4760.           g_warning ("Error in onlayers val %d", selvals.onlayers);
  4761.           break;
  4762.         }
  4763.         }
  4764.       
  4765.       objs->obj->paintfunc (objs->obj);
  4766.       
  4767.       /* Fill layer if required */
  4768.       if (selvals.painttype == PAINT_SELECTION_FILL_TYPE 
  4769.           && selopt.fill_when == FILL_EACH)
  4770.         paint_layer_fill ();
  4771.     }
  4772.  
  4773.       objs = objs->next;
  4774.       
  4775.       ccount++;
  4776. #if 0 
  4777.       gtk_progress_bar_update (GTK_PROGRESS_BAR (progress_widget), (gfloat)ccount/(gfloat)count);
  4778.       gtk_widget_draw (GTK_WIDGET (progress_widget), NULL);
  4779. #endif /* 0 */
  4780.     }
  4781.  
  4782.   /* Fill layer if required */
  4783.   if (selvals.painttype == PAINT_SELECTION_FILL_TYPE 
  4784.       && selopt.fill_when == FILL_AFTER)
  4785.     paint_layer_fill ();
  4786.  
  4787.   gimp_displays_flush ();
  4788. }
  4789.  
  4790. static void
  4791. reload_button_callback (GtkWidget *widget,
  4792.             gpointer   data)
  4793. {
  4794.   refill_cache ();
  4795.   draw_grid_clear (widget, data);
  4796. }
  4797.  
  4798. static void
  4799. about_button_callback (GtkWidget *widget,
  4800.                gpointer   data)
  4801. {
  4802.   GtkWidget *window;
  4803.   GtkWidget *label;
  4804.   GtkWidget *hbox;
  4805.   GtkWidget *vbox;
  4806.   GtkWidget *pm;
  4807.  
  4808.   window = gimp_dialog_new (_("About GFig"), "gfig",
  4809.                 gimp_standard_help_func, "filters/gfig.html",
  4810.                 GTK_WIN_POS_MOUSE,
  4811.                 FALSE, FALSE, FALSE,
  4812.  
  4813.                 _("OK"), gtk_widget_destroy,
  4814.                 NULL, 1, NULL, TRUE, TRUE,
  4815.  
  4816.                 NULL);
  4817.  
  4818.   /* Bits and bobs */
  4819.   pm = gimp_pixmap_new (rulers_comp_xpm);
  4820.   gtk_widget_show (pm);
  4821.  
  4822.   hbox = gtk_hbox_new (FALSE, 1);
  4823.   gtk_widget_show (hbox);
  4824.  
  4825.   vbox = gtk_vbox_new (FALSE, 1);
  4826.   gtk_widget_show (vbox);
  4827.  
  4828.   gtk_box_pack_start (GTK_BOX (hbox), pm, TRUE, TRUE, 0);
  4829.   gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
  4830.   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox, TRUE, TRUE, 0);
  4831.  
  4832.   label = gtk_label_new (_("Gfig - GIMP plug-in"));
  4833.   gtk_misc_set_padding (GTK_MISC (label), 2, 2);
  4834.   gtk_widget_show (label);
  4835.   gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
  4836.  
  4837.   label = gtk_label_new (_("Release 1.3"));
  4838.   gtk_misc_set_padding (GTK_MISC (label), 2, 2);
  4839.   gtk_widget_show (label);
  4840.   gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
  4841.  
  4842.   label = gtk_label_new ("Andy Thomas");
  4843.   gtk_misc_set_padding (GTK_MISC (label), 2, 2);
  4844.   gtk_widget_show (label);
  4845.   gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
  4846.  
  4847.   label = gtk_label_new (_("Email alt@picnic.demon.co.uk"));
  4848.   gtk_misc_set_padding (GTK_MISC (label), 2, 2);
  4849.   gtk_widget_show (label);
  4850.   gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
  4851.  
  4852.   label = gtk_label_new ("http://www.picnic.demon.co.uk/");
  4853.   gtk_misc_set_padding (GTK_MISC (label), 2, 2);
  4854.   gtk_widget_show (label);
  4855.   gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
  4856.  
  4857.   label = gtk_label_new (_("Isometric grid By Rob Saunders"));
  4858.   gtk_misc_set_padding (GTK_MISC (label), 2, 2);
  4859.   gtk_widget_show (label);
  4860.   gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
  4861.  
  4862.   gtk_widget_show (window);
  4863. }
  4864.  
  4865.  
  4866. static void
  4867. save_button_callback (GtkWidget *widget,
  4868.               gpointer   data)
  4869. {
  4870.   gfig_save ();  /* Save current object */
  4871. }
  4872.  
  4873. static void
  4874. rescan_button_callback (GtkWidget *widget,
  4875.             gpointer   data)
  4876. {
  4877.   gfig_rescan_list ();
  4878. }
  4879.  
  4880. static GtkWidget *
  4881. new_gfig_obj (gchar *name)
  4882. {
  4883.   GFigObj   *gfig;
  4884.   GtkWidget *new_list_item;
  4885.   /* Create a new entry */
  4886.  
  4887.   gfig = gfig_new ();
  4888.  
  4889.   if (!name)
  4890.     name = _("New gfig obj");
  4891.  
  4892.   gfig->draw_name = g_strdup (name);
  4893.  
  4894.   /* Leave options as before */
  4895.   pic_obj = current_obj = gfig;
  4896.  
  4897.   new_list_item = gfig_list_add (gfig);
  4898.  
  4899.   tmp_bezier = obj_creating = tmp_line = NULL;
  4900.  
  4901.   /* Redraw areas */
  4902.   update_draw_area (gfig_preview, NULL);
  4903.   list_button_update (gfig);
  4904.  
  4905.   return new_list_item;
  4906. }
  4907.  
  4908. static void
  4909. new_button_callback (GtkWidget *widget,
  4910.              gpointer   data)
  4911. {
  4912.   GtkWidget *new_list_item;
  4913.  
  4914.   new_list_item = new_gfig_obj ((gchar*) data);
  4915.   gfig_dialog_edit_list (new_list_item, current_obj, TRUE);
  4916. }
  4917.  
  4918. static GtkWidget *delete_dialog = NULL;
  4919.  
  4920. static void
  4921. gfig_do_delete_gfig_callback (GtkWidget *widget,
  4922.                   gboolean   delete,
  4923.                   gpointer   data)
  4924. {
  4925.   gint pos;
  4926.   GList *sellist;
  4927.   GFigObj *sel_obj;
  4928.   GtkWidget *list = (GtkWidget *) data;
  4929.  
  4930.   if (!delete)
  4931.     {
  4932.       gtk_widget_set_sensitive (delete_frame_to_freeze, TRUE);
  4933.       return;
  4934.     }
  4935.  
  4936. #ifdef DEBUG
  4937.   printf ("Delete button pressed\n");
  4938. #endif /* DEBUG */
  4939.   /* Must update which object we are editing */
  4940.   /* Get the list and which item is selected */
  4941.   /* Only allow single selections */
  4942.  
  4943.   sellist = GTK_LIST (list)->selection; 
  4944.  
  4945.   sel_obj = (GFigObj *) gtk_object_get_user_data (GTK_OBJECT (sellist->data));
  4946.  
  4947.   pos = gtk_list_child_position (GTK_LIST (gfig_gtk_list), sellist->data);
  4948. #ifdef DEBUG
  4949.   printf ("delete pos = %d\n", pos);
  4950. #endif /* DEBUG */
  4951.  
  4952.   /* Delete the current  item + asssociated file */
  4953.   gtk_list_clear_items (GTK_LIST (gfig_gtk_list), pos, pos + 1);
  4954.   /* Shadow copy for ordering info */
  4955.   gfig_list = g_list_remove (gfig_list, sel_obj);
  4956.  
  4957.   if (sel_obj == current_obj)
  4958.     {
  4959.       clear_undo ();
  4960.     }
  4961.   
  4962.   /* Free current obj */
  4963.   gfig_free_everything (sel_obj);
  4964.  
  4965.   /* Select previous one */
  4966.   pos--;
  4967.  
  4968.   if (pos < 0)
  4969.     {
  4970.       if (g_list_length (gfig_list) == 0)
  4971.     {
  4972.       /* Warning - we have a problem here
  4973.        * since we are not really "creating an entry"
  4974.        * why call gfig_new?
  4975.        */
  4976.       new_button_callback (NULL, NULL);
  4977.     }
  4978.  
  4979.       pos = 0;
  4980.     }
  4981.  
  4982.   gtk_widget_set_sensitive (delete_frame_to_freeze, TRUE);
  4983.  
  4984.   gtk_list_select_item (GTK_LIST (gfig_gtk_list), pos);  
  4985.  
  4986.   current_obj = g_list_nth (gfig_list, pos)->data;
  4987.  
  4988.   update_draw_area (gfig_preview, NULL);
  4989.  
  4990.   list_button_update (current_obj);
  4991.  
  4992.   gfig_update_stat_labels ();
  4993. }
  4994.  
  4995. static void
  4996. gfig_delete_gfig_callback (GtkWidget *widget,
  4997.                gpointer   data)
  4998. {
  4999.   gchar *str;
  5000.  
  5001.   GtkWidget *list = (GtkWidget *) data;
  5002.   GList * sellist;
  5003.   GFigObj * sel_obj;
  5004.  
  5005.   sellist = GTK_LIST (list)->selection; 
  5006.  
  5007.   sel_obj = (GFigObj *) gtk_object_get_user_data (GTK_OBJECT (sellist->data));
  5008.  
  5009.   if (delete_dialog)
  5010.     return;
  5011.  
  5012.   str = g_strdup_printf (_("Are you sure you want to delete\n"
  5013.                "\"%s\" from the list and from disk?"),
  5014.              sel_obj->draw_name);
  5015.  
  5016.   delete_dialog = gimp_query_boolean_box (_("Delete Gfig Drawing"),
  5017.                       gimp_standard_help_func,
  5018.                       "filters/gfig.html",
  5019.                       FALSE,
  5020.                       str,
  5021.                       _("Delete"), _("Cancel"),
  5022.                       NULL, NULL,
  5023.                       gfig_do_delete_gfig_callback,
  5024.                       data);
  5025.  
  5026.   g_free (str);
  5027.  
  5028.   gtk_signal_connect (GTK_OBJECT (delete_dialog), "destroy",
  5029.               GTK_SIGNAL_FUNC (gtk_widget_destroyed),
  5030.               &delete_dialog);
  5031.  
  5032.   gtk_widget_set_sensitive (GTK_WIDGET (delete_frame_to_freeze), FALSE);
  5033.   gtk_widget_show (delete_dialog);
  5034. } 
  5035.  
  5036. static void
  5037. gfig_update_stat_labels (void)
  5038. {
  5039.   gchar str[45];
  5040.  
  5041.   if (current_obj->draw_name)
  5042.     sprintf (str, "%.34s", current_obj->draw_name);
  5043.   else
  5044.     sprintf (str,_("<NONE>"));
  5045.  
  5046.   gtk_label_set_text (GTK_LABEL (status_label_dname), str);
  5047.  
  5048.   if (current_obj->filename)
  5049.     {
  5050.       gint slen;
  5051.       gchar *hm = g_get_home_dir ();
  5052.       gchar *dfn = g_strdup (current_obj->filename);
  5053. #ifdef __EMX__
  5054.       if (hm)
  5055.     hm = _fnslashify (hm);
  5056. #endif
  5057.  
  5058.       
  5059. #ifndef __EMX__
  5060.       if (hm != NULL && !strncmp (dfn, hm, strlen (hm)-1))
  5061. #else
  5062.       if (hm != NULL && !strnicmp (dfn, hm, strlen (hm)-1))
  5063. #endif
  5064.      {
  5065.        strcpy (dfn, "~");
  5066.        strcat (dfn, &dfn[strlen (hm)]);
  5067.      }
  5068.       if ((slen = strlen (dfn)) > 40)
  5069.     {
  5070.       strncpy (str, dfn, 19);
  5071.       str[19] = '\0';
  5072.       strcat (str, "...");
  5073.       strncat (str, &dfn[slen - 21], 19);
  5074.       str[40] ='\0';
  5075.     }
  5076.       else
  5077.     sprintf (str, "%.40s", dfn);
  5078.       g_free (dfn);
  5079. #ifdef __EMX__
  5080.       g_free (hm);
  5081. #endif
  5082.     }
  5083.   else
  5084.     sprintf (str,_("<NONE>"));
  5085.  
  5086.   gtk_label_set_text (GTK_LABEL (status_label_fname), str);
  5087.  
  5088. }
  5089.  
  5090. static void 
  5091. new_obj_2edit (GFigObj *obj)
  5092. {
  5093.   GFigObj *old_current = current_obj;
  5094.  
  5095.   /* Clear undo levels */
  5096.   /* redraw the preview */
  5097.   /* Set up options as define in the selected object */
  5098.  
  5099.   clear_undo ();
  5100.  
  5101.   /* Point at this one */
  5102.   current_obj = obj;
  5103.  
  5104.   /* Show all objects to start with */
  5105.   obj_show_single = -1;
  5106.  
  5107.   /* Change options */
  5108.   update_options (old_current);
  5109.  
  5110.   /* If have old object and NOT scaleing currently then force 
  5111.    * back to saved coord type.
  5112.    */
  5113.   gfig_update_stat_labels ();
  5114.  
  5115.   /* redraw with new */
  5116.   update_draw_area (gfig_preview, NULL);
  5117.   /* And preview */
  5118.   list_button_update (current_obj);
  5119.  
  5120.   if (obj->obj_status & GFIG_READONLY)
  5121.     {
  5122.       g_message (_("Editing read-only object - "
  5123.            "you will not be able to save it"));
  5124.       gtk_widget_set_sensitive (save_button, FALSE);
  5125.     }
  5126.   else
  5127.     {
  5128.       gtk_widget_set_sensitive (save_button, TRUE);
  5129.     }
  5130. }
  5131.  
  5132. static void
  5133. edit_button_callback (GtkWidget *widget,
  5134.               gpointer   data)
  5135. {
  5136.   GList     *sellist;
  5137.   GFigObj   *sel_obj;
  5138.   GtkWidget *list = (GtkWidget *) data;
  5139.  
  5140. #ifdef DEBUG
  5141.   printf ("Edit button pressed\n");
  5142. #endif /* DEBUG */
  5143.   /* Must update which object we are editing */
  5144.   /* Get the list and which item is selected */
  5145.   /* Only allow single selections */
  5146.  
  5147.   sellist = GTK_LIST (list)->selection; 
  5148.  
  5149.   sel_obj = (GFigObj *) gtk_object_get_user_data (GTK_OBJECT (sellist->data));
  5150.  
  5151.   if (sel_obj)
  5152.     new_obj_2edit (sel_obj);
  5153.   else
  5154.     g_warning ("Internal error - list item has null object!");
  5155. }
  5156.  
  5157. static void
  5158. merge_button_callback (GtkWidget *widget,
  5159.                gpointer   data)
  5160. {
  5161.   GList     *sellist;
  5162.   GFigObj   *sel_obj;
  5163.   DAllObjs  *obj_copies;
  5164.   GtkWidget *list = (GtkWidget *) data;
  5165.  
  5166. #ifdef DEBUG
  5167.   printf ("Merge button pressed\n");
  5168. #endif /* DEBUG */
  5169.   /* Must update which object we are editing */
  5170.   /* Get the list and which item is selected */
  5171.   /* Only allow single selections */
  5172.  
  5173.   sellist = GTK_LIST (list)->selection; 
  5174.  
  5175.   sel_obj = (GFigObj *) gtk_object_get_user_data (GTK_OBJECT (sellist->data));
  5176.  
  5177.   if (sel_obj && sel_obj->obj_list && sel_obj != current_obj)
  5178.     {
  5179.       /* Copy list tag onto current & redraw */
  5180.       obj_copies = copy_all_objs (sel_obj->obj_list);
  5181.       prepend_to_all_obj (current_obj, obj_copies);
  5182.  
  5183.       /* redraw all */
  5184.       update_draw_area (gfig_preview, NULL);
  5185.       /* And preview */
  5186.       list_button_update (current_obj);
  5187.     }
  5188. }
  5189.  
  5190.  
  5191. static void
  5192. gfig_save_menu_callback (GtkWidget *widget,
  5193.              gpointer   data)
  5194. {
  5195.   GFigObj * real_current = current_obj;
  5196.   /* Fiddle the current object and save it */
  5197.   /* What happens if we get a redraw here ? */
  5198.  
  5199.   current_obj = gfig_obj_for_menu;
  5200.  
  5201.   gfig_save ();  /* Save current object */
  5202.  
  5203.   current_obj = real_current;
  5204. }
  5205.  
  5206. static void
  5207. gfig_edit_menu_callback (GtkWidget *widget,
  5208.              gpointer   data)
  5209. {
  5210.   new_obj_2edit (gfig_obj_for_menu);
  5211. }
  5212.  
  5213. static void
  5214. gfig_rename_menu_callback (GtkWidget *widget,
  5215.                gpointer   data)
  5216. {
  5217.   create_file_selection (gfig_obj_for_menu, gfig_obj_for_menu->filename);
  5218. }
  5219.  
  5220. static void
  5221. gfig_copy_menu_callback (GtkWidget *widget,
  5222.              gpointer   data)
  5223. {
  5224.   /* Create new entry with name + copy at end & copy object into it */
  5225.   gchar *new_name = g_strdup_printf (_("%s copy"), gfig_obj_for_menu->draw_name);
  5226.   new_gfig_obj (new_name);
  5227.   g_free (new_name);
  5228.  
  5229.   /* Copy objs across */
  5230.   current_obj->obj_list = copy_all_objs (gfig_obj_for_menu->obj_list);
  5231.   current_obj->opts = gfig_obj_for_menu->opts; /* Structure copy */
  5232.  
  5233.   /* redraw all */
  5234.   update_draw_area (gfig_preview, NULL);
  5235.   /* And preview */
  5236.   list_button_update (current_obj);
  5237. }
  5238.  
  5239. static void
  5240. gfig_op_menu_create (GtkWidget *window)
  5241. {
  5242.   GtkWidget *menu_item;
  5243. #if 0
  5244.   GtkAcceleratorTable *accelerator_table;
  5245. #endif /* 0 */
  5246.  
  5247.   gfig_op_menu = gtk_menu_new ();
  5248.  
  5249. #if 0
  5250.   accelerator_table = gtk_accelerator_table_new ();
  5251.   gtk_menu_set_accelerator_table (GTK_MENU (gfig_op_menu),
  5252.                   accelerator_table);
  5253.   gtk_window_add_accelerator_table (GTK_WINDOW (window), accelerator_table);
  5254. #endif /* 0 */
  5255.  
  5256.   save_menu_item = menu_item = gtk_menu_item_new_with_label (_("Save"));
  5257.   gtk_menu_append (GTK_MENU (gfig_op_menu), menu_item);
  5258.   gtk_widget_show (menu_item);
  5259.  
  5260.   gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
  5261.               (GtkSignalFunc)gfig_save_menu_callback,
  5262.               NULL);
  5263.  
  5264. #if 0 
  5265.   gtk_widget_install_accelerator (menu_item,
  5266.                   accelerator_table,
  5267.                   "activate", 'S', 0);
  5268. #endif /* 0 */
  5269.  
  5270.   menu_item = gtk_menu_item_new_with_label (_("Save as..."));
  5271.   gtk_menu_append (GTK_MENU (gfig_op_menu), menu_item);
  5272.   gtk_widget_show (menu_item);
  5273.   gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
  5274.               (GtkSignalFunc)gfig_rename_menu_callback,
  5275.               NULL);
  5276.  
  5277. #if 0 
  5278.   gtk_widget_install_accelerator (menu_item,
  5279.                   accelerator_table,
  5280.                   "activate", 'A', 0);
  5281. #endif /* 0 */
  5282.  
  5283.   menu_item = gtk_menu_item_new_with_label (_("Copy"));
  5284.   gtk_menu_append (GTK_MENU (gfig_op_menu), menu_item);
  5285.   gtk_widget_show (menu_item);
  5286.   gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
  5287.               (GtkSignalFunc)gfig_copy_menu_callback,
  5288.               NULL);
  5289.  
  5290. #if 0 
  5291.   gtk_widget_install_accelerator (menu_item,
  5292.                   accelerator_table,
  5293.                   "activate", 'C', 0);
  5294. #endif /* 0 */
  5295.  
  5296.   menu_item = gtk_menu_item_new_with_label (_("Edit"));
  5297.   gtk_menu_append (GTK_MENU (gfig_op_menu), menu_item);
  5298.   gtk_widget_show (menu_item);
  5299.   gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
  5300.               (GtkSignalFunc)gfig_edit_menu_callback,
  5301.               NULL);
  5302.  
  5303. #if 0 
  5304.   gtk_widget_install_accelerator (menu_item,
  5305.                   accelerator_table,
  5306.                   "activate", 'E', 0);
  5307. #endif /* 0 */
  5308.  
  5309. }
  5310.  
  5311. static void
  5312. gfig_op_menu_popup (gint     button,
  5313.             guint32  activate_time,
  5314.             GFigObj *obj)
  5315. {
  5316.   gfig_obj_for_menu = obj; /* Static data again!*/
  5317.  
  5318.   if (obj->obj_status & GFIG_READONLY)
  5319.     {
  5320.       gtk_widget_set_sensitive (save_menu_item, FALSE);
  5321.     }
  5322.   else
  5323.     {
  5324.       gtk_widget_set_sensitive (save_menu_item, TRUE);
  5325.     }
  5326.  
  5327.   gtk_menu_popup (GTK_MENU (gfig_op_menu),
  5328.           NULL, NULL, NULL, NULL,
  5329.           button, activate_time);
  5330. }
  5331.  
  5332.  
  5333. static gint
  5334. list_button_press (GtkWidget      *widget,
  5335.            GdkEventButton *event,
  5336.            gpointer        data)
  5337. {
  5338.   switch (event->type)
  5339.     {
  5340.     case GDK_BUTTON_PRESS:
  5341. #ifdef DEBUG
  5342.       printf ("Single button press\n");
  5343. #endif /* DEBUG */
  5344.       if (event->button == 3)
  5345.     {
  5346. #ifdef DEBUG
  5347.       printf ("Popup on '%s'\n", ((GFigObj *)data)->draw_name);
  5348. #endif /* DEBUG */
  5349.       gfig_op_menu_popup (event->button, event->time, (GFigObj *) data);
  5350.       return FALSE;
  5351.     }
  5352.       list_button_update ((GFigObj *) data);
  5353.       break;
  5354.     case GDK_2BUTTON_PRESS:
  5355. #ifdef DEBUG
  5356.       printf ("Two button press\n");
  5357. #endif /* DEBUG */
  5358.       gfig_dialog_edit_list (widget, data, FALSE);
  5359.       break;
  5360.     default:
  5361.       g_warning ("gfig: unknown event.\n");
  5362.       break;
  5363.     }
  5364.  
  5365.   return FALSE;
  5366. }
  5367.  
  5368. static void
  5369. gfig_scale_update_scale (GtkAdjustment *adjustment,
  5370.              gdouble       *value)
  5371. {
  5372.   gimp_double_adjustment_update (adjustment, value);
  5373.  
  5374.   if (!selvals.scaletoimage)
  5375.     {
  5376.       scale_x_factor = (1 / (*value)) * org_scale_x_factor;
  5377.       scale_y_factor = (1 / (*value)) * org_scale_y_factor;
  5378.       update_draw_area (gfig_preview, NULL);
  5379.     }
  5380. } 
  5381.  
  5382. /* Use to toggle the toggles */
  5383. static void
  5384. gfig_scale2img_update (GtkWidget *widget,
  5385.                gpointer   data)
  5386. {
  5387.   gimp_toggle_button_update (widget, data);
  5388.  
  5389.   if (*((gint *) data))
  5390.     {
  5391.       GtkObject *adj;
  5392.  
  5393.       adj = gtk_object_get_user_data (GTK_OBJECT (widget));
  5394.  
  5395.       scale_x_factor = org_scale_x_factor;
  5396.       scale_y_factor = org_scale_y_factor;
  5397.       gtk_adjustment_set_value (GTK_ADJUSTMENT (adj), 1.0);
  5398.  
  5399.       update_draw_area (gfig_preview, NULL);
  5400.     }
  5401. }
  5402.  
  5403. /* Given a row then srink it down a bit */
  5404. static void
  5405. do_gfig_preview (guchar *dest_row, 
  5406.          guchar *src_row,
  5407.          gint    width,
  5408.          gint    dh,
  5409.          gint    height,
  5410.          gint    bpp)
  5411. {
  5412.   memcpy (dest_row, src_row, width*bpp);
  5413. }
  5414.  
  5415. static void
  5416. dialog_update_preview (void)
  5417. {
  5418.   gint y;
  5419.   gint check, check_0, check_1;  
  5420.  
  5421.   if (!selvals.showimage)
  5422.     {
  5423.       memset (preview_row, -1, preview_width*4);      
  5424.       for (y = 0; y < preview_height; y++)
  5425.     {
  5426.       gtk_preview_draw_row (GTK_PREVIEW (gfig_preview), preview_row,
  5427.                 0, y, preview_width);
  5428.     }
  5429.       return;
  5430.     }
  5431.  
  5432.   if (!pv_cache)
  5433.     {
  5434.       refill_cache ();
  5435.     }
  5436.  
  5437.   for (y = 0; y < preview_height; y++)
  5438.     {
  5439.       if ((y / GIMP_CHECK_SIZE) & 1)
  5440.     {
  5441.       check_0 = GIMP_CHECK_DARK * 255;
  5442.       check_1 = GIMP_CHECK_LIGHT * 255;
  5443.     }
  5444.       else
  5445.     {
  5446.       check_0 = GIMP_CHECK_LIGHT * 255;
  5447.       check_1 = GIMP_CHECK_DARK * 255;
  5448.     }
  5449.  
  5450.       do_gfig_preview (preview_row,
  5451.                pv_cache+y*preview_width*img_bpp,
  5452.                preview_width,
  5453.                y,
  5454.                preview_height,
  5455.                img_bpp);
  5456.  
  5457.       if (img_bpp > 3)
  5458.     {
  5459.       int i, j;
  5460.       for (i = 0, j = 0 ; i < sizeof (preview_row); i += 4, j += 3)
  5461.         {
  5462.           gint alphaval;
  5463.           if (((i/4) / GIMP_CHECK_SIZE) & 1)
  5464.         check = check_0;
  5465.           else
  5466.         check = check_1;
  5467.         
  5468.           alphaval = preview_row[i + 3];
  5469.  
  5470.           preview_row[j] = 
  5471.         check + (((preview_row[i] - check)*alphaval)/255);
  5472.           preview_row[j + 1] = 
  5473.         check + (((preview_row[i + 1] - check)*alphaval)/255);
  5474.           preview_row[j + 2] = 
  5475.         check + (((preview_row[i + 2] - check)*alphaval)/255);
  5476.         }
  5477.     }
  5478.  
  5479.       gtk_preview_draw_row (GTK_PREVIEW (gfig_preview), preview_row,
  5480.                 0, y, preview_width);
  5481.     }
  5482. }
  5483.  
  5484. static void
  5485. gfig_new_gc (void)
  5486. {
  5487.  GdkColor fg, bg;
  5488.  
  5489.  /*  create a new graphics context  */
  5490.  gfig_gc = gdk_gc_new (gfig_preview->window);
  5491.  gdk_gc_set_function (gfig_gc, GDK_INVERT);
  5492.  fg.pixel = 0xFFFFFFFF;
  5493.  bg.pixel = 0x00000000;
  5494.  gdk_gc_set_foreground (gfig_gc, &fg);
  5495.  gdk_gc_set_background (gfig_gc, &bg);
  5496.  gdk_gc_set_line_attributes (gfig_gc, 1, GDK_LINE_SOLID, GDK_CAP_BUTT, GDK_JOIN_MITER);
  5497. }
  5498.  
  5499. static gint 
  5500. get_num_radials (void)
  5501. {
  5502.   gint gridsp = MAX_GRID + MIN_GRID;
  5503.   /* select number of radials to draw */
  5504.   /* Either have 16 32 or 48 */
  5505.   /* correspond to GRID_MAX, midway and GRID_MIN */
  5506.  
  5507.   return (gridsp - selvals.opts.gridspacing);
  5508. }
  5509.  
  5510. #define SQ_SIZE 8
  5511.  
  5512. static gint 
  5513. inside_sqr (GdkPoint *cpnt,
  5514.         GdkPoint *testpnt)
  5515. {
  5516.   /* Return TRUE if testpnt is near cpnt */
  5517.   gint16 x = cpnt->x;
  5518.   gint16 y = cpnt->y;
  5519.   gint16 tx = testpnt->x;
  5520.   gint16 ty = testpnt->y;
  5521.  
  5522. #ifdef DEBUG
  5523.   printf ("Testing if (%x,%x) is near (%x,%x)\n", tx, ty, x, y);
  5524. #endif /* DEBUG */
  5525.   return (abs (x - tx) <= SQ_SIZE && abs (y - ty) < SQ_SIZE);
  5526. }
  5527.  
  5528. /* find_grid_pos - Given an x, y point return the grid position of it */
  5529. /* return the new position in the passed point */
  5530.  
  5531. static void
  5532. find_grid_pos (GdkPoint *p,
  5533.            GdkPoint *gp,
  5534.            guint     is_butt3)
  5535. {
  5536.   gint16 x = p->x;
  5537.   gint16 y = p->y;
  5538.   static GdkPoint cons_pnt;
  5539.   static gdouble cons_radius;
  5540.   static gdouble cons_ang;
  5541.   static gboolean cons_center;
  5542.   
  5543.   if (selvals.opts.gridtype == RECT_GRID)
  5544.     {
  5545.       if (p->x % selvals.opts.gridspacing > selvals.opts.gridspacing/2)
  5546.     x += selvals.opts.gridspacing;
  5547.       
  5548.       if (p->y % selvals.opts.gridspacing > selvals.opts.gridspacing/2)
  5549.     y += selvals.opts.gridspacing;
  5550.       
  5551.       gp->x = (x/selvals.opts.gridspacing)*selvals.opts.gridspacing;
  5552.       gp->y = (y/selvals.opts.gridspacing)*selvals.opts.gridspacing;
  5553.  
  5554.       if (is_butt3)
  5555.     {
  5556.       if (abs (gp->x - cons_pnt.x) < abs (gp->y - cons_pnt.y))
  5557.         gp->x = cons_pnt.x;
  5558.       else
  5559.         gp->y = cons_pnt.y;
  5560.     }
  5561.       else
  5562.     {
  5563.       /* Store the point since might be used later */
  5564.       cons_pnt = *gp; /* Structure copy */
  5565.     }
  5566.     }
  5567.   else if (selvals.opts.gridtype == POLAR_GRID)
  5568.     { 
  5569.       gdouble ang_grid;
  5570.       gdouble ang_radius;
  5571.       gdouble real_radius;
  5572.       gdouble real_angle;
  5573.       gdouble rounded_angle;
  5574.       gint rounded_radius;
  5575.       gint16 shift_x = x - preview_width/2;
  5576.       gint16 shift_y = -y + preview_height/2;
  5577.  
  5578.       real_radius = ang_radius = sqrt ((shift_y*shift_y) + (shift_x*shift_x));
  5579.  
  5580.       /* round radius */
  5581.       rounded_radius = (gint) (RINT (ang_radius/selvals.opts.gridspacing))*selvals.opts.gridspacing;
  5582.       if (rounded_radius <= 0 || real_radius <=0)
  5583.     {
  5584.       /* DEAD CENTER */
  5585.       gp->x = preview_width/2;
  5586.       gp->y = preview_height/2;
  5587.       if (!is_butt3) cons_center = TRUE;
  5588. #ifdef DEBUG
  5589.       printf ("Dead center\n");
  5590. #endif /* DEBUG */
  5591.       return;
  5592.     }
  5593.  
  5594.       ang_grid = 2*G_PI/get_num_radials ();
  5595.  
  5596.       real_angle = atan2 (shift_y, shift_x);
  5597.       if (real_angle < 0)
  5598.     real_angle += 2*G_PI;
  5599.  
  5600.       rounded_angle = (RINT ((real_angle/ang_grid)))*ang_grid;
  5601. #ifdef DEBUG
  5602.       printf ("real_ang = %f ang_gid = %f rounded_angle = %f rounded radius = %d\n",
  5603.           real_angle, ang_grid, rounded_angle, rounded_radius);
  5604.  
  5605.       printf ("preview_width = %d preview_height = %d\n", preview_width, preview_height);
  5606. #endif /* DEBUG */
  5607.       gp->x = (gint)RINT ((rounded_radius*cos (rounded_angle))) + preview_width/2;
  5608.       gp->y = -(gint)RINT ((rounded_radius*sin (rounded_angle))) + preview_height/2;
  5609.  
  5610.       if (is_butt3)
  5611.     {
  5612.       if (!cons_center)
  5613.         {
  5614.           if (fabs (rounded_angle - cons_ang) > ang_grid/2)
  5615.         {
  5616.           gp->x = (gint)RINT ((cons_radius*cos (rounded_angle))) + preview_width/2;
  5617.           gp->y = -(gint)RINT ((cons_radius*sin (rounded_angle))) + preview_height/2;
  5618.         }
  5619.           else
  5620.         {
  5621.           gp->x = (gint)RINT ((rounded_radius*cos (cons_ang))) + preview_width/2;
  5622.           gp->y = -(gint)RINT ((rounded_radius*sin (cons_ang))) + preview_height/2;
  5623.         }
  5624.         }
  5625.     }
  5626.       else
  5627.     {
  5628.       cons_radius = rounded_radius;
  5629.       cons_ang = rounded_angle;
  5630.       cons_center = FALSE;
  5631.     }
  5632.     }
  5633.    else if (selvals.opts.gridtype == ISO_GRID)
  5634.      {
  5635.     if (is_butt3)
  5636.       {
  5637.          static GdkPoint b_pnt;
  5638.          static GdkPoint i_pnt;
  5639.          static GdkPoint ii_pnt;
  5640.          gint d;
  5641.          gint dd;
  5642.  
  5643.          b_pnt.x = cons_pnt.x;
  5644.          b_pnt.y = cons_pnt.y + preview_width;
  5645.          d = calculate_point_to_line_distance (p, &cons_pnt, &b_pnt, &i_pnt);
  5646.  
  5647.          b_pnt.x = cons_pnt.x;
  5648.          b_pnt.y = cons_pnt.y - preview_width;
  5649.          dd = calculate_point_to_line_distance (p, &cons_pnt, &b_pnt, &ii_pnt);
  5650.          if (dd < d)
  5651.          {
  5652.         i_pnt.x = ii_pnt.x;
  5653.         i_pnt.y = ii_pnt.y;
  5654.         d = dd;
  5655.          }
  5656.  
  5657.          b_pnt.x = cons_pnt.x + preview_width;
  5658.          b_pnt.y = cons_pnt.y + preview_width/2;
  5659.          dd = calculate_point_to_line_distance (p, &cons_pnt, &b_pnt, &ii_pnt);
  5660.          if (dd < d)
  5661.          {
  5662.         i_pnt.x = ii_pnt.x;
  5663.         i_pnt.y = ii_pnt.y;
  5664.         d = dd;
  5665.          }
  5666.  
  5667.          b_pnt.x = cons_pnt.x + preview_width;
  5668.          b_pnt.y = cons_pnt.y - preview_width/2;
  5669.          dd = calculate_point_to_line_distance (p, &cons_pnt, &b_pnt, &ii_pnt);
  5670.          if (dd < d)
  5671.          {
  5672.         i_pnt.x = ii_pnt.x;
  5673.         i_pnt.y = ii_pnt.y;
  5674.         d = dd;
  5675.          }
  5676.  
  5677.          b_pnt.x = cons_pnt.x - preview_width;
  5678.          b_pnt.y = cons_pnt.y + preview_width/2;
  5679.          dd = calculate_point_to_line_distance (p, &cons_pnt, &b_pnt, &ii_pnt);
  5680.          if (dd < d)
  5681.          {
  5682.         i_pnt.x = ii_pnt.x;
  5683.         i_pnt.y = ii_pnt.y;
  5684.         d = dd;
  5685.          }
  5686.  
  5687.          b_pnt.x = cons_pnt.x - preview_width;
  5688.          b_pnt.y = cons_pnt.y - preview_width/2;
  5689.          dd = calculate_point_to_line_distance (p, &cons_pnt, &b_pnt, &ii_pnt);
  5690.          if (dd < d)
  5691.          {
  5692.         i_pnt.x = ii_pnt.x;
  5693.         i_pnt.y = ii_pnt.y;
  5694.         d = dd;
  5695.          }
  5696.  
  5697.          x = i_pnt.x;
  5698.          y = i_pnt.y;
  5699.       }
  5700.  
  5701.     if (x % selvals.opts.gridspacing > selvals.opts.gridspacing/2)
  5702.       x += selvals.opts.gridspacing;
  5703.  
  5704.     gp->x = (x/selvals.opts.gridspacing)*selvals.opts.gridspacing;
  5705.  
  5706.     if (((gp->x/selvals.opts.gridspacing) % 2) != 0)
  5707.       {
  5708.          y -= selvals.opts.gridspacing/2;
  5709.  
  5710.          if (y % selvals.opts.gridspacing > selvals.opts.gridspacing/2)
  5711.            y += selvals.opts.gridspacing;
  5712.     
  5713.          gp->y = (selvals.opts.gridspacing/2) + ((y/selvals.opts.gridspacing)*selvals.opts.gridspacing);
  5714.       }
  5715.     else
  5716.       {
  5717.          if (y % selvals.opts.gridspacing > selvals.opts.gridspacing/2)
  5718.            y += selvals.opts.gridspacing;
  5719.     
  5720.          gp->y = (y/selvals.opts.gridspacing)*selvals.opts.gridspacing;
  5721.       }
  5722.  
  5723.     if (!is_butt3)
  5724.       {
  5725.          /* Store the point since it might be used later */
  5726.          cons_pnt = *gp; /* Structure copy */
  5727.       }
  5728.      }
  5729. }
  5730.  
  5731. /* Calculate distance from a point to a line
  5732.  * Taken from the newsgroup comp.graphics.algorithms FAQ. */
  5733. static gint
  5734. calculate_point_to_line_distance (GdkPoint *p,
  5735.                   GdkPoint *A,
  5736.                   GdkPoint *B,
  5737.                   GdkPoint *I)
  5738. {
  5739.    gint L2;
  5740.    gint L;
  5741.  
  5742.    L2 = ((B->x - A->x)*(B->x - A->x)) + ((B->y - A->y)*(B->y - A->y));
  5743.    L = (gint) sqrt (L2);
  5744.  
  5745.    /* gint r; */
  5746.    /* gint s; */
  5747.    /* r = ((A->y - p->y)*(A->y - B->y) - (A->x - p->x)*(B->x - A->x))/L2; */
  5748.    /* s = ((A->y - p->y)*(B->x - A->x) - (A->x - p->x)*(B->y - A->y))/L2; */
  5749.  
  5750.    /* Let I be the point of perpendicular projection of C onto AB. */
  5751.  
  5752.    I->x = A->x + (((A->y - p->y)*(A->y - B->y) - (A->x - p->x)*(B->x - A->x))*(B->x - A->x))/L2;
  5753.    I->y = A->y + (((A->y - p->y)*(A->y - B->y) - (A->x - p->x)*(B->x - A->x))*(B->y - A->y))/L2;
  5754.  
  5755.    return abs ((((A->y - p->y)*(B->x - A->x)) - ((A->x - p->x)*(B->y - A->y)))*L);
  5756. }
  5757.  
  5758. /* Given a point x, y draw a circle */
  5759. static void
  5760. draw_circle (GdkPoint *p)
  5761. {
  5762.   if (!selvals.opts.showcontrol || drawing_pic)
  5763.     return;
  5764.  
  5765.   gdk_draw_arc (gfig_preview->window,
  5766.         gfig_gc,
  5767.         0,
  5768.         p->x - SQ_SIZE/2,
  5769.         p->y - SQ_SIZE/2,
  5770.         SQ_SIZE,
  5771.         SQ_SIZE,
  5772.         0,
  5773.         360*64);
  5774. }
  5775.  
  5776.  
  5777. /* Given a point x, y draw a square around it */
  5778. static void
  5779. draw_sqr (GdkPoint *p)
  5780. {
  5781.   if (!selvals.opts.showcontrol || drawing_pic)
  5782.     return;
  5783.  
  5784.   gdk_draw_rectangle (gfig_preview->window,
  5785.               gfig_gc,
  5786.               0,
  5787.               gfig_scale_x ((gint)p->x) - SQ_SIZE/2,
  5788.               gfig_scale_y ((gint)p->y) - SQ_SIZE/2,
  5789.               (gint)SQ_SIZE,
  5790.               (gint)SQ_SIZE);
  5791. }
  5792.  
  5793. /* Draw the grid on the screen
  5794.  */
  5795.  
  5796. static void
  5797. draw_grid_clear (GtkWidget *widget,
  5798.          gpointer   data)
  5799. {
  5800.   /* wipe slate and start again */
  5801.   dialog_update_preview ();
  5802.   draw_grid (widget, data);
  5803.   draw_objects (current_obj->obj_list, TRUE);
  5804.   gtk_widget_draw (gfig_preview, NULL);
  5805.   gdk_flush ();
  5806. }
  5807.  
  5808. static void
  5809. toggle_tooltips (GtkWidget *widget,
  5810.          gpointer   data)
  5811. {
  5812.   gimp_toggle_button_update (widget, data);
  5813.  
  5814.   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
  5815.     gimp_help_enable_tooltips ();
  5816.   else
  5817.     gimp_help_disable_tooltips ();
  5818. }
  5819.  
  5820. static void
  5821. toggle_show_image (GtkWidget *widget,
  5822.            gpointer   data)
  5823. {
  5824.   /* wipe slate and start again */
  5825.   draw_grid_clear (widget, data);
  5826. }
  5827.  
  5828. static void
  5829. toggle_obj_type (GtkWidget *widget,
  5830.          gpointer   data)
  5831. {
  5832.   GdkCursorType ctype = GDK_LAST_CURSOR;
  5833.   static GdkCursor* p_cursors[DEL_OBJ + 1];
  5834.  
  5835.   if (selvals.otype != (DobjType) data)
  5836.     {
  5837.       /* Mem leak */
  5838.       obj_creating = NULL;
  5839.       tmp_line = NULL;
  5840.       tmp_bezier = NULL;
  5841.  
  5842.       if ((DobjType)data < MOVE_OBJ)
  5843.     {
  5844.       obj_show_single = -1; /* Cancel select preview */
  5845.     }
  5846.       /* Update draw areas */
  5847.       update_draw_area (gfig_preview, NULL);
  5848.       /* And preview */
  5849.       list_button_update (current_obj);
  5850.     }
  5851.  
  5852.   selvals.otype = (DobjType) data;
  5853.  
  5854.   switch (selvals.otype)
  5855.     {
  5856.     case LINE:
  5857.     case CIRCLE:
  5858.     case ELLIPSE:
  5859.     case ARC:
  5860.     case POLY:
  5861.     case STAR:
  5862.     case SPIRAL:
  5863.     case BEZIER:
  5864.     default:
  5865.       ctype = GDK_CROSSHAIR;
  5866.       break;
  5867.     case MOVE_OBJ:
  5868.     case MOVE_POINT:
  5869.     case COPY_OBJ:
  5870.     case MOVE_COPY_OBJ:
  5871.       ctype = GDK_DIAMOND_CROSS;
  5872.       break;
  5873.     case DEL_OBJ:
  5874.       ctype = GDK_PIRATE;
  5875.       break;
  5876.     }
  5877.  
  5878.   if (!p_cursors[selvals.otype])
  5879.     p_cursors[selvals.otype] = gdk_cursor_new (ctype);
  5880.  
  5881.   gdk_window_set_cursor (gfig_preview->window, p_cursors[selvals.otype]);
  5882. }
  5883.  
  5884. static void
  5885. draw_grid_polar (GdkGC *drawgc)
  5886. {
  5887.   gint step;
  5888.   gint loop;
  5889.   gint radius;
  5890.   gint max_rad;
  5891.   gdouble ang_grid;
  5892.   gdouble ang_loop;
  5893.   gdouble ang_radius;
  5894.   /* Pick center and draw concentric circles */
  5895.  
  5896.   gint grid_x_center = preview_width/2;
  5897.   gint grid_y_center = preview_height/2;
  5898.  
  5899.   step = selvals.opts.gridspacing;
  5900.   max_rad = sqrt (preview_width * preview_width +
  5901.           preview_height * preview_height) / 2;
  5902.  
  5903.   for (loop = 0; loop < max_rad; loop += step)
  5904.     {
  5905.       radius = loop;
  5906.  
  5907.       gdk_draw_arc (gfig_preview->window,
  5908.             drawgc,
  5909.             0,
  5910.             grid_x_center - radius,
  5911.             grid_y_center - radius,
  5912.             radius*2,
  5913.             radius*2,
  5914.             0,
  5915.             360 * 64);
  5916.     }
  5917.  
  5918.   /* Lines */
  5919.   ang_grid = 2 * G_PI / get_num_radials ();
  5920.   ang_radius = sqrt ((preview_width * preview_width) +
  5921.              (preview_height * preview_height)) / 2;
  5922.  
  5923.   for (loop = 0; loop <= get_num_radials (); loop++)
  5924.     {
  5925.       gint lx, ly;
  5926.  
  5927.       ang_loop = loop * ang_grid;
  5928.     
  5929.       lx = (gint) RINT (ang_radius * cos (ang_loop));
  5930.       ly = (gint) RINT (ang_radius * sin (ang_loop));
  5931.  
  5932.       gdk_draw_line (gfig_preview->window,
  5933.              drawgc,
  5934.              (gint) lx + (preview_width) / 2,
  5935.              -(gint) ly + (preview_height) / 2,
  5936.              (gint) (preview_width) / 2,
  5937.              (gint) (preview_height) / 2);
  5938.     }
  5939. }
  5940.  
  5941. static void
  5942. draw_grid_sq (GdkGC *drawgc)
  5943. {
  5944.   gint step;
  5945.   gint loop;
  5946.  
  5947.   /* Draw the horizontal lines */
  5948.   step = selvals.opts.gridspacing;
  5949.  
  5950.   for (loop = 0 ; loop < preview_height ; loop += step)
  5951.     {
  5952.       gdk_draw_line (gfig_preview->window,
  5953.              drawgc,
  5954.              (gint)0,
  5955.              (gint)loop,
  5956.              (gint)preview_width,
  5957.              (gint)loop);
  5958.     }
  5959.  
  5960.   /* Draw the vertical lines */
  5961.  
  5962.   for (loop = 0 ; loop < preview_width ; loop += step)
  5963.     {
  5964.       gdk_draw_line (gfig_preview->window,
  5965.              drawgc,
  5966.              (gint)loop,
  5967.              (gint)0,
  5968.              (gint)loop,
  5969.              (gint)preview_height);
  5970.     }
  5971. }
  5972.  
  5973. static void
  5974. draw_grid_iso (GdkGC *drawgc)
  5975. {
  5976.    gint step;
  5977.    gint loop;
  5978.  
  5979.    gint diagonal_start;
  5980.    gint diagonal_end;
  5981.    gint diagonal_width;
  5982.    gint diagonal_height;
  5983.    
  5984.    step = selvals.opts.gridspacing;
  5985.    
  5986.    /* Draw the vertical lines */
  5987.    for (loop = 0 ; loop < preview_width ; loop += step)
  5988.      {
  5989.        gdk_draw_line (gfig_preview->window,
  5990.               drawgc,
  5991.               (gint)loop,
  5992.               (gint)0,
  5993.               (gint)loop,
  5994.               (gint)preview_height);
  5995.      }
  5996.  
  5997.    diagonal_start = preview_width/2;
  5998.    diagonal_start = diagonal_start - (diagonal_start % step);
  5999.    diagonal_start = -diagonal_start;
  6000.    
  6001.    diagonal_end = preview_height + (preview_width/2);
  6002.    diagonal_end = diagonal_end - (diagonal_end % step);
  6003.    
  6004.    diagonal_width = preview_width;
  6005.    diagonal_height = diagonal_width/2;
  6006.    
  6007.    /* Draw diagonal lines */
  6008.    for (loop = diagonal_start ; loop < diagonal_end ; loop += step)
  6009.      {
  6010.        gdk_draw_line (gfig_preview->window,
  6011.               drawgc,
  6012.               (gint)0,
  6013.               (gint)loop,
  6014.               (gint)diagonal_width,
  6015.               (gint)loop + diagonal_height);
  6016.  
  6017.        gdk_draw_line (gfig_preview->window,
  6018.               drawgc,
  6019.               (gint)0,
  6020.               (gint)loop,
  6021.               (gint)diagonal_width,
  6022.               (gint)loop - diagonal_height);
  6023.      }
  6024. }
  6025.  
  6026. static GdkGC *
  6027. gfig_get_grid_gc (GtkWidget *w, gint gctype)
  6028. {
  6029.   switch (gctype)
  6030.     {
  6031.     case GFIG_BLACK_GC:
  6032.       return (w->style->black_gc);
  6033.     case GFIG_WHITE_GC:
  6034.       return (w->style->white_gc);
  6035.     case GFIG_GREY_GC:
  6036.       return (grid_hightlight_drawgc);
  6037.     case GTK_STATE_NORMAL:
  6038.       return (w->style->bg_gc[GTK_STATE_NORMAL]);
  6039.     case GTK_STATE_ACTIVE:
  6040.       return (w->style->bg_gc[GTK_STATE_ACTIVE]);
  6041.     case GTK_STATE_PRELIGHT:
  6042.       return (w->style->bg_gc[GTK_STATE_PRELIGHT]);
  6043.     case GTK_STATE_SELECTED:
  6044.       return (w->style->bg_gc[GTK_STATE_SELECTED]);
  6045.     case GTK_STATE_INSENSITIVE:
  6046.       return (w->style->bg_gc[GTK_STATE_INSENSITIVE]);
  6047.     default:
  6048.       g_warning ("Unknown type for grid colouring\n");
  6049.       return (w->style->bg_gc[GTK_STATE_PRELIGHT]);
  6050.     }
  6051. }
  6052.  
  6053. static void
  6054. draw_grid (GtkWidget *widget,
  6055.       gpointer   data)
  6056. {
  6057.   GdkGC *drawgc;
  6058.   /* Get the size of the preview and calc where the lines go */
  6059.   /* Draw in prelight to start with... */
  6060.   /* Always start in the upper left corner for rect.
  6061.    */
  6062.  
  6063.   if ((preview_width < selvals.opts.gridspacing &&
  6064.        preview_height < selvals.opts.gridspacing) ||
  6065.       drawing_pic)
  6066.     {
  6067.       /* Don't draw if they don't fit */
  6068.       return;
  6069.     }
  6070.  
  6071.   if (selvals.opts.drawgrid)
  6072.     drawgc = gfig_get_grid_gc (gfig_preview, grid_gc_type);
  6073.   else
  6074.     return;
  6075.  
  6076.   if (selvals.opts.gridtype == RECT_GRID)
  6077.     draw_grid_sq (drawgc);
  6078.   else if (selvals.opts.gridtype == POLAR_GRID)
  6079.     draw_grid_polar (drawgc);
  6080.   else if (selvals.opts.gridtype == ISO_GRID)
  6081.     draw_grid_iso (drawgc);
  6082. }
  6083.  
  6084. static void
  6085. do_gfig (void)
  6086. {
  6087.   /* Not sure if requre post proc - leave stub in */
  6088. }
  6089.  
  6090. /* This could belong in a separate file ... but makes it easier to lump into
  6091.  * one when compiling the plugin.
  6092.  */
  6093.  
  6094. /* Stuff for the generation/deletion of objects. */
  6095.  
  6096. /* Objects are easy one they are created - you just go down the object 
  6097.  * list calling the draw function for each object but... when they 
  6098.  * are been created we have to be a little more careful. When 
  6099.  * the first point is placed on the canvas we create the object, 
  6100.  * the mouse position then defines the next point that can move around.
  6101.  * careful how we draw this position.
  6102.  */
  6103.  
  6104. static void
  6105. free_one_obj (Dobject *obj)
  6106. {
  6107.   d_delete_dobjpoints (obj->points);
  6108.   g_free (obj);
  6109. }
  6110.  
  6111. static void
  6112. free_all_objs (DAllObjs * objs)
  6113. {
  6114.   /* Free all objects */
  6115.   DAllObjs * next;
  6116.   
  6117.   while (objs)
  6118.     {
  6119.       free_one_obj (objs->obj);
  6120.       next = objs->next;
  6121.       g_free (objs);
  6122.       objs = next;
  6123.     }
  6124. }
  6125.  
  6126. static gchar *
  6127. get_line (gchar *buf,
  6128.       gint   s,
  6129.       FILE  *from,
  6130.       gint   init)
  6131. {
  6132.   gint slen;
  6133.   char * ret;
  6134.  
  6135.   if (init)
  6136.     line_no = 1;
  6137.   else
  6138.     line_no++;
  6139.  
  6140.   do
  6141.     {
  6142.       ret = fgets (buf, s, from);
  6143.     } while (!ferror (from) && buf[0] == '#');
  6144.  
  6145.   slen = strlen (buf);
  6146.  
  6147.   /* The last newline is a pain */
  6148.   if (slen > 0)
  6149.     buf[slen - 1] = '\0';
  6150.   
  6151.   if (ferror (from))
  6152.     {
  6153.       g_warning (_("Error reading file"));
  6154.       return (0);
  6155.     }
  6156.  
  6157. #ifdef DEBUG
  6158.   printf ("Processing line '%s'\n", buf);
  6159. #endif /* DEBUG */
  6160.  
  6161.   return (ret);
  6162. }
  6163.  
  6164. static void
  6165. gfig_clear_callback (GtkWidget *widget,
  6166.              gpointer   data)
  6167. {
  6168.   /* Make sure we can get back - if we have some objects to get back to */
  6169.   if (!current_obj->obj_list)
  6170.     return;
  6171.  
  6172.   setup_undo ();
  6173.   /* Free all objects */
  6174.   free_all_objs (current_obj->obj_list);
  6175.   current_obj->obj_list = NULL;
  6176.   obj_creating = NULL;
  6177.   tmp_line = NULL;
  6178.   tmp_bezier = NULL;
  6179.   update_draw_area (gfig_preview, NULL);
  6180.   /* And preview */
  6181.   list_button_update (current_obj);
  6182. }
  6183.  
  6184.  
  6185. static void
  6186. gfig_undo_callback (GtkWidget *widget,
  6187.             gpointer   data)
  6188. {
  6189.   if (undo_water_mark >= 0)
  6190.     {
  6191.       /* Free current objects an reinstate previous */
  6192.       free_all_objs (current_obj->obj_list);
  6193.       current_obj->obj_list = NULL;
  6194.       tmp_bezier = tmp_line = obj_creating = NULL;
  6195.       current_obj->obj_list = undo_table[undo_water_mark];
  6196.       undo_water_mark--;
  6197.       /* Update the screen */
  6198.       update_draw_area (gfig_preview, NULL);
  6199.       /* And preview */
  6200.       list_button_update (current_obj);
  6201.       gfig_obj_modified (current_obj, GFIG_MODIFIED);
  6202.       current_obj->obj_status |= GFIG_MODIFIED;
  6203.   }
  6204.  
  6205.   if (undo_water_mark < 0)
  6206.     gtk_widget_set_sensitive (widget, FALSE);
  6207. }
  6208.  
  6209. static void
  6210. clear_undo (void)
  6211. {
  6212.   int lv;
  6213.  
  6214.   for (lv = undo_water_mark; lv >= 0; lv--) 
  6215.     {
  6216.       if (undo_table[lv])
  6217.     free_all_objs (undo_table[lv]);
  6218.       undo_table[lv] = NULL;
  6219.     }
  6220.  
  6221.   undo_water_mark = -1;
  6222.   gtk_widget_set_sensitive (undo_widget, FALSE);
  6223. }
  6224.  
  6225. static void
  6226. setup_undo (void)
  6227. {
  6228.   /* Copy object list to undo buffer */
  6229. #if DEBUG
  6230.   printf ("setup undo level [%d]\n", undo_water_mark);
  6231. #endif /*DEBUG*/  
  6232.  
  6233.   if (!current_obj)
  6234.     {
  6235.       /* If no current_obj must be loading -> no undo */
  6236.       return;
  6237.     }
  6238.  
  6239.   if (undo_water_mark >= selvals.maxundo - 1)
  6240.     {
  6241.       int loop;
  6242.       /* the little one in the bed said "roll over".. */
  6243.       if (undo_table[0])
  6244.     free_one_obj (undo_table[0]->obj);
  6245.       for (loop = 0; loop < undo_water_mark; loop++)
  6246.     {
  6247.       undo_table[loop] = undo_table[loop + 1];
  6248.     }
  6249.     }
  6250.   else
  6251.     {
  6252.       undo_water_mark++;
  6253.     }
  6254.   undo_table[undo_water_mark] = copy_all_objs (current_obj->obj_list);
  6255.   gtk_widget_set_sensitive (undo_widget, TRUE);
  6256.  
  6257.   gfig_obj_modified (current_obj, GFIG_MODIFIED);
  6258.   current_obj->obj_status |= GFIG_MODIFIED;
  6259. }
  6260.  
  6261. /* Given a number of float co-ords adjust for scaling back to org size */
  6262. /* Size is number of PAIRS of points */
  6263. /* FP + int varients */
  6264.  
  6265. static void
  6266. scale_to_orginal_x (gdouble *list)
  6267. {
  6268.   *list *= scale_x_factor;
  6269. }
  6270.  
  6271. static gint
  6272. gfig_scale_x (gint x)
  6273. {
  6274.   if (!selvals.scaletoimage)
  6275.     return (gint) (x * (1 / scale_x_factor));
  6276.   else
  6277.     return x;
  6278. }
  6279.  
  6280. static gint
  6281. gfig_invscale_x (gint x)
  6282. {
  6283.   if (!selvals.scaletoimage)
  6284.     return (gint) (x * (scale_x_factor));
  6285.   else
  6286.     return x;
  6287. }
  6288.  
  6289. static void
  6290. scale_to_orginal_y (gdouble *list)
  6291. {
  6292.   *list *= scale_y_factor;
  6293. }
  6294.  
  6295. static gint
  6296. gfig_scale_y (gint y)
  6297. {
  6298.   if (!selvals.scaletoimage)
  6299.     return (gint) (y * (1 / scale_y_factor));
  6300.   else
  6301.     return y;
  6302. }
  6303.  
  6304. static gint
  6305. gfig_invscale_y (gint y)
  6306. {
  6307.   if (!selvals.scaletoimage)
  6308.     return (gint) (y*(scale_y_factor));
  6309.   else
  6310.     return y;
  6311. }
  6312.  
  6313. /* Pairs x followed by y */
  6314. static void
  6315. scale_to_original_xy (gdouble *list,
  6316.               gint     size)
  6317. {
  6318.   gint i;
  6319.  
  6320.   for (i = 0; i < size * 2; i += 2)
  6321.     {
  6322.       scale_to_orginal_x (&list[i]);
  6323.       scale_to_orginal_y (&list[i + 1]);
  6324.     }
  6325. }
  6326.  
  6327. /* Pairs x followed by y */
  6328. static void
  6329. scale_to_xy (gdouble *list,
  6330.          gint     size)
  6331. {
  6332.   gint i;
  6333.  
  6334.   for (i = 0; i < size * 2; i += 2)
  6335.     {
  6336.       list[i] *= (org_scale_x_factor / scale_x_factor);
  6337.       list[i + 1] *= (org_scale_y_factor / scale_y_factor);
  6338.     }
  6339. }
  6340.  
  6341. /* Given an list of PAIRS of doubles reverse the list */
  6342. /* Size is number of pairs to swap */
  6343. static void
  6344. reverse_pairs_list (gdouble *list,
  6345.             gint     size)
  6346. {
  6347.   gint i;
  6348.  
  6349.   struct cs
  6350.   { 
  6351.     gdouble i1; 
  6352.     gdouble i2;
  6353.   } copyit, *orglist;
  6354.  
  6355.   orglist = (struct cs *) list;
  6356.  
  6357.   /* Uses struct copies */
  6358.   for (i = 0; i < size / 2; i++)
  6359.     {
  6360.       copyit = orglist[i];
  6361.       orglist[i] = orglist[size - 1 - i];
  6362.       orglist[size - 1 - i] = copyit;
  6363.     }
  6364. }
  6365.  
  6366. /* Delete a list of points */
  6367. static void
  6368. d_delete_dobjpoints (DobjPoints * pnts)
  6369. {
  6370.   DobjPoints * next;
  6371.   DobjPoints * pnt2del = pnts;
  6372.  
  6373.   while (pnt2del)
  6374.     {
  6375.       next = pnt2del->next;
  6376.       g_free (pnt2del);
  6377.       pnt2del = next;
  6378.     }
  6379. }
  6380.  
  6381. static DobjPoints *
  6382. d_copy_dobjpoints (DobjPoints * pnts)
  6383. {
  6384.   DobjPoints *ret = NULL;
  6385.   DobjPoints *head = NULL;
  6386.   DobjPoints *newpnt;
  6387.   DobjPoints *pnt2copy = pnts;
  6388.  
  6389.   while (pnt2copy)
  6390.     {
  6391.       newpnt = g_new0 (DobjPoints, 1);
  6392.       newpnt->pnt.x = pnt2copy->pnt.x;
  6393.       newpnt->pnt.y = pnt2copy->pnt.y;
  6394.  
  6395.       if (!ret)
  6396.     head = ret = newpnt;
  6397.       else
  6398.     {
  6399.       head->next = newpnt;
  6400.       head = newpnt;
  6401.     }
  6402.       pnt2copy = pnt2copy->next;
  6403.     }
  6404.  
  6405.   return ret;
  6406. }
  6407.  
  6408. static gint
  6409. scan_obj_points (DobjPoints *opnt,
  6410.          GdkPoint   *pnt)
  6411. {
  6412.   while (opnt)
  6413.     {
  6414.       if (inside_sqr (&opnt->pnt, pnt))
  6415.     {
  6416.       opnt->found_me = TRUE;
  6417.       return TRUE;
  6418.     }
  6419.       opnt->found_me = FALSE;
  6420.       opnt = opnt->next;
  6421.     }
  6422.   return FALSE;
  6423. }
  6424.  
  6425. static Dobject *
  6426. get_nearest_objs (GFigObj  *obj,
  6427.           GdkPoint *pnt)
  6428. {
  6429.   /* Nearest object to given point or NULL */
  6430.   DAllObjs *all;
  6431.   Dobject  *test_obj;
  6432.   gint count = 0;
  6433.  
  6434.   if (!obj)
  6435.     return NULL;
  6436.  
  6437.   all = obj->obj_list;
  6438.  
  6439.   while (all)
  6440.     {
  6441.       test_obj = all->obj;
  6442.  
  6443.       if (count == obj_show_single || obj_show_single == -1)
  6444.     if (scan_obj_points (test_obj->points, pnt))
  6445.       {
  6446.         return test_obj;
  6447.       }
  6448.       all = all->next;
  6449.       count++;
  6450.     }
  6451.   return NULL;
  6452. }
  6453.  
  6454. static void
  6455. scale_obj_points (DobjPoints *opnt,
  6456.           gdouble     scale_x,
  6457.           gdouble     scale_y)
  6458. {
  6459.   while (opnt)
  6460.     {
  6461.       opnt->pnt.x = (gint) (opnt->pnt.x * scale_x);
  6462.       opnt->pnt.y = (gint) (opnt->pnt.y * scale_y);
  6463.       opnt = opnt->next;
  6464.     }
  6465. }
  6466.  
  6467. static void
  6468. remove_obj_from_list (GFigObj *obj,
  6469.               Dobject *del_obj)
  6470. {
  6471.   /* Nearest object to given point or NULL */
  6472.   DAllObjs *all;
  6473.   DAllObjs *prev_all = NULL;
  6474.   
  6475.   g_assert (del_obj != NULL);
  6476.  
  6477.   all = obj->obj_list;
  6478.  
  6479.   while (all)
  6480.     {
  6481.       if (all->obj == del_obj)
  6482.     {
  6483.       /* Found the one to delete */
  6484. #ifdef DEBUG
  6485.       printf ("Found the one to delete\n");
  6486. #endif /* DEBUG */
  6487.  
  6488.       if (prev_all)
  6489.         prev_all->next = all->next;
  6490.       else
  6491.         obj->obj_list = all->next;
  6492.  
  6493.       /* Draw obj (which will actually undraw it! */
  6494.       del_obj->drawfunc (del_obj);
  6495.  
  6496.       free_one_obj (del_obj);
  6497.       g_free (all);
  6498.  
  6499.       if (obj_show_single != -1)
  6500.         {
  6501.           /* We've just deleted the only visible one */
  6502.           draw_grid_clear (NULL, NULL); /*Args not used */
  6503.           obj_show_single = -1; /* Show all again */
  6504.         }
  6505.       return;
  6506.     }
  6507.       prev_all = all;
  6508.       all = all->next;
  6509.     }
  6510.   g_warning (_("Hey where has the object gone ?"));
  6511. }
  6512.  
  6513. static DobjPoints *
  6514. get_diffs (Dobject  *obj,
  6515.        gint16   *xdiff,
  6516.        gint16   *ydiff,
  6517.        GdkPoint *to_pnt)
  6518. {
  6519.   DobjPoints *spnt;
  6520.  
  6521.   g_assert (obj != NULL);
  6522.  
  6523.   spnt = obj->points;
  6524.   
  6525.   if (!spnt)
  6526.     return (NULL); /* no-line */
  6527.   
  6528.   /* Slow slow slowwwwww....*/
  6529.   while (spnt)
  6530.     {
  6531.       if (spnt->found_me)
  6532.     {
  6533.       *xdiff = spnt->pnt.x - to_pnt->x;
  6534.       *ydiff = spnt->pnt.y - to_pnt->y;
  6535.       return (spnt);
  6536.     }
  6537.       spnt = spnt->next;
  6538.     }
  6539.   return (NULL);
  6540. }
  6541.  
  6542. static void
  6543. update_pnts (Dobject *obj,
  6544.          gint16   xdiff,
  6545.          gint16   ydiff)
  6546. {
  6547.   DobjPoints *spnt;
  6548.  
  6549.   g_assert (obj != NULL);
  6550.  
  6551.   /* Update all pnts */
  6552.   spnt = obj->points;
  6553.  
  6554.   if (!spnt)
  6555.     return; /* no-line */
  6556.   
  6557.   /* Go around all the points drawing a line from one to the next */
  6558.   while (spnt)
  6559.     {
  6560.       spnt->pnt.x = spnt->pnt.x - xdiff;
  6561.       spnt->pnt.y = spnt->pnt.y - ydiff;
  6562.       spnt = spnt->next;
  6563.     }
  6564. }
  6565.  
  6566.  
  6567. static void
  6568. do_move_all_obj (GdkPoint *to_pnt)
  6569. {
  6570.   /* Move all objects in one go */
  6571.   /* Undraw/then draw in new pos */
  6572.   DAllObjs *all;
  6573.   Dobject *obj;
  6574.   gint16 xdiff = 0;
  6575.   gint16 ydiff = 0;
  6576.   
  6577.   xdiff = move_all_pnt->x - to_pnt->x;
  6578.   ydiff = move_all_pnt->y - to_pnt->y;
  6579.   
  6580.   if (!xdiff && !ydiff)
  6581.     return;
  6582.   
  6583.   all = current_obj->obj_list;
  6584.  
  6585.   while (all)
  6586.     {
  6587.       obj = all->obj;
  6588.  
  6589.       /* undraw ! */
  6590.       draw_one_obj (obj);
  6591.       
  6592.       update_pnts (obj, xdiff, ydiff);
  6593.       
  6594.       /* Draw in new pos */
  6595.       draw_one_obj (obj);
  6596.  
  6597.       all = all->next;
  6598.     }
  6599.  
  6600.   *move_all_pnt = *to_pnt; /* Structure copy */
  6601. }
  6602.  
  6603.  
  6604. static void
  6605. do_move_obj (Dobject  *obj,
  6606.          GdkPoint *to_pnt)
  6607. {
  6608.   /* Move the whole line - undraw the line to start with */
  6609.   /* Then draw in new pos */
  6610.   gint16 xdiff = 0;
  6611.   gint16 ydiff = 0;
  6612.   
  6613.   get_diffs (obj, &xdiff, &ydiff, to_pnt);
  6614.   
  6615.   if (!xdiff && !ydiff)
  6616.     return;
  6617.   
  6618.   /* undraw ! */
  6619.   draw_one_obj (obj);
  6620.   
  6621.   update_pnts (obj, xdiff, ydiff);
  6622.   
  6623.   /* Draw in new pos */
  6624.   draw_one_obj (obj);
  6625.   
  6626. }
  6627.  
  6628. static void
  6629. do_move_obj_pnt (Dobject  *obj,
  6630.          GdkPoint *to_pnt)
  6631. {
  6632.   /* Move the whole line - undraw the line to start with */
  6633.   /* Then draw in new pos */
  6634.   DobjPoints *spnt;
  6635.   gint16 xdiff = 0;
  6636.   gint16 ydiff = 0;
  6637.   
  6638.   spnt = get_diffs (obj, &xdiff, &ydiff, to_pnt);
  6639.   
  6640.   if ((!xdiff && !ydiff) || !spnt)
  6641.     return;
  6642.   
  6643.   /* undraw ! */
  6644.   draw_one_obj (obj);
  6645.  
  6646.   spnt->pnt.x = spnt->pnt.x - xdiff;
  6647.   spnt->pnt.y = spnt->pnt.y - ydiff;
  6648.   
  6649.   /* Draw in new pos */
  6650.   draw_one_obj (obj);
  6651. }
  6652.  
  6653. /* Save a line away to the specified stream */
  6654.  
  6655. static void
  6656. d_save_line (Dobject *obj,
  6657.          FILE    *to)
  6658. {
  6659.   DobjPoints * spnt;
  6660.  
  6661.   spnt = obj->points;
  6662.  
  6663.   if (!spnt)
  6664.     return; /* End-of-line */
  6665.  
  6666.   fprintf (to, "<LINE>\n");
  6667.  
  6668.   while (spnt)
  6669.     {
  6670.       fprintf (to, "%d %d\n",
  6671.           (gint)spnt->pnt.x,
  6672.           (gint)spnt->pnt.y);
  6673.       spnt = spnt->next;
  6674.     }
  6675.   
  6676.   fprintf (to, "</LINE>\n");
  6677. }
  6678.  
  6679. /* Load a line from the specified stream */
  6680.  
  6681. static Dobject *
  6682. d_load_line (FILE *from)
  6683. {
  6684.   Dobject *new_obj = NULL;
  6685.   gint xpnt;
  6686.   gint ypnt;
  6687.   gchar buf[MAX_LOAD_LINE];
  6688.  
  6689. #ifdef DEBUG
  6690.   printf ("Load line called\n");
  6691. #endif /* DEBUG */
  6692.  
  6693.   while (get_line (buf, MAX_LOAD_LINE, from, 0))
  6694.     {
  6695.       if (sscanf (buf, "%d %d", &xpnt, &ypnt) != 2)
  6696.     {
  6697.       /* Must be the end */
  6698.       if (strcmp ("</LINE>", buf))
  6699.         {
  6700.           g_warning ("[%d] Internal load error while loading line",
  6701.             line_no);
  6702.           return (NULL);
  6703.         }
  6704.       return (new_obj);
  6705.     }
  6706.  
  6707.       if (!new_obj)
  6708.     new_obj = d_new_line (xpnt, ypnt);
  6709.       else
  6710.     d_pnt_add_line (new_obj, xpnt, ypnt, -1);
  6711.     }
  6712.  
  6713.   return (new_obj);
  6714. }
  6715.  
  6716. static Dobject *
  6717. d_copy_line (Dobject *obj)
  6718. {
  6719.   Dobject *nl;
  6720.  
  6721.   if (!obj)
  6722.     return (NULL);
  6723.  
  6724.   g_assert (obj->type == LINE);
  6725.  
  6726.   nl = d_new_line (obj->points->pnt.x, obj->points->pnt.y);
  6727.   
  6728.   nl->points->next = d_copy_dobjpoints (obj->points->next);
  6729.  
  6730.   return (nl);
  6731. }
  6732.  
  6733. /* Draw the given line -- */
  6734. static void
  6735. d_draw_line (Dobject *obj)
  6736. {
  6737.   DobjPoints *spnt;
  6738.   DobjPoints *epnt;
  6739.  
  6740.   spnt = obj->points;
  6741.  
  6742.   if (!spnt)
  6743.     return; /* End-of-line */
  6744.  
  6745.   epnt = spnt->next;
  6746.  
  6747.   while (spnt && epnt)
  6748.     {
  6749. #if DEBUG
  6750.       printf ("Drawing line 0x%x (%x,%x) -> (%x,%x)\n", spnt,
  6751.           (gint)spnt->pnt.x,
  6752.           (gint)spnt->pnt.y,
  6753.           (gint)epnt->pnt.x,
  6754.           (gint)epnt->pnt.y);
  6755. #endif /* DEBUG */
  6756.  
  6757.       draw_sqr (&spnt->pnt);
  6758.       /* Go around all the points drawing a line from one to the next */
  6759.       if (drawing_pic)
  6760.     {
  6761.       gdk_draw_line (pic_preview->window,
  6762.              pic_preview->style->black_gc,
  6763.              adjust_pic_coords ((gint)spnt->pnt.x, preview_width),
  6764.              adjust_pic_coords ((gint)spnt->pnt.y, preview_height),
  6765.              adjust_pic_coords ((gint)epnt->pnt.x, preview_width),
  6766.              adjust_pic_coords ((gint)epnt->pnt.y, preview_height));
  6767.     }
  6768.       else
  6769.     {
  6770.       gdk_draw_line (gfig_preview->window,
  6771.              gfig_gc,
  6772.              gfig_scale_x ((gint)spnt->pnt.x),
  6773.              gfig_scale_y ((gint)spnt->pnt.y),
  6774.              gfig_scale_x ((gint)epnt->pnt.x),
  6775.              gfig_scale_y ((gint)epnt->pnt.y));
  6776.     }
  6777.       spnt = epnt;
  6778.       epnt = epnt->next;
  6779.     }
  6780.   draw_sqr (&spnt->pnt);
  6781. }
  6782.  
  6783. static void 
  6784. d_paint_line (Dobject *obj)
  6785. {
  6786.   DobjPoints * spnt;
  6787.   gdouble *line_pnts;
  6788.   gint seg_count = 0;
  6789.   gint i = 0;
  6790.  
  6791.   spnt = obj->points;
  6792.  
  6793.   /* count */
  6794.  
  6795.   while (spnt)
  6796.     {
  6797.       seg_count++;
  6798.       spnt = spnt->next;
  6799.     }
  6800.  
  6801.   spnt = obj->points;
  6802.  
  6803.   if (!spnt || !seg_count)
  6804.     return; /* no-line */
  6805.  
  6806.   line_pnts = g_new0 (gdouble, 2 * seg_count + 1);
  6807.   
  6808.   /* Go around all the points drawing a line from one to the next */
  6809.   while (spnt)
  6810.     {
  6811.       line_pnts[i++] = spnt->pnt.x;
  6812.       line_pnts[i++] = spnt->pnt.y;
  6813.       spnt = spnt->next;
  6814.     }
  6815.  
  6816.   /* Reverse line if approp */
  6817.   if (selvals.reverselines)
  6818.     reverse_pairs_list (&line_pnts[0], i/2);
  6819.  
  6820.   /* Scale before drawing */
  6821.   if (selvals.scaletoimage)
  6822.     scale_to_original_xy (&line_pnts[0], i/2);
  6823.   else
  6824.     scale_to_xy (&line_pnts[0], i/2);
  6825.  
  6826.   /* One go */
  6827.   if (selvals.painttype == PAINT_BRUSH_TYPE)
  6828.     {
  6829.       gfig_paint (selvals.brshtype,
  6830.           gfig_drawable,
  6831.           seg_count * 2, line_pnts);
  6832.     }
  6833.   else 
  6834.     {
  6835.       gimp_free_select (gfig_image,
  6836.             seg_count * 2, line_pnts,
  6837.             selopt.type,
  6838.             selopt.antia,
  6839.             selopt.feather,
  6840.             selopt.feather_radius);
  6841.     }
  6842.  
  6843.   g_free (line_pnts);
  6844. }
  6845.  
  6846.  
  6847. /* Create a new line object. starting at the x, y point might add styles 
  6848.  * later.
  6849.  */
  6850.  
  6851. static Dobject *
  6852. d_new_line (gint x,
  6853.         gint y)
  6854. {
  6855.   Dobject    *nobj;
  6856.   DobjPoints *npnt;
  6857.  
  6858.   /* Get new object and starting point */
  6859.  
  6860.   /* Start point */
  6861.   npnt = g_new0 (DobjPoints, 1);
  6862.  
  6863. #if DEBUG
  6864.   printf ("New line start at (%x,%x)\n", x, y);
  6865. #endif /* DEBUG */
  6866.   npnt->pnt.x = x;
  6867.   npnt->pnt.y = y;
  6868.  
  6869.   nobj = g_new0 (Dobject, 1);
  6870.  
  6871.   nobj->type = LINE;
  6872.   nobj->points = npnt;
  6873.   nobj->drawfunc  = d_draw_line;
  6874.   nobj->loadfunc  = d_load_line;
  6875.   nobj->savefunc  = d_save_line;
  6876.   nobj->paintfunc = d_paint_line;
  6877.   nobj->copyfunc  = d_copy_line;
  6878.  
  6879.   return (nobj);
  6880. }
  6881.  
  6882. /* You guessed it delete the object !*/
  6883. /*
  6884. static void
  6885. d_delete_line (Dobject *obj)
  6886. {
  6887.   g_assert (obj != NULL);
  6888.   * First free the list of points - then the object itself *
  6889.   d_delete_dobjpoints (obj->points);
  6890.   g_free (obj);
  6891. }
  6892. */
  6893.  
  6894. /* Add a point to a line (given x, y)
  6895.  * pos = 0 = head
  6896.  * pos = -1 = tail
  6897.  * 0 < pos = nth position
  6898.  */
  6899.  
  6900. static void
  6901. d_pnt_add_line (Dobject *obj,
  6902.         gint     x,
  6903.         gint     y,
  6904.         gint     pos)
  6905. {
  6906.   DobjPoints *npnts = g_new0 (DobjPoints, 1);
  6907.  
  6908.   g_assert (obj != NULL);
  6909.  
  6910.   npnts->pnt.x = x;
  6911.   npnts->pnt.y = y;
  6912.  
  6913.   if (!pos)
  6914.     {
  6915.       /* Add to head */
  6916.       npnts->next = obj->points;
  6917.       obj->points = npnts;
  6918.     }
  6919.   else
  6920.     {
  6921.       DobjPoints *pnt = obj->points;
  6922.  
  6923.       /* Go down chain until the end if pos */
  6924.       while (pos < 0 || pos-- > 0)
  6925.     {
  6926.       if (!(pnt->next) || !pos)
  6927.         {
  6928.           npnts->next = pnt->next;
  6929.           pnt->next = npnts;
  6930.           break;
  6931.         }
  6932.       else
  6933.         {
  6934.           pnt = pnt->next;
  6935.         }
  6936.     }
  6937.     }
  6938. }
  6939.  
  6940. /* Update end point of line */
  6941. static void
  6942. d_update_line (GdkPoint *pnt)
  6943. {
  6944.   DobjPoints *spnt, *epnt;
  6945.   /* Get last but one segment and undraw it -
  6946.    * Then draw new segment in.
  6947.    * always dealing with the static object.
  6948.    */
  6949.  
  6950.   /* Get start of segments */
  6951.   spnt = obj_creating->points;
  6952.   
  6953.   if (!spnt)
  6954.     return; /* No points */
  6955.  
  6956.   if ((epnt = spnt->next))
  6957.     {
  6958.       /* undraw  current */
  6959.       /* Draw square on point */
  6960.       draw_circle (&epnt->pnt);
  6961.       
  6962.       gdk_draw_line (gfig_preview->window,
  6963.              /*gfig_preview->style->bg_gc[GTK_STATE_NORMAL],*/
  6964.              gfig_gc,
  6965.              (gint) spnt->pnt.x,
  6966.              (gint) spnt->pnt.y,
  6967.              (gint) epnt->pnt.x,
  6968.              (gint) epnt->pnt.y);
  6969.       g_free (epnt);
  6970.     }
  6971.  
  6972.   /* draw new */
  6973.   /* Draw circle on point */
  6974.   draw_circle (pnt);
  6975.  
  6976.   epnt = g_new0 (DobjPoints, 1);
  6977.  
  6978.   epnt->pnt.x = pnt->x;
  6979.   epnt->pnt.y = pnt->y;
  6980.  
  6981.   gdk_draw_line (gfig_preview->window,
  6982.          /*gfig_preview->style->bg_gc[GTK_STATE_NORMAL],*/
  6983.          gfig_gc,
  6984.          (gint) spnt->pnt.x,
  6985.          (gint) spnt->pnt.y,
  6986.          (gint) epnt->pnt.x,
  6987.          (gint) epnt->pnt.y);
  6988.   spnt->next = epnt;
  6989. }
  6990.  
  6991. static void
  6992. d_line_start (GdkPoint *pnt,
  6993.           gint      shift_down)
  6994. {
  6995.   if (!obj_creating || !shift_down)
  6996.     {
  6997.       /* Draw square on point */
  6998.       /* Must delete obj_creating if we have one */
  6999.       obj_creating = d_new_line (pnt->x, pnt->y);
  7000.     }
  7001.   else
  7002.     {
  7003.       /* Contniuation */
  7004.       d_update_line (pnt);
  7005.     }
  7006. }
  7007.  
  7008. static void
  7009. d_line_end (GdkPoint *pnt,
  7010.         gint      shift_down)
  7011. {
  7012.   /* Undraw the last circle */
  7013.   draw_circle (pnt);
  7014.  
  7015.   if (shift_down)
  7016.     {
  7017.       if (tmp_line)
  7018.     {
  7019.       GdkPoint tmp_pnt = *pnt;
  7020.  
  7021.       if (need_to_scale)
  7022.         {
  7023.           tmp_pnt.x = (gint) (pnt->x * scale_x_factor);
  7024.           tmp_pnt.y = (gint) (pnt->y * scale_y_factor);
  7025.         }
  7026.  
  7027.       d_pnt_add_line (tmp_line, tmp_pnt.x, tmp_pnt.y, -1);
  7028.       free_one_obj (obj_creating);
  7029.       /* Must free obj_creating */
  7030.     }
  7031.       else
  7032.     {
  7033.       tmp_line = obj_creating;
  7034.       add_to_all_obj (current_obj, obj_creating);
  7035.     }
  7036.  
  7037.       obj_creating = d_new_line (pnt->x, pnt->y);
  7038.     }
  7039.   else
  7040.     {
  7041.       if (tmp_line)
  7042.     {
  7043.       GdkPoint tmp_pnt = *pnt;
  7044.  
  7045.       if (need_to_scale)
  7046.         {
  7047.           tmp_pnt.x = (gint) (pnt->x * scale_x_factor);
  7048.           tmp_pnt.y = (gint) (pnt->y * scale_y_factor);
  7049.         }
  7050.  
  7051.       d_pnt_add_line (tmp_line, tmp_pnt.x, tmp_pnt.y, -1);
  7052.       free_one_obj (obj_creating);
  7053.       /* Must free obj_creating */
  7054.     }
  7055.       else
  7056.     {
  7057.       add_to_all_obj (current_obj, obj_creating);
  7058.     }
  7059.       obj_creating = NULL;
  7060.       tmp_line = NULL;
  7061.     }
  7062.   /*update_draw_area (gfig_preview, NULL);*/
  7063. }
  7064.  
  7065. /* Save a circle away to the specified stream */
  7066.  
  7067. static void
  7068. d_save_circle (Dobject *obj,
  7069.            FILE    *to)
  7070. {
  7071.   DobjPoints *spnt;
  7072.  
  7073.   spnt = obj->points;
  7074.  
  7075.   if (!spnt)
  7076.     return;
  7077.  
  7078.   fprintf (to, "<CIRCLE>\n");
  7079.  
  7080.   while (spnt)
  7081.     {
  7082.       fprintf (to, "%d %d\n",
  7083.            (gint) spnt->pnt.x,
  7084.            (gint) spnt->pnt.y);
  7085.       spnt = spnt->next;
  7086.     }
  7087.  
  7088.   fprintf (to, "</CIRCLE>\n");
  7089. }
  7090.  
  7091. /* Load a circle from the specified stream */
  7092.  
  7093. static Dobject *
  7094. d_load_circle (FILE *from)
  7095. {
  7096.   Dobject *new_obj = NULL;
  7097.   gint     xpnt;
  7098.   gint     ypnt;
  7099.   gchar    buf[MAX_LOAD_LINE];
  7100.  
  7101. #ifdef DEBUG
  7102.   printf ("Load circle called\n");
  7103. #endif /* DEBUG */
  7104.  
  7105.   while (get_line (buf, MAX_LOAD_LINE, from, 0))
  7106.     {
  7107.       if (sscanf (buf, "%d %d", &xpnt, &ypnt) != 2)
  7108.     {
  7109.       /* Must be the end */
  7110.       if (strcmp ("</CIRCLE>", buf))
  7111.         {
  7112.           g_warning ("[%d] Internal load error while loading circle",
  7113.              line_no);
  7114.           return NULL;
  7115.         }
  7116.       return new_obj;
  7117.     }
  7118.  
  7119.       if (!new_obj)
  7120.     new_obj = d_new_circle (xpnt, ypnt);
  7121.       else
  7122.     {
  7123.       DobjPoints *edge_pnt;
  7124.       /* Circles only have two points */
  7125.       edge_pnt = g_new0 (DobjPoints, 1);
  7126.  
  7127.       edge_pnt->pnt.x = xpnt;
  7128.       edge_pnt->pnt.y = ypnt;
  7129.       
  7130.       new_obj->points->next = edge_pnt;
  7131.     }
  7132.     }
  7133.  
  7134.   g_warning ("[%d] Not enough points for circle", line_no);
  7135.   return NULL;
  7136. }
  7137.  
  7138. static void
  7139. d_draw_circle (Dobject * obj)
  7140. {
  7141.   DobjPoints *center_pnt;
  7142.   DobjPoints *edge_pnt;
  7143.   gdouble     radius;
  7144.  
  7145.   center_pnt = obj->points;
  7146.  
  7147.   if (!center_pnt)
  7148.     return; /* End-of-line */
  7149.  
  7150.   edge_pnt = center_pnt->next;
  7151.  
  7152.   if (!edge_pnt)
  7153.     {
  7154.       g_warning ("Internal error - circle no edge pnt");
  7155.     }
  7156.  
  7157.   radius = sqrt (((center_pnt->pnt.x - edge_pnt->pnt.x) *
  7158.           (center_pnt->pnt.x - edge_pnt->pnt.x)) +
  7159.          ((center_pnt->pnt.y - edge_pnt->pnt.y) *
  7160.           (center_pnt->pnt.y - edge_pnt->pnt.y)));
  7161.  
  7162.   draw_sqr (¢er_pnt->pnt);
  7163.   draw_sqr (&edge_pnt->pnt);
  7164.  
  7165.   if (drawing_pic)
  7166.     {
  7167.       gdk_draw_arc (pic_preview->window,
  7168.             pic_preview->style->black_gc,
  7169.             0,
  7170.             adjust_pic_coords (center_pnt->pnt.x - radius,
  7171.                        preview_width),
  7172.             adjust_pic_coords (center_pnt->pnt.y - radius,
  7173.                        preview_height),
  7174.             adjust_pic_coords (radius * 2,
  7175.                        preview_width),
  7176.             adjust_pic_coords (radius * 2,
  7177.                        preview_height),
  7178.             0,
  7179.             360 * 64);
  7180.     }
  7181.   else
  7182.     {
  7183.       gdk_draw_arc (gfig_preview->window,
  7184.             gfig_gc,
  7185.             0,
  7186.             gfig_scale_x (center_pnt->pnt.x - (gint) RINT (radius)),
  7187.             gfig_scale_y (center_pnt->pnt.y - (gint) RINT (radius)),
  7188.             gfig_scale_x ((gint) RINT (radius) * 2),
  7189.             gfig_scale_y ((gint) RINT (radius) * 2),
  7190.             0,
  7191.             360 * 64);
  7192.     }
  7193. }
  7194.  
  7195. static void
  7196. d_paint_circle (Dobject *obj)
  7197. {
  7198.   DobjPoints * center_pnt;
  7199.   DobjPoints * edge_pnt;
  7200.   gint radius;
  7201.   gdouble dpnts[4];
  7202.  
  7203.   g_assert (obj != NULL);
  7204.  
  7205.   if (selvals.approxcircles)
  7206.     {
  7207.       obj->type_data = (gpointer) 600;
  7208. #ifdef DEBUG
  7209.       printf ("Painting circle as polygon\n");
  7210. #endif /* DEBUG */
  7211.       d_paint_poly (obj);
  7212.       return;
  7213.     }      
  7214.  
  7215.   /* Drawing circles is hard .
  7216.    * 1) select circle
  7217.    * 2) stroke it
  7218.    */
  7219.   center_pnt = obj->points;
  7220.  
  7221.   if (!center_pnt)
  7222.     return; /* End-of-line */
  7223.  
  7224.   edge_pnt = center_pnt->next;
  7225.  
  7226.   if (!edge_pnt)
  7227.     {
  7228.       g_error ("Internal error - circle no edge pnt");
  7229.     }
  7230.  
  7231.   radius = (gint) sqrt (((center_pnt->pnt.x - edge_pnt->pnt.x) *
  7232.              (center_pnt->pnt.x - edge_pnt->pnt.x)) +
  7233.             ((center_pnt->pnt.y - edge_pnt->pnt.y) *
  7234.              (center_pnt->pnt.y - edge_pnt->pnt.y)));
  7235.  
  7236.   dpnts[0] = (gdouble) center_pnt->pnt.x - radius;
  7237.   dpnts[1] = (gdouble) center_pnt->pnt.y - radius;
  7238.   dpnts[3] = dpnts[2] = (gdouble) radius * 2;
  7239.  
  7240.   /* Scale before drawing */
  7241.   if (selvals.scaletoimage)
  7242.     scale_to_original_xy (&dpnts[0], 2);
  7243.   else
  7244.     scale_to_xy (&dpnts[0], 2);
  7245.  
  7246.   gimp_ellipse_select (gfig_image,
  7247.                dpnts[0], dpnts[1],
  7248.                dpnts[2], dpnts[3],
  7249.                selopt.type,
  7250.                selopt.antia,
  7251.                selopt.feather,
  7252.                selopt.feather_radius);
  7253.  
  7254.   /* Is selection all we need ? */
  7255.   if (selvals.painttype == PAINT_SELECTION_TYPE)
  7256.     return;
  7257.  
  7258.   gimp_edit_stroke (gfig_drawable);
  7259.  
  7260.   gimp_selection_clear (gfig_image);
  7261. }
  7262.  
  7263. static Dobject *
  7264. d_copy_circle (Dobject * obj)
  7265. {
  7266.   Dobject *nc;
  7267.  
  7268. #if DEBUG
  7269.   printf ("Copy circle\n");
  7270. #endif /*DEBUG*/
  7271.   if (!obj)
  7272.     return NULL;
  7273.  
  7274.   g_assert (obj->type == CIRCLE);
  7275.  
  7276.   nc = d_new_circle (obj->points->pnt.x, obj->points->pnt.y);
  7277.  
  7278.   nc->points->next = d_copy_dobjpoints (obj->points->next);
  7279.  
  7280. #if DEBUG
  7281.   printf ("Circle (%x,%x) to (%x,%x)\n",
  7282.       nc->points->pnt.x, obj->points->pnt.y,
  7283.       nc->points->next->pnt.x, obj->points->next->pnt.y);
  7284.   printf ("Done copy\n");
  7285. #endif /*DEBUG*/
  7286.   return nc;
  7287. }
  7288.  
  7289. static Dobject *
  7290. d_new_circle (gint x,
  7291.           gint y)
  7292. {
  7293.   Dobject *nobj;
  7294.   DobjPoints *npnt;
  7295.  
  7296.   /* Get new object and starting point */
  7297.  
  7298.   /* Start point */
  7299.   npnt = g_new0 (DobjPoints, 1);
  7300.  
  7301. #if DEBUG
  7302.   printf ("New circle start at (%x,%x)\n", x, y);
  7303. #endif /* DEBUG */
  7304.   npnt->pnt.x = x;
  7305.   npnt->pnt.y = y;
  7306.  
  7307.   nobj = g_new0 (Dobject, 1);
  7308.  
  7309.   nobj->type   = CIRCLE;
  7310.   nobj->points = npnt;
  7311.   nobj->drawfunc  = d_draw_circle;
  7312.   nobj->loadfunc  = d_load_circle;
  7313.   nobj->savefunc  = d_save_circle;
  7314.   nobj->paintfunc = d_paint_circle;
  7315.   nobj->copyfunc  = d_copy_circle;
  7316.  
  7317.   return nobj;
  7318. }
  7319.  
  7320. static void
  7321. d_update_circle (GdkPoint *pnt)
  7322. {
  7323.   DobjPoints *center_pnt, *edge_pnt;
  7324.   gdouble radius;
  7325.  
  7326.   /* Undraw last one then draw new one */
  7327.   center_pnt = obj_creating->points;
  7328.  
  7329.   if (!center_pnt)
  7330.     return; /* No points */
  7331.  
  7332.   if ((edge_pnt = center_pnt->next))
  7333.     {
  7334.       /* Undraw current */
  7335.       draw_circle (&edge_pnt->pnt);
  7336.       radius = sqrt (((center_pnt->pnt.x - edge_pnt->pnt.x) *
  7337.               (center_pnt->pnt.x - edge_pnt->pnt.x)) +
  7338.              ((center_pnt->pnt.y - edge_pnt->pnt.y) *
  7339.               (center_pnt->pnt.y - edge_pnt->pnt.y)));
  7340.       
  7341.       gdk_draw_arc (gfig_preview->window,
  7342.             gfig_gc,
  7343.             0,
  7344.             center_pnt->pnt.x - (gint) RINT (radius),
  7345.             center_pnt->pnt.y - (gint) RINT (radius),
  7346.             (gint) RINT (radius) * 2,
  7347.             (gint) RINT (radius) * 2,
  7348.             0,
  7349.             360 * 64);
  7350.     }
  7351.  
  7352.   draw_circle (pnt);
  7353.  
  7354.   edge_pnt = g_new0 (DobjPoints, 1);
  7355.  
  7356.   edge_pnt->pnt.x = pnt->x;
  7357.   edge_pnt->pnt.y = pnt->y;
  7358.  
  7359.   radius = sqrt (((center_pnt->pnt.x - edge_pnt->pnt.x) *
  7360.           (center_pnt->pnt.x - edge_pnt->pnt.x)) +
  7361.          ((center_pnt->pnt.y - edge_pnt->pnt.y) *
  7362.           (center_pnt->pnt.y - edge_pnt->pnt.y)));
  7363.  
  7364.   gdk_draw_arc (gfig_preview->window,
  7365.         gfig_gc,
  7366.         0,
  7367.         center_pnt->pnt.x - (gint) RINT (radius),
  7368.         center_pnt->pnt.y - (gint) RINT (radius),
  7369.         (gint) RINT (radius) * 2,
  7370.         (gint) RINT (radius) * 2,
  7371.         0,
  7372.         360 * 64);
  7373.  
  7374.   center_pnt->next = edge_pnt;
  7375. }
  7376.  
  7377. static void
  7378. d_circle_start (GdkPoint *pnt,
  7379.         gint      shift_down)
  7380. {
  7381.   obj_creating = d_new_circle (pnt->x, pnt->y);
  7382. }
  7383.  
  7384. static void
  7385. d_circle_end (GdkPoint *pnt,
  7386.           gint      shift_down)
  7387. {
  7388.   /* Under contrl point */
  7389.   if (!obj_creating->points->next)
  7390.     {
  7391.       /* No circle created */
  7392.       free_one_obj (obj_creating);
  7393.     }
  7394.   else
  7395.     {
  7396.       draw_circle (pnt);
  7397.       add_to_all_obj (current_obj, obj_creating);
  7398.     }
  7399.  
  7400.   obj_creating = NULL;
  7401. }
  7402.  
  7403. /* Save an ellipse away to the specified stream */
  7404.  
  7405. static void
  7406. d_save_ellipse (Dobject *obj,
  7407.         FILE    *to)
  7408. {
  7409.   DobjPoints *spnt;
  7410.  
  7411.   spnt = obj->points;
  7412.  
  7413.   if (!spnt)
  7414.     return;
  7415.  
  7416.   fprintf (to, "<ELLIPSE>\n");
  7417.  
  7418.   while (spnt)
  7419.     {
  7420.       fprintf (to, "%d %d\n",
  7421.            (gint) spnt->pnt.x,
  7422.            (gint) spnt->pnt.y);
  7423.       spnt = spnt->next;
  7424.     }
  7425.  
  7426.   fprintf (to, "</ELLIPSE>\n");
  7427. }
  7428.  
  7429. /* Load a circle from the specified stream */
  7430.  
  7431. static Dobject *
  7432. d_load_ellipse (FILE *from)
  7433. {
  7434.   Dobject *new_obj = NULL;
  7435.   gint     xpnt;
  7436.   gint     ypnt;
  7437.   gchar    buf[MAX_LOAD_LINE];
  7438.  
  7439. #ifdef DEBUG
  7440.   printf ("Load ellipse called\n");
  7441. #endif /* DEBUG */
  7442.  
  7443.   while (get_line (buf, MAX_LOAD_LINE, from, 0))
  7444.     {
  7445.       if (sscanf (buf, "%d %d", &xpnt, &ypnt) != 2)
  7446.     {
  7447.       /* Must be the end */
  7448.       if (strcmp ("</ELLIPSE>", buf))
  7449.         {
  7450.           g_message ("[%d] Internal load error while loading ellipse",
  7451.              line_no);
  7452.           return NULL;
  7453.         }
  7454.       return new_obj;
  7455.     }
  7456.  
  7457.       if (!new_obj)
  7458.     new_obj = d_new_ellipse (xpnt, ypnt);
  7459.       else
  7460.     {
  7461.       DobjPoints *edge_pnt;
  7462.       /* Circles only have two points */
  7463.       edge_pnt = g_new0 (DobjPoints, 1);
  7464.  
  7465.       edge_pnt->pnt.x = xpnt;
  7466.       edge_pnt->pnt.y = ypnt;
  7467.  
  7468.       new_obj->points->next = edge_pnt;
  7469.     }
  7470.     }
  7471.  
  7472.   g_message ("[%d] Not enough points for ellipse", line_no);
  7473.   return NULL;
  7474. }
  7475.  
  7476. static void
  7477. d_draw_ellipse (Dobject * obj)
  7478. {
  7479.   DobjPoints *center_pnt;
  7480.   DobjPoints *edge_pnt;
  7481.   gint bound_wx;
  7482.   gint bound_wy;
  7483.   gint top_x;
  7484.   gint top_y;
  7485.  
  7486.   center_pnt = obj->points;
  7487.  
  7488.   if (!center_pnt)
  7489.     return; /* End-of-line */
  7490.  
  7491.   edge_pnt = center_pnt->next;
  7492.  
  7493.   if (!edge_pnt)
  7494.     {
  7495.       g_warning ("Internal error - ellipse no edge pnt");
  7496.     }
  7497.  
  7498.   draw_sqr (¢er_pnt->pnt);
  7499.   draw_sqr (&edge_pnt->pnt);
  7500.  
  7501.   bound_wx = abs (center_pnt->pnt.x - edge_pnt->pnt.x) * 2;
  7502.   bound_wy = abs (center_pnt->pnt.y - edge_pnt->pnt.y) * 2;
  7503.  
  7504.   if (edge_pnt->pnt.x > center_pnt->pnt.x)
  7505.     top_x = 2 * center_pnt->pnt.x - edge_pnt->pnt.x;
  7506.   else
  7507.     top_x = edge_pnt->pnt.x;
  7508.   
  7509.   if (edge_pnt->pnt.y > center_pnt->pnt.y)
  7510.     top_y = 2 * center_pnt->pnt.y - edge_pnt->pnt.y;
  7511.   else
  7512.     top_y = edge_pnt->pnt.y;
  7513.  
  7514.   if (drawing_pic)
  7515.     {
  7516.       gdk_draw_arc (pic_preview->window,
  7517.             pic_preview->style->black_gc,
  7518.             0,
  7519.             adjust_pic_coords (top_x,
  7520.                        preview_width),
  7521.             adjust_pic_coords (top_y,
  7522.                        preview_height),
  7523.             adjust_pic_coords (bound_wx,
  7524.                        preview_width),
  7525.             adjust_pic_coords (bound_wy,
  7526.                        preview_height),
  7527.             0,
  7528.             360 * 64);
  7529.     }
  7530.   else
  7531.     {
  7532.       gdk_draw_arc (gfig_preview->window,
  7533.             gfig_gc,
  7534.             0,
  7535.             gfig_scale_x (top_x),
  7536.             gfig_scale_y (top_y),
  7537.             gfig_scale_x (bound_wx),
  7538.             gfig_scale_y (bound_wy),
  7539.             0,
  7540.             360 * 64);
  7541.     }
  7542. }
  7543.  
  7544. static void
  7545. d_paint_approx_ellipse (Dobject *obj)
  7546. {
  7547.   /* first point center */
  7548.   /* Next point is radius */
  7549.   gdouble *line_pnts;
  7550.   gint seg_count = 0;
  7551.   gint i = 0;
  7552.   DobjPoints * center_pnt;
  7553.   DobjPoints * radius_pnt;
  7554.   gdouble a_axis;
  7555.   gdouble b_axis;
  7556.   gdouble ang_grid;
  7557.   gdouble ang_loop;
  7558.   gdouble radius;
  7559.   gint loop;
  7560.   GdkPoint first_pnt, last_pnt;
  7561.   gint first = 1;
  7562.  
  7563.   g_assert (obj != NULL);
  7564.  
  7565.   /* count - add one to close polygon */
  7566.   seg_count = 600;
  7567.  
  7568.   center_pnt = obj->points;
  7569.  
  7570.   if (!center_pnt || !seg_count)
  7571.     return; /* no-line */
  7572.  
  7573.   line_pnts = g_new0 (gdouble, 2 * seg_count + 1);
  7574.  
  7575.   /* Go around all the points drawing a line from one to the next */
  7576.  
  7577.   radius_pnt = center_pnt->next; /* this defines the vetices */
  7578.  
  7579.   /* Have center and radius - get lines */
  7580.   a_axis = ((gdouble) (radius_pnt->pnt.x - center_pnt->pnt.x));
  7581.   b_axis = ((gdouble) (radius_pnt->pnt.y - center_pnt->pnt.y));
  7582.  
  7583.   /* Lines */
  7584.   ang_grid = 2 * G_PI / (gdouble) (gint) 600;
  7585.  
  7586.   for (loop = 0; loop < (gint) 600; loop++)
  7587.     {
  7588.       gdouble lx, ly;
  7589.       GdkPoint calc_pnt;
  7590.  
  7591.       ang_loop = (gdouble)loop * ang_grid;
  7592.  
  7593.       radius = (a_axis * b_axis /
  7594.         (sqrt (cos (ang_loop) * cos (ang_loop) *
  7595.                (b_axis * b_axis - a_axis * a_axis) + a_axis * a_axis)));
  7596.  
  7597.       lx = radius * cos (ang_loop);
  7598.       ly = radius * sin (ang_loop);
  7599.  
  7600.       calc_pnt.x = (gint) RINT (lx + center_pnt->pnt.x);
  7601.       calc_pnt.y = (gint) RINT (ly + center_pnt->pnt.y);
  7602.  
  7603.       /* Miss out duped pnts */
  7604.       if (!first)
  7605.     {
  7606.       if (calc_pnt.x == last_pnt.x && calc_pnt.y == last_pnt.y)
  7607.         {
  7608.           continue;
  7609.         }
  7610.     }
  7611.  
  7612.       last_pnt.x = line_pnts[i++] = calc_pnt.x;
  7613.       last_pnt.y = line_pnts[i++] = calc_pnt.y;
  7614.  
  7615.       if (first)
  7616.     {
  7617.       first_pnt.x = calc_pnt.x;
  7618.       first_pnt.y = calc_pnt.y;
  7619.       first = 0;
  7620.     }
  7621.     }
  7622.  
  7623.   line_pnts[i++] = first_pnt.x;
  7624.   line_pnts[i++] = first_pnt.y;
  7625.  
  7626.   /* Reverse line if approp */
  7627.   if (selvals.reverselines)
  7628.     reverse_pairs_list (&line_pnts[0], i / 2);
  7629.  
  7630.   /* Scale before drawing */
  7631.   if (selvals.scaletoimage)
  7632.     scale_to_original_xy (&line_pnts[0], i / 2);
  7633.   else
  7634.     scale_to_xy (&line_pnts[0], i / 2);
  7635.  
  7636.   /* One go */
  7637.   if (selvals.painttype == PAINT_BRUSH_TYPE)
  7638.     {
  7639.       gfig_paint (selvals.brshtype,
  7640.           gfig_drawable,
  7641.           i, line_pnts);
  7642.     }
  7643.   else
  7644.     {
  7645.       gimp_free_select (gfig_image,
  7646.             i, line_pnts,
  7647.             selopt.type,
  7648.             selopt.antia,
  7649.             selopt.feather,
  7650.             selopt.feather_radius);
  7651.     }
  7652.  
  7653.   g_free (line_pnts);
  7654. }
  7655.  
  7656.  
  7657.  
  7658. static void
  7659. d_paint_ellipse (Dobject *obj)
  7660. {
  7661.   DobjPoints * center_pnt;
  7662.   DobjPoints * edge_pnt;
  7663.   gint bound_wx;
  7664.   gint bound_wy;
  7665.   gint top_x;
  7666.   gint top_y;
  7667.   gdouble dpnts[4];
  7668.  
  7669.   /* Drawing ellipse is hard .
  7670.    * 1) select circle
  7671.    * 2) stroke it
  7672.    */
  7673.  
  7674.   g_assert (obj != NULL);
  7675.  
  7676.   if (selvals.approxcircles)
  7677.     {
  7678. #ifdef DEBUG
  7679.       printf ("Painting ellipse as polygon\n");
  7680. #endif /* DEBUG */
  7681.       d_paint_approx_ellipse (obj);
  7682.       return;
  7683.     }      
  7684.  
  7685.   center_pnt = obj->points;
  7686.  
  7687.   if (!center_pnt)
  7688.     return; /* End-of-line */
  7689.  
  7690.   edge_pnt = center_pnt->next;
  7691.  
  7692.   if (!edge_pnt)
  7693.     {
  7694.       g_error ("Internal error - ellipse no edge pnt");
  7695.     }
  7696.  
  7697.   bound_wx = abs (center_pnt->pnt.x - edge_pnt->pnt.x)*2;
  7698.   bound_wy = abs (center_pnt->pnt.y - edge_pnt->pnt.y)*2;
  7699.  
  7700.   if (edge_pnt->pnt.x > center_pnt->pnt.x)
  7701.     top_x = 2*center_pnt->pnt.x - edge_pnt->pnt.x;
  7702.   else
  7703.     top_x = edge_pnt->pnt.x;
  7704.   
  7705.   if (edge_pnt->pnt.y > center_pnt->pnt.y)
  7706.     top_y = 2*center_pnt->pnt.y - edge_pnt->pnt.y;
  7707.   else
  7708.     top_y = edge_pnt->pnt.y;
  7709.  
  7710.   dpnts[0] = (gdouble)top_x;
  7711.   dpnts[1] = (gdouble)top_y;
  7712.   dpnts[2] = (gdouble)bound_wx;
  7713.   dpnts[3] = (gdouble)bound_wy;
  7714.  
  7715.   /* Scale before drawing */
  7716.   if (selvals.scaletoimage)
  7717.     scale_to_original_xy (&dpnts[0], 2);
  7718.   else
  7719.     scale_to_xy (&dpnts[0], 2);
  7720.  
  7721.  
  7722.   gimp_ellipse_select (gfig_image,
  7723.                dpnts[0], dpnts[1],
  7724.                dpnts[2], dpnts[3],
  7725.                selopt.type,
  7726.                selopt.antia,
  7727.                selopt.feather,
  7728.                selopt.feather_radius);
  7729.  
  7730.   /* Is selection all we need ? */
  7731.   if (selvals.painttype == PAINT_SELECTION_TYPE)
  7732.     return;
  7733.  
  7734.   gimp_edit_stroke (gfig_drawable);
  7735.  
  7736.   gimp_selection_clear (gfig_image);
  7737. }
  7738.  
  7739. static Dobject *
  7740. d_copy_ellipse (Dobject * obj)
  7741. {
  7742.   Dobject *nc;
  7743.  
  7744. #if DEBUG
  7745.   printf ("Copy ellipse\n");
  7746. #endif /*DEBUG*/
  7747.   if (!obj)
  7748.     return (NULL);
  7749.  
  7750.   g_assert (obj->type == ELLIPSE);
  7751.  
  7752.   nc = d_new_ellipse (obj->points->pnt.x, obj->points->pnt.y);
  7753.  
  7754.   nc->points->next = d_copy_dobjpoints (obj->points->next);
  7755.  
  7756. #if DEBUG
  7757.   printf ("Ellipse (%x,%x) to (%x,%x)\n",
  7758.      nc->points->pnt.x, obj->points->pnt.y,
  7759.      nc->points->next->pnt.x, obj->points->next->pnt.y);
  7760.   printf ("Done copy\n");
  7761. #endif /*DEBUG*/
  7762.   return (nc);
  7763. }
  7764.  
  7765. static Dobject *
  7766. d_new_ellipse (gint x, gint y)
  7767. {
  7768.   Dobject *nobj;
  7769.   DobjPoints *npnt;
  7770.  
  7771.   /* Get new object and starting point */
  7772.  
  7773.   /* Start point */
  7774.   npnt = g_new0 (DobjPoints, 1);
  7775.  
  7776. #if DEBUG
  7777.   printf ("New ellipse start at (%x,%x)\n", x, y);
  7778. #endif /* DEBUG */
  7779.   npnt->pnt.x = x;
  7780.   npnt->pnt.y = y;
  7781.  
  7782.   nobj = g_new0 (Dobject, 1);
  7783.  
  7784.   nobj->type = ELLIPSE;
  7785.   nobj->points = npnt;
  7786.   nobj->drawfunc  = d_draw_ellipse;
  7787.   nobj->loadfunc  = d_load_ellipse;
  7788.   nobj->savefunc  = d_save_ellipse;
  7789.   nobj->paintfunc = d_paint_ellipse;
  7790.   nobj->copyfunc  = d_copy_ellipse;
  7791.  
  7792.   return (nobj);
  7793. }
  7794.  
  7795. static void
  7796. d_update_ellipse (GdkPoint *pnt)
  7797. {
  7798.   DobjPoints *center_pnt, *edge_pnt;
  7799.   gint bound_wx;
  7800.   gint bound_wy;
  7801.   gint top_x;
  7802.   gint top_y;
  7803.  
  7804.   /* Undraw last one then draw new one */
  7805.   center_pnt = obj_creating->points;
  7806.   
  7807.   if (!center_pnt)
  7808.     return; /* No points */
  7809.  
  7810.   
  7811.   if ((edge_pnt = center_pnt->next))
  7812.     {
  7813.       /* Undraw current */
  7814.       bound_wx = abs (center_pnt->pnt.x - edge_pnt->pnt.x)*2;
  7815.       bound_wy = abs (center_pnt->pnt.y - edge_pnt->pnt.y)*2;
  7816.       
  7817.       if (edge_pnt->pnt.x > center_pnt->pnt.x)
  7818.     top_x = 2*center_pnt->pnt.x - edge_pnt->pnt.x;
  7819.       else
  7820.     top_x = edge_pnt->pnt.x;
  7821.       
  7822.       if (edge_pnt->pnt.y > center_pnt->pnt.y)
  7823.     top_y = 2*center_pnt->pnt.y - edge_pnt->pnt.y;
  7824.       else
  7825.     top_y = edge_pnt->pnt.y;
  7826.  
  7827.       draw_circle (&edge_pnt->pnt);
  7828.       
  7829.       gdk_draw_arc (gfig_preview->window,
  7830.             gfig_gc,
  7831.             0,
  7832.             top_x,
  7833.             top_y,
  7834.             bound_wx,
  7835.             bound_wy,
  7836.             0,
  7837.             360*64);
  7838.     }
  7839.  
  7840.   draw_circle (pnt);
  7841.  
  7842.   edge_pnt = g_new0 (DobjPoints, 1);
  7843.  
  7844.   edge_pnt->pnt.x = pnt->x;
  7845.   edge_pnt->pnt.y = pnt->y;
  7846.  
  7847.   bound_wx = abs (center_pnt->pnt.x - edge_pnt->pnt.x)*2;
  7848.   bound_wy = abs (center_pnt->pnt.y - edge_pnt->pnt.y)*2;
  7849.  
  7850.   if (edge_pnt->pnt.x > center_pnt->pnt.x)
  7851.     top_x = 2*center_pnt->pnt.x - edge_pnt->pnt.x;
  7852.   else
  7853.     top_x = edge_pnt->pnt.x;
  7854.   
  7855.   if (edge_pnt->pnt.y > center_pnt->pnt.y)
  7856.     top_y = 2* center_pnt->pnt.y - edge_pnt->pnt.y;
  7857.   else
  7858.     top_y = edge_pnt->pnt.y;
  7859.   
  7860.   gdk_draw_arc (gfig_preview->window,
  7861.         gfig_gc,
  7862.         0,
  7863.         top_x,
  7864.         top_y,
  7865.         bound_wx,
  7866.         bound_wy,
  7867.         0,
  7868.         360*64);
  7869.   
  7870.   center_pnt->next = edge_pnt;
  7871. }
  7872.  
  7873. static void
  7874. d_ellipse_start (GdkPoint *pnt, gint shift_down)
  7875. {
  7876.   obj_creating = d_new_ellipse (pnt->x, pnt->y);
  7877. }
  7878.  
  7879. static void
  7880. d_ellipse_end (GdkPoint *pnt, gint shift_down)
  7881. {
  7882.   /* Under contrl point */
  7883.   if (!obj_creating->points->next)
  7884.     {
  7885.       /* No circle created */
  7886.       free_one_obj (obj_creating);
  7887.     }
  7888.   else
  7889.     {
  7890.       draw_circle (pnt);
  7891.       add_to_all_obj (current_obj, obj_creating);
  7892.     }
  7893.  
  7894.   obj_creating = NULL;
  7895. }
  7896.  
  7897. /* Normal polygon */
  7898.  
  7899. static void
  7900. d_save_poly (Dobject * obj, FILE *to)
  7901. {
  7902.   DobjPoints * spnt;
  7903.   
  7904.   spnt = obj->points;
  7905.  
  7906.   if (!spnt)
  7907.     return; /* End-of-line */
  7908.  
  7909.   fprintf (to, "<POLY>\n");
  7910.  
  7911.   while (spnt)
  7912.     {
  7913.       fprintf (to, "%d %d\n",
  7914.           (gint)spnt->pnt.x,
  7915.           (gint)spnt->pnt.y);
  7916.       spnt = spnt->next;
  7917.     }
  7918.   
  7919.   fprintf (to, "<EXTRA>\n");
  7920.   fprintf (to, "%d\n</EXTRA>\n", (gint)obj->type_data);
  7921.   fprintf (to, "</POLY>\n");
  7922.  
  7923. }
  7924.  
  7925. /* Load a circle from the specified stream */
  7926.  
  7927. static Dobject *
  7928. d_load_poly (FILE *from)
  7929. {
  7930.   Dobject *new_obj = NULL;
  7931.   gint xpnt;
  7932.   gint ypnt;
  7933.   gchar buf[MAX_LOAD_LINE];
  7934.  
  7935. #ifdef DEBUG
  7936.   printf ("Load poly called\n");
  7937. #endif /* DEBUG */
  7938.  
  7939.   while (get_line (buf, MAX_LOAD_LINE, from, 0))
  7940.     {
  7941.       if (sscanf (buf, "%d %d", &xpnt, &ypnt) != 2)
  7942.     {
  7943.       /* Must be the end */
  7944.       if (!strcmp ("<EXTRA>", buf))
  7945.         {
  7946.           gint nsides = 3;
  7947.           /* Number of sides - data item */
  7948.           if (!new_obj)
  7949.         {
  7950.           g_warning ("[%d] Internal load error while loading poly (extra area)",
  7951.                 line_no);
  7952.           return (NULL);
  7953.         }
  7954.           get_line (buf, MAX_LOAD_LINE, from, 0);
  7955.           if (sscanf (buf, "%d", &nsides) != 1)
  7956.         {
  7957.           g_warning ("[%d] Internal load error while loading poly (extra area scanf)",
  7958.                 line_no);
  7959.           return (NULL);
  7960.         }
  7961.           new_obj->type_data = (gpointer)nsides;
  7962.           get_line (buf, MAX_LOAD_LINE, from, 0);
  7963.           if (strcmp ("</EXTRA>", buf))
  7964.         {
  7965.           g_warning ("[%d] Internal load error while loading poly",
  7966.                 line_no);
  7967.           return (NULL);
  7968.         } 
  7969.           /* Go around and read the last line */
  7970.           continue;
  7971.         }
  7972.       else if (strcmp ("</POLY>", buf))
  7973.         {
  7974.           g_warning ("[%d] Internal load error while loading poly",
  7975.             line_no);
  7976.           return (NULL);
  7977.         }
  7978.       return (new_obj);
  7979.     }
  7980.       
  7981.       if (!new_obj)
  7982.     new_obj = d_new_poly (xpnt, ypnt);
  7983.       else
  7984.     d_pnt_add_line (new_obj, xpnt, ypnt, -1);
  7985.     }
  7986.   return (new_obj);
  7987. }
  7988.  
  7989. static void
  7990. d_draw_poly (Dobject *obj)
  7991. {
  7992.   DobjPoints * center_pnt;
  7993.   DobjPoints * radius_pnt;
  7994.   gint16 shift_x;
  7995.   gint16 shift_y;
  7996.   gdouble ang_grid;
  7997.   gdouble ang_loop;
  7998.   gdouble radius;
  7999.   gdouble offset_angle;
  8000.   gint loop;
  8001.   GdkPoint start_pnt;
  8002.   GdkPoint first_pnt;
  8003.   gint do_line = 0;
  8004.  
  8005.   center_pnt = obj->points;
  8006.  
  8007.   if (!center_pnt)
  8008.     return; /* End-of-line */
  8009.  
  8010.   /* First point is the center */
  8011.   /* Just draw a control point around it */
  8012.  
  8013.   draw_sqr (¢er_pnt->pnt);
  8014.  
  8015.   /* Next point defines the radius */
  8016.   radius_pnt = center_pnt->next; /* this defines the vertices */
  8017.  
  8018.   if (!radius_pnt)
  8019.     {
  8020. #ifdef DEBUG
  8021.       g_warning ("Internal error in polygon - no vertice point \n");
  8022. #endif /* DEBUG */
  8023.       return;
  8024.     }
  8025.  
  8026.   /* Other control point */
  8027.   draw_sqr (&radius_pnt->pnt);
  8028.  
  8029.   /* Have center and radius - draw polygon */
  8030.  
  8031.   shift_x = radius_pnt->pnt.x - center_pnt->pnt.x;
  8032.   shift_y = radius_pnt->pnt.y - center_pnt->pnt.y;
  8033.  
  8034.   radius = sqrt ((shift_x*shift_x) + (shift_y*shift_y));
  8035.  
  8036.   /* Lines */
  8037.   ang_grid = 2*G_PI/(gdouble) (gint)obj->type_data;
  8038.   offset_angle = atan2 (shift_y, shift_x);
  8039.  
  8040.   for (loop = 0 ; loop < (gint)obj->type_data ; loop++)
  8041.     {
  8042.       gdouble lx, ly;
  8043.       GdkPoint calc_pnt;
  8044.  
  8045.       ang_loop = (gdouble)loop * ang_grid + offset_angle;
  8046.     
  8047.       lx = radius * cos (ang_loop);
  8048.       ly = radius * sin (ang_loop);
  8049.  
  8050.       calc_pnt.x = (gint)RINT (lx + center_pnt->pnt.x);
  8051.       calc_pnt.y = (gint)RINT (ly + center_pnt->pnt.y);
  8052.  
  8053.       if (do_line)
  8054.     {
  8055.  
  8056.       /* Miss out points that come to the same location */
  8057.       if (calc_pnt.x == start_pnt.x && calc_pnt.y == start_pnt.y)
  8058.         continue;
  8059.  
  8060.       if (drawing_pic)
  8061.         {
  8062.           gdk_draw_line (pic_preview->window,
  8063.                  pic_preview->style->black_gc,                
  8064.                  adjust_pic_coords (calc_pnt.x,
  8065.                         preview_width),
  8066.                  adjust_pic_coords (calc_pnt.y,
  8067.                         preview_height),
  8068.                  adjust_pic_coords (start_pnt.x,
  8069.                         preview_width),
  8070.                  adjust_pic_coords (start_pnt.y,
  8071.                         preview_height));
  8072.         }
  8073.       else
  8074.         {
  8075.           gdk_draw_line (gfig_preview->window,
  8076.                  gfig_gc,
  8077.                  gfig_scale_x (calc_pnt.x),
  8078.                  gfig_scale_y (calc_pnt.y),
  8079.                  gfig_scale_x (start_pnt.x),
  8080.                  gfig_scale_y (start_pnt.y));
  8081.         }
  8082.     }
  8083.       else
  8084.     {
  8085.       do_line = 1;
  8086.       first_pnt.x = calc_pnt.x;
  8087.       first_pnt.y = calc_pnt.y;
  8088.     }
  8089.       start_pnt.x = calc_pnt.x;
  8090.       start_pnt.y = calc_pnt.y;
  8091.     }
  8092.  
  8093.   /* Join up */
  8094.   if (drawing_pic)
  8095.     {
  8096.       gdk_draw_line (pic_preview->window,
  8097.              pic_preview->style->black_gc,
  8098.              adjust_pic_coords (first_pnt.x, preview_width),
  8099.              adjust_pic_coords (first_pnt.y, preview_width),
  8100.              adjust_pic_coords (start_pnt.x, preview_width),
  8101.              adjust_pic_coords (start_pnt.y, preview_width));
  8102.     }
  8103.   else
  8104.     {
  8105.       gdk_draw_line (gfig_preview->window,
  8106.              gfig_gc,
  8107.              gfig_scale_x (first_pnt.x),
  8108.              gfig_scale_y (first_pnt.y),
  8109.              gfig_scale_x (start_pnt.x),
  8110.              gfig_scale_y (start_pnt.y));
  8111.     }
  8112. }
  8113.  
  8114. static void
  8115. d_paint_poly (Dobject *obj)
  8116. {
  8117.   /* first point center */
  8118.   /* Next point is radius */
  8119.   gdouble *line_pnts;
  8120.   gint seg_count = 0;
  8121.   gint i = 0;
  8122.   DobjPoints * center_pnt;
  8123.   DobjPoints * radius_pnt;
  8124.   gint16 shift_x;
  8125.   gint16 shift_y;
  8126.   gdouble ang_grid;
  8127.   gdouble ang_loop;
  8128.   gdouble radius;
  8129.   gdouble offset_angle;
  8130.   gint loop;
  8131.   GdkPoint first_pnt, last_pnt;
  8132.   gint first = 1;
  8133.  
  8134.   g_assert (obj != NULL);
  8135.  
  8136.   /* count - add one to close polygon */
  8137.   seg_count = (gint)obj->type_data + 1;
  8138.  
  8139.   center_pnt = obj->points;
  8140.  
  8141.   if (!center_pnt || !seg_count || !center_pnt->next)
  8142.     return; /* no-line */
  8143.  
  8144.   line_pnts = g_new0 (gdouble, 2 * seg_count + 1);
  8145.   
  8146.   /* Go around all the points drawing a line from one to the next */
  8147.  
  8148.   radius_pnt = center_pnt->next; /* this defines the vetices */
  8149.  
  8150.   /* Have center and radius - get lines */
  8151.   shift_x = radius_pnt->pnt.x - center_pnt->pnt.x;
  8152.   shift_y = radius_pnt->pnt.y - center_pnt->pnt.y;
  8153.  
  8154.   radius = sqrt ((shift_x*shift_x) + (shift_y*shift_y));
  8155.  
  8156.   /* Lines */
  8157.   ang_grid = 2*G_PI/(gdouble) (gint)obj->type_data;
  8158.   offset_angle = atan2 (shift_y, shift_x);
  8159.  
  8160.   for (loop = 0 ; loop < (gint)obj->type_data ; loop++)
  8161.     {
  8162.       gdouble lx, ly;
  8163.       GdkPoint calc_pnt;
  8164.       
  8165.       ang_loop = (gdouble)loop * ang_grid + offset_angle;
  8166.     
  8167.       lx = radius * cos (ang_loop);
  8168.       ly = radius * sin (ang_loop);
  8169.  
  8170.       calc_pnt.x = (gint)RINT (lx + center_pnt->pnt.x);
  8171.       calc_pnt.y = (gint)RINT (ly + center_pnt->pnt.y);
  8172.  
  8173.       /* Miss out duped pnts */
  8174.       if (!first)
  8175.     {
  8176.       if (calc_pnt.x == last_pnt.x && calc_pnt.y == last_pnt.y)
  8177.         {
  8178.           continue;
  8179.         }
  8180.     }
  8181.  
  8182.       last_pnt.x = line_pnts[i++] = calc_pnt.x;
  8183.       last_pnt.y = line_pnts[i++] = calc_pnt.y;
  8184.  
  8185.       if (first)
  8186.     {
  8187.       first_pnt.x = calc_pnt.x;
  8188.       first_pnt.y = calc_pnt.y;
  8189.       first = 0;
  8190.     }
  8191.     }
  8192.  
  8193.   line_pnts[i++] = first_pnt.x;
  8194.   line_pnts[i++] = first_pnt.y;
  8195.  
  8196.   /* Reverse line if approp */
  8197.   if (selvals.reverselines)
  8198.     reverse_pairs_list (&line_pnts[0], i/2);
  8199.  
  8200.   /* Scale before drawing */
  8201.   if (selvals.scaletoimage)
  8202.     scale_to_original_xy (&line_pnts[0], i/2);
  8203.   else
  8204.     scale_to_xy (&line_pnts[0], i/2);
  8205.  
  8206.   /* One go */
  8207.   if (selvals.painttype == PAINT_BRUSH_TYPE)
  8208.     {
  8209.       gfig_paint (selvals.brshtype,
  8210.           gfig_drawable,
  8211.           i, line_pnts);
  8212.     }
  8213.   else
  8214.     {
  8215.       gimp_free_select (gfig_image,
  8216.             i, line_pnts,
  8217.             selopt.type,
  8218.             selopt.antia,
  8219.             selopt.feather,
  8220.             selopt.feather_radius);
  8221.     }
  8222.  
  8223.   g_free (line_pnts);
  8224. }
  8225.  
  8226. static void
  8227. d_poly2lines (Dobject *obj)
  8228. {
  8229.   /* first point center */
  8230.   /* Next point is radius */
  8231.   gint seg_count = 0;
  8232.   DobjPoints * center_pnt;
  8233.   DobjPoints * radius_pnt;
  8234.   gint16 shift_x;
  8235.   gint16 shift_y;
  8236.   gdouble ang_grid;
  8237.   gdouble ang_loop;
  8238.   gdouble radius;
  8239.   gdouble offset_angle;
  8240.   gint loop;
  8241.   GdkPoint first_pnt, last_pnt;
  8242.   gint first = 1;
  8243.  
  8244.   g_assert (obj != NULL);
  8245.  
  8246. #ifdef DEBUG
  8247.   printf ("d_poly2lines --- \n");
  8248. #endif /* DEBUG */
  8249.  
  8250.   /* count - add one to close polygon */
  8251.   seg_count = (gint)obj->type_data + 1;
  8252.  
  8253.   center_pnt = obj->points;
  8254.  
  8255.   if (!center_pnt)
  8256.     return; /* no-line */
  8257.  
  8258.   /* Undraw it to start with - removes control points */ 
  8259.   obj->drawfunc (obj);
  8260.  
  8261.   /* NULL out these points free later */
  8262.   obj->points = NULL;
  8263.  
  8264.   /* Go around all the points creating line points */
  8265.  
  8266.   radius_pnt = center_pnt->next; /* this defines the vertices */
  8267.  
  8268.   /* Have center and radius - get lines */
  8269.   shift_x = radius_pnt->pnt.x - center_pnt->pnt.x;
  8270.   shift_y = radius_pnt->pnt.y - center_pnt->pnt.y;
  8271.  
  8272.   radius = sqrt ((shift_x*shift_x) + (shift_y*shift_y));
  8273.  
  8274.   /* Lines */
  8275.   ang_grid = 2*G_PI/(gdouble) (gint)obj->type_data;
  8276.   offset_angle = atan2 (shift_y, shift_x);
  8277.  
  8278.   for (loop = 0 ; loop < (gint)obj->type_data ; loop++)
  8279.     {
  8280.       gdouble lx, ly;
  8281.       GdkPoint calc_pnt;
  8282.       
  8283.       ang_loop = (gdouble)loop * ang_grid + offset_angle;
  8284.     
  8285.       lx = radius * cos (ang_loop);
  8286.       ly = radius * sin (ang_loop);
  8287.  
  8288.       calc_pnt.x = (gint)RINT (lx + center_pnt->pnt.x);
  8289.       calc_pnt.y = (gint)RINT (ly + center_pnt->pnt.y);
  8290.  
  8291.       if (!first)
  8292.     {
  8293.       if (calc_pnt.x == last_pnt.x && calc_pnt.y == last_pnt.y)
  8294.         {
  8295.           continue;
  8296.         }
  8297.     }
  8298.  
  8299.       d_pnt_add_line (obj, calc_pnt.x, calc_pnt.y, 0);
  8300.  
  8301.       last_pnt.x = calc_pnt.x;
  8302.       last_pnt.y = calc_pnt.y;
  8303.  
  8304.       if (first)
  8305.     {
  8306.       first_pnt.x = calc_pnt.x;
  8307.       first_pnt.y = calc_pnt.y;
  8308.       first = 0;
  8309.     }
  8310.     }
  8311.  
  8312.   d_pnt_add_line (obj, first_pnt.x, first_pnt.y, 0);
  8313.   /* Free old pnts */
  8314.   d_delete_dobjpoints (center_pnt);
  8315.  
  8316.   /* hey we're a line now */
  8317.   obj->type = LINE;
  8318.   obj->drawfunc  = d_draw_line;
  8319.   obj->loadfunc  = d_load_line;
  8320.   obj->savefunc  = d_save_line;
  8321.   obj->paintfunc = d_paint_line;
  8322.   obj->copyfunc  = d_copy_line;
  8323.  
  8324.   /* draw it + control pnts */
  8325.   obj->drawfunc (obj);
  8326. }
  8327.  
  8328. static void
  8329. d_star2lines (Dobject *obj)
  8330. {
  8331.   /* first point center */
  8332.   /* Next point is radius */
  8333.   gint seg_count = 0;
  8334.   DobjPoints * center_pnt;
  8335.   DobjPoints * outer_radius_pnt;
  8336.   DobjPoints * inner_radius_pnt;
  8337.   gint16 shift_x;
  8338.   gint16 shift_y;
  8339.   gdouble ang_grid;
  8340.   gdouble ang_loop;
  8341.   gdouble outer_radius;
  8342.   gdouble inner_radius;
  8343.   gdouble offset_angle;
  8344.   gint loop;
  8345.   GdkPoint first_pnt, last_pnt;
  8346.   gint first = 1;
  8347.  
  8348.   g_assert (obj != NULL);
  8349.  
  8350. #ifdef DEBUG
  8351.   printf ("d_star2lines --- \n");
  8352. #endif /* DEBUG */
  8353.  
  8354.   /* count - add one to close polygon */
  8355.   seg_count = 2*(gint)obj->type_data + 1;
  8356.  
  8357.   center_pnt = obj->points;
  8358.  
  8359.   if (!center_pnt)
  8360.     return; /* no-line */
  8361.  
  8362.   /* Undraw it to start with - removes control points */ 
  8363.   obj->drawfunc (obj);
  8364.  
  8365.   /* NULL out these points free later */
  8366.   obj->points = NULL;
  8367.  
  8368.   /* Go around all the points creating line points */
  8369.   /* Next point defines the radius */
  8370.   outer_radius_pnt = center_pnt->next; /* this defines the vetices */
  8371.  
  8372.   if (!outer_radius_pnt)
  8373.     {
  8374. #ifdef DEBUG
  8375.       g_warning ("Internal error in star - no outer vertice point \n");
  8376. #endif /* DEBUG */
  8377.       return;
  8378.     }
  8379.  
  8380.   inner_radius_pnt = outer_radius_pnt->next; /* this defines the vetices */
  8381.  
  8382.   if (!inner_radius_pnt)
  8383.     {
  8384. #ifdef DEBUG
  8385.       g_warning ("Internal error in star - no inner vertice point \n");
  8386. #endif /* DEBUG */
  8387.       return;
  8388.     }
  8389.  
  8390.   shift_x = outer_radius_pnt->pnt.x - center_pnt->pnt.x;
  8391.   shift_y = outer_radius_pnt->pnt.y - center_pnt->pnt.y;
  8392.  
  8393.   outer_radius = sqrt ((shift_x*shift_x) + (shift_y*shift_y));
  8394.  
  8395.   /* Lines */
  8396.   ang_grid = 2*G_PI/(2.0*(gdouble) (gint)obj->type_data);
  8397.   offset_angle = atan2 (shift_y, shift_x);
  8398.  
  8399.   shift_x = inner_radius_pnt->pnt.x - center_pnt->pnt.x;
  8400.   shift_y = inner_radius_pnt->pnt.y - center_pnt->pnt.y;
  8401.  
  8402.   inner_radius = sqrt ((shift_x*shift_x) + (shift_y*shift_y));
  8403.  
  8404.   for (loop = 0 ; loop < 2*(gint)obj->type_data ; loop++)
  8405.     {
  8406.       gdouble lx, ly;
  8407.       GdkPoint calc_pnt;
  8408.       
  8409.       ang_loop = (gdouble)loop * ang_grid + offset_angle;
  8410.  
  8411.       if (loop%2)
  8412.     {
  8413.       lx = inner_radius * cos (ang_loop);
  8414.       ly = inner_radius * sin (ang_loop);
  8415.     }
  8416.       else
  8417.     {
  8418.       lx = outer_radius * cos (ang_loop);
  8419.       ly = outer_radius * sin (ang_loop);
  8420.     }
  8421.  
  8422.       calc_pnt.x = (gint)RINT (lx + center_pnt->pnt.x);
  8423.       calc_pnt.y = (gint)RINT (ly + center_pnt->pnt.y);
  8424.  
  8425.       if (!first)
  8426.     {
  8427.       if (calc_pnt.x == last_pnt.x && calc_pnt.y == last_pnt.y)
  8428.         {
  8429.           continue;
  8430.         }
  8431.     }
  8432.  
  8433.       d_pnt_add_line (obj, calc_pnt.x, calc_pnt.y, 0);
  8434.  
  8435.       last_pnt.x = calc_pnt.x;
  8436.       last_pnt.y = calc_pnt.y;
  8437.  
  8438.       if (first)
  8439.     {
  8440.       first_pnt.x = calc_pnt.x;
  8441.       first_pnt.y = calc_pnt.y;
  8442.       first = 0;
  8443.     }
  8444.     }
  8445.  
  8446.   d_pnt_add_line (obj, first_pnt.x, first_pnt.y, 0);
  8447.   /* Free old pnts */
  8448.   d_delete_dobjpoints (center_pnt);
  8449.  
  8450.   /* hey we're a line now */
  8451.   obj->type = LINE;
  8452.   obj->drawfunc  = d_draw_line;
  8453.   obj->loadfunc  = d_load_line;
  8454.   obj->savefunc  = d_save_line;
  8455.   obj->paintfunc = d_paint_line;
  8456.   obj->copyfunc  = d_copy_line;
  8457.  
  8458.   /* draw it + control pnts */
  8459.   obj->drawfunc (obj);
  8460. }
  8461.  
  8462. static Dobject *
  8463. d_copy_poly (Dobject * obj)
  8464. {
  8465.   Dobject *np;
  8466.  
  8467. #if DEBUG
  8468.   printf ("Copy poly\n");
  8469. #endif /*DEBUG*/
  8470.   if (!obj)
  8471.     return (NULL);
  8472.  
  8473.   g_assert (obj->type == POLY);
  8474.  
  8475.   np = d_new_poly (obj->points->pnt.x, obj->points->pnt.y);
  8476.  
  8477.   np->points->next = d_copy_dobjpoints (obj->points->next);
  8478.  
  8479.   np->type_data = obj->type_data;
  8480.  
  8481. #if DEBUG
  8482.   printf ("Done poly copy\n");
  8483. #endif /*DEBUG*/
  8484.   return (np);
  8485. }
  8486.  
  8487. static Dobject *
  8488. d_new_poly (gint x, gint y)
  8489. {
  8490.   Dobject *nobj;
  8491.   DobjPoints *npnt;
  8492.  
  8493.   /* Get new object and starting point */
  8494.  
  8495.   /* Start point */
  8496.   npnt = g_new0 (DobjPoints, 1);
  8497.  
  8498. #if DEBUG
  8499.   printf ("New POLY start at (%x,%x)\n", x, y);
  8500. #endif /* DEBUG */
  8501.   npnt->pnt.x = x;
  8502.   npnt->pnt.y = y;
  8503.  
  8504.   nobj = g_new0 (Dobject, 1);
  8505.  
  8506.   nobj->type = POLY;
  8507.   nobj->type_data = (gpointer)3; /* Default to three sides */
  8508.   nobj->points = npnt;
  8509.   nobj->drawfunc  = d_draw_poly;
  8510.   nobj->loadfunc  = d_load_poly;
  8511.   nobj->savefunc  = d_save_poly;
  8512.   nobj->paintfunc = d_paint_poly;
  8513.   nobj->copyfunc  = d_copy_poly;
  8514.  
  8515.   return (nobj);
  8516. }
  8517.  
  8518. static void
  8519. d_update_poly (GdkPoint *pnt)
  8520. {
  8521.   DobjPoints *center_pnt, *edge_pnt;
  8522.   gint saved_cnt_pnt = selvals.opts.showcontrol;
  8523.  
  8524.   /* Undraw last one then draw new one */
  8525.   center_pnt = obj_creating->points;
  8526.   
  8527.   if (!center_pnt)
  8528.     return; /* No points */
  8529.  
  8530.   /* Leave the first pnt alone -
  8531.    * Edge point defines "radius"
  8532.    * Only undraw if already have edge point.
  8533.    */
  8534.  
  8535.   /* Hack - turn off cnt points in draw routine 
  8536.    * Looking back over the other update routines I could
  8537.    * use this trick again and cut down on code size!
  8538.    */
  8539.  
  8540.  
  8541.   if ((edge_pnt = center_pnt->next))
  8542.     {
  8543.       /* Undraw */
  8544.       draw_circle (&edge_pnt->pnt);
  8545.       selvals.opts.showcontrol = 0;
  8546.       d_draw_poly (obj_creating);
  8547.  
  8548.       edge_pnt->pnt.x = pnt->x;
  8549.       edge_pnt->pnt.y = pnt->y;
  8550.     }
  8551.   else
  8552.     {
  8553.       /* Radius is a few pixels away */
  8554.       /* First edge point */
  8555.       d_pnt_add_line (obj_creating, pnt->x, pnt->y, -1);
  8556.       edge_pnt = center_pnt->next;
  8557.     }
  8558.  
  8559.   /* draw it */
  8560.   selvals.opts.showcontrol = 0;
  8561.   d_draw_poly (obj_creating);
  8562.   selvals.opts.showcontrol = saved_cnt_pnt;
  8563.  
  8564.   /* Realy draw the control points */
  8565.   draw_circle (&edge_pnt->pnt);
  8566. }
  8567.  
  8568. /* first point is center 
  8569.  * next defines the radius
  8570.  */
  8571.  
  8572. static void
  8573. d_poly_start (GdkPoint *pnt,
  8574.           gint      shift_down)
  8575. {
  8576.   gint16 x, y;
  8577.   /* First is center point */
  8578.   obj_creating = d_new_poly (x = pnt->x, y = pnt->y);
  8579.   obj_creating->type_data = (gpointer)poly_num_sides;
  8580. }
  8581.  
  8582. static void
  8583. d_poly_end (GdkPoint *pnt,
  8584.         gint      shift_down)
  8585. {
  8586.   draw_circle (pnt);
  8587.   add_to_all_obj (current_obj, obj_creating);
  8588.   obj_creating = NULL;
  8589. }
  8590.  
  8591. /* ARC stuff */
  8592. /* Distance between two lines */
  8593. static gdouble
  8594. dist (gdouble x1,
  8595.       gdouble y1,
  8596.       gdouble x2,
  8597.       gdouble y2)
  8598. {
  8599.  
  8600.   double s1 = x1 - x2;
  8601.   double s2 = y1 - y2;
  8602.  
  8603.   return (sqrt ((s1*s1) + (s2*s2)));
  8604. }
  8605.  
  8606. /* Mid point of line returned */
  8607. static void
  8608. mid_point (gdouble x1,
  8609.        gdouble y1,
  8610.        gdouble x2,
  8611.        gdouble y2,
  8612.        gdouble *mx,
  8613.        gdouble *my)
  8614. {
  8615.   *mx = ((double) (x1 - x2))/2.0 + (double)x2;
  8616.   *my = ((double) (y1 - y2))/2.0 + (double)y2;
  8617. }
  8618.  
  8619. /* Careful about infinite grads */
  8620. static gdouble
  8621. line_grad (gdouble x1,
  8622.        gdouble y1,
  8623.        gdouble x2,
  8624.        gdouble y2)
  8625. {
  8626.   double dx, dy;
  8627.   
  8628.   dx = x1 - x2;
  8629.   dy = y1 - y2;
  8630.  
  8631.   if (dx == 0.0)
  8632.     return (0.0); /* Infinite ! */
  8633.  
  8634.   return (dy/dx);
  8635. }
  8636.  
  8637. /* Constant of line that goes through x, y with grad lgrad */
  8638. static gdouble
  8639. line_cons (gdouble x,
  8640.        gdouble y,
  8641.        gdouble lgrad)
  8642. {
  8643.   return (y - lgrad*x);
  8644. }
  8645.  
  8646. /*Get grad & const for perpend. line to given points */
  8647. static void
  8648. line_definition (gdouble  x1,
  8649.          gdouble  y1,
  8650.          gdouble  x2,
  8651.          gdouble  y2,
  8652.          gdouble *lgrad,
  8653.          gdouble *lconst)
  8654. {
  8655.   double grad1;
  8656.   double midx, midy;
  8657.  
  8658.   grad1 = line_grad (x1, y1, x2, y2);
  8659.  
  8660.   if (grad1 == 0.0)
  8661.     {
  8662. #ifdef DEBUG
  8663.       printf ("Infinite grad....\n");
  8664. #endif /* DEBUG */
  8665.       return;
  8666.     }
  8667.  
  8668.   mid_point (x1, y1, x2, y2, &midx, &midy);
  8669.  
  8670.   /* Invert grad for perpen gradient */
  8671.  
  8672.   *lgrad = -1.0/grad1;
  8673.   
  8674.   *lconst = line_cons (midx, midy,*lgrad);
  8675. }
  8676.  
  8677. /* Arch details 
  8678.  * Given three points get arc radius and the co-ords 
  8679.  * of center point.
  8680.  */
  8681.  
  8682. static void
  8683. arc_details (GdkPoint *vert_a,
  8684.          GdkPoint *vert_b,
  8685.          GdkPoint *vert_c,
  8686.          GdkPoint *center_pnt,
  8687.          gdouble  *radius)
  8688. {
  8689.   /* Only vertices are in whole numbers - everything else is in doubles */
  8690.   double ax, ay;
  8691.   double bx, by;
  8692.   double cx, cy;
  8693.  
  8694.   double len_a, len_b, len_c;
  8695.   double sum_sides2;
  8696.   double area;
  8697.   double circumcircle_R;
  8698.   double line1_grad, line1_const;
  8699.   double line2_grad, line2_const;
  8700.   double inter_x=0.0, inter_y=0.0;
  8701.   int got_x=0, got_y=0;
  8702.  
  8703.   ax = (double) (vert_a->x);
  8704.   ay = (double) (vert_a->y);
  8705.   bx = (double) (vert_b->x);
  8706.   by = (double) (vert_b->y);
  8707.   cx = (double) (vert_c->x);
  8708.   cy = (double) (vert_c->y);
  8709.  
  8710. #ifdef DEBUG
  8711.   printf ("Vertices (%f,%f), (%f,%f), (%f,%f)\n", ax, ay, bx, by, cx, cy);
  8712. #endif /* DEBUG */
  8713.  
  8714.   len_a = dist (ax, ay, bx, by);
  8715.   len_b = dist (bx, by, cx, cy);
  8716.   len_c = dist (cx, cy, ax, ay);
  8717. #ifdef DEBUG
  8718.   printf ("len_a = %f, len_b = %f, len_c = %f\n", len_a, len_b, len_c);
  8719. #endif /* DEBUG */
  8720.  
  8721.  
  8722.   sum_sides2 = (fabs (len_a) + fabs (len_b) + fabs (len_c))/2;
  8723. #ifdef DEBUG
  8724.   printf ("Sum sides / 2 = %f\n", sum_sides2);
  8725. #endif /* DEBUG */
  8726.  
  8727.   /* Area */
  8728.   area = sqrt (sum_sides2*(sum_sides2 - len_a)*(sum_sides2 - len_b)*(sum_sides2 - len_c));
  8729. #ifdef DEBUG
  8730.   printf ("Area of triangle = %f\n", area);
  8731. #endif /* DEBUG */
  8732.   
  8733.   /* Circumcircle */
  8734.   circumcircle_R = len_a*len_b*len_c/(4*area);
  8735.   *radius = circumcircle_R;
  8736. #ifdef DEBUG
  8737.   printf ("Circumcircle radius = %f\n", circumcircle_R);
  8738. #endif /* DEBUG */
  8739.  
  8740.   /* Deal with exceptions - I hate exceptions */
  8741.  
  8742.   if (ax == bx || ax == cx || cx == bx)
  8743.     {
  8744.       /* vert line -> mid point gives inter_x */
  8745.       if (ax == bx && bx == cx)
  8746.     {
  8747.       /* Straight line */
  8748.       double miny = ay;
  8749.       double maxy = ay;
  8750.  
  8751.       if (by > maxy)
  8752.         maxy = by;
  8753.       
  8754.       if (by < miny)
  8755.         miny = by;
  8756.  
  8757.       if (cy > maxy)
  8758.         maxy = cy;
  8759.  
  8760.       if (cy < miny)
  8761.         miny = cy;
  8762.  
  8763.       inter_y = (maxy - miny)/2 + miny;
  8764.     }
  8765.       else if (ax == bx)
  8766.     {
  8767.       inter_y = (ay - by)/2 + by;
  8768.     }
  8769.       else if (bx == cx)
  8770.     {
  8771.       inter_y = (by - cy)/2 + cy;
  8772.     }
  8773.       else
  8774.     {
  8775.       inter_y = (cy - ay)/2 + ay;
  8776.     }
  8777.       got_y = 1;
  8778.     }
  8779.  
  8780.   if (ay == by || by == cy || ay == cy)
  8781.     {
  8782.       /* Horz line -> midpoint gives inter_y */
  8783.       if (ax == bx && bx == cx)
  8784.     {
  8785.       /* Straight line */
  8786.       double minx = ax;
  8787.       double maxx = ax;
  8788.  
  8789.       if (bx > maxx)
  8790.         maxx = bx;
  8791.       
  8792.       if (bx < minx)
  8793.         minx = bx;
  8794.  
  8795.       if (cx > maxx)
  8796.         maxx = cx;
  8797.  
  8798.       if (cx < minx)
  8799.         minx = cx;
  8800.  
  8801.       inter_x = (maxx - minx)/2 + minx;
  8802.     }
  8803.       else if (ay == by)
  8804.     {
  8805.       inter_x = (ax - bx)/2 + bx;
  8806.     }
  8807.       else if (by == cy)
  8808.     {
  8809.       inter_x = (bx - cx)/2 + cx;
  8810.     }
  8811.       else
  8812.     {
  8813.       inter_x = (cx - ax)/2 + ax;
  8814.     }
  8815.       got_x = 1;
  8816.     }
  8817.  
  8818.   if (!got_x || !got_y)
  8819.     {
  8820.       /* At least two of the lines are not parallel to the axis */
  8821.       /*first line */
  8822.       if (ax != bx && ay != by)
  8823.     line_definition (ax, ay, bx, by, &line1_grad, &line1_const);
  8824.       else
  8825.     line_definition (ax, ay, cx, cy, &line1_grad, &line1_const);
  8826.       /* second line */
  8827.       if (bx != cx && by != cy)
  8828.     line_definition (bx, by, cx, cy, &line2_grad, &line2_const);
  8829.       else
  8830.     line_definition (ax, ay, cx, cy, &line2_grad, &line2_const);
  8831.     }
  8832.  
  8833.   /* Intersection point */
  8834.  
  8835.   if (!got_x)
  8836.     inter_x = /*rint*/((line2_const - line1_const)/(line1_grad - line2_grad));
  8837.   if (!got_y)
  8838.     inter_y = /*rint*/((line1_grad * inter_x + line1_const));
  8839.  
  8840. #ifdef DEBUG
  8841.   printf ("Intersection point is (%f,%f)\n", inter_x, inter_y);
  8842. #endif /* DEBUG */
  8843.  
  8844.   center_pnt->x = (gint16)inter_x;
  8845.   center_pnt->y = (gint16)inter_y;
  8846. }
  8847.  
  8848. static gdouble
  8849. arc_angle (GdkPoint *pnt,
  8850.        GdkPoint *center)
  8851. {
  8852.   /* Get angle (in degress) of point given origin of center */
  8853.   gint16 shift_x;
  8854.   gint16 shift_y;
  8855.   gdouble offset_angle;
  8856.  
  8857.   shift_x = pnt->x - center->x;
  8858.   shift_y = -pnt->y + center->y;
  8859.   offset_angle = atan2 (shift_y, shift_x);
  8860. #ifdef DEBUG
  8861.   printf ("offset_ang = %f\n", offset_angle);
  8862. #endif /* DEBUG */
  8863.   if (offset_angle < 0)
  8864.     offset_angle += 2*G_PI;
  8865.  
  8866.   return (offset_angle*360/(2*G_PI));
  8867. }
  8868.  
  8869. static void
  8870. d_save_arc (Dobject *obj,
  8871.         FILE    *to)
  8872. {
  8873.   DobjPoints * spnt;
  8874.  
  8875.   spnt = obj->points;
  8876.  
  8877.   if (!spnt)
  8878.     return;
  8879.  
  8880.   fprintf (to, "<ARC>\n");
  8881.  
  8882.   while (spnt)
  8883.     {
  8884.       fprintf (to, "%d %d\n",
  8885.           (gint)spnt->pnt.x,
  8886.           (gint)spnt->pnt.y);
  8887.       spnt = spnt->next;
  8888.     }
  8889.   
  8890.   fprintf (to, "</ARC>\n");
  8891. }
  8892.  
  8893. /* Load a circle from the specified stream */
  8894.  
  8895. static Dobject *
  8896. d_load_arc (FILE *from)
  8897. {
  8898.   Dobject *new_obj = NULL;
  8899.   gint xpnt;
  8900.   gint ypnt;
  8901.   gchar buf[MAX_LOAD_LINE];
  8902.   gint num_pnts = 0;
  8903.  
  8904. #ifdef DEBUG
  8905.   printf ("Load arc called\n");
  8906. #endif /* DEBUG */
  8907.  
  8908.   while (get_line (buf, MAX_LOAD_LINE, from, 0))
  8909.     {
  8910.       if (sscanf (buf, "%d %d", &xpnt, &ypnt) != 2)
  8911.     {
  8912.       /* Must be the end */
  8913.       if (strcmp ("</ARC>", buf) || num_pnts != 3)
  8914.         {
  8915.           g_warning ("[%d] Internal load error while loading arc",
  8916.             line_no);
  8917.           return (NULL);
  8918.         }
  8919.       return (new_obj);
  8920.     }
  8921.       
  8922.       num_pnts++;
  8923.  
  8924.       if (!new_obj)
  8925.     new_obj = d_new_arc (xpnt, ypnt);
  8926.       else
  8927.     {
  8928.       d_pnt_add_line (new_obj, xpnt, ypnt,-1);
  8929.     }
  8930.     }
  8931.   g_warning ("[%d] Not enough points for arc", line_no);
  8932.   return (NULL);
  8933. }
  8934.  
  8935. static void
  8936. arc_drawing_details (Dobject  *obj,
  8937.              gdouble  *minang,
  8938.              GdkPoint *center_pnt,
  8939.              gdouble  *arcang,
  8940.              gdouble  *radius,
  8941.              gint      draw_cnts,
  8942.              gint      do_scale)
  8943. {
  8944.   DobjPoints * pnt1 = NULL;
  8945.   DobjPoints * pnt2 = NULL;
  8946.   DobjPoints * pnt3 = NULL;
  8947.   DobjPoints dpnts[3];
  8948.   gdouble ang1, ang2, ang3;
  8949.   gdouble maxang;
  8950.  
  8951.   pnt1 = obj->points;
  8952.  
  8953.   if (!pnt1)
  8954.     return; /* Not fully drawn */
  8955.  
  8956.   pnt2 = pnt1->next;
  8957.  
  8958.   if (!pnt2)
  8959.     return; /* Not fully drawn */
  8960.  
  8961.   pnt3 = pnt2->next;
  8962.  
  8963.   if (!pnt3)
  8964.     return; /* Still not fully drawn */
  8965.  
  8966.   if (draw_cnts)
  8967.     {
  8968.       draw_sqr (&pnt1->pnt);
  8969.       draw_sqr (&pnt2->pnt);
  8970.       draw_sqr (&pnt3->pnt);
  8971.     }
  8972.  
  8973.   if (do_scale)
  8974.     {
  8975.       /* Adjust pnts for scaling */
  8976.       /* Warning struct copies here! and casting to double <-> int */
  8977.       /* Too complex fix me - to much hacking */
  8978.       gdouble xy[2];
  8979.       int j;
  8980.  
  8981.       dpnts[0] = *pnt1;
  8982.       dpnts[1] = *pnt2;
  8983.       dpnts[2] = *pnt3;
  8984.  
  8985.       pnt1 = &dpnts[0];
  8986.       pnt2 = &dpnts[1];
  8987.       pnt3 = &dpnts[2];
  8988.  
  8989.       for (j = 0 ; j < 3; j++)
  8990.     {
  8991.       xy[0] = dpnts[j].pnt.x;
  8992.       xy[1] = dpnts[j].pnt.y;
  8993.       if (selvals.scaletoimage)
  8994.         scale_to_original_xy (&xy[0], 1);
  8995.       else
  8996.         scale_to_xy (&xy[0], 1);
  8997.       dpnts[j].pnt.x = xy[0];
  8998.       dpnts[j].pnt.y = xy[1];
  8999.     }
  9000.     }
  9001.  
  9002.   arc_details (&pnt1->pnt, &pnt2->pnt, &pnt3->pnt, center_pnt, radius);
  9003.   
  9004.   ang1 = arc_angle (&pnt1->pnt, center_pnt);
  9005.   ang2 = arc_angle (&pnt2->pnt, center_pnt);
  9006.   ang3 = arc_angle (&pnt3->pnt, center_pnt);
  9007.  
  9008.   /* Find min/max angle */
  9009.  
  9010.   maxang = ang1;
  9011.  
  9012.   if (ang3 > maxang)
  9013.     maxang = ang3;
  9014.   
  9015.   *minang = ang1;
  9016.  
  9017.   if (ang3 < *minang)
  9018.     *minang = ang3;
  9019.  
  9020.   if (ang2 > *minang && ang2 < maxang)
  9021.     *arcang = maxang - *minang;
  9022.   else
  9023.     *arcang = maxang - *minang - 360;
  9024. }
  9025.  
  9026. static void
  9027. d_draw_arc (Dobject * obj)
  9028. {
  9029.   GdkPoint center_pnt;
  9030.   gdouble radius, minang, arcang;
  9031.  
  9032.   g_assert (obj != NULL);
  9033.  
  9034.   if (!obj)
  9035.     return;
  9036.  
  9037.   arc_drawing_details (obj, &minang, ¢er_pnt, &arcang, &radius, TRUE, FALSE);
  9038.   
  9039. #ifdef DEBUG
  9040.   printf ("Min ang = %f Arc ang = %f\n", minang, arcang);
  9041. #endif /* DEBUG */
  9042.  
  9043.   if (drawing_pic)
  9044.     {
  9045.       gdk_draw_arc (pic_preview->window,
  9046.             pic_preview->style->black_gc,
  9047.             0,
  9048.             adjust_pic_coords (center_pnt.x - (gint)radius,
  9049.                       preview_width),
  9050.             adjust_pic_coords (center_pnt.y - (gint)radius,
  9051.                       preview_height),
  9052.             adjust_pic_coords ((gint) (radius * 2),
  9053.                       preview_width),
  9054.             adjust_pic_coords ((gint) (radius * 2),
  9055.                       preview_height),
  9056.             (gint) (minang*64),
  9057.             (gint) (arcang*64));
  9058.     }
  9059.   else
  9060.     {
  9061.       gdk_draw_arc (gfig_preview->window,
  9062.             gfig_gc,
  9063.             0,
  9064.             gfig_scale_x (center_pnt.x - (gint)radius),
  9065.             gfig_scale_y (center_pnt.y - (gint)radius),
  9066.             gfig_scale_x ((gint) (radius * 2)),
  9067.             gfig_scale_y ((gint) (radius * 2)),
  9068.             (gint) (minang*64),
  9069.             (gint) (arcang*64));
  9070.     }
  9071. }
  9072.  
  9073. static void
  9074. d_paint_arc (Dobject *obj)
  9075. {
  9076.   /* first point center */
  9077.   /* Next point is radius */
  9078.   gdouble *line_pnts;
  9079.   gint seg_count = 0;
  9080.   gint i = 0;
  9081.   gdouble ang_grid;
  9082.   gdouble ang_loop;
  9083.   gdouble radius;
  9084.   gint loop;
  9085.   GdkPoint first_pnt, last_pnt;
  9086.   gint first = 1;
  9087.   GdkPoint center_pnt;
  9088.   gdouble minang, arcang;
  9089.  
  9090.   g_assert (obj != NULL);
  9091.  
  9092.   if (!obj)
  9093.     return;
  9094.  
  9095.   /* No cnt pnts & must scale */
  9096.   arc_drawing_details (obj, &minang, ¢er_pnt, &arcang, &radius, FALSE, TRUE);
  9097.  
  9098. #ifdef DEBUG
  9099.   printf ("Paint Min ang = %f Arc ang = %f\n", minang, arcang);
  9100. #endif /* DEBUG */
  9101.  
  9102.   seg_count = 360; /* Should make a smoth-ish curve */
  9103.  
  9104.   /* +3 because we MIGHT do pie selection */
  9105.   line_pnts = g_new0 (gdouble, 2 * seg_count + 3);
  9106.  
  9107.   /* Lines */
  9108.   ang_grid = 2*G_PI/(gdouble)360;
  9109.  
  9110.   if (arcang < 0.0)
  9111.     {
  9112.       /* Swap - since we always draw anti-clock wise */
  9113.       minang += arcang;
  9114.       arcang = -arcang;
  9115.     }
  9116.  
  9117.   minang = minang * (2*G_PI/360); /* min ang is in degrees - need in rads*/
  9118.  
  9119.   for (loop = 0 ; loop < abs ((gint)arcang) ; loop++)
  9120.     {
  9121.       gdouble lx, ly;
  9122.       GdkPoint calc_pnt;
  9123.       
  9124.       ang_loop = (gdouble)loop * ang_grid + minang;
  9125.  
  9126.       lx = radius * cos (ang_loop);
  9127.       ly = -radius * sin (ang_loop); /* y grows down screen and angs measured from x clockwise */
  9128.  
  9129.       calc_pnt.x = (gint)RINT (lx + center_pnt.x);
  9130.       calc_pnt.y = (gint)RINT (ly + center_pnt.y);
  9131.  
  9132.       /* Miss out duped pnts */
  9133.       if (!first)
  9134.     {
  9135.       if (calc_pnt.x == last_pnt.x && calc_pnt.y == last_pnt.y)
  9136.         {
  9137.           continue;
  9138.         }
  9139.     }
  9140.  
  9141.       last_pnt.x = line_pnts[i++] = calc_pnt.x;
  9142.       last_pnt.y = line_pnts[i++] = calc_pnt.y;
  9143.  
  9144.       if (first)
  9145.     {
  9146.       first_pnt.x = calc_pnt.x;
  9147.       first_pnt.y = calc_pnt.y;
  9148.       first = 0;
  9149.     }
  9150.     }
  9151.  
  9152.   /* Reverse line if approp */
  9153.   if (selvals.reverselines)
  9154.     reverse_pairs_list (&line_pnts[0], i/2);
  9155.  
  9156.   /* One go */
  9157.   if (selvals.painttype == PAINT_BRUSH_TYPE)
  9158.     {
  9159.       gfig_paint (selvals.brshtype,
  9160.           gfig_drawable,
  9161.           i, line_pnts);
  9162.     }
  9163.   else
  9164.     {
  9165.       if (selopt.as_pie)
  9166.     {
  9167.       /* Add center point - cause a pie like selection... */
  9168.       line_pnts[i++] = center_pnt.x;
  9169.       line_pnts[i++] = center_pnt.y;
  9170.     }
  9171.  
  9172.       gimp_free_select (gfig_image,
  9173.             i, line_pnts,
  9174.             selopt.type,
  9175.             selopt.antia,
  9176.             selopt.feather,
  9177.             selopt.feather_radius);
  9178.     }
  9179.  
  9180.   g_free (line_pnts);
  9181. }
  9182.  
  9183. static Dobject *
  9184. d_copy_arc (Dobject * obj)
  9185. {
  9186.   Dobject *nc;
  9187.  
  9188. #if DEBUG
  9189.   printf ("Copy ellipse\n");
  9190. #endif /*DEBUG*/
  9191.   if (!obj)
  9192.     return (NULL);
  9193.  
  9194.   g_assert (obj->type == ARC);
  9195.  
  9196.   nc = d_new_arc (obj->points->pnt.x, obj->points->pnt.y);
  9197.  
  9198.   nc->points->next = d_copy_dobjpoints (obj->points->next);
  9199.  
  9200. #if DEBUG
  9201.   printf ("Arc (%x,%x), (%x,%x), (%x,%x)\n",
  9202.      nc->points->pnt.x, obj->points->pnt.y,
  9203.      nc->points->next->pnt.x, obj->points->next->pnt.y,
  9204.      nc->points->next->next->pnt.x, obj->points->next->next->pnt.y);
  9205.   printf ("Done copy\n");
  9206. #endif /*DEBUG*/
  9207.   return (nc);
  9208. }
  9209.  
  9210. static Dobject *
  9211. d_new_arc (gint x,
  9212.        gint y)
  9213. {
  9214.   Dobject *nobj;
  9215.   DobjPoints *npnt;
  9216.  
  9217.   /* Get new object and starting point */
  9218.  
  9219.   /* Start point */
  9220.   npnt = g_new0 (DobjPoints, 1);
  9221.  
  9222. #if DEBUG
  9223.   printf ("New arc start at (%x,%x)\n", x, y);
  9224. #endif /* DEBUG */
  9225.   npnt->pnt.x = x;
  9226.   npnt->pnt.y = y;
  9227.  
  9228.   nobj = g_new0 (Dobject, 1);
  9229.  
  9230.   nobj->type = ARC;
  9231.   nobj->points = npnt;
  9232.   nobj->drawfunc  = d_draw_arc;
  9233.   nobj->loadfunc  = d_load_arc;
  9234.   nobj->savefunc  = d_save_arc;
  9235.   nobj->paintfunc = d_paint_arc;
  9236.   nobj->copyfunc  = d_copy_arc;
  9237.  
  9238.   return (nobj);
  9239. }
  9240.  
  9241. static void
  9242. d_update_arc (GdkPoint *pnt)
  9243. {
  9244.   DobjPoints * pnt1 = NULL;
  9245.   DobjPoints * pnt2 = NULL;
  9246.   DobjPoints * pnt3 = NULL;
  9247.  
  9248.   /* First two points as line only become arch when third
  9249.    * point is placed on canvas.
  9250.    */
  9251.  
  9252.   pnt1 = obj_creating->points;
  9253.  
  9254.   if (!pnt1 ||
  9255.      !(pnt2 = pnt1->next) ||
  9256.      !(pnt3 = pnt2->next))
  9257.     {
  9258.       d_update_line (pnt);
  9259.       return; /* Not fully drawn */
  9260.     }
  9261.  
  9262.   /* Update a real curve */
  9263.   /* Nothing to be done ... */
  9264. }
  9265.  
  9266. static void
  9267. d_arc_start (GdkPoint *pnt,
  9268.          gint      shift_down)
  9269. {
  9270.   /* Draw lines to start with -- then convert to an arc */
  9271.   if (!tmp_line)
  9272.     draw_sqr (pnt);
  9273.   d_line_start (pnt, TRUE); /* TRUE means multiple pointed line */
  9274. }
  9275.  
  9276. static void
  9277. d_arc_end (GdkPoint *pnt,
  9278.        gint      shift_down)
  9279. {
  9280.   /* Under contrl point */
  9281.   if (!tmp_line ||
  9282.      !tmp_line->points ||
  9283.      !tmp_line->points->next)
  9284.     {
  9285.       /* No arc created  - yet */
  9286.       /* Must have three points */
  9287. #ifdef DEBUG
  9288.       printf ("No arc created yet\n");
  9289. #endif /* DEBUG */
  9290.       d_line_end (pnt, TRUE);
  9291.     }
  9292.   else
  9293.     {
  9294.       /* Complete arc */
  9295.       /* Convert to an arc ... */
  9296.       tmp_line->type = ARC;
  9297.       tmp_line->drawfunc  = d_draw_arc;
  9298.       tmp_line->loadfunc  = d_load_arc;
  9299.       tmp_line->savefunc  = d_save_arc;
  9300.       tmp_line->paintfunc = d_paint_arc;
  9301.       tmp_line->copyfunc  = d_copy_arc;
  9302.       d_line_end (pnt, FALSE);
  9303.       /*d_draw_line (newarc);  Should undraw line */
  9304.       if (need_to_scale)
  9305.     {
  9306.       selvals.scaletoimage = 0;
  9307.     }
  9308.       /*d_draw_arc (newarc);*/
  9309.       update_draw_area (gfig_preview, NULL);
  9310.       if (need_to_scale)
  9311.     {
  9312.       selvals.scaletoimage = 1;
  9313.     }
  9314.  
  9315.     }
  9316. }
  9317. /*XXXXXXXXXXXXXXXXXXXXXXX*/
  9318. /* Star shape */
  9319.  
  9320. static void
  9321. d_save_star (Dobject *obj,
  9322.          FILE    *to)
  9323. {
  9324.   DobjPoints * spnt;
  9325.   
  9326.   spnt = obj->points;
  9327.  
  9328.   if (!spnt)
  9329.     return; /* End-of-line */
  9330.  
  9331.   fprintf (to, "<STAR>\n");
  9332.  
  9333.   while (spnt)
  9334.     {
  9335.       fprintf (to, "%d %d\n",
  9336.           (gint)spnt->pnt.x,
  9337.           (gint)spnt->pnt.y);
  9338.       spnt = spnt->next;
  9339.     }
  9340.   
  9341.   fprintf (to, "<EXTRA>\n");
  9342.   fprintf (to, "%d\n</EXTRA>\n", (gint)obj->type_data);
  9343.   fprintf (to, "</STAR>\n");
  9344. }
  9345.  
  9346. /* Load a circle from the specified stream */
  9347.  
  9348. static Dobject *
  9349. d_load_star (FILE *from)
  9350. {
  9351.   Dobject *new_obj = NULL;
  9352.   gint xpnt;
  9353.   gint ypnt;
  9354.   gchar buf[MAX_LOAD_LINE];
  9355.  
  9356. #ifdef DEBUG
  9357.   printf ("Load star called\n");
  9358. #endif /* DEBUG */
  9359.  
  9360.   while (get_line (buf, MAX_LOAD_LINE, from, 0))
  9361.     {
  9362.       if (sscanf (buf, "%d %d", &xpnt, &ypnt) != 2)
  9363.     {
  9364.       /* Must be the end */
  9365.       if (!strcmp ("<EXTRA>", buf))
  9366.         {
  9367.           gint nsides = 3;
  9368.           /* Number of sides - data item */
  9369.           if (!new_obj)
  9370.         {
  9371.           g_warning ("[%d] Internal load error while loading star (extra area)",
  9372.                 line_no);
  9373.           return (NULL);
  9374.         }
  9375.           get_line (buf, MAX_LOAD_LINE, from, 0);
  9376.           if (sscanf (buf, "%d", &nsides) != 1)
  9377.         {
  9378.           g_warning ("[%d] Internal load error while loading star (extra area scanf)",
  9379.                 line_no);
  9380.           return (NULL);
  9381.         }
  9382.           new_obj->type_data = (gpointer)nsides;
  9383.           get_line (buf, MAX_LOAD_LINE, from, 0);
  9384.           if (strcmp ("</EXTRA>", buf))
  9385.         {
  9386.           g_warning ("[%d] Internal load error while loading star",
  9387.                 line_no);
  9388.           return (NULL);
  9389.         } 
  9390.           /* Go around and read the last line */
  9391.           continue;
  9392.         }
  9393.       else if (strcmp ("</STAR>", buf))
  9394.         {
  9395.           g_warning ("[%d] Internal load error while loading star",
  9396.             line_no);
  9397.           return (NULL);
  9398.         }
  9399.       return (new_obj);
  9400.     }
  9401.       
  9402.       if (!new_obj)
  9403.     new_obj = d_new_star (xpnt, ypnt);
  9404.       else
  9405.     d_pnt_add_line (new_obj, xpnt, ypnt,-1);
  9406.     }
  9407.   return (new_obj);
  9408. }
  9409.  
  9410. static void
  9411. d_draw_star (Dobject *obj)
  9412. {
  9413.   DobjPoints * center_pnt;
  9414.   DobjPoints * outer_radius_pnt;
  9415.   DobjPoints * inner_radius_pnt;
  9416.   gint16 shift_x;
  9417.   gint16 shift_y;
  9418.   gdouble ang_grid;
  9419.   gdouble ang_loop;
  9420.   gdouble outer_radius;
  9421.   gdouble inner_radius;
  9422.   gdouble offset_angle;
  9423.   gint loop;
  9424.   GdkPoint start_pnt;
  9425.   GdkPoint first_pnt;
  9426.   gint do_line = 0;
  9427.  
  9428.   center_pnt = obj->points;
  9429.  
  9430.   if (!center_pnt)
  9431.     return; /* End-of-line */
  9432.  
  9433.   /* First point is the center */
  9434.   /* Just draw a control point around it */
  9435.  
  9436.   draw_sqr (¢er_pnt->pnt);
  9437.  
  9438.   /* Next point defines the radius */
  9439.   outer_radius_pnt = center_pnt->next; /* this defines the vetices */
  9440.  
  9441.   if (!outer_radius_pnt)
  9442.     {
  9443. #ifdef DEBUG
  9444.       g_warning ("Internal error in star - no outer vertice point \n");
  9445. #endif /* DEBUG */
  9446.       return;
  9447.     }
  9448.  
  9449.   inner_radius_pnt = outer_radius_pnt->next; /* this defines the vetices */
  9450.  
  9451.   if (!inner_radius_pnt)
  9452.     {
  9453. #ifdef DEBUG
  9454.       g_warning ("Internal error in star - no inner vertice point \n");
  9455. #endif /* DEBUG */
  9456.       return;
  9457.     }
  9458.  
  9459.   /* Other control points */
  9460.   draw_sqr (&outer_radius_pnt->pnt);
  9461.   draw_sqr (&inner_radius_pnt->pnt);
  9462.  
  9463.   /* Have center and radius - draw star */
  9464.  
  9465.   shift_x = outer_radius_pnt->pnt.x - center_pnt->pnt.x;
  9466.   shift_y = outer_radius_pnt->pnt.y - center_pnt->pnt.y;
  9467.  
  9468.   outer_radius = sqrt ((shift_x*shift_x) + (shift_y*shift_y));
  9469.  
  9470.   /* Lines */
  9471.   ang_grid = 2*G_PI/(2.0*(gdouble) (gint)obj->type_data);
  9472.   offset_angle = atan2 (shift_y, shift_x);
  9473.  
  9474.   shift_x = inner_radius_pnt->pnt.x - center_pnt->pnt.x;
  9475.   shift_y = inner_radius_pnt->pnt.y - center_pnt->pnt.y;
  9476.  
  9477.   inner_radius = sqrt ((shift_x*shift_x) + (shift_y*shift_y));
  9478.  
  9479.   for (loop = 0 ; loop < 2*(gint)obj->type_data ; loop++)
  9480.     {
  9481.       gdouble lx, ly;
  9482.       GdkPoint calc_pnt;
  9483.  
  9484.       ang_loop = (gdouble)loop * ang_grid + offset_angle;
  9485.     
  9486.       if (loop%2)
  9487.     {
  9488.       lx = inner_radius * cos (ang_loop);
  9489.       ly = inner_radius * sin (ang_loop);
  9490.     }
  9491.       else
  9492.     {
  9493.       lx = outer_radius * cos (ang_loop);
  9494.       ly = outer_radius * sin (ang_loop);
  9495.     }
  9496.  
  9497.       calc_pnt.x = (gint)RINT (lx + center_pnt->pnt.x);
  9498.       calc_pnt.y = (gint)RINT (ly + center_pnt->pnt.y);
  9499.  
  9500.       if (do_line)
  9501.     {
  9502.  
  9503.       /* Miss out points that come to the same location */
  9504.       if (calc_pnt.x == start_pnt.x && calc_pnt.y == start_pnt.y)
  9505.         continue;
  9506.  
  9507.       if (drawing_pic)
  9508.         {
  9509.           gdk_draw_line (pic_preview->window,
  9510.                  pic_preview->style->black_gc,                
  9511.                  adjust_pic_coords (calc_pnt.x,
  9512.                         preview_width),
  9513.                  adjust_pic_coords (calc_pnt.y,
  9514.                         preview_height),
  9515.                  adjust_pic_coords (start_pnt.x,
  9516.                         preview_width),
  9517.                  adjust_pic_coords (start_pnt.y,
  9518.                         preview_height));
  9519.         }
  9520.       else
  9521.         {
  9522.           gdk_draw_line (gfig_preview->window,
  9523.                  gfig_gc,
  9524.                  gfig_scale_x (calc_pnt.x),
  9525.                  gfig_scale_y (calc_pnt.y),
  9526.                  gfig_scale_x (start_pnt.x),
  9527.                  gfig_scale_y (start_pnt.y));
  9528.         }
  9529.     }
  9530.       else
  9531.     {
  9532.       do_line = 1;
  9533.       first_pnt.x = calc_pnt.x;
  9534.       first_pnt.y = calc_pnt.y;
  9535.     }
  9536.       start_pnt.x = calc_pnt.x;
  9537.       start_pnt.y = calc_pnt.y;
  9538.     }
  9539.  
  9540.   /* Join up */
  9541.   if (drawing_pic)
  9542.     {
  9543.       gdk_draw_line (pic_preview->window,
  9544.              pic_preview->style->black_gc,
  9545.              adjust_pic_coords (first_pnt.x, preview_width),
  9546.              adjust_pic_coords (first_pnt.y, preview_width),
  9547.              adjust_pic_coords (start_pnt.x, preview_width),
  9548.              adjust_pic_coords (start_pnt.y, preview_width));
  9549.     }
  9550.   else
  9551.     {
  9552.       gdk_draw_line (gfig_preview->window,
  9553.              gfig_gc,
  9554.              gfig_scale_x (first_pnt.x),
  9555.              gfig_scale_y (first_pnt.y),
  9556.              gfig_scale_x (start_pnt.x),
  9557.              gfig_scale_y (start_pnt.y));
  9558.     }
  9559. }
  9560.  
  9561. static void
  9562. d_paint_star (Dobject *obj)
  9563. {
  9564.   /* first point center */
  9565.   /* Next point is radius */
  9566.   gdouble *line_pnts;
  9567.   gint seg_count = 0;
  9568.   gint i = 0;
  9569.   DobjPoints * center_pnt;
  9570.   DobjPoints * outer_radius_pnt;
  9571.   DobjPoints * inner_radius_pnt;
  9572.   gint16 shift_x;
  9573.   gint16 shift_y;
  9574.   gdouble ang_grid;
  9575.   gdouble ang_loop;
  9576.   gdouble outer_radius;
  9577.   gdouble inner_radius;
  9578.  
  9579.   gdouble offset_angle;
  9580.   gint loop;
  9581.   GdkPoint first_pnt, last_pnt;
  9582.   gint first = 1;
  9583.  
  9584.   g_assert (obj != NULL);
  9585.  
  9586.   /* count - add one to close polygon */
  9587.   seg_count = 2*(gint)obj->type_data + 1;
  9588.  
  9589.   center_pnt = obj->points;
  9590.  
  9591.   if (!center_pnt || !seg_count)
  9592.     return; /* no-line */
  9593.  
  9594.   line_pnts = g_new0 (gdouble, 2 * seg_count + 1);
  9595.   
  9596.   /* Go around all the points drawing a line from one to the next */
  9597.   /* Next point defines the radius */
  9598.   outer_radius_pnt = center_pnt->next; /* this defines the vetices */
  9599.  
  9600.   if (!outer_radius_pnt)
  9601.     {
  9602. #ifdef DEBUG
  9603.       g_warning ("Internal error in star - no outer vertice point \n");
  9604. #endif /* DEBUG */
  9605.       return;
  9606.     }
  9607.  
  9608.   inner_radius_pnt = outer_radius_pnt->next; /* this defines the vetices */
  9609.  
  9610.   if (!inner_radius_pnt)
  9611.     {
  9612. #ifdef DEBUG
  9613.       g_warning ("Internal error in star - no inner vertice point \n");
  9614. #endif /* DEBUG */
  9615.       return;
  9616.     }
  9617.  
  9618.   shift_x = outer_radius_pnt->pnt.x - center_pnt->pnt.x;
  9619.   shift_y = outer_radius_pnt->pnt.y - center_pnt->pnt.y;
  9620.  
  9621.   outer_radius = sqrt ((shift_x*shift_x) + (shift_y*shift_y));
  9622.  
  9623.   /* Lines */
  9624.   ang_grid = 2*G_PI/(2.0*(gdouble) (gint)obj->type_data);
  9625.   offset_angle = atan2 (shift_y, shift_x);
  9626.  
  9627.   shift_x = inner_radius_pnt->pnt.x - center_pnt->pnt.x;
  9628.   shift_y = inner_radius_pnt->pnt.y - center_pnt->pnt.y;
  9629.  
  9630.   inner_radius = sqrt ((shift_x*shift_x) + (shift_y*shift_y));
  9631.  
  9632.   for (loop = 0 ; loop < 2*(gint)obj->type_data ; loop++)
  9633.     {
  9634.       gdouble lx, ly;
  9635.       GdkPoint calc_pnt;
  9636.       
  9637.       ang_loop = (gdouble)loop * ang_grid + offset_angle;
  9638.     
  9639.       if (loop%2)
  9640.     {
  9641.       lx = inner_radius * cos (ang_loop);
  9642.       ly = inner_radius * sin (ang_loop);
  9643.     }
  9644.       else
  9645.     {
  9646.       lx = outer_radius * cos (ang_loop);
  9647.       ly = outer_radius * sin (ang_loop);
  9648.     }
  9649.  
  9650.       calc_pnt.x = (gint)RINT (lx + center_pnt->pnt.x);
  9651.       calc_pnt.y = (gint)RINT (ly + center_pnt->pnt.y);
  9652.  
  9653.       /* Miss out duped pnts */
  9654.       if (!first)
  9655.     {
  9656.       if (calc_pnt.x == last_pnt.x && calc_pnt.y == last_pnt.y)
  9657.         {
  9658.           continue;
  9659.         }
  9660.     }
  9661.  
  9662.       last_pnt.x = line_pnts[i++] = calc_pnt.x;
  9663.       last_pnt.y = line_pnts[i++] = calc_pnt.y;
  9664.  
  9665.       if (first)
  9666.     {
  9667.       first_pnt.x = calc_pnt.x;
  9668.       first_pnt.y = calc_pnt.y;
  9669.       first = 0;
  9670.     }
  9671.     }
  9672.  
  9673.   line_pnts[i++] = first_pnt.x;
  9674.   line_pnts[i++] = first_pnt.y;
  9675.  
  9676.   /* Reverse line if approp */
  9677.   if (selvals.reverselines)
  9678.     reverse_pairs_list (&line_pnts[0], i/2);
  9679.  
  9680.   /* Scale before drawing */
  9681.   if (selvals.scaletoimage)
  9682.     scale_to_original_xy (&line_pnts[0], i/2);
  9683.   else
  9684.     scale_to_xy (&line_pnts[0], i/2);
  9685.  
  9686.   /* One go */
  9687.   if (selvals.painttype == PAINT_BRUSH_TYPE)
  9688.     {
  9689.       gfig_paint (selvals.brshtype,
  9690.           gfig_drawable,
  9691.           i, line_pnts);
  9692.     }
  9693.   else
  9694.     {
  9695.       gimp_free_select (gfig_image,
  9696.             i, line_pnts,
  9697.             selopt.type,
  9698.             selopt.antia,
  9699.             selopt.feather,
  9700.             selopt.feather_radius);
  9701.     }
  9702.  
  9703.   g_free (line_pnts);
  9704. }
  9705.  
  9706. static Dobject *
  9707. d_copy_star (Dobject * obj)
  9708. {
  9709.   Dobject *np;
  9710.  
  9711. #if DEBUG
  9712.   printf ("Copy star\n");
  9713. #endif /*DEBUG*/
  9714.   if (!obj)
  9715.     return (NULL);
  9716.  
  9717.   g_assert (obj->type == STAR);
  9718.  
  9719.   np = d_new_star (obj->points->pnt.x, obj->points->pnt.y);
  9720.  
  9721.   np->points->next = d_copy_dobjpoints (obj->points->next);
  9722.  
  9723.   np->type_data = obj->type_data;
  9724.  
  9725. #if DEBUG
  9726.   printf ("Done star copy\n");
  9727. #endif /*DEBUG*/
  9728.   return (np);
  9729. }
  9730.  
  9731. static Dobject *
  9732. d_new_star (gint x,
  9733.         gint y)
  9734. {
  9735.   Dobject *nobj;
  9736.   DobjPoints *npnt;
  9737.  
  9738.   /* Get new object and starting point */
  9739.  
  9740.   /* Start point */
  9741.   npnt = g_new0 (DobjPoints, 1);
  9742.  
  9743. #if DEBUG
  9744.   printf ("New STAR start at (%x,%x)\n", x, y);
  9745. #endif /* DEBUG */
  9746.   npnt->pnt.x = x;
  9747.   npnt->pnt.y = y;
  9748.  
  9749.   nobj = g_new0 (Dobject, 1);
  9750.  
  9751.   nobj->type = STAR;
  9752.   nobj->type_data = (gpointer)3; /* Default to three sides 6 points*/
  9753.   nobj->points = npnt;
  9754.   nobj->drawfunc  = d_draw_star;
  9755.   nobj->loadfunc  = d_load_star;
  9756.   nobj->savefunc  = d_save_star;
  9757.   nobj->paintfunc = d_paint_star;
  9758.   nobj->copyfunc  = d_copy_star;
  9759.  
  9760.   return (nobj);
  9761. }
  9762.  
  9763. static void
  9764. d_update_star (GdkPoint *pnt)
  9765. {
  9766.   DobjPoints *center_pnt, *inner_pnt, *outer_pnt;
  9767.   gint saved_cnt_pnt = selvals.opts.showcontrol;
  9768.  
  9769.   /* Undraw last one then draw new one */
  9770.   center_pnt = obj_creating->points;
  9771.   
  9772.   if (!center_pnt)
  9773.     return; /* No points */
  9774.  
  9775.   /* Leave the first pnt alone -
  9776.    * Edge point defines "radius"
  9777.    * Only undraw if already have edge point.
  9778.    */
  9779.  
  9780.   /* Hack - turn off cnt points in draw routine 
  9781.    * Looking back over the other update routines I could
  9782.    * use this trick again and cut down on code size!
  9783.    */
  9784.  
  9785.  
  9786.   if ((outer_pnt = center_pnt->next))
  9787.     {
  9788.       /* Undraw */
  9789.       inner_pnt = outer_pnt->next;
  9790.       draw_circle (&inner_pnt->pnt);
  9791.       draw_circle (&outer_pnt->pnt);
  9792.       selvals.opts.showcontrol = 0;
  9793.       d_draw_star (obj_creating);
  9794.       outer_pnt->pnt.x = pnt->x;
  9795.       outer_pnt->pnt.y = pnt->y;
  9796.       inner_pnt->pnt.x = pnt->x + (2*(center_pnt->pnt.x - pnt->x))/3;
  9797.       inner_pnt->pnt.y = pnt->y + (2*(center_pnt->pnt.y - pnt->y))/3;
  9798.     }
  9799.   else
  9800.     {
  9801.       /* Radius is a few pixels away */
  9802.       /* First edge point */
  9803.       d_pnt_add_line (obj_creating, pnt->x, pnt->y,-1);
  9804.       outer_pnt = center_pnt->next;
  9805.       /* Inner radius */
  9806.       d_pnt_add_line (obj_creating,
  9807.               pnt->x + (2*(center_pnt->pnt.x - pnt->x))/3,
  9808.               pnt->y + (2*(center_pnt->pnt.y - pnt->y))/3,
  9809.               -1);
  9810.       inner_pnt = outer_pnt->next;
  9811.     }
  9812.  
  9813.   /* draw it */
  9814.   selvals.opts.showcontrol = 0;
  9815.   d_draw_star (obj_creating);
  9816.   selvals.opts.showcontrol = saved_cnt_pnt;
  9817.  
  9818.   /* Realy draw the control points */
  9819.   draw_circle (&outer_pnt->pnt);
  9820.   draw_circle (&inner_pnt->pnt);
  9821. }
  9822.  
  9823. /* first point is center 
  9824.  * next defines the radius
  9825.  */
  9826.  
  9827. static void
  9828. d_star_start (GdkPoint *pnt,
  9829.           gint      shift_down)
  9830. {
  9831.   gint16 x, y;
  9832.   /* First is center point */
  9833.   obj_creating = d_new_star (x = pnt->x, y = pnt->y);
  9834.   obj_creating->type_data = (gpointer)star_num_sides;
  9835. }
  9836.  
  9837. static void
  9838. d_star_end (GdkPoint *pnt,
  9839.         gint      shift_down)
  9840. {
  9841.   draw_circle (pnt);
  9842.   add_to_all_obj (current_obj, obj_creating);
  9843.   obj_creating = NULL;
  9844. }
  9845.  
  9846.  
  9847. /* Spiral */
  9848.  
  9849. static void
  9850. d_save_spiral (Dobject *obj,
  9851.            FILE    *to)
  9852. {
  9853.   DobjPoints * spnt;
  9854.   
  9855.   spnt = obj->points;
  9856.  
  9857.   if (!spnt)
  9858.     return; /* End-of-line */
  9859.  
  9860.   fprintf (to, "<SPIRAL>\n");
  9861.  
  9862.   while (spnt)
  9863.     {
  9864.       fprintf (to, "%d %d\n",
  9865.            (gint)spnt->pnt.x,
  9866.            (gint)spnt->pnt.y);
  9867.       spnt = spnt->next;
  9868.     }
  9869.   
  9870.   fprintf (to, "<EXTRA>\n");
  9871.   fprintf (to, "%d\n</EXTRA>\n", (gint)obj->type_data);
  9872.   fprintf (to, "</SPIRAL>\n");
  9873.  
  9874. }
  9875.  
  9876. /* Load a spiral from the specified stream */
  9877.  
  9878. static Dobject *
  9879. d_load_spiral (FILE *from)
  9880. {
  9881.   Dobject *new_obj = NULL;
  9882.   gint xpnt;
  9883.   gint ypnt;
  9884.   gchar buf[MAX_LOAD_LINE];
  9885.  
  9886. #ifdef DEBUG
  9887.   printf ("Load spiral called\n");
  9888. #endif /* DEBUG */
  9889.  
  9890.   while (get_line (buf, MAX_LOAD_LINE, from, 0))
  9891.     {
  9892.       if (sscanf (buf, "%d %d", &xpnt, &ypnt) != 2)
  9893.     {
  9894.       /* Must be the end */
  9895.       if (!strcmp ("<EXTRA>", buf))
  9896.         {
  9897.           gint nsides = 3;
  9898.           /* Number of sides - data item */
  9899.           if (!new_obj)
  9900.         {
  9901.           g_warning ("[%d] Internal load error while loading spiral (extra area)",
  9902.                 line_no);
  9903.           return (NULL);
  9904.         }
  9905.           get_line (buf, MAX_LOAD_LINE, from, 0);
  9906.           if (sscanf (buf, "%d", &nsides) != 1)
  9907.         {
  9908.           g_warning ("[%d] Internal load error while loading spiral (extra area scanf)",
  9909.                 line_no);
  9910.           return (NULL);
  9911.         }
  9912.           new_obj->type_data = (gpointer)nsides;
  9913.           get_line (buf, MAX_LOAD_LINE, from, 0);
  9914.           if (strcmp ("</EXTRA>", buf))
  9915.         {
  9916.           g_warning ("[%d] Internal load error while loading spiral",
  9917.                 line_no);
  9918.           return (NULL);
  9919.         } 
  9920.           /* Go around and read the last line */
  9921.           continue;
  9922.         }
  9923.       else if (strcmp ("</SPIRAL>", buf))
  9924.         {
  9925.           g_warning ("[%d] Internal load error while loading spiral",
  9926.             line_no);
  9927.           return (NULL);
  9928.         }
  9929.       return (new_obj);
  9930.     }
  9931.       
  9932.       if (!new_obj)
  9933.     new_obj = d_new_spiral (xpnt, ypnt);
  9934.       else
  9935.     d_pnt_add_line (new_obj, xpnt, ypnt,-1);
  9936.     }
  9937.   return (new_obj);
  9938. }
  9939.  
  9940. static void
  9941. d_draw_spiral (Dobject *obj)
  9942. {
  9943.   DobjPoints * center_pnt;
  9944.   DobjPoints * radius_pnt;
  9945.   gint16 shift_x;
  9946.   gint16 shift_y;
  9947.   gdouble ang_grid;
  9948.   gdouble ang_loop;
  9949.   gdouble radius;
  9950.   gdouble offset_angle;
  9951.   gdouble sp_cons;
  9952.   gint loop;
  9953.   GdkPoint start_pnt;
  9954.   GdkPoint first_pnt;
  9955.   gint do_line = 0;
  9956.   gint clock_wise = 1;
  9957.  
  9958.   center_pnt = obj->points;
  9959.  
  9960.   if (!center_pnt)
  9961.     return; /* End-of-line */
  9962.  
  9963.   /* First point is the center */
  9964.   /* Just draw a control point around it */
  9965.  
  9966.   draw_sqr (¢er_pnt->pnt);
  9967.  
  9968.   /* Next point defines the radius */
  9969.   radius_pnt = center_pnt->next; /* this defines the vetices */
  9970.  
  9971.   if (!radius_pnt)
  9972.     {
  9973. #ifdef DEBUG
  9974.       g_warning ("Internal error in spiral - no vertice point \n");
  9975. #endif /* DEBUG */
  9976.       return;
  9977.     }
  9978.  
  9979.   /* Other control point */
  9980.   draw_sqr (&radius_pnt->pnt);
  9981.  
  9982.   /* Have center and radius - draw spiral */
  9983.  
  9984.   shift_x = radius_pnt->pnt.x - center_pnt->pnt.x;
  9985.   shift_y = radius_pnt->pnt.y - center_pnt->pnt.y;
  9986.  
  9987.   radius = sqrt ((shift_x*shift_x) + (shift_y*shift_y));
  9988.  
  9989.   offset_angle = atan2 (shift_y, shift_x);
  9990.  
  9991.   clock_wise = ((gint)obj->type_data)/(abs ((gint) (obj->type_data)));
  9992.  
  9993.   if (offset_angle < 0)
  9994.     offset_angle += 2*G_PI;
  9995.  
  9996.   sp_cons = radius/((gint)obj->type_data * 2 * G_PI + offset_angle);
  9997.   /* Lines */
  9998.   ang_grid = 2.0*G_PI/(gdouble)180;
  9999.  
  10000.  
  10001.   for (loop = 0 ; loop <= abs ((gint) (obj->type_data)*180) + clock_wise*(gint)RINT (offset_angle/ang_grid) ; loop++)
  10002.     {
  10003.       gdouble lx, ly;
  10004.       GdkPoint calc_pnt;
  10005.  
  10006.       ang_loop = (gdouble)loop * ang_grid;
  10007.     
  10008.       lx = sp_cons * ang_loop * cos (ang_loop)*clock_wise;
  10009.       ly = sp_cons * ang_loop * sin (ang_loop);
  10010.  
  10011.       calc_pnt.x = (gint)RINT (lx + center_pnt->pnt.x);
  10012.       calc_pnt.y = (gint)RINT (ly + center_pnt->pnt.y);
  10013.  
  10014.       if (do_line)
  10015.     {
  10016.  
  10017.       /* Miss out points that come to the same location */
  10018.       if (calc_pnt.x == start_pnt.x && calc_pnt.y == start_pnt.y)
  10019.         continue;
  10020.  
  10021.       if (drawing_pic)
  10022.         {
  10023.           gdk_draw_line (pic_preview->window,
  10024.                  pic_preview->style->black_gc,                
  10025.                  adjust_pic_coords (calc_pnt.x,
  10026.                         preview_width),
  10027.                  adjust_pic_coords (calc_pnt.y,
  10028.                         preview_height),
  10029.                  adjust_pic_coords (start_pnt.x,
  10030.                         preview_width),
  10031.                  adjust_pic_coords (start_pnt.y,
  10032.                         preview_height));
  10033.         }
  10034.       else
  10035.         {
  10036.           gdk_draw_line (gfig_preview->window,
  10037.                  gfig_gc,
  10038.                  gfig_scale_x (calc_pnt.x),
  10039.                  gfig_scale_y (calc_pnt.y),
  10040.                  gfig_scale_x (start_pnt.x),
  10041.                  gfig_scale_y (start_pnt.y));
  10042.         }
  10043.     }
  10044.       else
  10045.     {
  10046.       do_line = 1;
  10047.       first_pnt.x = calc_pnt.x;
  10048.       first_pnt.y = calc_pnt.y;
  10049.     }
  10050.       start_pnt.x = calc_pnt.x;
  10051.       start_pnt.y = calc_pnt.y;
  10052.     }
  10053. }
  10054.  
  10055. static void
  10056. d_paint_spiral (Dobject *obj)
  10057. {
  10058.   /* first point center */
  10059.   /* Next point is radius */
  10060.   gdouble *line_pnts;
  10061.   gint seg_count = 0;
  10062.   gint i = 0;
  10063.   DobjPoints * center_pnt;
  10064.   DobjPoints * radius_pnt;
  10065.   gint16 shift_x;
  10066.   gint16 shift_y;
  10067.   gdouble ang_grid;
  10068.   gdouble ang_loop;
  10069.   gdouble radius;
  10070.   gdouble offset_angle;
  10071.   gdouble sp_cons;
  10072.   gint loop;
  10073.   GdkPoint last_pnt;
  10074.   gint clock_wise = 1;
  10075.  
  10076.   g_assert (obj != NULL);
  10077.  
  10078.   center_pnt = obj->points;
  10079.  
  10080.   if (!center_pnt || !center_pnt->next)
  10081.     return; /* no-line */
  10082.  
  10083.   /* Go around all the points drawing a line from one to the next */
  10084.  
  10085.   radius_pnt = center_pnt->next; /* this defines the vetices */
  10086.  
  10087.   /* Have center and radius - get lines */
  10088.   shift_x = radius_pnt->pnt.x - center_pnt->pnt.x;
  10089.   shift_y = radius_pnt->pnt.y - center_pnt->pnt.y;
  10090.  
  10091.   radius = sqrt ((shift_x*shift_x) + (shift_y*shift_y));
  10092.  
  10093.   clock_wise = ((gint)obj->type_data)/(abs ((gint) (obj->type_data)));
  10094.  
  10095.   offset_angle = atan2 (shift_y, shift_x);
  10096.  
  10097.   if (offset_angle < 0)
  10098.     offset_angle += 2*G_PI;
  10099.  
  10100.   sp_cons = radius/((gint)obj->type_data * 2 * G_PI + offset_angle);
  10101.   /* Lines */
  10102.   ang_grid = 2.0*G_PI/(gdouble)180;
  10103.  
  10104.  
  10105.   /* count - */
  10106.   seg_count = abs ((gint) (obj->type_data)*180) + clock_wise*(gint)RINT (offset_angle/ang_grid);
  10107.  
  10108.   line_pnts = g_new0 (gdouble, 2 * seg_count + 3);
  10109.  
  10110.   for (loop = 0 ; loop <= seg_count; loop++)
  10111.     {
  10112.       gdouble lx, ly;
  10113.       GdkPoint calc_pnt;
  10114.  
  10115.       ang_loop = (gdouble)loop * ang_grid;
  10116.     
  10117.       lx = sp_cons * ang_loop * cos (ang_loop)*clock_wise;
  10118.       ly = sp_cons * ang_loop * sin (ang_loop);
  10119.  
  10120.       calc_pnt.x = (gint)RINT (lx + center_pnt->pnt.x);
  10121.       calc_pnt.y = (gint)RINT (ly + center_pnt->pnt.y);
  10122.  
  10123.       /* Miss out duped pnts */
  10124.       if (!loop)
  10125.     {
  10126.       if (calc_pnt.x == last_pnt.x && calc_pnt.y == last_pnt.y)
  10127.         {
  10128.           continue;
  10129.         }
  10130.     }
  10131.  
  10132.       last_pnt.x = line_pnts[i++] = calc_pnt.x;
  10133.       last_pnt.y = line_pnts[i++] = calc_pnt.y;
  10134.     }
  10135.  
  10136.   /* Reverse line if approp */
  10137.   if (selvals.reverselines)
  10138.     reverse_pairs_list (&line_pnts[0], i/2);
  10139.  
  10140.   /* Scale before drawing */
  10141.   if (selvals.scaletoimage)
  10142.     scale_to_original_xy (&line_pnts[0], i/2);
  10143.   else
  10144.     scale_to_xy (&line_pnts[0], i/2);
  10145.  
  10146.   /* One go */
  10147.   if (selvals.painttype == PAINT_BRUSH_TYPE)
  10148.     {
  10149.       gfig_paint (selvals.brshtype,
  10150.           gfig_drawable,
  10151.           i, line_pnts);
  10152.     }
  10153.   else
  10154.     {
  10155.       gimp_free_select (gfig_image,
  10156.             i, line_pnts,
  10157.             selopt.type,
  10158.             selopt.antia,
  10159.             selopt.feather,
  10160.             selopt.feather_radius);
  10161.     }
  10162.  
  10163.   g_free (line_pnts);
  10164. }
  10165.  
  10166. static Dobject *
  10167. d_copy_spiral (Dobject * obj)
  10168. {
  10169.   Dobject *np;
  10170.  
  10171. #if DEBUG
  10172.   printf ("Copy spiral\n");
  10173. #endif /*DEBUG*/
  10174.   if (!obj)
  10175.     return (NULL);
  10176.  
  10177.   g_assert (obj->type == SPIRAL);
  10178.  
  10179.   np = d_new_spiral (obj->points->pnt.x, obj->points->pnt.y);
  10180.  
  10181.   np->points->next = d_copy_dobjpoints (obj->points->next);
  10182.  
  10183.   np->type_data = obj->type_data;
  10184.  
  10185. #if DEBUG
  10186.   printf ("Done spiral copy\n");
  10187. #endif /*DEBUG*/
  10188.   return (np);
  10189. }
  10190.  
  10191. static Dobject *
  10192. d_new_spiral (gint x,
  10193.           gint y)
  10194. {
  10195.   Dobject *nobj;
  10196.   DobjPoints *npnt;
  10197.  
  10198.   /* Get new object and starting point */
  10199.  
  10200.   /* Start point */
  10201.   npnt = g_new0 (DobjPoints, 1);
  10202.  
  10203. #if DEBUG
  10204.   printf ("New SPIRAL start at (%x,%x)\n", x, y);
  10205. #endif /* DEBUG */
  10206.   npnt->pnt.x = x;
  10207.   npnt->pnt.y = y;
  10208.  
  10209.   nobj = g_new0 (Dobject, 1);
  10210.  
  10211.   nobj->type = SPIRAL;
  10212.   nobj->type_data = (gpointer)4; /* Default to four turns */
  10213.   nobj->points = npnt;
  10214.   nobj->drawfunc  = d_draw_spiral;
  10215.   nobj->loadfunc  = d_load_spiral;
  10216.   nobj->savefunc  = d_save_spiral;
  10217.   nobj->paintfunc = d_paint_spiral;
  10218.   nobj->copyfunc  = d_copy_spiral;
  10219.  
  10220.   return (nobj);
  10221. }
  10222.  
  10223. static void
  10224. d_update_spiral (GdkPoint *pnt)
  10225. {
  10226.   DobjPoints *center_pnt, *edge_pnt;
  10227.   gint saved_cnt_pnt = selvals.opts.showcontrol;
  10228.  
  10229.   /* Undraw last one then draw new one */
  10230.   center_pnt = obj_creating->points;
  10231.   
  10232.   if (!center_pnt)
  10233.     return; /* No points */
  10234.  
  10235.   /* Leave the first pnt alone -
  10236.    * Edge point defines "radius"
  10237.    * Only undraw if already have edge point.
  10238.    */
  10239.  
  10240.   /* Hack - turn off cnt points in draw routine 
  10241.    * Looking back over the other update routines I could
  10242.    * use this trick again and cut down on code size!
  10243.    */
  10244.  
  10245.   if ((edge_pnt = center_pnt->next))
  10246.     {
  10247.       /* Undraw */
  10248.       draw_circle (&edge_pnt->pnt);
  10249.       selvals.opts.showcontrol = 0;
  10250.       d_draw_spiral (obj_creating);
  10251.  
  10252.       edge_pnt->pnt.x = pnt->x;
  10253.       edge_pnt->pnt.y = pnt->y;
  10254.     }
  10255.   else
  10256.     {
  10257.       /* Radius is a few pixels away */
  10258.       /* First edge point */
  10259.       d_pnt_add_line (obj_creating, pnt->x, pnt->y, -1);
  10260.       edge_pnt = center_pnt->next;
  10261.     }
  10262.  
  10263.   /* draw it */
  10264.   selvals.opts.showcontrol = 0;
  10265.   d_draw_spiral (obj_creating);
  10266.   selvals.opts.showcontrol = saved_cnt_pnt;
  10267.  
  10268.   /* Realy draw the control points */
  10269.   draw_circle (&edge_pnt->pnt);
  10270. }
  10271.  
  10272. /* first point is center 
  10273.  * next defines the radius
  10274.  */
  10275.  
  10276. static void
  10277. d_spiral_start (GdkPoint *pnt,
  10278.         gint      shift_down)
  10279. {
  10280.   gint16 x, y;
  10281.   /* First is center point */
  10282.   obj_creating = d_new_spiral (x = pnt->x, y = pnt->y);
  10283.   obj_creating->type_data =
  10284.     (gpointer) (spiral_num_turns * ((spiral_toggle == 0) ? 1 : -1));
  10285. }
  10286.  
  10287. static void
  10288. d_spiral_end (GdkPoint *pnt,
  10289.           gint     shift_down)
  10290. {
  10291.   draw_circle (pnt);
  10292.   add_to_all_obj (current_obj, obj_creating);
  10293.   obj_creating = NULL;
  10294. }
  10295.  
  10296. /* Stuff for bezier curves... */
  10297.  
  10298. static void
  10299. d_save_bezier (Dobject *obj,
  10300.            FILE    *to)
  10301. {
  10302.   DobjPoints *spnt;
  10303.  
  10304.   spnt = obj->points;
  10305.  
  10306.   if (!spnt)
  10307.     return; /* End-of-line */
  10308.  
  10309.   fprintf (to, "<BEZIER>\n");
  10310.  
  10311.   while (spnt)
  10312.     {
  10313.       fprintf (to, "%d %d\n",
  10314.            (gint)spnt->pnt.x,
  10315.            (gint)spnt->pnt.y);
  10316.       spnt = spnt->next;
  10317.     }
  10318.   
  10319.   fprintf (to, "<EXTRA>\n");
  10320.   fprintf (to, "%d\n</EXTRA>\n", (gint) obj->type_data);
  10321.   fprintf (to, "</BEZIER>\n");
  10322. }
  10323.  
  10324. /* Load a bezier from the specified stream */
  10325.  
  10326. static Dobject *
  10327. d_load_bezier (FILE *from)
  10328. {
  10329.   Dobject *new_obj = NULL;
  10330.   gint xpnt;
  10331.   gint ypnt;
  10332.   gchar buf[MAX_LOAD_LINE];
  10333.  
  10334. #ifdef DEBUG
  10335.   printf ("Load bezier called\n");
  10336. #endif /* DEBUG */
  10337.  
  10338.   while (get_line (buf, MAX_LOAD_LINE, from, 0))
  10339.     {
  10340.       if (sscanf (buf, "%d %d", &xpnt, &ypnt) != 2)
  10341.     {
  10342.       /* Must be the end */
  10343.       if (!strcmp ("<EXTRA>", buf))
  10344.         {
  10345.           gint nsides = 3;
  10346.           /* Number of sides - data item */
  10347.           if ( !new_obj)
  10348.         {
  10349.           g_message ("[%d] Internal load error while loading bezier "
  10350.                  "(extra area)", line_no);
  10351.           return NULL;
  10352.         }
  10353.           get_line (buf, MAX_LOAD_LINE, from, 0);
  10354.           if (sscanf (buf, "%d", &nsides) != 1)
  10355.         {
  10356.           g_message ("[%d] Internal load error while loading bezier "
  10357.                  "(extra area scanf)", line_no);
  10358.           return NULL;
  10359.         }
  10360.           new_obj->type_data = (gpointer) nsides;
  10361.           get_line (buf, MAX_LOAD_LINE, from, 0);
  10362.           if (strcmp ("</EXTRA>", buf))
  10363.         {
  10364.           g_message ("[%d] Internal load error while loading bezier",
  10365.                  line_no);
  10366.           return NULL;
  10367.         } 
  10368.           /* Go around and read the last line */
  10369.           continue;
  10370.         }
  10371.       else if (strcmp ("</BEZIER>", buf))
  10372.         {
  10373.           g_message ("[%d] Internal load error while loading bezier",
  10374.              line_no);
  10375.           return NULL;
  10376.         }
  10377.       return new_obj;
  10378.     }
  10379.       
  10380.       if (!new_obj)
  10381.     new_obj = d_new_bezier (xpnt, ypnt);
  10382.       else
  10383.     d_pnt_add_line (new_obj, xpnt, ypnt, -1);
  10384.     }
  10385.  
  10386.   return new_obj;
  10387. }
  10388.  
  10389.  
  10390. #define FP_PNT_MAX  10
  10391.  
  10392. static int fp_pnt_cnt = 0;
  10393. static int fp_pnt_chunk = 0;
  10394. static gdouble *fp_pnt_pnts = NULL;
  10395.  
  10396. static void
  10397. fp_pnt_start (void)
  10398. {
  10399.   fp_pnt_cnt = 0;
  10400. }
  10401.  
  10402. /* Add a line segment to collection array */
  10403. static void
  10404. fp_pnt_add (gdouble p1,
  10405.         gdouble p2,
  10406.         gdouble p3,
  10407.         gdouble p4)
  10408. {
  10409.   if (!fp_pnt_pnts)
  10410.     {
  10411.       fp_pnt_pnts = g_new0 (gdouble, FP_PNT_MAX);
  10412.       fp_pnt_chunk = 1;
  10413.     }
  10414.  
  10415.   if (((fp_pnt_cnt + 4) / FP_PNT_MAX) >= fp_pnt_chunk)
  10416.     {
  10417.       /* more space pls */
  10418.       fp_pnt_chunk++;
  10419.       fp_pnt_pnts =
  10420.     (gdouble *) g_realloc (fp_pnt_pnts,
  10421.                    sizeof (gdouble) * fp_pnt_chunk * FP_PNT_MAX);
  10422.     }
  10423.  
  10424.   fp_pnt_pnts[fp_pnt_cnt++] = p1;
  10425.   fp_pnt_pnts[fp_pnt_cnt++] = p2;
  10426.   fp_pnt_pnts[fp_pnt_cnt++] = p3;
  10427.   fp_pnt_pnts[fp_pnt_cnt++] = p4;
  10428. }
  10429.  
  10430. static gdouble *
  10431. d_bz_get_array (gint *sz)
  10432. {
  10433.   *sz = fp_pnt_cnt;
  10434.   return fp_pnt_pnts;
  10435. }
  10436.  
  10437.  
  10438. static void
  10439. d_bz_line (void)
  10440. {
  10441.   gint i, x0, y0, x1, y1; 
  10442.  
  10443.   g_assert ((fp_pnt_cnt % 4) == 0);
  10444.  
  10445.   for (i = 0 ; i < fp_pnt_cnt; i += 4)
  10446.     {
  10447.       x0 = (gint) fp_pnt_pnts[i];
  10448.       y0 = (gint) fp_pnt_pnts[i + 1];
  10449.       x1 = (gint) fp_pnt_pnts[i + 2];
  10450.       y1 = (gint) fp_pnt_pnts[i + 3];
  10451.  
  10452.       if (drawing_pic)
  10453.     {
  10454.       gdk_draw_line (pic_preview->window,
  10455.              pic_preview->style->black_gc,
  10456.              adjust_pic_coords ((gint) x0,
  10457.                         preview_width),
  10458.              adjust_pic_coords ((gint) y0,
  10459.                         preview_height),
  10460.              adjust_pic_coords ((gint) x1,
  10461.                         preview_width),
  10462.              adjust_pic_coords ((gint) y1,
  10463.                         preview_height));
  10464.     }
  10465.       else
  10466.     {
  10467.       gdk_draw_line (gfig_preview->window,
  10468.              gfig_gc,
  10469.              gfig_scale_x ((gint) x0),
  10470.              gfig_scale_y ((gint) y0),
  10471.              gfig_scale_x ((gint) x1),
  10472.              gfig_scale_y ((gint) y1));
  10473.     }
  10474.     }
  10475. }
  10476.  
  10477. /*  Return points to plot */
  10478. /* Terminate by point with DBL_MAX, DBL_MAX */
  10479. typedef gdouble (*fp_pnt)[2];
  10480.  
  10481. static void
  10482. DrawBezier (gdouble (*points)[2],
  10483.         gint      np,
  10484.         gdouble   mid,
  10485.         gint      depth)
  10486. {
  10487.   gint i, j, x0 = 0, y0 = 0, x1, y1; 
  10488.   fp_pnt left;
  10489.   fp_pnt right;
  10490.   
  10491.     if (depth == 0) /* draw polyline */
  10492.       {
  10493.     for (i = 0; i < np; i++)
  10494.       {
  10495.         x1 = (int) points[i][0];
  10496.         y1 = (int) points[i][1];
  10497.         if (i > 0 && (x1 != x0 || y1 != y0))
  10498.           {
  10499.         /* Add pnts up */
  10500.         fp_pnt_add ((gdouble) x0, (gdouble) y0,
  10501.                 (gdouble) x1, (gdouble) y1);
  10502.           }
  10503.         x0 = x1;
  10504.         y0 = y1;
  10505.       }
  10506.       }
  10507.     else /* subdivide control points at mid */
  10508.       {
  10509.     left = (fp_pnt) g_new (gdouble, np * 2);
  10510.     right = (fp_pnt) g_new (gdouble, np * 2);
  10511.     for (i = 0; i < np; i++)
  10512.       {
  10513.         right[i][0] = points[i][0];
  10514.         right[i][1] = points[i][1];
  10515.       } 
  10516.     left[0][0] = right[0][0];
  10517.     left[0][1] = right[0][1];
  10518.     for (j = np - 1; j >= 1; j--)
  10519.       {
  10520.         for (i = 0; i < j; i++)
  10521.           {
  10522.         right[i][0] = (1 - mid) * right[i][0] + mid * right[i + 1][0];
  10523.         right[i][1] = (1 - mid) * right[i][1] + mid * right[i + 1][1];
  10524.           }
  10525.         left[np - j][0] = right[0][0];
  10526.         left[np - j][1] = right[0][1];
  10527.       }
  10528.     if (depth > 0)
  10529.       {
  10530.         DrawBezier (left, np, mid, depth - 1);
  10531.         DrawBezier (right, np, mid, depth - 1);
  10532.         g_free (left);
  10533.         g_free (right);
  10534.       }
  10535.       }
  10536. }
  10537.  
  10538.  
  10539. static void
  10540. d_draw_bezier (Dobject *obj)
  10541. {
  10542.   DobjPoints * spnt;
  10543.   gint seg_count = 0;
  10544.   gint i = 0;
  10545.   gdouble (*line_pnts)[2];
  10546.  
  10547.   spnt = obj->points;
  10548.  
  10549.   /* First count the number of points */
  10550.  
  10551.   /* count */
  10552.   while (spnt)
  10553.     {
  10554.       seg_count++;
  10555.       spnt = spnt->next;
  10556.     }
  10557.  
  10558.   spnt = obj->points;
  10559.  
  10560.   if (!spnt || !seg_count)
  10561.     return; /* no-line */
  10562.  
  10563.   line_pnts = (fp_pnt) g_new0 (gdouble, 2 * seg_count + 1);
  10564.  
  10565.   /* Go around all the points drawing a line from one to the next */
  10566.   while (spnt)
  10567.     {
  10568.       draw_sqr (&spnt->pnt);
  10569.       line_pnts[i][0] = spnt->pnt.x;
  10570.       line_pnts[i++][1] = spnt->pnt.y;
  10571.       spnt = spnt->next;
  10572.     }
  10573.  
  10574.   /* Generate an array of doubles which are the control points */
  10575.  
  10576.   if (!drawing_pic && bezier_line_frame && tmp_bezier)
  10577.     {
  10578.       fp_pnt_start ();
  10579.       DrawBezier (line_pnts, seg_count, 0.5, 0);
  10580.       d_bz_line ();
  10581.     }
  10582.  
  10583.   fp_pnt_start ();
  10584.   DrawBezier (line_pnts, seg_count, 0.5, 3);
  10585.   d_bz_line ();
  10586.   /*bezier4 (line_pnts, seg_count, 20);*/
  10587.  
  10588.   g_free (line_pnts);
  10589. }
  10590.  
  10591. static void
  10592. d_paint_bezier (Dobject *obj)
  10593. {
  10594.   gdouble *line_pnts;
  10595.   gdouble (*bz_line_pnts)[2];
  10596.   DobjPoints *spnt;
  10597.   gint seg_count = 0;
  10598.  
  10599.   gint i = 0;
  10600.  
  10601.   spnt = obj->points;
  10602.  
  10603.   /* First count the number of points */
  10604.  
  10605.   /* count */
  10606.   while (spnt)
  10607.     {
  10608.       seg_count++;
  10609.       spnt = spnt->next;
  10610.     }
  10611.  
  10612.   spnt = obj->points;
  10613.  
  10614.   if (!spnt || !seg_count)
  10615.     return; /* no-line */
  10616.  
  10617.   bz_line_pnts = (fp_pnt) g_new0 (gdouble, 2 * seg_count + 1);
  10618.  
  10619.   /* Go around all the points drawing a line from one to the next */
  10620.   while (spnt)
  10621.     {
  10622.       bz_line_pnts[i][0] = spnt->pnt.x;
  10623.       bz_line_pnts[i++][1] = spnt->pnt.y;
  10624.       spnt = spnt->next;
  10625.     }
  10626.  
  10627.   fp_pnt_start ();
  10628.   DrawBezier (bz_line_pnts, seg_count, 0.5, 5);
  10629.   line_pnts = d_bz_get_array (&i);
  10630.  
  10631.   /* Reverse line if approp */
  10632.   if (selvals.reverselines)
  10633.     reverse_pairs_list (&line_pnts[0], i / 2);
  10634.  
  10635.   /* Scale before drawing */
  10636.   if (selvals.scaletoimage)
  10637.     scale_to_original_xy (&line_pnts[0], i / 2);
  10638.   else
  10639.     scale_to_xy (&line_pnts[0], i / 2);
  10640.  
  10641.   /* One go */
  10642.   if (selvals.painttype == PAINT_BRUSH_TYPE)
  10643.     {
  10644.       gfig_paint (selvals.brshtype,
  10645.           gfig_drawable,
  10646.           i, line_pnts);
  10647.     }
  10648.   else
  10649.     {
  10650.       gimp_free_select (gfig_image,
  10651.             i, line_pnts,
  10652.             selopt.type,
  10653.             selopt.antia,
  10654.             selopt.feather,
  10655.             selopt.feather_radius);
  10656.     }
  10657.  
  10658.   g_free (bz_line_pnts);
  10659.   /* Don't free line_pnts - may need again */
  10660. }
  10661.  
  10662. static Dobject *
  10663. d_copy_bezier (Dobject * obj)
  10664. {
  10665.   Dobject *np;
  10666.  
  10667. #if DEBUG
  10668.   printf ("Copy bezier\n");
  10669. #endif /*DEBUG*/
  10670.   if (!obj)
  10671.     return (NULL);
  10672.  
  10673.   g_assert (obj->type == BEZIER);
  10674.  
  10675.   np = d_new_bezier (obj->points->pnt.x, obj->points->pnt.y);
  10676.  
  10677.   np->points->next = d_copy_dobjpoints (obj->points->next);
  10678.  
  10679.   np->type_data = obj->type_data;
  10680.  
  10681. #if DEBUG
  10682.   printf ("Done bezier copy\n");
  10683. #endif /*DEBUG*/
  10684.   return np;
  10685. }
  10686.  
  10687. static Dobject *
  10688. d_new_bezier (gint x, gint y)
  10689. {
  10690.   Dobject *nobj;
  10691.   DobjPoints *npnt;
  10692.  
  10693.   /* Get new object and starting point */
  10694.  
  10695.   /* Start point */
  10696.   npnt = g_new0 (DobjPoints, 1);
  10697.  
  10698. #if DEBUG
  10699.   printf ("New BEZIER start at (%x,%x)\n", x, y);
  10700. #endif /* DEBUG */
  10701.   npnt->pnt.x = x;
  10702.   npnt->pnt.y = y;
  10703.  
  10704.   nobj = g_new0 (Dobject, 1);
  10705.  
  10706.   nobj->type = BEZIER;
  10707.   nobj->type_data = (gpointer)4; /* Default to four turns */
  10708.   nobj->points = npnt;
  10709.   nobj->drawfunc  = d_draw_bezier;
  10710.   nobj->loadfunc  = d_load_bezier;
  10711.   nobj->savefunc  = d_save_bezier;
  10712.   nobj->paintfunc = d_paint_bezier;
  10713.   nobj->copyfunc  = d_copy_bezier;
  10714.  
  10715.   return (nobj);
  10716. }
  10717.  
  10718. static void
  10719. d_update_bezier (GdkPoint *pnt)
  10720. {
  10721.   DobjPoints *s_pnt, *l_pnt;
  10722.   gint saved_cnt_pnt = selvals.opts.showcontrol;
  10723.  
  10724.   g_assert (tmp_bezier != NULL);
  10725.  
  10726.   /* Undraw last one then draw new one */
  10727.   s_pnt = tmp_bezier->points;
  10728.   
  10729.   if (!s_pnt)
  10730.     return; /* No points */
  10731.  
  10732.   /* Hack - turn off cnt points in draw routine 
  10733.    */
  10734.  
  10735.   if ((l_pnt = s_pnt->next))
  10736.     {
  10737.       /* Undraw */
  10738.       while (l_pnt->next)
  10739.     {
  10740.       l_pnt = l_pnt->next;
  10741.     }
  10742.  
  10743.       draw_circle (&l_pnt->pnt);
  10744.       selvals.opts.showcontrol = 0;
  10745.       d_draw_bezier (tmp_bezier);
  10746.       l_pnt->pnt.x = pnt->x;
  10747.       l_pnt->pnt.y = pnt->y;
  10748.     }
  10749.   else
  10750.     {
  10751.       /* Radius is a few pixels away */
  10752.       /* First edge point */
  10753.       d_pnt_add_line (tmp_bezier, pnt->x, pnt->y,-1);
  10754.       l_pnt = s_pnt->next;
  10755.     }
  10756.  
  10757.   /* draw it */
  10758.   selvals.opts.showcontrol = 0;
  10759.   d_draw_bezier (tmp_bezier);
  10760.   selvals.opts.showcontrol = saved_cnt_pnt;
  10761.  
  10762.   /* Realy draw the control points */
  10763.   draw_circle (&l_pnt->pnt);
  10764. }
  10765.  
  10766. /* first point is center 
  10767.  * next defines the radius
  10768.  */
  10769.  
  10770. static void
  10771. d_bezier_start (GdkPoint *pnt, gint shift_down)
  10772. {
  10773.   gint16 x, y;
  10774.   /* First is center point */
  10775.   if (!tmp_bezier)
  10776.     {
  10777.       /* New curve */
  10778.       tmp_bezier = obj_creating = d_new_bezier (x = pnt->x, y = pnt->y);
  10779.     }
  10780. }
  10781.  
  10782. static void
  10783. d_bezier_end (GdkPoint *pnt, gint shift_down)
  10784. {
  10785.   DobjPoints *l_pnt;
  10786.  
  10787.   if (!tmp_bezier)
  10788.     {
  10789.       tmp_bezier = obj_creating;
  10790.     }
  10791.   
  10792.   l_pnt = tmp_bezier->points->next;
  10793.  
  10794.   if (!l_pnt) 
  10795.     return;
  10796.  
  10797.   if (shift_down)
  10798.     {
  10799.       /* Undraw circle on last pnt */
  10800.       while (l_pnt->next)
  10801.     {
  10802.       l_pnt = l_pnt->next;
  10803.     }
  10804.  
  10805.       if (l_pnt)
  10806.     {
  10807.       draw_circle (&l_pnt->pnt);
  10808.       draw_sqr (&l_pnt->pnt);
  10809.  
  10810.       if (bezier_closed)
  10811.         {
  10812.           gint tmp_frame = bezier_line_frame;
  10813.           /* if closed then add first point */
  10814.           d_draw_bezier (tmp_bezier);
  10815.           d_pnt_add_line (tmp_bezier,
  10816.                  tmp_bezier->points->pnt.x,
  10817.                  tmp_bezier->points->pnt.y,-1);
  10818.           /* Final has no frame */
  10819.           bezier_line_frame = 0; /* False */
  10820.           d_draw_bezier (tmp_bezier);
  10821.           bezier_line_frame = tmp_frame; /* What is was */
  10822.         }
  10823.       else if (bezier_line_frame)
  10824.         {
  10825.           d_draw_bezier (tmp_bezier);
  10826.           bezier_line_frame = 0; /* False */
  10827.           d_draw_bezier (tmp_bezier);
  10828.           bezier_line_frame = 1; /* What is was */
  10829.         }
  10830.  
  10831.       add_to_all_obj (current_obj, obj_creating);
  10832.     }
  10833.  
  10834.       /* small mem leak if !l_pnt ? */
  10835.       tmp_bezier = NULL;
  10836.       obj_creating = NULL;
  10837.     }
  10838.   else
  10839.     {
  10840.       if (!tmp_bezier->points->next)
  10841.     {
  10842.       draw_circle (&tmp_bezier->points->pnt);
  10843.       draw_sqr (&tmp_bezier->points->pnt);
  10844.     }
  10845.  
  10846.       d_draw_bezier (tmp_bezier);
  10847.       d_pnt_add_line (tmp_bezier, pnt->x, pnt->y,-1);
  10848.       d_draw_bezier (tmp_bezier);
  10849.     }
  10850. }
  10851.  
  10852.  
  10853. /* copy objs */
  10854. static DAllObjs *
  10855. copy_all_objs (DAllObjs *objs)
  10856. {
  10857.   DAllObjs *nobj;
  10858.   DAllObjs *new_all_objs = NULL;
  10859.   DAllObjs *ret = NULL;
  10860.  
  10861.   while (objs)
  10862.     {
  10863.       nobj = g_new0 (DAllObjs, 1);
  10864.  
  10865.      if (!ret)
  10866.     {
  10867.       ret = new_all_objs = nobj;
  10868.     }
  10869.       else
  10870.     {
  10871.       new_all_objs->next = nobj;
  10872.       new_all_objs = nobj;
  10873.     }
  10874.  
  10875.       nobj->obj = (Dobject *) objs->obj->copyfunc (objs->obj);
  10876.  
  10877.       objs = objs->next;
  10878.     }
  10879.  
  10880.   return ret;
  10881. }
  10882.  
  10883. /* Screen refresh */
  10884. static void
  10885. draw_one_obj (Dobject * obj)
  10886. {
  10887.   obj->drawfunc (obj);
  10888. }
  10889.  
  10890. static void
  10891. draw_objects (DAllObjs *objs,
  10892.           gint      show_single)
  10893. {
  10894.   /* Show_single - only one object to draw Unless shift 
  10895.    * is down in whcih case show all.
  10896.    */
  10897.  
  10898.   gint count = 0;
  10899.  
  10900.   while (objs)
  10901.     {
  10902.       if (!show_single || count == obj_show_single || obj_show_single == -1)
  10903.     draw_one_obj (objs->obj);
  10904.       objs = objs->next;
  10905.       count++;
  10906.     }
  10907. }
  10908.  
  10909. static void
  10910. prepend_to_all_obj (GFigObj  *fobj,
  10911.             DAllObjs *nobj)
  10912. {
  10913.   DAllObjs *cobj;
  10914.  
  10915.   setup_undo (); /* Remember ME */
  10916.  
  10917.   if (!fobj->obj_list)
  10918.     {
  10919.       fobj->obj_list = nobj;
  10920.       return;
  10921.     }
  10922.  
  10923.   cobj = fobj->obj_list;
  10924.  
  10925.   while (cobj->next)
  10926.     {
  10927.       cobj = cobj->next;
  10928.     }
  10929.  
  10930.   cobj->next = nobj;
  10931. }
  10932.  
  10933. static void
  10934. add_to_all_obj (GFigObj *fobj,
  10935.         Dobject *obj)
  10936. {
  10937.   DAllObjs *nobj;
  10938.   
  10939.   nobj = g_new0 (DAllObjs, 1);
  10940.  
  10941.   nobj->obj = obj;
  10942.  
  10943.   if (need_to_scale)
  10944.     scale_obj_points (obj->points, scale_x_factor, scale_y_factor);
  10945.  
  10946.   prepend_to_all_obj (fobj, nobj);
  10947. }
  10948.  
  10949. static void
  10950. object_operation_start (GdkPoint *pnt,
  10951.             gint      shift_down)
  10952. {
  10953.   Dobject *new_obj;
  10954.  
  10955.   /* Find point in given object list */
  10956.   operation_obj = get_nearest_objs (current_obj, pnt);
  10957.  
  10958.   /* Special case if shift down && move obj then moving all objs */
  10959.  
  10960.   if (shift_down && selvals.otype == MOVE_OBJ)
  10961.     {
  10962.       move_all_pnt = g_malloc0 (sizeof (*move_all_pnt));
  10963.       *move_all_pnt = *pnt; /* Structure copy */
  10964.       setup_undo ();
  10965.       return;
  10966.     }
  10967.  
  10968.   if (!operation_obj)
  10969.     return;/* None to work on */
  10970.  
  10971.   setup_undo ();
  10972.  
  10973.   switch (selvals.otype)
  10974.     {
  10975.     case MOVE_OBJ:
  10976.       if (operation_obj->type == BEZIER)
  10977.     {
  10978.       d_draw_bezier (operation_obj);
  10979.       tmp_bezier = operation_obj;
  10980.       d_draw_bezier (operation_obj);
  10981.     }
  10982.       break;
  10983.     case MOVE_POINT:
  10984.       if (operation_obj->type == BEZIER)
  10985.     {
  10986.       d_draw_bezier (operation_obj);
  10987.       tmp_bezier = operation_obj;
  10988.       d_draw_bezier (operation_obj);
  10989.     }
  10990.       /* If shift is down the break into sep lines */
  10991.       if ((operation_obj->type == POLY  
  10992.       || operation_obj->type == STAR)
  10993.      && shift_down)
  10994.     {
  10995.       switch (operation_obj->type)
  10996.         {
  10997.         case POLY:
  10998.           d_poly2lines (operation_obj);
  10999.           break;
  11000.         case STAR:
  11001.           d_star2lines (operation_obj);
  11002.           break;
  11003.         default:
  11004.           break;
  11005.         }
  11006.       /* Re calc which object point we are lookin at */
  11007.       scan_obj_points (operation_obj->points, pnt);
  11008.     }
  11009.       break;
  11010.     case COPY_OBJ:
  11011.       /* Copy the "operation object" */
  11012.       /* Then bung us into "copy/move" mode */
  11013. #ifdef DEBUG
  11014.       printf ("In copy obj\n");
  11015. #endif /* DEBUG */
  11016.       new_obj = (Dobject *) operation_obj->copyfunc (operation_obj);
  11017.       if (new_obj)
  11018.     {
  11019.       scan_obj_points (new_obj->points, pnt);
  11020.       add_to_all_obj (current_obj, new_obj);
  11021.       operation_obj = new_obj;
  11022.       selvals.otype = MOVE_COPY_OBJ;
  11023.       new_obj->drawfunc (new_obj);
  11024.     }
  11025.       break;
  11026.     case DEL_OBJ:
  11027.       remove_obj_from_list (current_obj, operation_obj);
  11028.       break;
  11029.     case MOVE_COPY_OBJ: /* Never when button down */
  11030.     default:
  11031.       g_warning ("Internal error selvals.otype object operation start");
  11032.       break;
  11033.     }
  11034. }
  11035.  
  11036. static void
  11037. object_operation_end (GdkPoint *pnt,
  11038.               gint      shift_down)
  11039. {
  11040.   if (selvals.otype != DEL_OBJ && operation_obj && operation_obj->type == BEZIER)
  11041.     {
  11042.       d_draw_bezier (operation_obj);
  11043.       tmp_bezier = NULL; /* use as switch */
  11044.       d_draw_bezier (operation_obj);
  11045.     }
  11046.  
  11047.   operation_obj = NULL;
  11048.  
  11049.   if (move_all_pnt)
  11050.     {
  11051.       g_free (move_all_pnt);
  11052.       move_all_pnt = 0;
  11053.     }
  11054.  
  11055.   /* Special case - if copying mode MUST be copy when button up received */
  11056.   if (selvals.otype == MOVE_COPY_OBJ)
  11057.     selvals.otype = COPY_OBJ;
  11058. }
  11059.  
  11060. /* Move object around */
  11061. static void
  11062. object_operation (GdkPoint *to_pnt,
  11063.           gint      shift_down)
  11064. {
  11065.   /* Must do diffent things depending on object type */
  11066.   /* but must have object to operate on! */
  11067.  
  11068.   /* Special case - if shift own and move_obj then move ALL objects */
  11069.   if (move_all_pnt && shift_down && selvals.otype == MOVE_OBJ)
  11070.     {
  11071.       do_move_all_obj (to_pnt);
  11072.       return;
  11073.     }
  11074.  
  11075.   if (!operation_obj)
  11076.     return;
  11077.  
  11078.   switch (selvals.otype)
  11079.     {
  11080.     case MOVE_OBJ:
  11081.     case MOVE_COPY_OBJ:
  11082.       switch (operation_obj->type)
  11083.     {
  11084.     case LINE:
  11085.     case CIRCLE:
  11086.     case ELLIPSE:
  11087.     case POLY:
  11088.     case ARC:
  11089.     case STAR:
  11090.     case SPIRAL:
  11091.     case BEZIER:
  11092.       do_move_obj (operation_obj, to_pnt);
  11093.       break;
  11094.     default:
  11095.       /* Internal error */
  11096.       g_warning ("Internal error in operation_obj->type");
  11097.       break;
  11098.     }
  11099.       break;
  11100.     case MOVE_POINT:
  11101.       switch (operation_obj->type)
  11102.     {
  11103.     case LINE:
  11104.     case CIRCLE:
  11105.     case ELLIPSE:
  11106.     case POLY:
  11107.     case ARC:
  11108.     case STAR:
  11109.     case SPIRAL:
  11110.     case BEZIER:
  11111.       do_move_obj_pnt (operation_obj, to_pnt);
  11112.       break;
  11113.     default:
  11114.       /* Internal error */
  11115.       g_warning ("Internal error in operation_obj->type");
  11116.       break;
  11117.     }
  11118.       break;
  11119.     case DEL_OBJ:
  11120.       break;
  11121.     case COPY_OBJ: /* Should have been changed to MOVE_COPY_OBJ */
  11122.     default:
  11123.       g_warning ("Internal error selvals.otype");
  11124.       break;
  11125.     }
  11126. }
  11127.  
  11128. /* First button press -- start drawing object */
  11129. static void
  11130. object_start (GdkPoint *pnt,
  11131.           gint      shift_down)
  11132. {
  11133.   /* start for the current object */
  11134.   if (!selvals.scaletoimage)
  11135.     {
  11136.       need_to_scale = 1;
  11137.       selvals.scaletoimage = 1;
  11138.     }
  11139.   else
  11140.     {
  11141.       need_to_scale = 0;
  11142.     }
  11143.  
  11144.   switch (selvals.otype)
  11145.     {
  11146.     case LINE:
  11147.       /* Shift means we are still drawing */
  11148.       if (!shift_down || !obj_creating)
  11149.     draw_sqr (pnt);
  11150.       d_line_start (pnt, shift_down);
  11151.       break;
  11152.     case CIRCLE:
  11153.       draw_sqr (pnt);
  11154.       d_circle_start (pnt, shift_down);
  11155.       break;
  11156.     case ELLIPSE:
  11157.       draw_sqr (pnt);
  11158.       d_ellipse_start (pnt, shift_down);
  11159.       break;
  11160.     case POLY:
  11161.       draw_sqr (pnt);
  11162.       d_poly_start (pnt, shift_down);
  11163.       break;
  11164.     case ARC:
  11165.       d_arc_start (pnt, shift_down);
  11166.       break;
  11167.     case STAR:
  11168.       draw_sqr (pnt);
  11169.       d_star_start (pnt, shift_down);
  11170.       break;
  11171.     case SPIRAL:
  11172.       draw_sqr (pnt);
  11173.       d_spiral_start (pnt, shift_down);
  11174.       break;
  11175.     case BEZIER:
  11176.       if (!tmp_bezier)
  11177.     draw_sqr (pnt);
  11178.       d_bezier_start (pnt, shift_down);
  11179.       break;
  11180.     default:
  11181.       /* Internal error */
  11182.       break;
  11183.     }
  11184. }
  11185.   
  11186. /* Real object now !*/
  11187. static void
  11188. object_end (GdkPoint *pnt,
  11189.         gint      shift_down)
  11190. {
  11191.   /* end for the current object */
  11192.   /* Add onto global object list */
  11193.  
  11194.   /* If shift is down may carry on drawing */
  11195.   switch (selvals.otype)
  11196.     {
  11197.     case LINE:
  11198.       d_line_end (pnt, shift_down);
  11199.       draw_sqr (pnt);
  11200.       break;
  11201.     case CIRCLE:
  11202.       draw_sqr (pnt);
  11203.       d_circle_end (pnt, shift_down);
  11204.       break;
  11205.     case ELLIPSE:
  11206.       draw_sqr (pnt);
  11207.       d_ellipse_end (pnt, shift_down);
  11208.       break;
  11209.     case POLY:
  11210.       draw_sqr (pnt);
  11211.       d_poly_end (pnt, shift_down);
  11212.       break;
  11213.     case STAR:
  11214.       draw_sqr (pnt);
  11215.       d_star_end (pnt, shift_down);
  11216.       break;
  11217.     case ARC:
  11218.       draw_sqr (pnt);
  11219.       d_arc_end (pnt, shift_down);
  11220.       break;
  11221.     case SPIRAL:
  11222.       draw_sqr (pnt);
  11223.       d_spiral_end (pnt, shift_down);
  11224.       break;
  11225.     case BEZIER:
  11226.       d_bezier_end (pnt, shift_down);
  11227.       break;
  11228.     default:
  11229.       /* Internal error */
  11230.       break;
  11231.     }
  11232.  
  11233.   if (need_to_scale)
  11234.     {
  11235.       need_to_scale = 0;
  11236.       selvals.scaletoimage = 0;
  11237.     }
  11238. }
  11239.  
  11240. static void
  11241. object_update (GdkPoint *pnt)
  11242. {
  11243.   /* update for the current object */
  11244.   /* New position xy */
  11245.   switch (selvals.otype)
  11246.     {
  11247.     case LINE:
  11248.       d_update_line (pnt);
  11249.       break;
  11250.     case CIRCLE:
  11251.       d_update_circle (pnt);
  11252.       break;
  11253.     case ELLIPSE:
  11254.       d_update_ellipse (pnt);
  11255.       break;
  11256.     case POLY:
  11257.       d_update_poly (pnt);
  11258.       break;
  11259.     case STAR:
  11260.       d_update_star (pnt);
  11261.       break;
  11262.     case ARC:
  11263.       d_update_arc (pnt);
  11264.       break;
  11265.     case SPIRAL:
  11266.       d_update_spiral (pnt);
  11267.       break;
  11268.     case BEZIER:
  11269.       d_update_bezier (pnt);
  11270.       break;
  11271.     default:
  11272.       /* Internal error */
  11273.       break;
  11274.     }
  11275. }
  11276.