GNOME.org
 

[dia] LineCaps and LineJoin switchable for Standard objects

commit 29c546d04476935dee461bca9e58d590246e91f0
Author: Hans Breuer <hans breuer org>
Date:   Sun Nov 1 22:47:02 2009 +0100

    LineCaps and LineJoin switchable for Standard objects

 lib/properties.c              |   12 ++++++++++++
 lib/properties.h              |   26 ++++++++++++++++++++++++++
 objects/standard/arc.c        |   18 ++++++++++++++++--
 objects/standard/bezier.c     |   33 ++++++++++++++++++++++++++++++---
 objects/standard/beziergon.c  |   16 +++++++++++++++-
 objects/standard/line.c       |   18 ++++++++++++++++--
 objects/standard/polygon.c    |   15 ++++++++++++++-
 objects/standard/polyline.c   |   36 ++++++++++++++++++++++++++++++------
 objects/standard/zigzagline.c |   34 +++++++++++++++++++++++++++++-----
 9 files changed, 188 insertions(+), 20 deletions(-)
---
diff --git a/lib/properties.c b/lib/properties.c
index f8c96f0..8f8c5b2 100644
--- a/lib/properties.c
+++ b/lib/properties.c
@@ -67,6 +67,18 @@ PropEnumData prop_std_text_align_data[] = {
   { N_("Right"), ALIGN_RIGHT },
   { NULL, 0 }
 };
+PropEnumData prop_std_line_join_data[] = {
+  { N_("Miter"), LINEJOIN_MITER },
+  { N_("Round"), LINEJOIN_ROUND },
+  { N_("Bevel"), LINEJOIN_BEVEL },
+  { NULL, 0 }
+};
+PropEnumData prop_std_line_caps_data[] = {
+  { N_("Butt"), LINECAPS_BUTT },
+  { N_("Round"), LINECAPS_ROUND },
+  { N_("Projecting"), LINECAPS_PROJECTING },
+  { NULL, 0 }
+};
 #endif
 
 #ifdef FOR_TRANSLATORS_ONLY
diff --git a/lib/properties.h b/lib/properties.h
index 7ebf73d..7e2071d 100644
--- a/lib/properties.h
+++ b/lib/properties.h
@@ -480,9 +480,23 @@ static PropEnumData prop_std_text_align_data[] = {
   { N_("Right"), ALIGN_RIGHT },
   { NULL, 0 }
 };
+static PropEnumData prop_std_line_join_data[] = {
+  { N_("Miter"), LINEJOIN_MITER },
+  { N_("Round"), LINEJOIN_ROUND },
+  { N_("Bevel"), LINEJOIN_BEVEL },
+  { NULL, 0 }
+};
+static PropEnumData prop_std_line_caps_data[] = {
+  { N_("Butt"), LINECAPS_BUTT },
+  { N_("Round"), LINECAPS_ROUND },
+  { N_("Projecting"), LINECAPS_PROJECTING },
+  { NULL, 0 }
+};
 #else
 extern PropNumData prop_std_line_width_data, prop_std_text_height_data;
 extern PropEnumData prop_std_text_align_data[];
+extern PropEnumData prop_std_line_join_data[];
+extern PropEnumData prop_std_line_caps_data[];
 #endif
 
 #define PROP_STDNAME_LINE_WIDTH "line_width"
@@ -505,6 +519,18 @@ extern PropEnumData prop_std_text_align_data[];
 #define PROP_STD_LINE_STYLE_OPTIONAL \
   { "line_style", PROP_TYPE_LINESTYLE, PROP_FLAG_VISIBLE|PROP_FLAG_STANDARD|PROP_FLAG_OPTIONAL, \
     N_("Line style"), NULL, NULL }
