1 /* === S Y N F I G ========================================================= */
2 /*! \file valuenode_bline.cpp
3 ** \brief Implementation of the "BLine" valuenode conversion.
8 ** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
9 ** Copyright (c) 2007, 2008 Chris Moore
11 ** This package is free software; you can redistribute it and/or
12 ** modify it under the terms of the GNU General Public License as
13 ** published by the Free Software Foundation; either version 2 of
14 ** the License, or (at your option) any later version.
16 ** This package is distributed in the hope that it will be useful,
17 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 ** General Public License for more details.
22 /* ========================================================================= */
24 /* === H E A D E R S ======================================================= */
33 #include "valuenode_bline.h"
34 #include "valuenode_const.h"
35 #include "valuenode_composite.h"
37 #include "exception.h"
38 #include "blinepoint.h"
42 #include <ETL/hermite>
43 #include <ETL/calculus>
45 #include "curve_helper.h"
49 /* === U S I N G =========================================================== */
53 using namespace synfig;
55 /* === M A C R O S ========================================================= */
57 #define EPSILON 0.0000001f
59 /* === G L O B A L S ======================================================= */
61 /* === P R O C E D U R E S ================================================= */
64 linear_interpolation(const float& a, const float& b, float c)
68 linear_interpolation(const Vector& a, const Vector& b, float c)
72 radial_interpolation(const Vector& a, const Vector& b, float c)
74 // if either extreme is zero then use linear interpolation instead
75 if (a.is_equal_to(Vector::zero()) || b.is_equal_to(Vector::zero()))
76 return linear_interpolation(a, b, c);
78 affine_combo<Real,float> mag_combo;
79 affine_combo<Angle,float> ang_combo;
81 Real mag(mag_combo(a.mag(),b.mag(),c));
82 Angle ang(ang_combo(Angle::tan(a[1],a[0]),Angle::tan(b[1],b[0]),c));
84 return Point( mag*Angle::cos(ang).get(),mag*Angle::sin(ang).get() );
88 transform_coords(Vector in, Vector& out, const Point& coord_origin, const Point *coord_sys)
91 out[0] = in * coord_sys[0];
92 out[1] = in * coord_sys[1];
96 untransform_coords(const Vector& in, Vector& out, const Point& coord_origin, const Point *coord_sys)
98 out[0] = in * coord_sys[0];
99 out[1] = in * coord_sys[1];
104 synfig::convert_bline_to_segment_list(const ValueBase& bline)
106 std::vector<Segment> ret;
108 // std::vector<BLinePoint> list(bline.operator std::vector<BLinePoint>());
109 //std::vector<BLinePoint> list(bline);
110 std::vector<BLinePoint> list(bline.get_list().begin(),bline.get_list().end());
111 std::vector<BLinePoint>::const_iterator iter;
113 BLinePoint prev,first;
115 //start with prev = first and iter on the second...
117 if(list.empty()) return ValueBase(ret,bline.get_loop());
118 first = prev = list.front();
120 for(iter=++list.begin();iter!=list.end();++iter)
143 return ValueBase(ret,bline.get_loop());
147 synfig::convert_bline_to_width_list(const ValueBase& bline)
149 std::vector<Real> ret;
150 // std::vector<BLinePoint> list(bline.operator std::vector<BLinePoint>());
151 //std::vector<BLinePoint> list(bline);
152 std::vector<BLinePoint> list(bline.get_list().begin(),bline.get_list().end());
153 std::vector<BLinePoint>::const_iterator iter;
156 return ValueBase(ValueBase::TYPE_LIST);
158 for(iter=list.begin();iter!=list.end();++iter)
159 ret.push_back(iter->get_width());
162 ret.push_back(list.front().get_width());
164 return ValueBase(ret,bline.get_loop());
168 synfig::find_closest_point(const ValueBase &bline, const Point &pos, Real &radius, bool loop, Point *out_point)
174 synfig::Point best_point;
176 if(radius==0)radius=10000000;
177 Real closest(10000000);
180 std::vector<BLinePoint> list(bline.get_list().begin(),bline.get_list().end());
181 typedef std::vector<BLinePoint>::const_iterator iterT;
182 iterT iter, prev, first;
183 for(iter=list.begin(); iter!=list.end(); ++i, ++iter)
185 if( first == iterT() )
188 if( prev != iterT() )
192 curve[0] = (*prev).get_vertex();
193 curve[1] = curve[0] + (*prev).get_tangent2()/3;
194 curve[3] = (*iter).get_vertex();
195 curve[2] = curve[3] - (*iter).get_tangent1()/3;
199 // I don't know why this doesn't work
200 time=curve.find_closest(pos,6);
201 d=((curve(time)-pos).mag_squared());
204 //set the step size based on the size of the picture
205 d = (curve[1] - curve[0]).mag() + (curve[2]-curve[1]).mag() + (curve[3]-curve[2]).mag();
207 step = d/(2*radius); //want to make the distance between lines happy
209 step = max(step,0.01); //100 samples should be plenty
210 step = min(step,0.1); //10 is minimum
212 d = find_closest(curve,pos,step,&closest,&time);
220 best_point = curve(best_time);
229 if( loop && ( first != iterT() ) && ( prev != iterT() ) )
233 curve[0] = (*prev).get_vertex();
234 curve[1] = curve[0] + (*prev).get_tangent2()/3;
235 curve[3] = (*first).get_vertex();
236 curve[2] = curve[3] - (*first).get_tangent1()/3;
240 // I don't know why this doesn't work
241 time=curve.find_closest(pos,6);
242 d=((curve(time)-pos).mag_squared());
245 //set the step size based on the size of the picture
246 d = (curve[1] - curve[0]).mag() + (curve[2]-curve[1]).mag() + (curve[3]-curve[2]).mag();
248 step = d/(2*radius); //want to make the distance between lines happy
250 step = max(step,0.01); //100 samples should be plenty
251 step = min(step,0.1); //10 is minimum
253 d = find_closest(curve,pos,step,&closest,&time);
261 best_point = curve(best_time);
268 *out_point = best_point;
270 int loop_adjust(loop ? 0 : -1);
271 int size = list.size();
272 Real amount = (best_index + best_time + loop_adjust) / (size + loop_adjust);
280 /* === M E T H O D S ======================================================= */
283 ValueNode_BLine::ValueNode_BLine():
284 ValueNode_DynamicList(ValueBase::TYPE_BLINEPOINT)
288 ValueNode_BLine::~ValueNode_BLine()
293 ValueNode_BLine::create(const ValueBase &value)
295 if(value.get_type()!=ValueBase::TYPE_LIST)
298 ValueNode_BLine* value_node(new ValueNode_BLine());
302 switch(value.get_contained_type())
304 case ValueBase::TYPE_BLINEPOINT:
306 // std::vector<BLinePoint> bline_points(value.operator std::vector<BLinePoint>());
307 //std::vector<BLinePoint> bline_points(value);
308 std::vector<BLinePoint> bline_points(value.get_list().begin(),value.get_list().end());
309 std::vector<BLinePoint>::const_iterator iter;
311 for(iter=bline_points.begin();iter!=bline_points.end();iter++)
313 value_node->add(ValueNode::Handle(ValueNode_Composite::create(*iter)));
315 value_node->set_loop(value.get_loop());
318 case ValueBase::TYPE_SEGMENT:
320 // Here, we want to convert a list of segments
321 // into a list of BLinePoints. We make an assumption
322 // that the segment list is continuous(sp), but not necessarily
325 value_node->set_loop(false);
326 // std::vector<Segment> segments(value.operator std::vector<Segment>());
327 // std::vector<Segment> segments(value);
328 std::vector<Segment> segments(value.get_list().begin(),value.get_list().end());
329 std::vector<Segment>::const_iterator iter,last(segments.end());
331 ValueNode_Const::Handle prev,first;
333 for(iter=segments.begin();iter!=segments.end();iter++)
335 #define PREV_POINT prev->get_value().get(BLinePoint())
336 #define FIRST_POINT first->get_value().get(BLinePoint())
337 #define CURR_POINT curr->get_value().get(BLinePoint())
338 if(iter==segments.begin())
340 prev=ValueNode_Const::create(ValueBase::TYPE_BLINEPOINT);
342 BLinePoint prev_point(PREV_POINT);
343 prev_point.set_vertex(iter->p1);
344 prev_point.set_tangent1(iter->t1);
345 prev_point.set_width(0.01);
346 prev_point.set_origin(0.5);
347 prev_point.set_split_tangent_flag(false);
348 prev->set_value(prev_point);
351 value_node->add(ValueNode::Handle(prev));
354 if(iter==last && iter->p2.is_equal_to(FIRST_POINT.get_vertex()))
356 value_node->set_loop(true);
357 if(!iter->t2.is_equal_to(FIRST_POINT.get_tangent1()))
359 BLinePoint first_point(FIRST_POINT);
360 first_point.set_tangent1(iter->t2);
361 first->set_value(first_point);
366 ValueNode_Const::Handle curr;
367 curr=ValueNode_Const::create(ValueBase::TYPE_BLINEPOINT);
369 BLinePoint curr_point(CURR_POINT);
370 curr_point.set_vertex(iter->p2);
371 curr_point.set_tangent1(iter->t2);
372 curr_point.set_width(0.01);
373 curr_point.set_origin(0.5);
374 curr_point.set_split_tangent_flag(false);
375 curr->set_value(curr_point);
377 if(!PREV_POINT.get_tangent1().is_equal_to(iter->t1))
379 BLinePoint prev_point(PREV_POINT);
380 prev_point.set_split_tangent_flag(true);
381 prev_point.set_tangent2(iter->t1);
382 prev->set_value(prev_point);
384 value_node->add(ValueNode::Handle(curr));
391 // We got a list of who-knows-what. We don't have any idea
392 // what to do with it.
401 ValueNode_BLine::ListEntry
402 ValueNode_BLine::create_list_entry(int index, Time time, Real origin)
404 ValueNode_BLine::ListEntry ret;
406 synfig::BLinePoint prev,next;
410 index=index%link_count();
414 ret.set_parent_value_node(this);
416 if(!list[index].status_at_time(time))
417 next_i=find_next_valid_entry(index,time);
420 prev_i=find_prev_valid_entry(index,time);
422 //synfig::info("index=%d, next_i=%d, prev_i=%d",index,next_i,prev_i);
424 next=(*list[next_i].value_node)(time);
425 prev=(*list[prev_i].value_node)(time);
427 etl::hermite<Vector> curve(prev.get_vertex(),next.get_vertex(),prev.get_tangent2(),next.get_tangent1());
428 etl::derivative< etl::hermite<Vector> > deriv(curve);
430 synfig::BLinePoint bline_point;
431 bline_point.set_vertex(curve(origin));
432 bline_point.set_width((next.get_width()-prev.get_width())*origin+prev.get_width());
433 bline_point.set_tangent1(deriv(origin)*min(1.0-origin,origin));
434 bline_point.set_tangent2(bline_point.get_tangent1());
435 bline_point.set_split_tangent_flag(false);
436 bline_point.set_origin(origin);
438 ret.value_node=ValueNode_Composite::create(bline_point);
444 ValueNode_BLine::operator()(Time t)const
446 std::vector<BLinePoint> ret_list;
448 std::vector<ListEntry>::const_iterator iter,first_iter;
449 bool first_flag(true);
452 float next_scale(1.0f);
454 BLinePoint prev,first;
455 first.set_origin(100.0f);
457 // loop through all the list's entries
458 for(iter=list.begin();iter!=list.end();++iter,index++)
460 // how 'on' is this vertex?
461 float amount(iter->amount_at_time(t,&rising));
463 assert(amount>=0.0f);
464 assert(amount<=1.0f);
467 if (amount > 1.0f - EPSILON)
472 first=prev=(*iter->value_node)(t).get(prev);
474 ret_list.push_back(first);
479 curr=(*iter->value_node)(t).get(prev);
483 ret_list.back().set_split_tangent_flag(true);
484 ret_list.back().set_tangent2(prev.get_tangent2()*next_scale);
486 ret_list.push_back(curr);
488 ret_list.back().set_split_tangent_flag(true);
489 ret_list.back().set_tangent2(curr.get_tangent2());
490 ret_list.back().set_tangent1(curr.get_tangent1()*next_scale);
496 ret_list.push_back(curr);
504 std::vector<ListEntry>::const_iterator begin_iter,end_iter;
506 // This is where the interesting stuff happens
507 // We need to seek forward in the list to see what the next
510 BLinePoint blp_here_on; // the current vertex, when fully on
511 BLinePoint blp_here_off; // the current vertex, when fully off
512 BLinePoint blp_here_now; // the current vertex, right now (between on and off)
513 BLinePoint blp_prev_off; // the beginning of dynamic group when fully off
514 BLinePoint blp_next_off; // the end of the dynamic group when fully off
516 int dist_from_begin(0), dist_from_end(0);
517 Time off_time, on_time;
519 if(!rising) // if not rising, then we were fully on in the past, and will be fully off in the future
521 try{ on_time=iter->find_prev(t)->get_time(); }
522 catch(...) { on_time=Time::begin(); }
523 try{ off_time=iter->find_next(t)->get_time(); }
524 catch(...) { off_time=Time::end(); }
526 else // otherwise we were fully off in the past, and will be fully on in the future
528 try{ off_time=iter->find_prev(t)->get_time(); }
529 catch(...) { off_time=Time::begin(); }
530 try{ on_time=iter->find_next(t)->get_time(); }
531 catch(...) { on_time=Time::end(); }
534 blp_here_on=(*iter->value_node)(on_time).get(blp_here_on);
535 // blp_here_on=(*iter->value_node)(t).get(blp_here_on);
537 // Find "end" of dynamic group - ie. search forward along
538 // the bline from the current point until we find a point
539 // which is more 'on' than the current one
541 // for(++end_iter;begin_iter!=list.end();++end_iter)
542 for(++end_iter;end_iter!=list.end();++end_iter)
543 if(end_iter->amount_at_time(t)>amount)
546 // If we did not find an end of the dynamic group...
547 // Writeme! at least now it doesn't crash if first_iter
549 if(end_iter==list.end())
551 if(get_loop() && !first_flag)
554 end_iter=--list.end();
557 blp_next_off=(*end_iter->value_node)(off_time).get(prev);
559 // Find "begin" of dynamic group
561 blp_prev_off.set_origin(100.0f); // set the origin to 100 (which is crazy) so that we can check to see if it was found
564 if(begin_iter==list.begin())
567 begin_iter=list.end();
575 // if we've gone all around the loop, give up
579 if(begin_iter->amount_at_time(t)>amount)
581 blp_prev_off=(*begin_iter->value_node)(off_time).get(prev);
586 // If we did not find a begin
587 if(blp_prev_off.get_origin()==100.0f)
589 // Writeme! - this needs work, but at least now it
592 begin_iter=list.begin();
594 begin_iter=first_iter;
595 blp_prev_off=(*begin_iter->value_node)(off_time).get(prev);
598 // this is how the curve looks when we have completely vanished
599 etl::hermite<Vector> curve(blp_prev_off.get_vertex(), blp_next_off.get_vertex(),
600 blp_prev_off.get_tangent2(), blp_next_off.get_tangent1());
601 etl::derivative< etl::hermite<Vector> > deriv(curve);
603 // where would we be on this curve, how wide will we be, and
604 // where will our tangents point (all assuming that we hadn't vanished)
605 blp_here_off.set_vertex(curve(blp_here_on.get_origin()));
606 blp_here_off.set_width((blp_next_off.get_width()-blp_prev_off.get_width())*blp_here_on.get_origin()+blp_prev_off.get_width());
607 blp_here_off.set_tangent1(deriv(blp_here_on.get_origin()));
608 blp_here_off.set_tangent2(deriv(blp_here_on.get_origin()));
610 float prev_tangent_scalar(1.0f);
611 float next_tangent_scalar(1.0f);
613 //synfig::info("index_%d:dist_from_begin=%d",index,dist_from_begin);
614 //synfig::info("index_%d:dist_from_end=%d",index,dist_from_end);
616 // If we are the next to the begin
617 if(begin_iter==--std::vector<ListEntry>::const_iterator(iter) || dist_from_begin==1)
618 prev_tangent_scalar=linear_interpolation(blp_here_on.get_origin(), 1.0f, amount);
620 prev_tangent_scalar=linear_interpolation(blp_here_on.get_origin()-prev.get_origin(), 1.0f, amount);
622 // If we are the next to the end
623 if(end_iter==++std::vector<ListEntry>::const_iterator(iter) || dist_from_end==1)
624 next_tangent_scalar=linear_interpolation(1.0-blp_here_on.get_origin(), 1.0f, amount);
625 else if(list.end()!=++std::vector<ListEntry>::const_iterator(iter))
628 next=((*(++std::vector<ListEntry>::const_iterator(iter))->value_node)(t).get(prev));
629 next_tangent_scalar=linear_interpolation(next.get_origin()-blp_here_on.get_origin(), 1.0f, amount);
632 //! \todo this isn't quite right; we should handle looped blines identically no matter where the loop happens
633 //! and we currently don't. this at least makes it a lot better than it was before
634 next_tangent_scalar=linear_interpolation(blp_next_off.get_origin()-blp_here_on.get_origin(), 1.0f, amount);
635 next_scale=next_tangent_scalar;
637 //blp_here_now.set_vertex(linear_interpolation(blp_here_off.get_vertex(), blp_here_on.get_vertex(), amount));
641 // Point ref_point_begin(((*begin_iter->value_node)(off_time).get(prev).get_vertex() +
642 // (*end_iter->value_node)(off_time).get(prev).get_vertex()) * 0.5);
643 // Point ref_point_end(((*begin_iter->value_node)(on_time).get(prev).get_vertex() +
644 // (*end_iter->value_node)(on_time).get(prev).get_vertex()) * 0.5);
645 // Point ref_point_now(((*begin_iter->value_node)(t).get(prev).get_vertex() +
646 // (*end_iter->value_node)(t).get(prev).get_vertex()) * 0.5);
647 // Point ref_point_linear(linear_interpolation(ref_point_begin, ref_point_end, amount));
649 // blp_here_now.set_vertex(linear_interpolation(blp_here_off.get_vertex(), blp_here_on.get_vertex(), amount) +
650 // (ref_point_now-ref_point_linear));
651 // blp_here_now.set_tangent1(linear_interpolation(blp_here_off.get_tangent1(), blp_here_on.get_tangent1(), amount));
652 // blp_here_now.set_split_tangent_flag(blp_here_on.get_split_tangent_flag());
653 // if(blp_here_now.get_split_tangent_flag())
654 // blp_here_now.set_tangent2(linear_interpolation(blp_here_off.get_tangent2(), blp_here_on.get_tangent2(), amount));
660 // define 3 coordinate systems:
661 Point off_coord_sys[2], off_coord_origin; // when the current vertex is completely off
662 Point on_coord_sys[2] , on_coord_origin; // when the current vertex is completely on
663 Point curr_coord_sys[2], curr_coord_origin; // the current state - somewhere in between
665 // for each of the 3 systems, the origin is half way between the previous and next active point
666 // and the axes are based on a vector from the next active point to the previous
668 const Point end_pos_at_off_time(( *end_iter->value_node)(off_time).get(prev).get_vertex());
669 const Point begin_pos_at_off_time((*begin_iter->value_node)(off_time).get(prev).get_vertex());
670 off_coord_origin=(begin_pos_at_off_time + end_pos_at_off_time)/2;
671 off_coord_sys[0]=(begin_pos_at_off_time - end_pos_at_off_time).norm();
672 off_coord_sys[1]=off_coord_sys[0].perp();
674 const Point end_pos_at_on_time(( *end_iter->value_node)(on_time).get(prev).get_vertex());
675 const Point begin_pos_at_on_time((*begin_iter->value_node)(on_time).get(prev).get_vertex());
676 on_coord_origin=(begin_pos_at_on_time + end_pos_at_on_time)/2;
677 on_coord_sys[0]=(begin_pos_at_on_time - end_pos_at_on_time).norm();
678 on_coord_sys[1]=on_coord_sys[0].perp();
680 const Point end_pos_at_current_time(( *end_iter->value_node)(t).get(prev).get_vertex());
681 const Point begin_pos_at_current_time((*begin_iter->value_node)(t).get(prev).get_vertex());
682 curr_coord_origin=(begin_pos_at_current_time + end_pos_at_current_time)/2;
683 curr_coord_sys[0]=(begin_pos_at_current_time - end_pos_at_current_time).norm();
684 curr_coord_sys[1]=curr_coord_sys[0].perp();
686 // Invert (transpose) the last of these matrices, since we use it for transform back
687 swap(curr_coord_sys[0][1],curr_coord_sys[1][0]);
690 /* The code that was here before used just end_iter as the origin, rather than the mid-point */
692 // We know our location and tangent(s) when fully on and fully off
693 // Transform each of these into their corresponding coordinate system
694 Point trans_on_point, trans_off_point;
695 Vector trans_on_t1, trans_on_t2, trans_off_t1, trans_off_t2;
697 transform_coords(blp_here_on.get_vertex(), trans_on_point, on_coord_origin, on_coord_sys);
698 transform_coords(blp_here_off.get_vertex(), trans_off_point, off_coord_origin, off_coord_sys);
700 #define COORD_SYS_RADIAL_TAN_INTERP 1
702 #ifdef COORD_SYS_RADIAL_TAN_INTERP
703 transform_coords(blp_here_on.get_tangent1(), trans_on_t1, Point::zero(), on_coord_sys);
704 transform_coords(blp_here_off.get_tangent1(), trans_off_t1, Point::zero(), off_coord_sys);
706 if(blp_here_on.get_split_tangent_flag())
708 transform_coords(blp_here_on.get_tangent2(), trans_on_t2, Point::zero(), on_coord_sys);
709 transform_coords(blp_here_off.get_tangent2(), trans_off_t2, Point::zero(), off_coord_sys);
714 // Interpolate between the 'on' point and the 'off' point and untransform to get our point's location
716 untransform_coords(linear_interpolation(trans_off_point, trans_on_point, amount),
717 tmp, curr_coord_origin, curr_coord_sys);
718 blp_here_now.set_vertex(tmp);
721 #define INTERP_FUNCTION radial_interpolation
722 //#define INTERP_FUNCTION linear_interpolation
724 #ifdef COORD_SYS_RADIAL_TAN_INTERP
727 untransform_coords(INTERP_FUNCTION(trans_off_t1,trans_on_t1,amount), tmp, Point::zero(), curr_coord_sys);
728 blp_here_now.set_tangent1(tmp);
731 blp_here_now.set_tangent1(radial_interpolation(blp_here_off.get_tangent1(),blp_here_on.get_tangent1(),amount));
734 if (blp_here_on.get_split_tangent_flag())
736 blp_here_now.set_split_tangent_flag(true);
737 #ifdef COORD_SYS_RADIAL_TAN_INTERP
740 untransform_coords(INTERP_FUNCTION(trans_off_t2,trans_on_t2,amount), tmp, Point::zero(), curr_coord_sys);
741 blp_here_now.set_tangent2(tmp);
744 blp_here_now.set_tangent2(radial_interpolation(blp_here_off.get_tangent2(),blp_here_on.get_tangent2(),amount));
748 blp_here_now.set_split_tangent_flag(false);
751 blp_here_now.set_origin(blp_here_on.get_origin());
752 blp_here_now.set_width(linear_interpolation(blp_here_off.get_width(), blp_here_on.get_width(), amount));
754 // Handle the case where we are the first vertex
757 blp_here_now.set_tangent1(blp_here_now.get_tangent1()*prev_tangent_scalar);
759 first=prev=blp_here_now;
761 ret_list.push_back(blp_here_now);
765 ret_list.back().set_split_tangent_flag(true);
766 ret_list.back().set_tangent2(prev.get_tangent2()*prev_tangent_scalar);
767 ret_list.push_back(blp_here_now);
768 ret_list.back().set_split_tangent_flag(true);
769 //ret_list.back().set_tangent2(blp_here_now.get_tangent1());
770 ret_list.back().set_tangent1(blp_here_now.get_tangent1()*prev_tangent_scalar);
778 ret_list.back().set_split_tangent_flag(true);
779 ret_list.back().set_tangent2(prev.get_tangent2()*next_scale);
783 if(get_loop() && !first_flag)
797 synfig::warning(string("ValueNode_BLine::operator()():")+_("No entries in list"));
800 synfig::warning(string("ValueNode_BLine::operator()():")+_("No entries in ret_list"));
802 return ValueBase(ret_list,get_loop());
806 ValueNode_BLine::link_local_name(int i)const
808 assert(i>=0 && (unsigned)i<list.size());
809 return etl::strprintf(_("Vertex %03d"),i+1);
813 ValueNode_BLine::clone(const GUID& deriv_guid)const
815 { ValueNode* x(find_value_node(get_guid()^deriv_guid).get()); if(x)return x; }
817 ValueNode_BLine* ret=new ValueNode_BLine();
818 ret->set_guid(get_guid()^deriv_guid);
820 std::vector<ListEntry>::const_iterator iter;
822 for(iter=list.begin();iter!=list.end();++iter)
824 if(iter->value_node->is_exported())
828 ListEntry list_entry(*iter);
829 //list_entry.value_node=find_value_node(iter->value_node->get_guid()^deriv_guid).get();
830 //if(!list_entry.value_node)
831 list_entry.value_node=iter->value_node->clone(deriv_guid);
832 ret->add(list_entry);
833 //ret->list.back().value_node=iter->value_node.clone();
836 ret->set_loop(get_loop());
842 ValueNode_BLine::get_name()const
848 ValueNode_BLine::get_local_name()const
854 ValueNode_BLine::create_new()const
861 ValueNode_BLine::check_type(ValueBase::Type type)
863 return type==ValueBase::TYPE_LIST;