[dia] [restructuring] prepare code sharing between BezierConn and BezierShape
- From: Hans Breuer <hans src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [dia] [restructuring] prepare code sharing between BezierConn and BezierShape
- Date: Wed, 3 Oct 2012 20:02:35 +0000 (UTC)
commit bead4d3a924bd083be9ac48fd11deb48e4cdf189
Author: Hans Breuer <hans breuer org>
Date: Tue Oct 2 10:51:38 2012 +0200
[restructuring] prepare code sharing between BezierConn and BezierShape
There is a lot of code duplication between BezierConn and BezierShape.
To help identify shareable code names are adjusted. The BezierShape
is abbreviated as 'bezier', the BezierConn was abbreviated as bez.
This commit just changes the latter name (s/bez/bezier/).
lib/bezier_conn.c | 556 ++++++++++++++++++++++++++--------------------------
1 files changed, 278 insertions(+), 278 deletions(-)
---
diff --git a/lib/bezier_conn.c b/lib/bezier_conn.c
index ee31e4d..b549d42 100644
--- a/lib/bezier_conn.c
+++ b/lib/bezier_conn.c
@@ -67,14 +67,14 @@ struct CornerChange {
};
static ObjectChange *
-bezierconn_create_point_change(BezierConn *bez, enum change_type type,
+bezierconn_create_point_change(BezierConn *bezier, enum change_type type,
BezPoint *point, BezCornerType corner_type,
int segment,
Handle *handle1, ConnectionPoint *connected_to1,
Handle *handle2, ConnectionPoint *connected_to2,
Handle *handle3, ConnectionPoint *connected_to3);
static ObjectChange *
-bezierconn_create_corner_change(BezierConn *bez, Handle *handle,
+bezierconn_create_corner_change(BezierConn *bezier, Handle *handle,
Point *point_left, Point *point_right,
BezCornerType old_corner_type,
BezCornerType new_corner_type);
@@ -94,30 +94,30 @@ setup_handle(Handle *handle, HandleId id)
}
/** Get the number in the array of handles that a given handle has.
- * @param bez A bezierconn object with handles set up.
+ * @param bezier A bezierconn object with handles set up.
* @param handle A handle object.
* @returns The index in bex->object.handles of the handle object, or -1 if
* `handle' is not in the array.
*/
static int
-get_handle_nr(BezierConn *bez, Handle *handle)
+get_handle_nr(BezierConn *bezier, Handle *handle)
{
int i = 0;
- for (i=0;i<bez->object.num_handles;i++) {
- if (bez->object.handles[i] == handle)
+ for (i=0;i<bezier->object.num_handles;i++) {
+ if (bezier->object.handles[i] == handle)
return i;
}
return -1;
}
-void new_handles(BezierConn *bez, int num_points);
+void new_handles(BezierConn *bezier, int num_points);
#define get_comp_nr(hnum) (((int)(hnum)+2)/3)
#define get_major_nr(hnum) (((int)(hnum)+1)/3)
/** Function called to move one of the handles associated with the
* bezierconn.
- * @param bez The object whose handle is being moved.
+ * @param bezier The object whose handle is being moved.
* @param handle The handle being moved.
* @param to The position it has been moved to (corrected for
* vertical/horizontal only movement).
@@ -128,7 +128,7 @@ void new_handles(BezierConn *bez, int num_points);
* @return NULL
*/
ObjectChange*
-bezierconn_move_handle(BezierConn *bez, Handle *handle,
+bezierconn_move_handle(BezierConn *bezier, Handle *handle,
Point *to, ConnectionPoint *cp,
HandleMoveReason reason, ModifierKeys modifiers)
{
@@ -138,48 +138,48 @@ bezierconn_move_handle(BezierConn *bez, Handle *handle,
delta = *to;
point_sub(&delta, &handle->pos);
- handle_nr = get_handle_nr(bez, handle);
+ handle_nr = get_handle_nr(bezier, handle);
comp_nr = get_comp_nr(handle_nr);
switch(handle->id) {
case HANDLE_MOVE_STARTPOINT:
- bez->points[0].p1 = *to;
+ bezier->points[0].p1 = *to;
/* shift adjacent point */
- point_add(&bez->points[1].p1, &delta);
+ point_add(&bezier->points[1].p1, &delta);
break;
case HANDLE_MOVE_ENDPOINT:
- bez->points[bez->numpoints-1].p3 = *to;
+ bezier->points[bezier->numpoints-1].p3 = *to;
/* shift adjacent point */
- point_add(&bez->points[bez->numpoints-1].p2, &delta);
+ point_add(&bezier->points[bezier->numpoints-1].p2, &delta);
break;
case HANDLE_BEZMAJOR:
- bez->points[comp_nr].p3 = *to;
+ bezier->points[comp_nr].p3 = *to;
/* shift adjacent point */
- point_add(&bez->points[comp_nr].p2, &delta);
- point_add(&bez->points[comp_nr+1].p1, &delta);
+ point_add(&bezier->points[comp_nr].p2, &delta);
+ point_add(&bezier->points[comp_nr+1].p1, &delta);
break;
case HANDLE_LEFTCTRL:
- bez->points[comp_nr].p2 = *to;
- if (comp_nr < bez->numpoints - 1) {
- switch (bez->corner_types[comp_nr]) {
+ bezier->points[comp_nr].p2 = *to;
+ if (comp_nr < bezier->numpoints - 1) {
+ switch (bezier->corner_types[comp_nr]) {
case BEZ_CORNER_SYMMETRIC:
- pt = bez->points[comp_nr].p3;
- point_sub(&pt, &bez->points[comp_nr].p2);
- point_add(&pt, &bez->points[comp_nr].p3);
- bez->points[comp_nr+1].p1 = pt;
+ pt = bezier->points[comp_nr].p3;
+ point_sub(&pt, &bezier->points[comp_nr].p2);
+ point_add(&pt, &bezier->points[comp_nr].p3);
+ bezier->points[comp_nr+1].p1 = pt;
break;
case BEZ_CORNER_SMOOTH: {
real len;
- pt = bez->points[comp_nr+1].p1;
- point_sub(&pt, &bez->points[comp_nr].p3);
+ pt = bezier->points[comp_nr+1].p1;
+ point_sub(&pt, &bezier->points[comp_nr].p3);
len = point_len(&pt);
- pt = bez->points[comp_nr].p2;
- point_sub(&pt, &bez->points[comp_nr].p3);
+ pt = bezier->points[comp_nr].p2;
+ point_sub(&pt, &bezier->points[comp_nr].p3);
if (point_len(&pt) > 0)
point_normalize(&pt);
else { pt.x = 1.0; pt.y = 0.0; }
point_scale(&pt, -len);
- point_add(&pt, &bez->points[comp_nr].p3);
- bez->points[comp_nr+1].p1 = pt;
+ point_add(&pt, &bezier->points[comp_nr].p3);
+ bezier->points[comp_nr+1].p1 = pt;
break;
}
case BEZ_CORNER_CUSP:
@@ -189,28 +189,28 @@ bezierconn_move_handle(BezierConn *bez, Handle *handle,
}
break;
case HANDLE_RIGHTCTRL:
- bez->points[comp_nr].p1 = *to;
+ bezier->points[comp_nr].p1 = *to;
if (comp_nr > 1) {
- switch (bez->corner_types[comp_nr-1]) {
+ switch (bezier->corner_types[comp_nr-1]) {
case BEZ_CORNER_SYMMETRIC:
- pt = bez->points[comp_nr - 1].p3;
- point_sub(&pt, &bez->points[comp_nr].p1);
- point_add(&pt, &bez->points[comp_nr - 1].p3);
- bez->points[comp_nr-1].p2 = pt;
+ pt = bezier->points[comp_nr - 1].p3;
+ point_sub(&pt, &bezier->points[comp_nr].p1);
+ point_add(&pt, &bezier->points[comp_nr - 1].p3);
+ bezier->points[comp_nr-1].p2 = pt;
break;
case BEZ_CORNER_SMOOTH: {
real len;
- pt = bez->points[comp_nr-1].p2;
- point_sub(&pt, &bez->points[comp_nr-1].p3);
+ pt = bezier->points[comp_nr-1].p2;
+ point_sub(&pt, &bezier->points[comp_nr-1].p3);
len = point_len(&pt);
- pt = bez->points[comp_nr].p1;
- point_sub(&pt, &bez->points[comp_nr-1].p3);
+ pt = bezier->points[comp_nr].p1;
+ point_sub(&pt, &bezier->points[comp_nr-1].p3);
if (point_len(&pt) > 0)
point_normalize(&pt);
else { pt.x = 1.0; pt.y = 0.0; }
point_scale(&pt, -len);
- point_add(&pt, &bez->points[comp_nr-1].p3);
- bez->points[comp_nr-1].p2 = pt;
+ point_add(&pt, &bezier->points[comp_nr-1].p3);
+ bezier->points[comp_nr-1].p2 = pt;
break;
}
case BEZ_CORNER_CUSP:
@@ -228,39 +228,39 @@ bezierconn_move_handle(BezierConn *bez, Handle *handle,
/** Function called to move the entire object.
- * @param bez The object being moved.
+ * @param bezier The object being moved.
* @param to Where the object is being moved to. This is the first point
* of the points array.
* @return NULL
* \memberof _BezierConn
*/
ObjectChange*
-bezierconn_move(BezierConn *bez, Point *to)
+bezierconn_move(BezierConn *bezier, Point *to)
{
Point p;
int i;
p = *to;
- point_sub(&p, &bez->points[0].p1);
+ point_sub(&p, &bezier->points[0].p1);
- bez->points[0].p1 = *to;
- for (i = 1; i < bez->numpoints; i++) {
- point_add(&bez->points[i].p1, &p);
- point_add(&bez->points[i].p2, &p);
- point_add(&bez->points[i].p3, &p);
+ bezier->points[0].p1 = *to;
+ for (i = 1; i < bezier->numpoints; i++) {
+ point_add(&bezier->points[i].p1, &p);
+ point_add(&bezier->points[i].p2, &p);
+ point_add(&bezier->points[i].p3, &p);
}
return NULL;
}
/** Return the segment of the bezierconn closest to a given point.
- * @param bez The bezierconn object
+ * @param bezier The bezierconn object
* @param point A point to find the closest segment to.
* @param line_width Line width of the bezier line.
* @returns The index of the segment closest to point.
*/
int
-bezierconn_closest_segment(BezierConn *bez, Point *point, real line_width)
+bezierconn_closest_segment(BezierConn *bezier, Point *point, real line_width)
{
Point last;
int i;
@@ -268,57 +268,57 @@ bezierconn_closest_segment(BezierConn *bez, Point *point, real line_width)
int closest;
closest = 0;
- last = bez->points[0].p1;
- for (i = 0; i < bez->numpoints - 1; i++) {
- real new_dist = distance_bez_seg_point(&last, &bez->points[i+1].p1,
- &bez->points[i+1].p2, &bez->points[i+1].p3,
+ last = bezier->points[0].p1;
+ for (i = 0; i < bezier->numpoints - 1; i++) {
+ real new_dist = distance_bez_seg_point(&last, &bezier->points[i+1].p1,
+ &bezier->points[i+1].p2, &bezier->points[i+1].p3,
line_width, point);
if (new_dist < dist) {
dist = new_dist;
closest = i;
}
- last = bez->points[i+1].p3;
+ last = bezier->points[i+1].p3;
}
return closest;
}
/** Return the handle closest to a given point.
- * @param bez A bezierconn object
+ * @param bezier A bezierconn object
* @param point A point to find distances from
- * @return The handle on `bez' closest to `point'.
+ * @return The handle on `bezier' closest to `point'.
*
* \memberof _BezierConn Conceptually this is a member function
*/
Handle *
-bezierconn_closest_handle(BezierConn *bez, Point *point)
+bezierconn_closest_handle(BezierConn *bezier, Point *point)
{
int i, hn;
real dist;
Handle *closest;
- closest = bez->object.handles[0];
+ closest = bezier->object.handles[0];
dist = distance_point_point( point, &closest->pos);
- for (i = 1, hn = 1; i < bez->numpoints; i++, hn++) {
+ for (i = 1, hn = 1; i < bezier->numpoints; i++, hn++) {
real new_dist;
- new_dist = distance_point_point(point, &bez->points[i].p1);
+ new_dist = distance_point_point(point, &bezier->points[i].p1);
if (new_dist < dist) {
dist = new_dist;
- closest = bez->object.handles[hn];
+ closest = bezier->object.handles[hn];
}
hn++;
- new_dist = distance_point_point(point, &bez->points[i].p2);
+ new_dist = distance_point_point(point, &bezier->points[i].p2);
if (new_dist < dist) {
dist = new_dist;
- closest = bez->object.handles[hn];
+ closest = bezier->object.handles[hn];
}
hn++;
- new_dist = distance_point_point(point, &bez->points[i].p3);
+ new_dist = distance_point_point(point, &bezier->points[i].p3);
if (new_dist < dist) {
dist = new_dist;
- closest = bez->object.handles[hn];
+ closest = bezier->object.handles[hn];
}
}
return closest;
@@ -326,7 +326,7 @@ bezierconn_closest_handle(BezierConn *bez, Point *point)
/** Return the major handle for the control point with the handle closest to
* a given point.
- * @param bez A bezier connection
+ * @param bezier A bezier connection
* @param point A point
* @return The major (middle) handle of the bezier control that has the
* handle closest to point.
@@ -336,28 +336,28 @@ bezierconn_closest_handle(BezierConn *bez, Point *point)
* point close to the major handle.
*/
Handle *
-bezierconn_closest_major_handle(BezierConn *bez, Point *point)
+bezierconn_closest_major_handle(BezierConn *bezier, Point *point)
{
- Handle *closest = bezierconn_closest_handle(bez, point);
+ Handle *closest = bezierconn_closest_handle(bezier, point);
- return bez->object.handles[3*get_major_nr(get_handle_nr(bez, closest))];
+ return bezier->object.handles[3*get_major_nr(get_handle_nr(bezier, closest))];
}
/** Return the distance from a bezier to a point.
- * @param bez A bezierconn object.
+ * @param bezier A bezierconn object.
* @param point A point to compare with.
* @param line_width The line width of the bezier line.
* @returns The shortest distance from the point to any part of the bezier.
*/
real
-bezierconn_distance_from(BezierConn *bez, Point *point, real line_width)
+bezierconn_distance_from(BezierConn *bezier, Point *point, real line_width)
{
- return distance_bez_line_point(bez->points, bez->numpoints,
+ return distance_bez_line_point(bezier->points, bezier->numpoints,
line_width, point);
}
/** Add a trio of handles to a bezier.
- * @param bez The bezierconn having handles added.
+ * @param bezier The bezierconn having handles added.
* @param pos Where in the list of segments to add the handle
* @param point The bezier point to add. This should already be initialized
* with sensible positions.
@@ -367,7 +367,7 @@ bezierconn_distance_from(BezierConn *bez, Point *point, real line_width)
* @param handle3 The handle that will be put after handle1
*/
static void
-add_handles(BezierConn *bez, int pos, BezPoint *point,
+add_handles(BezierConn *bezier, int pos, BezPoint *point,
BezCornerType corner_type, Handle *handle1,
Handle *handle2, Handle *handle3)
{
@@ -376,37 +376,37 @@ add_handles(BezierConn *bez, int pos, BezPoint *point,
g_assert(pos > 0);
- obj = (DiaObject *)bez;
- bez->numpoints++;
- bez->points = g_realloc(bez->points, bez->numpoints*sizeof(BezPoint));
- bez->corner_types = g_realloc(bez->corner_types,
- bez->numpoints * sizeof(BezCornerType));
-
- for (i = bez->numpoints-1; i > pos; i--) {
- bez->points[i] = bez->points[i-1];
- bez->corner_types[i] = bez->corner_types[i-1];
+ obj = (DiaObject *)bezier;
+ bezier->numpoints++;
+ bezier->points = g_realloc(bezier->points, bezier->numpoints*sizeof(BezPoint));
+ bezier->corner_types = g_realloc(bezier->corner_types,
+ bezier->numpoints * sizeof(BezCornerType));
+
+ for (i = bezier->numpoints-1; i > pos; i--) {
+ bezier->points[i] = bezier->points[i-1];
+ bezier->corner_types[i] = bezier->corner_types[i-1];
}
- bez->points[pos] = *point;
- bez->points[pos].p1 = bez->points[pos+1].p1;
- bez->points[pos+1].p1 = point->p1;
- bez->corner_types[pos] = corner_type;
+ bezier->points[pos] = *point;
+ bezier->points[pos].p1 = bezier->points[pos+1].p1;
+ bezier->points[pos+1].p1 = point->p1;
+ bezier->corner_types[pos] = corner_type;
object_add_handle_at(obj, handle1, 3*pos-2);
object_add_handle_at(obj, handle2, 3*pos-1);
object_add_handle_at(obj, handle3, 3*pos);
- if (pos==bez->numpoints-1) {
+ if (pos==bezier->numpoints-1) {
obj->handles[obj->num_handles-4]->type = HANDLE_MINOR_CONTROL;
obj->handles[obj->num_handles-4]->id = HANDLE_BEZMAJOR;
}
}
/** Remove a trio of handles from a bezierconn.
- * @param bez The bezierconn to remove handles from.
+ * @param bezier The bezierconn to remove handles from.
* @param pos The position in the bezierpoint array to remove handles and
* bezpoint at.
*/
static void
-remove_handles(BezierConn *bez, int pos)
+remove_handles(BezierConn *bezier, int pos)
{
int i;
DiaObject *obj;
@@ -415,7 +415,7 @@ remove_handles(BezierConn *bez, int pos)
g_assert(pos > 0);
- obj = (DiaObject *)bez;
+ obj = (DiaObject *)bezier;
if (pos==obj->num_handles-1) {
obj->handles[obj->num_handles-4]->type = HANDLE_MAJOR_CONTROL;
@@ -423,36 +423,36 @@ remove_handles(BezierConn *bez, int pos)
}
/* delete the points */
- bez->numpoints--;
- tmppoint = bez->points[pos].p1;
- for (i = pos; i < bez->numpoints; i++) {
- bez->points[i] = bez->points[i+1];
- bez->corner_types[i] = bez->corner_types[i+1];
+ bezier->numpoints--;
+ tmppoint = bezier->points[pos].p1;
+ for (i = pos; i < bezier->numpoints; i++) {
+ bezier->points[i] = bezier->points[i+1];
+ bezier->corner_types[i] = bezier->corner_types[i+1];
}
- bez->points[pos].p1 = tmppoint;
- bez->points = g_realloc(bez->points, bez->numpoints*sizeof(BezPoint));
- bez->corner_types = g_realloc(bez->corner_types,
- bez->numpoints * sizeof(BezCornerType));
+ bezier->points[pos].p1 = tmppoint;
+ bezier->points = g_realloc(bezier->points, bezier->numpoints*sizeof(BezPoint));
+ bezier->corner_types = g_realloc(bezier->corner_types,
+ bezier->numpoints * sizeof(BezCornerType));
old_handle1 = obj->handles[3*pos-2];
old_handle2 = obj->handles[3*pos-1];
old_handle3 = obj->handles[3*pos];
- object_remove_handle(&bez->object, old_handle1);
- object_remove_handle(&bez->object, old_handle2);
- object_remove_handle(&bez->object, old_handle3);
+ object_remove_handle(&bezier->object, old_handle1);
+ object_remove_handle(&bezier->object, old_handle2);
+ object_remove_handle(&bezier->object, old_handle3);
}
/** Add a point by splitting segment into two, putting the new point at
* 'point' or, if NULL, in the middle. This function will attempt to come
* up with reasonable placements for the control points.
- * @param bez The bezierconn to add the segment to.
+ * @param bezier The bezierconn to add the segment to.
* @param segment Which segment to split.
* @param point Where to put the new corner, or NULL if undetermined.
* @returns An ObjectChange object with undo information for the split.
*/
ObjectChange *
-bezierconn_add_segment(BezierConn *bez, int segment, Point *point)
+bezierconn_add_segment(BezierConn *bezier, int segment, Point *point)
{
BezPoint realpoint;
BezCornerType corner_type = BEZ_CORNER_SYMMETRIC;
@@ -460,24 +460,24 @@ bezierconn_add_segment(BezierConn *bez, int segment, Point *point)
Point startpoint;
if (segment == 0)
- startpoint = bez->points[0].p1;
+ startpoint = bezier->points[0].p1;
else
- startpoint = bez->points[segment].p3;
+ startpoint = bezier->points[segment].p3;
if (point == NULL) {
- realpoint.p1.x = (startpoint.x + bez->points[segment+1].p3.x) / 6;
- realpoint.p1.y = (startpoint.y + bez->points[segment+1].p3.y) / 6;
- realpoint.p2.x = (startpoint.x + bez->points[segment+1].p3.x) / 3;
- realpoint.p2.y = (startpoint.y + bez->points[segment+1].p3.y) / 3;
- realpoint.p3.x = (startpoint.x + bez->points[segment+1].p3.x) / 2;
- realpoint.p3.y = (startpoint.y + bez->points[segment+1].p3.y) / 2;
+ realpoint.p1.x = (startpoint.x + bezier->points[segment+1].p3.x) / 6;
+ realpoint.p1.y = (startpoint.y + bezier->points[segment+1].p3.y) / 6;
+ realpoint.p2.x = (startpoint.x + bezier->points[segment+1].p3.x) / 3;
+ realpoint.p2.y = (startpoint.y + bezier->points[segment+1].p3.y) / 3;
+ realpoint.p3.x = (startpoint.x + bezier->points[segment+1].p3.x) / 2;
+ realpoint.p3.y = (startpoint.y + bezier->points[segment+1].p3.y) / 2;
} else {
- realpoint.p2.x = point->x+(startpoint.x - bez->points[segment+1].p3.x)/6;
- realpoint.p2.y = point->y+(startpoint.y - bez->points[segment+1].p3.y)/6;
+ realpoint.p2.x = point->x+(startpoint.x - bezier->points[segment+1].p3.x)/6;
+ realpoint.p2.y = point->y+(startpoint.y - bezier->points[segment+1].p3.y)/6;
realpoint.p3 = *point;
/* this really goes into the next segment ... */
- realpoint.p1.x = point->x-(startpoint.x - bez->points[segment+1].p3.x)/6;
- realpoint.p1.y = point->y-(startpoint.y - bez->points[segment+1].p3.y)/6;
+ realpoint.p1.x = point->x-(startpoint.x - bezier->points[segment+1].p3.x)/6;
+ realpoint.p1.y = point->y-(startpoint.y - bezier->points[segment+1].p3.y)/6;
}
realpoint.type = BEZ_CURVE_TO;
@@ -487,9 +487,9 @@ bezierconn_add_segment(BezierConn *bez, int segment, Point *point)
setup_handle(new_handle1, HANDLE_RIGHTCTRL);
setup_handle(new_handle2, HANDLE_LEFTCTRL);
setup_handle(new_handle3, HANDLE_BEZMAJOR);
- add_handles(bez, segment+1, &realpoint, corner_type,
+ add_handles(bezier, segment+1, &realpoint, corner_type,
new_handle1, new_handle2, new_handle3);
- return bezierconn_create_point_change(bez, TYPE_ADD_POINT,
+ return bezierconn_create_point_change(bezier, TYPE_ADD_POINT,
&realpoint, corner_type, segment+1,
new_handle1, NULL,
new_handle2, NULL,
@@ -497,12 +497,12 @@ bezierconn_add_segment(BezierConn *bez, int segment, Point *point)
}
/** Remove a segment from a bezierconn.
- * @param bez The bezierconn to remove a segment from.
+ * @param bezier The bezierconn to remove a segment from.
* @param pos The index of the segment to remove.
* @returns Undo information for the segment removal.
*/
ObjectChange *
-bezierconn_remove_segment(BezierConn *bez, int pos)
+bezierconn_remove_segment(BezierConn *bezier, int pos)
{
Handle *old_handle1, *old_handle2, *old_handle3;
ConnectionPoint *cpt1, *cpt2, *cpt3;
@@ -510,31 +510,31 @@ bezierconn_remove_segment(BezierConn *bez, int pos)
BezCornerType old_ctype;
g_assert(pos > 0);
- g_assert(bez->numpoints > 2);
+ g_assert(bezier->numpoints > 2);
- if (pos == bez->numpoints-1) pos--;
+ if (pos == bezier->numpoints-1) pos--;
- old_handle1 = bez->object.handles[3*pos-2];
- old_handle2 = bez->object.handles[3*pos-1];
- old_handle3 = bez->object.handles[3*pos];
- old_point = bez->points[pos];
- old_ctype = bez->corner_types[pos];
+ old_handle1 = bezier->object.handles[3*pos-2];
+ old_handle2 = bezier->object.handles[3*pos-1];
+ old_handle3 = bezier->object.handles[3*pos];
+ old_point = bezier->points[pos];
+ old_ctype = bezier->corner_types[pos];
cpt1 = old_handle1->connected_to;
cpt2 = old_handle2->connected_to;
cpt3 = old_handle3->connected_to;
- object_unconnect((DiaObject *)bez, old_handle1);
- object_unconnect((DiaObject *)bez, old_handle2);
- object_unconnect((DiaObject *)bez, old_handle3);
+ object_unconnect((DiaObject *)bezier, old_handle1);
+ object_unconnect((DiaObject *)bezier, old_handle2);
+ object_unconnect((DiaObject *)bezier, old_handle3);
/* remember the other point before overwriting */
- old_point.p1 = bez->points[pos+1].p1;
- remove_handles(bez, pos);
+ old_point.p1 = bezier->points[pos+1].p1;
+ remove_handles(bezier, pos);
- bezierconn_update_data(bez);
+ bezierconn_update_data(bezier);
- return bezierconn_create_point_change(bez, TYPE_REMOVE_POINT,
+ return bezierconn_create_point_change(bezier, TYPE_REMOVE_POINT,
&old_point, old_ctype, pos,
old_handle1, cpt1,
old_handle2, cpt2,
@@ -543,42 +543,42 @@ bezierconn_remove_segment(BezierConn *bez, int pos)
/** Update a corner to have less freedom in its control handles, arranging
* the control points at some reasonable places.
- * @param bez A bezierconn to straighten a corner of
+ * @param bezier A bezierconn to straighten a corner of
* @param comp_nr The index into the corner_types array of the corner to
* straighten.
*/
static void
-bezierconn_straighten_corner(BezierConn *bez, int comp_nr)
+bezierconn_straighten_corner(BezierConn *bezier, int comp_nr)
{
/* Neat thing would be to have the kind of straigthening depend on
which handle was chosen: Mid-handle does average, other leaves that
handle where it is. */
- switch (bez->corner_types[comp_nr]) {
+ switch (bezier->corner_types[comp_nr]) {
case BEZ_CORNER_SYMMETRIC: {
Point pt1, pt2;
- pt1 = bez->points[comp_nr].p3;
- point_sub(&pt1, &bez->points[comp_nr].p2);
- pt2 = bez->points[comp_nr].p3;
- point_sub(&pt2, &bez->points[comp_nr+1].p1);
+ pt1 = bezier->points[comp_nr].p3;
+ point_sub(&pt1, &bezier->points[comp_nr].p2);
+ pt2 = bezier->points[comp_nr].p3;
+ point_sub(&pt2, &bezier->points[comp_nr+1].p1);
point_scale(&pt2, -1.0);
point_add(&pt1, &pt2);
point_scale(&pt1, 0.5);
pt2 = pt1;
point_scale(&pt1, -1.0);
- point_add(&pt1, &bez->points[comp_nr].p3);
- point_add(&pt2, &bez->points[comp_nr].p3);
- bez->points[comp_nr].p2 = pt1;
- bez->points[comp_nr+1].p1 = pt2;
- bezierconn_update_data(bez);
+ point_add(&pt1, &bezier->points[comp_nr].p3);
+ point_add(&pt2, &bezier->points[comp_nr].p3);
+ bezier->points[comp_nr].p2 = pt1;
+ bezier->points[comp_nr+1].p1 = pt2;
+ bezierconn_update_data(bezier);
}
break;
case BEZ_CORNER_SMOOTH: {
Point pt1, pt2;
real len1, len2;
- pt1 = bez->points[comp_nr].p3;
- point_sub(&pt1, &bez->points[comp_nr].p2);
- pt2 = bez->points[comp_nr].p3;
- point_sub(&pt2, &bez->points[comp_nr+1].p1);
+ pt1 = bezier->points[comp_nr].p3;
+ point_sub(&pt1, &bezier->points[comp_nr].p2);
+ pt2 = bezier->points[comp_nr].p3;
+ point_sub(&pt2, &bezier->points[comp_nr+1].p1);
len1 = point_len(&pt1);
len2 = point_len(&pt2);
point_scale(&pt2, -1.0);
@@ -590,12 +590,12 @@ bezierconn_straighten_corner(BezierConn *bez, int comp_nr)
point_scale(&pt1, 0.5);
pt2 = pt1;
point_scale(&pt1, -len1);
- point_add(&pt1, &bez->points[comp_nr].p3);
+ point_add(&pt1, &bezier->points[comp_nr].p3);
point_scale(&pt2, len2);
- point_add(&pt2, &bez->points[comp_nr].p3);
- bez->points[comp_nr].p2 = pt1;
- bez->points[comp_nr+1].p1 = pt2;
- bezierconn_update_data(bez);
+ point_add(&pt2, &bezier->points[comp_nr].p3);
+ bezier->points[comp_nr].p2 = pt1;
+ bezier->points[comp_nr+1].p1 = pt2;
+ bezierconn_update_data(bezier);
}
break;
case BEZ_CORNER_CUSP:
@@ -604,13 +604,13 @@ bezierconn_straighten_corner(BezierConn *bez, int comp_nr)
}
/** Change the corner type of a bezier line.
- * @param bez The bezierconn that has the corner
+ * @param bezier The bezierconn that has the corner
* @param handle The handle whose corner should be set.
* @param corner_type What type of corner the handle should have.
* @returns Undo information about the corner change.
*/
ObjectChange *
-bezierconn_set_corner_type(BezierConn *bez, Handle *handle,
+bezierconn_set_corner_type(BezierConn *bezier, Handle *handle,
BezCornerType corner_type)
{
Handle *mid_handle;
@@ -618,7 +618,7 @@ bezierconn_set_corner_type(BezierConn *bez, Handle *handle,
int old_type;
int handle_nr, comp_nr;
- handle_nr = get_handle_nr(bez, handle);
+ handle_nr = get_handle_nr(bezier, handle);
switch (handle->id) {
case HANDLE_BEZMAJOR:
@@ -626,11 +626,11 @@ bezierconn_set_corner_type(BezierConn *bez, Handle *handle,
break;
case HANDLE_LEFTCTRL:
handle_nr++;
- mid_handle = bez->object.handles[handle_nr];
+ mid_handle = bezier->object.handles[handle_nr];
break;
case HANDLE_RIGHTCTRL:
handle_nr--;
- mid_handle = bez->object.handles[handle_nr];
+ mid_handle = bezier->object.handles[handle_nr];
break;
default:
g_warning("Internal error: Setting corner type of endpoint of bezier");
@@ -639,85 +639,85 @@ bezierconn_set_corner_type(BezierConn *bez, Handle *handle,
comp_nr = get_major_nr(handle_nr);
- old_type = bez->corner_types[comp_nr];
- old_left = bez->points[comp_nr].p2;
- old_right = bez->points[comp_nr+1].p1;
+ old_type = bezier->corner_types[comp_nr];
+ old_left = bezier->points[comp_nr].p2;
+ old_right = bezier->points[comp_nr+1].p1;
- bez->corner_types[comp_nr] = corner_type;
+ bezier->corner_types[comp_nr] = corner_type;
- bezierconn_straighten_corner(bez, comp_nr);
+ bezierconn_straighten_corner(bezier, comp_nr);
- return bezierconn_create_corner_change(bez, mid_handle, &old_left, &old_right,
+ return bezierconn_create_corner_change(bezier, mid_handle, &old_left, &old_right,
old_type, corner_type);
}
/** Update handle array and handle positions after changes.
- * @param bez A bezierconn to update.
+ * @param bezier A bezierconn to update.
*/
void
-bezierconn_update_data(BezierConn *bez)
+bezierconn_update_data(BezierConn *bezier)
{
int i;
- DiaObject *obj = &bez->object;
+ DiaObject *obj = &bezier->object;
/* handle the case of whole points array update (via set_prop) */
- if (3*bez->numpoints-2 != obj->num_handles) {
+ if (3*bezier->numpoints-2 != obj->num_handles) {
/* also maintain potential connections */
- ConnectionPoint *cps = bez->object.handles[0]->connected_to;
- ConnectionPoint *cpe = bez->object.handles[obj->num_handles-1]->connected_to;
+ ConnectionPoint *cps = bezier->object.handles[0]->connected_to;
+ ConnectionPoint *cpe = bezier->object.handles[obj->num_handles-1]->connected_to;
g_assert(0 == obj->num_connections);
if (cps)
- object_unconnect (&bez->object, bez->object.handles[0]);
+ object_unconnect (&bezier->object, bezier->object.handles[0]);
if (cpe)
- object_unconnect (&bez->object, bez->object.handles[obj->num_handles-1]);
+ object_unconnect (&bezier->object, bezier->object.handles[obj->num_handles-1]);
for (i = 0; i < obj->num_handles; i++)
g_free(obj->handles[i]);
g_free(obj->handles);
- obj->num_handles = 3*bez->numpoints-2;
+ obj->num_handles = 3*bezier->numpoints-2;
obj->handles = g_new(Handle*, obj->num_handles);
- new_handles(bez, bez->numpoints);
+ new_handles(bezier, bezier->numpoints);
/* we may assign NULL once more here */
if (cps)
- object_connect(&bez->object, bez->object.handles[0], cps);
+ object_connect(&bezier->object, bezier->object.handles[0], cps);
if (cpe)
- object_connect(&bez->object, bez->object.handles[obj->num_handles-1], cpe);
+ object_connect(&bezier->object, bezier->object.handles[obj->num_handles-1], cpe);
}
/* Update handles: */
- bez->object.handles[0]->pos = bez->points[0].p1;
- for (i = 1; i < bez->numpoints; i++) {
- bez->object.handles[3*i-2]->pos = bez->points[i].p1;
- bez->object.handles[3*i-1]->pos = bez->points[i].p2;
- bez->object.handles[3*i]->pos = bez->points[i].p3;
+ bezier->object.handles[0]->pos = bezier->points[0].p1;
+ for (i = 1; i < bezier->numpoints; i++) {
+ bezier->object.handles[3*i-2]->pos = bezier->points[i].p1;
+ bezier->object.handles[3*i-1]->pos = bezier->points[i].p2;
+ bezier->object.handles[3*i]->pos = bezier->points[i].p3;
}
}
/** Update the boundingbox of the connection.
- * @param bez A bezier line to update bounding box for.
+ * @param bezier A bezier line to update bounding box for.
*/
void
-bezierconn_update_boundingbox(BezierConn *bez)
+bezierconn_update_boundingbox(BezierConn *bezier)
{
- g_assert(bez != NULL);
+ g_assert(bezier != NULL);
- polybezier_bbox(&bez->points[0],
- bez->numpoints,
- &bez->extra_spacing, FALSE,
- &bez->object.bounding_box);
+ polybezier_bbox(&bezier->points[0],
+ bezier->numpoints,
+ &bezier->extra_spacing, FALSE,
+ &bezier->object.bounding_box);
}
/** Draw the control lines from the points of the bezier conn.
* Note that the control lines are hardcoded to be dotted with dash length 1.
- * @param bez The bezier conn to draw control lines for.
+ * @param bezier The bezier conn to draw control lines for.
* @param renderer A renderer to draw with.
*/
void
-bezierconn_draw_control_lines(BezierConn *bez, DiaRenderer *renderer)
+bezierconn_draw_control_lines(BezierConn *bezier, DiaRenderer *renderer)
{
Color line_colour = { 0.0, 0.0, 0.6, 1.0 };
Point startpoint;
@@ -730,28 +730,28 @@ bezierconn_draw_control_lines(BezierConn *bez, DiaRenderer *renderer)
DIA_RENDERER_GET_CLASS(renderer)->set_linejoin(renderer, LINEJOIN_MITER);
DIA_RENDERER_GET_CLASS(renderer)->set_linecaps(renderer, LINECAPS_BUTT);
- startpoint = bez->points[0].p1;
- for (i = 1; i < bez->numpoints; i++) {
- DIA_RENDERER_GET_CLASS(renderer)->draw_line(renderer, &startpoint, &bez->points[i].p1,
+ startpoint = bezier->points[0].p1;
+ for (i = 1; i < bezier->numpoints; i++) {
+ DIA_RENDERER_GET_CLASS(renderer)->draw_line(renderer, &startpoint, &bezier->points[i].p1,
&line_colour);
- DIA_RENDERER_GET_CLASS(renderer)->draw_line(renderer, &bez->points[i].p2, &bez->points[i].p3,
+ DIA_RENDERER_GET_CLASS(renderer)->draw_line(renderer, &bezier->points[i].p2, &bezier->points[i].p3,
&line_colour);
- startpoint = bez->points[i].p3;
+ startpoint = bezier->points[i].p3;
}
}
/** Create all handles used by a bezier conn.
- * @param bez A bezierconn object initialized with room for 3*num_points-2
+ * @param bezier A bezierconn object initialized with room for 3*num_points-2
* handles.
* @param num_points The number of points of the bezierconn.
*/
void
-new_handles(BezierConn *bez, int num_points)
+new_handles(BezierConn *bezier, int num_points)
{
DiaObject *obj;
int i;
- obj = &bez->object;
+ obj = &bezier->object;
obj->handles[0] = g_new0(Handle,1);
obj->handles[0]->connect_type = HANDLE_CONNECTABLE;
@@ -778,55 +778,55 @@ new_handles(BezierConn *bez, int num_points)
* The points array of the bezierconn object should be previously
* initialized with appropriate positions.
* This will set up handles and make all corners symmetric.
- * @param bez A newly allocated bezierconn object.
+ * @param bezier A newly allocated bezierconn object.
* @param num_points The initial number of points on the curve.
*/
void
-bezierconn_init(BezierConn *bez, int num_points)
+bezierconn_init(BezierConn *bezier, int num_points)
{
DiaObject *obj;
int i;
- obj = &bez->object;
+ obj = &bezier->object;
object_init(obj, 3*num_points-2, 0);
- bez->numpoints = num_points;
+ bezier->numpoints = num_points;
- bez->points = g_new(BezPoint, num_points);
- bez->corner_types = g_new(BezCornerType, num_points);
- bez->points[0].type = BEZ_MOVE_TO;
- bez->corner_types[0] = BEZ_CORNER_SYMMETRIC;
+ bezier->points = g_new(BezPoint, num_points);
+ bezier->corner_types = g_new(BezCornerType, num_points);
+ bezier->points[0].type = BEZ_MOVE_TO;
+ bezier->corner_types[0] = BEZ_CORNER_SYMMETRIC;
for (i = 1; i < num_points; i++) {
- bez->points[i].type = BEZ_CURVE_TO;
- bez->corner_types[i] = BEZ_CORNER_SYMMETRIC;
+ bezier->points[i].type = BEZ_CURVE_TO;
+ bezier->corner_types[i] = BEZ_CORNER_SYMMETRIC;
}
- new_handles(bez, num_points);
+ new_handles(bezier, num_points);
- bezierconn_update_data(bez);
+ bezierconn_update_data(bezier);
}
/** Set a bezierconn to use the given array of points.
* This function does *not* set up handles
- * @param bez A bezierconn to operate on
+ * @param bezier A bezierconn to operate on
* @param num_points The number of points in the `points' array.
* @param points The new points that this bezier should be set to use.
*/
void
-bezierconn_set_points(BezierConn *bez, int num_points, BezPoint *points)
+bezierconn_set_points(BezierConn *bezier, int num_points, BezPoint *points)
{
int i;
- bez->numpoints = num_points;
+ bezier->numpoints = num_points;
- if (bez->points)
- g_free(bez->points);
+ if (bezier->points)
+ g_free(bezier->points);
- bez->points = g_malloc((bez->numpoints)*sizeof(BezPoint));
+ bezier->points = g_malloc((bezier->numpoints)*sizeof(BezPoint));
- for (i=0;i<bez->numpoints;i++) {
- bez->points[i] = points[i];
+ for (i=0;i<bezier->numpoints;i++) {
+ bezier->points[i] = points[i];
}
}
@@ -871,117 +871,117 @@ bezierconn_copy(BezierConn *from, BezierConn *to)
}
/** Destroy a bezierconn object.
- * @param bez An object to destroy. This function in turn calls object_destroy
+ * @param bezier An object to destroy. This function in turn calls object_destroy
* and frees structures allocated by this bezierconn, but not the object itself
*/
void
-bezierconn_destroy(BezierConn *bez)
+bezierconn_destroy(BezierConn *bezier)
{
int i, nh;
Handle **temp_handles;
/* Need to store these temporary since object.handles is
freed by object_destroy() */
- nh = bez->object.num_handles;
+ nh = bezier->object.num_handles;
temp_handles = g_new(Handle *, nh);
for (i = 0; i < nh; i++)
- temp_handles[i] = bez->object.handles[i];
+ temp_handles[i] = bezier->object.handles[i];
- object_destroy(&bez->object);
+ object_destroy(&bezier->object);
for (i = 0; i < nh; i++)
g_free(temp_handles[i]);
g_free(temp_handles);
- g_free(bez->points);
- g_free(bez->corner_types);
+ g_free(bezier->points);
+ g_free(bezier->corner_types);
}
/** Save the data defined by a bezierconn object to XML.
- * @param bez The object to save.
+ * @param bezier The object to save.
* @param obj_node The XML node to save it into
*/
void
-bezierconn_save(BezierConn *bez, ObjectNode obj_node)
+bezierconn_save(BezierConn *bezier, ObjectNode obj_node)
{
int i;
AttributeNode attr;
- object_save(&bez->object, obj_node);
+ object_save(&bezier->object, obj_node);
attr = new_attribute(obj_node, "bez_points");
- data_add_point(attr, &bez->points[0].p1);
- for (i = 1; i < bez->numpoints; i++) {
- if (BEZ_MOVE_TO == bez->points[i].type)
+ data_add_point(attr, &bezier->points[0].p1);
+ for (i = 1; i < bezier->numpoints; i++) {
+ if (BEZ_MOVE_TO == bezier->points[i].type)
g_warning("only first BezPoint can be a BEZ_MOVE_TO");
- data_add_point(attr, &bez->points[i].p1);
- data_add_point(attr, &bez->points[i].p2);
- data_add_point(attr, &bez->points[i].p3);
+ data_add_point(attr, &bezier->points[i].p1);
+ data_add_point(attr, &bezier->points[i].p2);
+ data_add_point(attr, &bezier->points[i].p3);
}
attr = new_attribute(obj_node, "corner_types");
- for (i = 0; i < bez->numpoints; i++)
- data_add_enum(attr, bez->corner_types[i]);
+ for (i = 0; i < bezier->numpoints; i++)
+ data_add_enum(attr, bezier->corner_types[i]);
}
/** Load a bezierconn object from XML.
* Does object_init() on the bezierconn object.
- * @param bez A newly allocated bezierconn object to load into.
+ * @param bezier A newly allocated bezierconn object to load into.
* @param obj_node The XML node to load from.
* @param ctx The context in which this function is called
*/
void
-bezierconn_load(BezierConn *bez, ObjectNode obj_node, DiaContext *ctx)
+bezierconn_load(BezierConn *bezier, ObjectNode obj_node, DiaContext *ctx)
{
int i;
AttributeNode attr;
DataNode data;
- DiaObject *obj = &bez->object;
+ DiaObject *obj = &bezier->object;
object_load(obj, obj_node, ctx);
attr = object_find_attribute(obj_node, "bez_points");
if (attr != NULL)
- bez->numpoints = (attribute_num_data(attr) + 2)/3;
+ bezier->numpoints = (attribute_num_data(attr) + 2)/3;
else
- bez->numpoints = 0;
+ bezier->numpoints = 0;
- object_init(obj, 3 * bez->numpoints - 2, 0);
+ object_init(obj, 3 * bezier->numpoints - 2, 0);
data = attribute_first_data(attr);
- if (bez->numpoints != 0) {
- bez->points = g_new(BezPoint, bez->numpoints);
- bez->points[0].type = BEZ_MOVE_TO;
- data_point(data, &bez->points[0].p1, ctx);
+ if (bezier->numpoints != 0) {
+ bezier->points = g_new(BezPoint, bezier->numpoints);
+ bezier->points[0].type = BEZ_MOVE_TO;
+ data_point(data, &bezier->points[0].p1, ctx);
data = data_next(data);
- for (i = 1; i < bez->numpoints; i++) {
- bez->points[i].type = BEZ_CURVE_TO;
- data_point(data, &bez->points[i].p1, ctx);
+ for (i = 1; i < bezier->numpoints; i++) {
+ bezier->points[i].type = BEZ_CURVE_TO;
+ data_point(data, &bezier->points[i].p1, ctx);
data = data_next(data);
- data_point(data, &bez->points[i].p2, ctx);
+ data_point(data, &bezier->points[i].p2, ctx);
data = data_next(data);
- data_point(data, &bez->points[i].p3, ctx);
+ data_point(data, &bezier->points[i].p3, ctx);
data = data_next(data);
}
}
- bez->corner_types = g_new(BezCornerType, bez->numpoints);
+ bezier->corner_types = g_new(BezCornerType, bezier->numpoints);
attr = object_find_attribute(obj_node, "corner_types");
/* if corner_types is missing or corrupt */
- if (!attr || attribute_num_data(attr) != bez->numpoints) {
- for (i = 0; i < bez->numpoints; i++) {
- bez->corner_types[i] = BEZ_CORNER_SYMMETRIC;
+ if (!attr || attribute_num_data(attr) != bezier->numpoints) {
+ for (i = 0; i < bezier->numpoints; i++) {
+ bezier->corner_types[i] = BEZ_CORNER_SYMMETRIC;
}
} else {
data = attribute_first_data(attr);
- for (i = 0; i < bez->numpoints; i++) {
- bez->corner_types[i] = data_enum(data, ctx);
+ for (i = 0; i < bezier->numpoints; i++) {
+ bezier->corner_types[i] = data_enum(data, ctx);
data = data_next(data);
}
}
@@ -992,7 +992,7 @@ bezierconn_load(BezierConn *bez, ObjectNode obj_node, DiaContext *ctx)
obj->handles[0]->type = HANDLE_MAJOR_CONTROL;
obj->handles[0]->id = HANDLE_MOVE_STARTPOINT;
- for (i = 1; i < bez->numpoints; i++) {
+ for (i = 1; i < bezier->numpoints; i++) {
obj->handles[3*i-2] = g_new0(Handle,1);
setup_handle(obj->handles[3*i-2], HANDLE_RIGHTCTRL);
obj->handles[3*i-1] = g_new0(Handle,1);
@@ -1006,7 +1006,7 @@ bezierconn_load(BezierConn *bez, ObjectNode obj_node, DiaContext *ctx)
obj->handles[obj->num_handles-1]->type = HANDLE_MAJOR_CONTROL;
obj->handles[obj->num_handles-1]->id = HANDLE_MOVE_ENDPOINT;
- bezierconn_update_data(bez);
+ bezierconn_update_data(bezier);
}
/*** Undo support ***/
@@ -1080,7 +1080,7 @@ bezierconn_point_change_revert(struct PointChange *change, DiaObject *obj)
}
/** Create undo information about a point being added or removed.
- * @param bez The object that the change applies to (ignored)
+ * @param bezier The object that the change applies to (ignored)
* @param type The type of change (either TYPE_ADD_POINT or TYPE_REMOVE_POINT)
* @param point The point being added or removed.
* @param corner_type Which type of corner is at the point.
@@ -1094,7 +1094,7 @@ bezierconn_point_change_revert(struct PointChange *change, DiaObject *obj)
* @return Newly created undo information.
*/
static ObjectChange *
-bezierconn_create_point_change(BezierConn *bez, enum change_type type,
+bezierconn_create_point_change(BezierConn *bezier, enum change_type type,
BezPoint *point, BezCornerType corner_type,
int pos,
Handle *handle1, ConnectionPoint *connected_to1,
@@ -1133,13 +1133,13 @@ static void
bezierconn_corner_change_apply(struct CornerChange *change,
DiaObject *obj)
{
- BezierConn *bez = (BezierConn *)obj;
- int handle_nr = get_handle_nr(bez, change->handle);
+ BezierConn *bezier = (BezierConn *)obj;
+ int handle_nr = get_handle_nr(bezier, change->handle);
int comp_nr = get_major_nr(handle_nr);
- bezierconn_straighten_corner(bez, comp_nr);
+ bezierconn_straighten_corner(bezier, comp_nr);
- bez->corner_types[comp_nr] = change->new_type;
+ bezier->corner_types[comp_nr] = change->new_type;
change->applied = 1;
}
@@ -1153,13 +1153,13 @@ static void
bezierconn_corner_change_revert(struct CornerChange *change,
DiaObject *obj)
{
- BezierConn *bez = (BezierConn *)obj;
- int handle_nr = get_handle_nr(bez, change->handle);
+ BezierConn *bezier = (BezierConn *)obj;
+ int handle_nr = get_handle_nr(bezier, change->handle);
int comp_nr = get_major_nr(handle_nr);
- bez->points[comp_nr].p2 = change->point_left;
- bez->points[comp_nr+1].p1 = change->point_right;
- bez->corner_types[comp_nr] = change->old_type;
+ bezier->points[comp_nr].p2 = change->point_left;
+ bezier->points[comp_nr+1].p1 = change->point_right;
+ bezier->corner_types[comp_nr] = change->old_type;
change->applied = 0;
}
@@ -1167,7 +1167,7 @@ bezierconn_corner_change_revert(struct CornerChange *change,
/** Create new undo information about a changing the type of a corner.
* Note that the created ObjectChange object has nothing in it that needs
* freeing.
- * @param bez The bezierconn object this applies to.
+ * @param bezier The bezierconn object this applies to.
* @param handle The handle of the corner being changed.
* @param point_left The position of the left control handle.
* @param point_right The position of the right control handle.
@@ -1176,7 +1176,7 @@ bezierconn_corner_change_revert(struct CornerChange *change,
* @returns Newly allocated undo information.
*/
static ObjectChange *
-bezierconn_create_corner_change(BezierConn *bez, Handle *handle,
+bezierconn_create_corner_change(BezierConn *bezier, Handle *handle,
Point *point_left, Point *point_right,
BezCornerType old_corner_type,
BezCornerType new_corner_type)
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