+#define PROP_STD_LINE_JOIN \
+  { "line_join", PROP_TYPE_ENUM, PROP_FLAG_VISIBLE, \
+    N_("Line join"), NULL, prop_std_line_join_data }
+#define PROP_STD_LINE_JOIN_OPTIONAL \
+  { "line_join", PROP_TYPE_ENUM, PROP_FLAG_VISIBLE|PROP_FLAG_OPTIONAL, \
+    N_("Line join"), NULL, prop_std_line_join_data }
+#define PROP_STD_LINE_CAPS \
+  { "line_caps", PROP_TYPE_ENUM, PROP_FLAG_VISIBLE, \
+    N_("Line caps"), NULL, prop_std_line_caps_data }
+#define PROP_STD_LINE_CAPS_OPTIONAL \
+  { "line_caps", PROP_TYPE_ENUM, PROP_FLAG_VISIBLE|PROP_FLAG_OPTIONAL, \
+    N_("Line caps"), NULL, prop_std_line_caps_data }
 
 #define PROP_STD_FILL_COLOUR \
   { "fill_colour", PROP_TYPE_COLOUR, PROP_FLAG_VISIBLE|PROP_FLAG_STANDARD, \
diff --git a/objects/standard/arc.c b/objects/standard/arc.c
index f55e8c7..141f5cc 100644
--- a/objects/standard/arc.c
+++ b/objects/standard/arc.c
@@ -52,6 +52,7 @@ struct _Arc {
   real curve_distance;
   real line_width;
   LineStyle line_style;
+  LineCaps line_caps;
   real dashlength;
   Arrow start_arrow, end_arrow;
 
@@ -135,6 +136,7 @@ static PropDescription arc_props[] = {
   PROP_STD_LINE_WIDTH,
   PROP_STD_LINE_COLOUR,
   PROP_STD_LINE_STYLE,
+  PROP_STD_LINE_CAPS_OPTIONAL,
   PROP_STD_START_ARROW,
   PROP_STD_END_ARROW,
   { "curve_distance", PROP_TYPE_REAL, 0,
@@ -156,6 +158,7 @@ static PropOffset arc_offsets[] = {
   { "line_colour", PROP_TYPE_COLOUR, offsetof(Arc, arc_color) },
   { "line_style", PROP_TYPE_LINESTYLE,
     offsetof(Arc, line_style), offsetof(Arc, dashlength) },
+  { "line_caps", PROP_TYPE_ENUM, offsetof(Arc, line_caps) },
   { "start_arrow", PROP_TYPE_ARROW, offsetof(Arc, start_arrow) },
   { "end_arrow", PROP_TYPE_ARROW, offsetof(Arc, end_arrow) },
   { "curve_distance", PROP_TYPE_REAL, offsetof(Arc, curve_distance) },
@@ -555,7 +558,7 @@ arc_draw(Arc *arc, DiaRenderer *renderer)
   renderer_ops->set_linewidth(renderer, arc->line_width);
   renderer_ops->set_linestyle(renderer, arc->line_style);
   renderer_ops->set_dashlength(renderer, arc->dashlength);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  renderer_ops->set_linecaps(renderer, arc->line_caps);
   
   /* Special case when almost line: */
   if (fabs(arc->curve_distance) <= 0.01) {
@@ -596,6 +599,7 @@ arc_create(Point *startpoint,
   arc->curve_distance = 1.0;
   arc->arc_color = attributes_get_foreground(); 
   attributes_get_default_line_style(&arc->line_style, &arc->dashlength);
+  arc->line_caps = LINECAPS_BUTT;
   arc->start_arrow = attributes_get_default_start_arrow();
   arc->end_arrow = attributes_get_default_end_arrow();
 
@@ -649,6 +653,7 @@ arc_copy(Arc *arc)
   newarc->curve_distance = arc->curve_distance;
   newarc->line_width = arc->line_width;
   newarc->line_style = arc->line_style;
+  newarc->line_caps = arc->line_caps;
   newarc->dashlength = arc->dashlength;
   newarc->start_arrow = arc->start_arrow;
   newarc->end_arrow = arc->end_arrow;
@@ -838,7 +843,11 @@ arc_save(Arc *arc, ObjectNode obj_node, const char *filename)
       arc->dashlength != DEFAULT_LINESTYLE_DASHLEN)
     data_add_real(new_attribute(obj_node, "dashlength"),
 		  arc->dashlength);
-  
+
+  if (arc->line_caps != LINECAPS_BUTT)
+    data_add_enum(new_attribute(obj_node, "line_caps"),
+                  arc->line_caps);
+
   if (arc->start_arrow.type != ARROW_NONE) {
     save_arrow(obj_node, &arc->start_arrow, "start_arrow",
 	     "start_arrow_length", "start_arrow_width");
@@ -893,6 +902,11 @@ arc_load(ObjectNode obj_node, int version, const char *filename)
   if (attr != NULL)
     arc->dashlength = data_real(attribute_first_data(attr));
 
+  arc->line_caps = LINECAPS_BUTT;
+  attr = object_find_attribute(obj_node, "line_caps");
+  if (attr != NULL)
+    arc->line_caps = data_enum(attribute_first_data(attr));
+
   load_arrow(obj_node, &arc->start_arrow, "start_arrow",
 	     "start_arrow_length", "start_arrow_width");
 
diff --git a/objects/standard/bezier.c b/objects/standard/bezier.c
index 683fcc3..7d8fe05 100644
--- a/objects/standard/bezier.c
+++ b/objects/standard/bezier.c
@@ -49,6 +49,8 @@ struct _Bezierline {
 
   Color line_color;
   LineStyle line_style;
+  LineJoin line_join;
+  LineCaps line_caps;
   real dashlength;
   real line_width;
   Arrow start_arrow, end_arrow;
@@ -134,6 +136,8 @@ static PropDescription bezierline_props[] = {
   PROP_STD_LINE_WIDTH,
   PROP_STD_LINE_COLOUR,
   PROP_STD_LINE_STYLE,
+  PROP_STD_LINE_JOIN_OPTIONAL,
+  PROP_STD_LINE_CAPS_OPTIONAL,
   PROP_STD_START_ARROW,
   PROP_STD_END_ARROW,
   PROP_FRAME_BEGIN("gaps",0,N_("Line gaps")),
@@ -159,6 +163,8 @@ static PropOffset bezierline_offsets[] = {
   { "line_colour", PROP_TYPE_COLOUR, offsetof(Bezierline, line_color) },
   { "line_style", PROP_TYPE_LINESTYLE,
     offsetof(Bezierline, line_style), offsetof(Bezierline, dashlength) },
+  { "line_join", PROP_TYPE_ENUM, offsetof(Bezierline, line_join) },
+  { "line_caps", PROP_TYPE_ENUM, offsetof(Bezierline, line_caps) },
   { "start_arrow", PROP_TYPE_ARROW, offsetof(Bezierline, start_arrow) },
   { "end_arrow", PROP_TYPE_ARROW, offsetof(Bezierline, end_arrow) },
   PROP_OFFSET_FRAME_BEGIN("gaps"),
@@ -365,8 +371,8 @@ bezierline_draw(Bezierline *bezierline, DiaRenderer *renderer)
   renderer_ops->set_linewidth(renderer, bezierline->line_width);
   renderer_ops->set_linestyle(renderer, bezierline->line_style);
   renderer_ops->set_dashlength(renderer, bezierline->dashlength);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  renderer_ops->set_linejoin(renderer, bezierline->line_join);
+  renderer_ops->set_linecaps(renderer, bezierline->line_caps);
 
   if (connpoint_is_autogap(bez->object.handles[0]->connected_to) ||
       connpoint_is_autogap(bez->object.handles[3*(bez->numpoints-1)]->connected_to) ||
@@ -459,6 +465,8 @@ bezierline_create(Point *startpoint,
   bezierline->line_color = attributes_get_foreground();
   attributes_get_default_line_style(&bezierline->line_style,
 				    &bezierline->dashlength);
+  bezierline->line_join = LINEJOIN_MITER;
+  bezierline->line_caps = LINECAPS_BUTT;
   bezierline->start_arrow = attributes_get_default_start_arrow();
   bezierline->end_arrow = attributes_get_default_end_arrow();
 
@@ -494,6 +502,8 @@ bezierline_copy(Bezierline *bezierline)
   newbezierline->line_color = bezierline->line_color;
   newbezierline->line_width = bezierline->line_width;
   newbezierline->line_style = bezierline->line_style;
+  newbezierline->line_join = bezierline->line_join;
+  newbezierline->line_caps = bezierline->line_caps;
   newbezierline->dashlength = bezierline->dashlength;
   newbezierline->start_arrow = bezierline->start_arrow;
   newbezierline->end_arrow = bezierline->end_arrow;
@@ -603,7 +613,14 @@ bezierline_save(Bezierline *bezierline, ObjectNode obj_node,
       bezierline->dashlength != DEFAULT_LINESTYLE_DASHLEN)
     data_add_real(new_attribute(obj_node, "dashlength"),
 		  bezierline->dashlength);
-  
+
+  if (bezierline->line_join != LINEJOIN_MITER)
+    data_add_enum(new_attribute(obj_node, "line_join"),
+                  bezierline->line_join);
+  if (bezierline->line_caps != LINECAPS_BUTT)
+    data_add_enum(new_attribute(obj_node, "line_caps"),
+                  bezierline->line_caps);
+
   if (bezierline->start_arrow.type != ARROW_NONE) {
     save_arrow(obj_node, &bezierline->start_arrow, "start_arrow",
 	     "start_arrow_length", "start_arrow_width");
@@ -655,6 +672,16 @@ bezierline_load(ObjectNode obj_node, int version, const char *filename)
   if (attr != NULL)
     bezierline->line_style = data_enum(attribute_first_data(attr));
 
+  bezierline->line_join = LINEJOIN_MITER;
+  attr = object_find_attribute(obj_node, "line_join");
+  if (attr != NULL)
+    bezierline->line_join = data_enum(attribute_first_data(attr));
+
+  bezierline->line_caps = LINECAPS_BUTT;
+  attr = object_find_attribute(obj_node, "line_caps");
+  if (attr != NULL)
+    bezierline->line_caps = data_enum(attribute_first_data(attr));
+
   bezierline->dashlength = DEFAULT_LINESTYLE_DASHLEN;
   attr = object_find_attribute(obj_node, "dashlength");
   if (attr != NULL)
diff --git a/objects/standard/beziergon.c b/objects/standard/beziergon.c
index ff61ab9..6780d43 100644
--- a/objects/standard/beziergon.c
+++ b/objects/standard/beziergon.c
@@ -49,6 +49,7 @@ typedef struct _Beziergon {
 
   Color line_color;
   LineStyle line_style;
+  LineJoin line_join;
   Color inner_color;
   gboolean show_background;
   real dashlength;
@@ -132,6 +133,7 @@ static PropDescription beziergon_props[] = {
   PROP_STD_LINE_WIDTH,
   PROP_STD_LINE_COLOUR,
   PROP_STD_LINE_STYLE,
+  PROP_STD_LINE_JOIN_OPTIONAL,
   PROP_STD_FILL_COLOUR,
   PROP_STD_SHOW_BACKGROUND,
   PROP_DESC_END
@@ -151,6 +153,7 @@ static PropOffset beziergon_offsets[] = {
   { "line_colour", PROP_TYPE_COLOUR, offsetof(Beziergon, line_color) },
   { "line_style", PROP_TYPE_LINESTYLE,
     offsetof(Beziergon, line_style), offsetof(Beziergon, dashlength) },
+  { "line_join", PROP_TYPE_ENUM, offsetof(Beziergon, line_join) },
   { "fill_colour", PROP_TYPE_COLOUR, offsetof(Beziergon, inner_color) },
   { "show_background", PROP_TYPE_BOOL, offsetof(Beziergon, show_background) },
   { NULL, 0, 0 }
@@ -232,7 +235,7 @@ beziergon_draw(Beziergon *beziergon, DiaRenderer *renderer)
   renderer_ops->set_linewidth(renderer, beziergon->line_width);
   renderer_ops->set_linestyle(renderer, beziergon->line_style);
   renderer_ops->set_dashlength(renderer, beziergon->dashlength);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+  renderer_ops->set_linejoin(renderer, beziergon->line_join);
   renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
 
   if (beziergon->show_background)
@@ -297,6 +300,7 @@ beziergon_create(Point *startpoint,
   beziergon->inner_color = attributes_get_background();
   attributes_get_default_line_style(&beziergon->line_style,
 				    &beziergon->dashlength);
+  beziergon->line_join = LINEJOIN_MITER;
   beziergon->show_background = default_properties.show_background;
 
   beziergon_update_data(beziergon);
@@ -330,6 +334,7 @@ beziergon_copy(Beziergon *beziergon)
   newbeziergon->line_color = beziergon->line_color;
   newbeziergon->line_width = beziergon->line_width;
   newbeziergon->line_style = beziergon->line_style;
+  newbeziergon->line_join = beziergon->line_join;
   newbeziergon->dashlength = beziergon->dashlength;
   newbeziergon->inner_color = beziergon->inner_color;
   newbeziergon->show_background = beziergon->show_background;
@@ -393,6 +398,10 @@ beziergon_save(Beziergon *beziergon, ObjectNode obj_node,
     data_add_real(new_attribute(obj_node, "dashlength"),
 		  beziergon->dashlength);
   
+  if (beziergon->line_join != LINEJOIN_MITER)
+    data_add_enum(new_attribute(obj_node, "line_join"),
+                  beziergon->line_join);
+
 }
 
 static DiaObject *
@@ -438,6 +447,11 @@ beziergon_load(ObjectNode obj_node, int version, const char *filename)
   if (attr != NULL)
     beziergon->line_style = data_enum(attribute_first_data(attr));
 
+  beziergon->line_join = LINEJOIN_MITER;
+  attr = object_find_attribute(obj_node, "line_join");
+  if (attr != NULL)
+    beziergon->line_join = data_enum(attribute_first_data(attr));
+
   beziergon->dashlength = DEFAULT_LINESTYLE_DASHLEN;
   attr = object_find_attribute(obj_node, "dashlength");
   if (attr != NULL)
diff --git a/objects/standard/line.c b/objects/standard/line.c
index 5981f46..4a65b84 100644
--- a/objects/standard/line.c
+++ b/objects/standard/line.c
@@ -48,7 +48,8 @@ typedef struct _Line {
 
   Color line_color;
   real line_width;
-  LineStyle line_style;  
+  LineStyle line_style;
+  LineCaps line_caps;
   Arrow start_arrow, end_arrow;
   real dashlength;
   real absolute_start_gap, absolute_end_gap;
@@ -131,6 +132,7 @@ static PropDescription line_props[] = {
   PROP_STD_LINE_WIDTH,
   PROP_STD_LINE_COLOUR,
   PROP_STD_LINE_STYLE,
+  PROP_STD_LINE_CAPS_OPTIONAL,
   PROP_FRAME_BEGIN("arrows",PROP_FLAG_STANDARD,N_("Arrows")),
   PROP_STD_START_ARROW,
   PROP_STD_END_ARROW,
@@ -164,6 +166,7 @@ static PropOffset line_offsets[] = {
   { "line_colour", PROP_TYPE_COLOUR, offsetof(Line, line_color) },
   { "line_style", PROP_TYPE_LINESTYLE,
     offsetof(Line, line_style), offsetof(Line, dashlength) },
+  { "line_caps", PROP_TYPE_ENUM, offsetof(Line, line_caps) },
   { "start_arrow", PROP_TYPE_ARROW, offsetof(Line, start_arrow) },
   { "end_arrow", PROP_TYPE_ARROW, offsetof(Line, end_arrow) },
   { "start_point", PROP_TYPE_POINT, offsetof(Connection, endpoints[0]) },
@@ -344,7 +347,7 @@ line_draw(Line *line, DiaRenderer *renderer)
   renderer_ops->set_linewidth(renderer, line->line_width);
   renderer_ops->set_linestyle(renderer, line->line_style);
   renderer_ops->set_dashlength(renderer, line->dashlength);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  renderer_ops->set_linecaps(renderer, line->line_caps);
 
   if (line->absolute_start_gap || line->absolute_end_gap ) {
     line_adjust_for_absolute_gap(line, gap_endpoints);
@@ -402,6 +405,7 @@ line_create(Point *startpoint,
   line->cpl = connpointline_create(obj,1);
 
   attributes_get_default_line_style(&line->line_style, &line->dashlength);
+  line->line_caps = LINECAPS_BUTT;
   line->start_arrow = attributes_get_default_start_arrow();
   line->end_arrow = attributes_get_default_end_arrow();
   line_update_data(line);
@@ -439,6 +443,7 @@ line_copy(Line *line)
   newline->line_color = line->line_color;
   newline->line_width = line->line_width;
   newline->line_style = line->line_style;
+  newline->line_caps = line->line_caps;
   newline->dashlength = line->dashlength;
   newline->start_arrow = line->start_arrow;
   newline->end_arrow = line->end_arrow;
@@ -541,6 +546,10 @@ line_save(Line *line, ObjectNode obj_node, const char *filename)
     data_add_enum(new_attribute(obj_node, "line_style"),
 		  line->line_style);
   
+  if (line->line_caps != LINECAPS_BUTT)
+    data_add_enum(new_attribute(obj_node, "line_caps"),
+                  line->line_caps);
+
   if (line->start_arrow.type != ARROW_NONE) {
     save_arrow(obj_node, &line->start_arrow,
 	       "start_arrow", "start_arrow_length", "start_arrow_width");
@@ -596,6 +605,11 @@ line_load(ObjectNode obj_node, int version, const char *filename)
   if (attr != NULL)
     line->line_style = data_enum(attribute_first_data(attr));
 
+  line->line_caps = LINECAPS_BUTT;
+  attr = object_find_attribute(obj_node, "line_caps");
+  if (attr != NULL)
+    line->line_caps = data_enum(attribute_first_data(attr));
+
   load_arrow(obj_node, &line->start_arrow, 
 	     "start_arrow", "start_arrow_length", "start_arrow_width");
 
diff --git a/objects/standard/polygon.c b/objects/standard/polygon.c
index 37d9706..3ee4378 100644
--- a/objects/standard/polygon.c
+++ b/objects/standard/polygon.c
@@ -53,6 +53,7 @@ typedef struct _Polygon {
 
   Color line_color;
   LineStyle line_style;
+  LineJoin line_join;
   Color inner_color;
   gboolean show_background;
   real dashlength;
@@ -135,6 +136,7 @@ static PropDescription polygon_props[] = {
   PROP_STD_LINE_WIDTH,
   PROP_STD_LINE_COLOUR,
   PROP_STD_LINE_STYLE,
+  PROP_STD_LINE_JOIN_OPTIONAL,
   PROP_STD_FILL_COLOUR,
   PROP_STD_SHOW_BACKGROUND,
   PROP_DESC_END
@@ -154,6 +156,7 @@ static PropOffset polygon_offsets[] = {
   { "line_colour", PROP_TYPE_COLOUR, offsetof(Polygon, line_color) },
   { "line_style", PROP_TYPE_LINESTYLE,
     offsetof(Polygon, line_style), offsetof(Polygon, dashlength) },
+  { "line_join", PROP_TYPE_ENUM, offsetof(Polygon, line_join) },
   { "fill_colour", PROP_TYPE_COLOUR, offsetof(Polygon, inner_color) },
   { "show_background", PROP_TYPE_BOOL, offsetof(Polygon, show_background) },
   { NULL, 0, 0 }
@@ -234,7 +237,7 @@ polygon_draw(Polygon *polygon, DiaRenderer *renderer)
   renderer_ops->set_linewidth(renderer, polygon->line_width);
   renderer_ops->set_linestyle(renderer, polygon->line_style);
   renderer_ops->set_dashlength(renderer, polygon->dashlength);
-  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
+  renderer_ops->set_linejoin(renderer, polygon->line_join);
   renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
 
   if (polygon->show_background)
@@ -282,6 +285,7 @@ polygon_create(Point *startpoint,
   polygon->inner_color = attributes_get_background();
   attributes_get_default_line_style(&polygon->line_style,
 				    &polygon->dashlength);
+  polygon->line_join = LINEJOIN_MITER;
   polygon->show_background = default_properties.show_background;
 
   polygon_update_data(polygon);
@@ -368,6 +372,10 @@ polygon_save(Polygon *polygon, ObjectNode obj_node,
     data_add_real(new_attribute(obj_node, "dashlength"),
 		  polygon->dashlength);
   
+  if (polygon->line_join != LINEJOIN_MITER)
+    data_add_enum(new_attribute(obj_node, "line_join"),
+                  polygon->line_join);
+
 }
 
 static DiaObject *
@@ -413,6 +421,11 @@ polygon_load(ObjectNode obj_node, int version, const char *filename)
   if (attr != NULL)
     polygon->line_style = data_enum(attribute_first_data(attr));
 
+  polygon->line_join = LINEJOIN_MITER;
+  attr = object_find_attribute(obj_node, "line_join");
+  if (attr != NULL)
+    polygon->line_join = data_enum(attribute_first_data(attr));
+
   polygon->dashlength = DEFAULT_LINESTYLE_DASHLEN;
   attr = object_find_attribute(obj_node, "dashlength");
   if (attr != NULL)
diff --git a/objects/standard/polyline.c b/objects/standard/polyline.c
index 4ae052d..b7b271c 100644
--- a/objects/standard/polyline.c
+++ b/objects/standard/polyline.c
@@ -45,6 +45,8 @@ typedef struct _Polyline {
 
   Color line_color;
   LineStyle line_style;
+  LineJoin line_join;
+  LineCaps line_caps;
   real dashlength;
   real line_width;
   real corner_radius;
@@ -130,6 +132,8 @@ static PropDescription polyline_props[] = {
   PROP_STD_LINE_WIDTH,
   PROP_STD_LINE_COLOUR,
   PROP_STD_LINE_STYLE,
+  PROP_STD_LINE_JOIN_OPTIONAL,
+  PROP_STD_LINE_CAPS_OPTIONAL,
   PROP_STD_START_ARROW,
   PROP_STD_END_ARROW,
   { "corner_radius", PROP_TYPE_REAL, PROP_FLAG_VISIBLE,
@@ -157,6 +161,8 @@ static PropOffset polyline_offsets[] = {
   { "line_colour", PROP_TYPE_COLOUR, offsetof(Polyline, line_color) },
   { "line_style", PROP_TYPE_LINESTYLE,
     offsetof(Polyline, line_style), offsetof(Polyline, dashlength) },
+  { "line_join", PROP_TYPE_ENUM, offsetof(Polyline, line_join) },
+  { "line_caps", PROP_TYPE_ENUM, offsetof(Polyline, line_caps) },
   { "start_arrow", PROP_TYPE_ARROW, offsetof(Polyline, start_arrow) },
   { "end_arrow", PROP_TYPE_ARROW, offsetof(Polyline, end_arrow) },
   { "corner_radius", PROP_TYPE_REAL, offsetof(Polyline, corner_radius) },
@@ -300,11 +306,8 @@ polyline_draw(Polyline *polyline, DiaRenderer *renderer)
   renderer_ops->set_linewidth(renderer, polyline->line_width);
   renderer_ops->set_linestyle(renderer, polyline->line_style);
   renderer_ops->set_dashlength(renderer, polyline->dashlength);
-  if (polyline->corner_radius > 0.0)
-    renderer_ops->set_linejoin(renderer, LINEJOIN_ROUND);
-  else
-    renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  renderer_ops->set_linejoin(renderer, polyline->line_join);
+  renderer_ops->set_linecaps(renderer, polyline->line_caps);
 
   polyline_calculate_gap_endpoints(polyline, gap_endpoints);
   polyline_exchange_gap_points(polyline, gap_endpoints);
@@ -369,6 +372,8 @@ polyline_create(Point *startpoint,
   polyline->line_color = attributes_get_foreground();
   attributes_get_default_line_style(&polyline->line_style,
 				    &polyline->dashlength);
+  polyline->line_join = LINEJOIN_MITER;
+  polyline->line_caps = LINECAPS_BUTT;
   polyline->start_arrow = attributes_get_default_start_arrow();
   polyline->end_arrow = attributes_get_default_end_arrow();
   polyline->corner_radius = 0.0;
@@ -402,6 +407,8 @@ polyline_copy(Polyline *polyline)
   newpolyline->line_color = polyline->line_color;
   newpolyline->line_width = polyline->line_width;
   newpolyline->line_style = polyline->line_style;
+  newpolyline->line_join = polyline->line_join;
+  newpolyline->line_caps = polyline->line_caps;
   newpolyline->dashlength = polyline->dashlength;
   newpolyline->start_arrow = polyline->start_arrow;
   newpolyline->end_arrow = polyline->end_arrow;
@@ -492,7 +499,14 @@ polyline_save(Polyline *polyline, ObjectNode obj_node,
       polyline->dashlength != DEFAULT_LINESTYLE_DASHLEN)
     data_add_real(new_attribute(obj_node, "dashlength"),
 		  polyline->dashlength);
-  
+
+  if (polyline->line_join != LINEJOIN_MITER)
+    data_add_enum(new_attribute(obj_node, "line_join"),
+                  polyline->line_join);
+  if (polyline->line_caps != LINECAPS_BUTT)
+    data_add_enum(new_attribute(obj_node, "line_caps"),
+                  polyline->line_caps);
+
   if (polyline->start_arrow.type != ARROW_NONE) {
     save_arrow(obj_node, &polyline->start_arrow, "start_arrow",
 	     "start_arrow_length", "start_arrow_width");
@@ -548,6 +562,16 @@ polyline_load(ObjectNode obj_node, int version, const char *filename)
   if (attr != NULL)
     polyline->line_style = data_enum(attribute_first_data(attr));
 
+  polyline->line_join = LINEJOIN_MITER;
+  attr = object_find_attribute(obj_node, "line_join");
+  if (attr != NULL)
+    polyline->line_join = data_enum(attribute_first_data(attr));
+
+  polyline->line_caps = LINECAPS_BUTT;
+  attr = object_find_attribute(obj_node, "line_caps");
+  if (attr != NULL)
+    polyline->line_caps = data_enum(attribute_first_data(attr));
+
   polyline->dashlength = DEFAULT_LINESTYLE_DASHLEN;
   attr = object_find_attribute(obj_node, "dashlength");
   if (attr != NULL)
diff --git a/objects/standard/zigzagline.c b/objects/standard/zigzagline.c
index fe25eb2..8f256d1 100644
--- a/objects/standard/zigzagline.c
+++ b/objects/standard/zigzagline.c
@@ -45,6 +45,8 @@ typedef struct _Zigzagline {
 
   Color line_color;
   LineStyle line_style;
+  LineJoin line_join;
+  LineCaps line_caps;
   real dashlength;
   real line_width;
   real corner_radius;
@@ -126,6 +128,8 @@ static PropDescription zigzagline_props[] = {
   PROP_STD_LINE_WIDTH,
   PROP_STD_LINE_COLOUR,
   PROP_STD_LINE_STYLE,
+  PROP_STD_LINE_JOIN_OPTIONAL,
+  PROP_STD_LINE_CAPS_OPTIONAL,
   PROP_STD_START_ARROW,
   PROP_STD_END_ARROW,
   { "corner_radius", PROP_TYPE_REAL, PROP_FLAG_VISIBLE,
@@ -147,6 +151,8 @@ static PropOffset zigzagline_offsets[] = {
   { "line_colour", PROP_TYPE_COLOUR, offsetof(Zigzagline, line_color) },
   { "line_style", PROP_TYPE_LINESTYLE,
     offsetof(Zigzagline, line_style), offsetof(Zigzagline, dashlength) },
+  { "line_join", PROP_TYPE_ENUM, offsetof(Zigzagline, line_join) },
+  { "line_caps", PROP_TYPE_ENUM, offsetof(Zigzagline, line_caps) },
   { "start_arrow", PROP_TYPE_ARROW, offsetof(Zigzagline, start_arrow) },
   { "end_arrow", PROP_TYPE_ARROW, offsetof(Zigzagline, end_arrow) },
   { "corner_radius", PROP_TYPE_REAL, offsetof(Zigzagline, corner_radius) },
@@ -224,11 +230,8 @@ zigzagline_draw(Zigzagline *zigzagline, DiaRenderer *renderer)
   renderer_ops->set_linewidth(renderer, zigzagline->line_width);
   renderer_ops->set_linestyle(renderer, zigzagline->line_style);
   renderer_ops->set_dashlength(renderer, zigzagline->dashlength);
-  if (zigzagline->corner_radius > 0)
-    renderer_ops->set_linejoin(renderer, LINEJOIN_ROUND);
-  else
-    renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
-  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);
+  renderer_ops->set_linejoin(renderer, zigzagline->line_join);
+  renderer_ops->set_linecaps(renderer, zigzagline->line_caps);
 
   renderer_ops->draw_rounded_polyline_with_arrows(renderer,
 						  points, n,
@@ -264,6 +267,8 @@ zigzagline_create(Point *startpoint,
   zigzagline->line_color = attributes_get_foreground();
   attributes_get_default_line_style(&zigzagline->line_style,
 				    &zigzagline->dashlength);
+  zigzagline->line_join = LINEJOIN_MITER;
+  zigzagline->line_caps = LINECAPS_BUTT;
   zigzagline->start_arrow = attributes_get_default_start_arrow();
   zigzagline->end_arrow = attributes_get_default_end_arrow();
   zigzagline->corner_radius = 0.0;
@@ -300,6 +305,8 @@ zigzagline_copy(Zigzagline *zigzagline)
   newzigzagline->line_color = zigzagline->line_color;
   newzigzagline->line_width = zigzagline->line_width;
   newzigzagline->line_style = zigzagline->line_style;
+  newzigzagline->line_join = zigzagline->line_join;
+  newzigzagline->line_caps = zigzagline->line_caps;
   newzigzagline->dashlength = zigzagline->dashlength;
   newzigzagline->start_arrow = zigzagline->start_arrow;
   newzigzagline->end_arrow = zigzagline->end_arrow;
@@ -422,6 +429,13 @@ zigzagline_save(Zigzagline *zigzagline, ObjectNode obj_node,
     data_add_enum(new_attribute(obj_node, "line_style"),
 		  zigzagline->line_style);
   
+  if (zigzagline->line_join != LINEJOIN_MITER)
+    data_add_enum(new_attribute(obj_node, "line_join"),
+                  zigzagline->line_join);
+  if (zigzagline->line_caps != LINECAPS_BUTT)
+    data_add_enum(new_attribute(obj_node, "line_caps"),
+                  zigzagline->line_caps);
+
   if (zigzagline->start_arrow.type != ARROW_NONE) {
     save_arrow(obj_node, &zigzagline->start_arrow, "start_arrow",
 	     "start_arrow_length", "start_arrow_width");
@@ -475,6 +489,16 @@ zigzagline_load(ObjectNode obj_node, int version, const char *filename)
   if (attr != NULL)
     zigzagline->line_style = data_enum(attribute_first_data(attr));
 
+  zigzagline->line_join = LINEJOIN_MITER;
+  attr = object_find_attribute(obj_node, "line_join");
+  if (attr != NULL)
+    zigzagline->line_join = data_enum(attribute_first_data(attr));
+
+  zigzagline->line_caps = LINECAPS_BUTT;
+  attr = object_find_attribute(obj_node, "line_caps");
+  if (attr != NULL)
+    zigzagline->line_caps = data_enum(attribute_first_data(attr));
+
   load_arrow(obj_node, &zigzagline->start_arrow, "start_arrow",
 	     "start_arrow_length", "start_arrow_width");
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]