void copy_text_ptr(T* sym)
{
std::string name = to_expression_string(*sym->get_name());
sym->set_name( parse_expression(name) );
// FIXME - orientation doesn't appear to be initialized in constructor?
//std::string orientation = to_expression_string(*sym->get_orientation());
//sym->set_orientation( parse_expression(orientation) );
float text_size = sym->get_text_size();
position displace = sym->get_displacement();
vertical_alignment_e valign = sym->get_vertical_alignment();
horizontal_alignment_e halign = sym->get_horizontal_alignment();
justify_alignment_e jalign = sym->get_justify_alignment();
text_placements_ptr placements = text_placements_ptr(boost::make_shared<text_placements_dummy>());
sym->set_placement_options( placements );
sym->set_text_size(text_size);
sym->set_displacement(displace);
sym->set_vertical_alignment(valign);
sym->set_horizontal_alignment(halign);
sym->set_justify_alignment(jalign);
}
rule(const rule& rhs, bool deep_copy = false)
: name_(rhs.name_),
min_scale_(rhs.min_scale_),
max_scale_(rhs.max_scale_),
syms_(rhs.syms_),
filter_(rhs.filter_),
else_filter_(rhs.else_filter_),
also_filter_(rhs.also_filter_)
{
if (deep_copy) {
std::string expr = to_expression_string(*filter_);
filter_ = parse_expression(expr,"utf8");
symbolizers::const_iterator it = syms_.begin();
symbolizers::const_iterator end = syms_.end();
// FIXME - metawriter_ptr?
for(; it != end; ++it)
{
boost::apply_visitor(deepcopy_symbolizer(),*it);
}
}
}
std::string operator() (expression_ptr const& expr) const
{
if (expr) return to_expression_string(*expr);
return "";
}
void operator() (expression_ptr const& expr) const
{
if (expr) node_.put("<xmlattr>." + name_, to_expression_string(*expr));
}
void copy_height_ptr(T & sym) const
{
std::string height_expr = to_expression_string(*sym.height());
sym.set_height(parse_expression(height_expr,"utf8"));
}
void text_symbolizer_properties::to_xml(boost::property_tree::ptree &node,
bool explicit_defaults,
text_symbolizer_properties const& dfl) const
{
if (orientation)
{
std::string const& orientationstr = to_expression_string(*orientation);
if (!dfl.orientation || orientationstr != to_expression_string(*(dfl.orientation)) || explicit_defaults) {
set_attr(node, "orientation", orientationstr);
}
}
if (displacement.x != dfl.displacement.x || explicit_defaults)
{
set_attr(node, "dx", displacement.x);
}
if (displacement.y != dfl.displacement.y || explicit_defaults)
{
set_attr(node, "dy", displacement.y);
}
if (label_placement != dfl.label_placement || explicit_defaults)
{
set_attr(node, "placement", label_placement);
}
if (valign != dfl.valign || explicit_defaults)
{
set_attr(node, "vertical-alignment", valign);
}
if (text_ratio != dfl.text_ratio || explicit_defaults)
{
set_attr(node, "text-ratio", text_ratio);
}
if (wrap_width != dfl.wrap_width || explicit_defaults)
{
set_attr(node, "wrap-width", wrap_width);
}
if (wrap_before != dfl.wrap_before || explicit_defaults)
{
set_attr(node, "wrap-before", wrap_before);
}
if (label_position_tolerance != dfl.label_position_tolerance || explicit_defaults)
{
set_attr(node, "label-position-tolerance", label_position_tolerance);
}
if (label_spacing != dfl.label_spacing || explicit_defaults)
{
set_attr(node, "spacing", label_spacing);
}
if (minimum_distance != dfl.minimum_distance || explicit_defaults)
{
set_attr(node, "minimum-distance", minimum_distance);
}
if (minimum_padding != dfl.minimum_padding || explicit_defaults)
{
set_attr(node, "minimum-padding", minimum_padding);
}
if (minimum_path_length != dfl.minimum_path_length || explicit_defaults)
{
set_attr(node, "minimum-path-length", minimum_path_length);
}
if (allow_overlap != dfl.allow_overlap || explicit_defaults)
{
set_attr(node, "allow-overlap", allow_overlap);
}
if (avoid_edges != dfl.avoid_edges || explicit_defaults)
{
set_attr(node, "avoid-edges", avoid_edges);
}
if (largest_bbox_only != dfl.largest_bbox_only|| explicit_defaults)
{
set_attr(node, "largest-bbox_only", largest_bbox_only);
}
if (max_char_angle_delta != dfl.max_char_angle_delta || explicit_defaults)
{
set_attr(node, "max-char-angle-delta", max_char_angle_delta);
}
if (halign != dfl.halign || explicit_defaults)
{
set_attr(node, "horizontal-alignment", halign);
}
if (jalign != dfl.jalign || explicit_defaults)
{
set_attr(node, "justify-alignment", jalign);
}
if (valign != dfl.valign || explicit_defaults)
{
set_attr(node, "vertical-alignment", valign);
}
if (rotate_displacement != dfl.rotate_displacement || explicit_defaults)
{
set_attr(node, "rotate-displacement", rotate_displacement);
}
if (upright != dfl.upright || explicit_defaults)
{
set_attr(node, "upright", upright);
}
format->to_xml(node, explicit_defaults, *(dfl.format));
if (tree_) tree_->to_xml(node);
}
