added PenJoin, PenCap and PathSym into our protobuf format, into Pen::Info structure and wrote deserialization code.

6 files changed, 2474 insertions, 401 deletions

diff --git a/indexer/drawing_rules.cpp b/indexer/drawing_rules.cpp
index 7c7050c340..b381f5ca12 100644
--- a/indexer/drawing_rules.cpp
+++ b/indexer/drawing_rules.cpp
@@ -184,6 +184,12 @@ namespace
         m_line.set_width(r.width());
         if (r.has_dashdot())
           *(m_line.mutable_dashdot()) = r.dashdot();
+        if (r.has_pathsym())
+          *(m_line.mutable_pathsym()) = r.pathsym();
+        if (r.has_join())
+          m_line.set_join(r.join());
+        if (r.has_cap())
+          m_line.set_cap(r.cap());
       }
 
       virtual LineDefProto const * GetLine() const { return &m_line; }
diff --git a/indexer/drules_struct.pb.cc b/indexer/drules_struct.pb.cc
index 268c04ecc2..3d68a88ccd 100644
--- a/indexer/drules_struct.pb.cc
+++ b/indexer/drules_struct.pb.cc
@@ -18,6 +18,9 @@ namespace {
 const ::google::protobuf::Descriptor* DashDotProto_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   DashDotProto_reflection_ = NULL;
+const ::google::protobuf::Descriptor* PathSymProto_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  PathSymProto_reflection_ = NULL;
 const ::google::protobuf::Descriptor* LineRuleProto_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   LineRuleProto_reflection_ = NULL;
@@ -51,6 +54,8 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* ContainerProto_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   ContainerProto_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* LineJoin_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* LineCap_descriptor_ = NULL;
 
 }  // namespace
 
@@ -77,12 +82,32 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(DashDotProto));
-  LineRuleProto_descriptor_ = file->message_type(1);
-  static const int LineRuleProto_offsets_[4] = {
+  PathSymProto_descriptor_ = file->message_type(1);
+  static const int PathSymProto_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathSymProto, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathSymProto, step_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathSymProto, offset_),
+  };
+  PathSymProto_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      PathSymProto_descriptor_,
+      PathSymProto::default_instance_,
+      PathSymProto_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathSymProto, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathSymProto, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(PathSymProto));
+  LineRuleProto_descriptor_ = file->message_type(2);
+  static const int LineRuleProto_offsets_[7] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, width_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, color_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, dashdot_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, priority_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, pathsym_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, join_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, cap_),
   };
   LineRuleProto_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -95,11 +120,14 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(LineRuleProto));
-  LineDefProto_descriptor_ = file->message_type(2);
-  static const int LineDefProto_offsets_[3] = {
+  LineDefProto_descriptor_ = file->message_type(3);
+  static const int LineDefProto_offsets_[6] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, width_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, color_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, dashdot_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, pathsym_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, join_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, cap_),
   };
   LineDefProto_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -112,7 +140,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(LineDefProto));
-  AreaRuleProto_descriptor_ = file->message_type(3);
+  AreaRuleProto_descriptor_ = file->message_type(4);
   static const int AreaRuleProto_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AreaRuleProto, color_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AreaRuleProto, border_),
@@ -129,7 +157,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(AreaRuleProto));
-  SymbolRuleProto_descriptor_ = file->message_type(4);
+  SymbolRuleProto_descriptor_ = file->message_type(5);
   static const int SymbolRuleProto_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SymbolRuleProto, name_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SymbolRuleProto, apply_for_type_),
@@ -146,7 +174,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(SymbolRuleProto));
-  CaptionDefProto_descriptor_ = file->message_type(5);
+  CaptionDefProto_descriptor_ = file->message_type(6);
   static const int CaptionDefProto_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, height_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, color_),
@@ -163,7 +191,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(CaptionDefProto));
-  CaptionRuleProto_descriptor_ = file->message_type(6);
+  CaptionRuleProto_descriptor_ = file->message_type(7);
   static const int CaptionRuleProto_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionRuleProto, primary_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionRuleProto, secondary_),
@@ -180,7 +208,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(CaptionRuleProto));
-  CircleRuleProto_descriptor_ = file->message_type(7);
+  CircleRuleProto_descriptor_ = file->message_type(8);
   static const int CircleRuleProto_offsets_[4] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CircleRuleProto, radius_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CircleRuleProto, color_),
@@ -198,7 +226,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(CircleRuleProto));
-  PathTextRuleProto_descriptor_ = file->message_type(8);
+  PathTextRuleProto_descriptor_ = file->message_type(9);
   static const int PathTextRuleProto_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathTextRuleProto, primary_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathTextRuleProto, secondary_),
@@ -215,7 +243,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(PathTextRuleProto));
-  DrawElementProto_descriptor_ = file->message_type(9);
+  DrawElementProto_descriptor_ = file->message_type(10);
   static const int DrawElementProto_offsets_[7] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrawElementProto, scale_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrawElementProto, lines_),
@@ -236,7 +264,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(DrawElementProto));
-  ClassifElementProto_descriptor_ = file->message_type(10);
+  ClassifElementProto_descriptor_ = file->message_type(11);
   static const int ClassifElementProto_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClassifElementProto, name_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClassifElementProto, element_),
@@ -252,7 +280,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(ClassifElementProto));
-  ContainerProto_descriptor_ = file->message_type(11);
+  ContainerProto_descriptor_ = file->message_type(12);
   static const int ContainerProto_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContainerProto, cont_),
   };
@@ -267,6 +295,8 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(ContainerProto));
+  LineJoin_descriptor_ = file->enum_type(0);
+  LineCap_descriptor_ = file->enum_type(1);
 }
 
 namespace {
@@ -282,6 +312,8 @@ void protobuf_RegisterTypes(const ::std::string&) {
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     DashDotProto_descriptor_, &DashDotProto::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    PathSymProto_descriptor_, &PathSymProto::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     LineRuleProto_descriptor_, &LineRuleProto::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     LineDefProto_descriptor_, &LineDefProto::default_instance());
@@ -310,6 +342,8 @@ void protobuf_RegisterTypes(const ::std::string&) {
 void protobuf_ShutdownFile_drules_5fstruct_2eproto() {
   delete DashDotProto::default_instance_;
   delete DashDotProto_reflection_;
+  delete PathSymProto::default_instance_;
+  delete PathSymProto_reflection_;
   delete LineRuleProto::default_instance_;
   delete LineRuleProto_reflection_;
   delete LineDefProto::default_instance_;
@@ -342,37 +376,46 @@ void protobuf_AddDesc_drules_5fstruct_2eproto() {
 
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
     "\n\023drules_struct.proto\"*\n\014DashDotProto\022\n\n"
-    "\002dd\030\001 \003(\001\022\016\n\006offset\030\002 \001(\001\"_\n\rLineRulePro"
-    "to\022\r\n\005width\030\001 \002(\001\022\r\n\005color\030\002 \002(\r\022\036\n\007dash"
-    "dot\030\003 \001(\0132\r.DashDotProto\022\020\n\010priority\030\004 \002"
-    "(\005\"L\n\014LineDefProto\022\r\n\005width\030\001 \002(\001\022\r\n\005col"
-    "or\030\002 \002(\r\022\036\n\007dashdot\030\003 \001(\0132\r.DashDotProto"
-    "\"O\n\rAreaRuleProto\022\r\n\005color\030\001 \002(\r\022\035\n\006bord"
-    "er\030\002 \001(\0132\r.LineDefProto\022\020\n\010priority\030\003 \002("
-    "\005\"I\n\017SymbolRuleProto\022\014\n\004name\030\001 \002(\t\022\026\n\016ap"
-    "ply_for_type\030\002 \001(\005\022\020\n\010priority\030\003 \002(\005\"F\n\017"
-    "CaptionDefProto\022\016\n\006height\030\001 \002(\005\022\r\n\005color"
-    "\030\002 \002(\r\022\024\n\014stroke_color\030\003 \001(\r\"l\n\020CaptionR"
-    "uleProto\022!\n\007primary\030\001 \002(\0132\020.CaptionDefPr"
-    "oto\022#\n\tsecondary\030\002 \001(\0132\020.CaptionDefProto"
-    "\022\020\n\010priority\030\003 \002(\005\"a\n\017CircleRuleProto\022\016\n"
-    "\006radius\030\001 \002(\001\022\r\n\005color\030\002 \002(\r\022\035\n\006border\030\003"
-    " \001(\0132\r.LineDefProto\022\020\n\010priority\030\004 \002(\005\"m\n"
-    "\021PathTextRuleProto\022!\n\007primary\030\001 \002(\0132\020.Ca"
-    "ptionDefProto\022#\n\tsecondary\030\002 \001(\0132\020.Capti"
-    "onDefProto\022\020\n\010priority\030\003 \002(\005\"\355\001\n\020DrawEle"
-    "mentProto\022\r\n\005scale\030\001 \002(\005\022\035\n\005lines\030\002 \003(\0132"
-    "\016.LineRuleProto\022\034\n\004area\030\003 \001(\0132\016.AreaRule"
-    "Proto\022 \n\006symbol\030\004 \001(\0132\020.SymbolRuleProto\022"
-    "\"\n\007caption\030\005 \001(\0132\021.CaptionRuleProto\022 \n\006c"
-    "ircle\030\006 \001(\0132\020.CircleRuleProto\022%\n\tpath_te"
-    "xt\030\007 \001(\0132\022.PathTextRuleProto\"G\n\023ClassifE"
-    "lementProto\022\014\n\004name\030\001 \002(\t\022\"\n\007element\030\002 \003"
-    "(\0132\021.DrawElementProto\"4\n\016ContainerProto\022"
-    "\"\n\004cont\030\001 \003(\0132\024.ClassifElementProto", 1155);
+    "\002dd\030\001 \003(\001\022\016\n\006offset\030\002 \001(\001\":\n\014PathSymProt"
+    "o\022\014\n\004name\030\001 \002(\t\022\014\n\004step\030\002 \002(\001\022\016\n\006offset\030"
+    "\003 \001(\001\"\257\001\n\rLineRuleProto\022\r\n\005width\030\001 \002(\001\022\r"
+    "\n\005color\030\002 \002(\r\022\036\n\007dashdot\030\003 \001(\0132\r.DashDot"
+    "Proto\022\020\n\010priority\030\004 \002(\005\022\036\n\007pathsym\030\005 \001(\013"
+    "2\r.PathSymProto\022\027\n\004join\030\006 \001(\0162\t.LineJoin"
+    "\022\025\n\003cap\030\007 \001(\0162\010.LineCap\"\234\001\n\014LineDefProto"
+    "\022\r\n\005width\030\001 \002(\001\022\r\n\005color\030\002 \002(\r\022\036\n\007dashdo"
+    "t\030\003 \001(\0132\r.DashDotProto\022\036\n\007pathsym\030\004 \001(\0132"
+    "\r.PathSymProto\022\027\n\004join\030\006 \001(\0162\t.LineJoin\022"
+    "\025\n\003cap\030\007 \001(\0162\010.LineCap\"O\n\rAreaRuleProto\022"
+    "\r\n\005color\030\001 \002(\r\022\035\n\006border\030\002 \001(\0132\r.LineDef"
+    "Proto\022\020\n\010priority\030\003 \002(\005\"I\n\017SymbolRulePro"
+    "to\022\014\n\004name\030\001 \002(\t\022\026\n\016apply_for_type\030\002 \001(\005"
+    "\022\020\n\010priority\030\003 \002(\005\"F\n\017CaptionDefProto\022\016\n"
+    "\006height\030\001 \002(\005\022\r\n\005color\030\002 \002(\r\022\024\n\014stroke_c"
+    "olor\030\003 \001(\r\"l\n\020CaptionRuleProto\022!\n\007primar"
+    "y\030\001 \002(\0132\020.CaptionDefProto\022#\n\tsecondary\030\002"
+    " \001(\0132\020.CaptionDefProto\022\020\n\010priority\030\003 \002(\005"
+    "\"a\n\017CircleRuleProto\022\016\n\006radius\030\001 \002(\001\022\r\n\005c"
+    "olor\030\002 \002(\r\022\035\n\006border\030\003 \001(\0132\r.LineDefProt"
+    "o\022\020\n\010priority\030\004 \002(\005\"m\n\021PathTextRuleProto"
+    "\022!\n\007primary\030\001 \002(\0132\020.CaptionDefProto\022#\n\ts"
+    "econdary\030\002 \001(\0132\020.CaptionDefProto\022\020\n\010prio"
+    "rity\030\003 \002(\005\"\355\001\n\020DrawElementProto\022\r\n\005scale"
+    "\030\001 \002(\005\022\035\n\005lines\030\002 \003(\0132\016.LineRuleProto\022\034\n"
+    "\004area\030\003 \001(\0132\016.AreaRuleProto\022 \n\006symbol\030\004 "
+    "\001(\0132\020.SymbolRuleProto\022\"\n\007caption\030\005 \001(\0132\021"
+    ".CaptionRuleProto\022 \n\006circle\030\006 \001(\0132\020.Circ"
+    "leRuleProto\022%\n\tpath_text\030\007 \001(\0132\022.PathTex"
+    "tRuleProto\"G\n\023ClassifElementProto\022\014\n\004nam"
+    "e\030\001 \002(\t\022\"\n\007element\030\002 \003(\0132\021.DrawElementPr"
+    "oto\"4\n\016ContainerProto\022\"\n\004cont\030\001 \003(\0132\024.Cl"
+    "assifElementProto*(\n\010LineJoin\022\r\n\tROUNDJO"
+    "IN\020\000\022\r\n\tBEVELJOIN\020\001*$\n\007LineCap\022\014\n\010ROUNDC"
+    "AP\020\000\022\013\n\007BUTTCAP\020\001", 1457);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "drules_struct.proto", &protobuf_RegisterTypes);
   DashDotProto::default_instance_ = new DashDotProto();
+  PathSymProto::default_instance_ = new PathSymProto();
   LineRuleProto::default_instance_ = new LineRuleProto();
   LineDefProto::default_instance_ = new LineDefProto();
   AreaRuleProto::default_instance_ = new AreaRuleProto();
@@ -385,6 +428,7 @@ void protobuf_AddDesc_drules_5fstruct_2eproto() {
   ClassifElementProto::default_instance_ = new ClassifElementProto();
   ContainerProto::default_instance_ = new ContainerProto();
   DashDotProto::default_instance_->InitAsDefaultInstance();
+  PathSymProto::default_instance_->InitAsDefaultInstance();
   LineRuleProto::default_instance_->InitAsDefaultInstance();
   LineDefProto::default_instance_->InitAsDefaultInstance();
   AreaRuleProto::default_instance_->InitAsDefaultInstance();
@@ -406,6 +450,34 @@ struct StaticDescriptorInitializer_drules_5fstruct_2eproto {
   }
 } static_descriptor_initializer_drules_5fstruct_2eproto_;
 
+const ::google::protobuf::EnumDescriptor* LineJoin_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return LineJoin_descriptor_;
+}
+bool LineJoin_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::google::protobuf::EnumDescriptor* LineCap_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return LineCap_descriptor_;
+}
+bool LineCap_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
 
 // ===================================================================
 
@@ -661,10 +733,314 @@ void DashDotProto::Swap(DashDotProto* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
+const int PathSymProto::kNameFieldNumber;
+const int PathSymProto::kStepFieldNumber;
+const int PathSymProto::kOffsetFieldNumber;
+#endif  // !_MSC_VER
+
+PathSymProto::PathSymProto()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+}
+
+void PathSymProto::InitAsDefaultInstance() {
+}
+
+PathSymProto::PathSymProto(const PathSymProto& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void PathSymProto::SharedCtor() {
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  step_ = 0;
+  offset_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PathSymProto::~PathSymProto() {
+  SharedDtor();
+}
+
+void PathSymProto::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::kEmptyString) {
+    delete name_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void PathSymProto::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* PathSymProto::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PathSymProto_descriptor_;
+}
+
+const PathSymProto& PathSymProto::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
+}
+
+PathSymProto* PathSymProto::default_instance_ = NULL;
+
+PathSymProto* PathSymProto::New() const {
+  return new PathSymProto;
+}
+
+void PathSymProto::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::kEmptyString) {
+        name_->clear();
+      }
+    }
+    step_ = 0;
+    offset_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool PathSymProto::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required string name = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(17)) goto parse_step;
+        break;
+      }
+      
+      // required double step = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+         parse_step:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &step_)));
+          set_has_step();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(25)) goto parse_offset;
+        break;
+      }
+      
+      // optional double offset = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+         parse_offset:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &offset_)));
+          set_has_offset();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void PathSymProto::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      1, this->name(), output);
+  }
+  
+  // required double step = 2;
+  if (has_step()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->step(), output);
+  }
+  
+  // optional double offset = 3;
+  if (has_offset()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(3, this->offset(), output);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* PathSymProto::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->name(), target);
+  }
+  
+  // required double step = 2;
+  if (has_step()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->step(), target);
+  }
+  
+  // optional double offset = 3;
+  if (has_offset()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(3, this->offset(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
+}
+
+int PathSymProto::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required string name = 1;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+    
+    // required double step = 2;
+    if (has_step()) {
+      total_size += 1 + 8;
+    }
+    
+    // optional double offset = 3;
+    if (has_offset()) {
+      total_size += 1 + 8;
+    }
+    
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void PathSymProto::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const PathSymProto* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const PathSymProto*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void PathSymProto::MergeFrom(const PathSymProto& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_step()) {
+      set_step(from.step());
+    }
+    if (from.has_offset()) {
+      set_offset(from.offset());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PathSymProto::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void PathSymProto::CopyFrom(const PathSymProto& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PathSymProto::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+  
+  return true;
+}
+
+void PathSymProto::Swap(PathSymProto* other) {
+  if (other != this) {
+    std::swap(name_, other->name_);
+    std::swap(step_, other->step_);
+    std::swap(offset_, other->offset_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata PathSymProto::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = PathSymProto_descriptor_;
+  metadata.reflection = PathSymProto_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
 const int LineRuleProto::kWidthFieldNumber;
 const int LineRuleProto::kColorFieldNumber;
 const int LineRuleProto::kDashdotFieldNumber;
 const int LineRuleProto::kPriorityFieldNumber;
+const int LineRuleProto::kPathsymFieldNumber;
+const int LineRuleProto::kJoinFieldNumber;
+const int LineRuleProto::kCapFieldNumber;
 #endif  // !_MSC_VER
 
 LineRuleProto::LineRuleProto()
@@ -674,6 +1050,7 @@ LineRuleProto::LineRuleProto()
 
 void LineRuleProto::InitAsDefaultInstance() {
   dashdot_ = const_cast< ::DashDotProto*>(&::DashDotProto::default_instance());
+  pathsym_ = const_cast< ::PathSymProto*>(&::PathSymProto::default_instance());
 }
 
 LineRuleProto::LineRuleProto(const LineRuleProto& from)
@@ -688,6 +1065,9 @@ void LineRuleProto::SharedCtor() {
   color_ = 0u;
   dashdot_ = NULL;
   priority_ = 0;
+  pathsym_ = NULL;
+  join_ = 0;
+  cap_ = 0;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -698,6 +1078,7 @@ LineRuleProto::~LineRuleProto() {
 void LineRuleProto::SharedDtor() {
   if (this != default_instance_) {
     delete dashdot_;
+    delete pathsym_;
   }
 }
 
@@ -729,6 +1110,11 @@ void LineRuleProto::Clear() {
       if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear();
     }
     priority_ = 0;
+    if (has_pathsym()) {
+      if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear();
+    }
+    join_ = 0;
+    cap_ = 0;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -797,6 +1183,62 @@ bool LineRuleProto::MergePartialFromCodedStream(
         } else {
           goto handle_uninterpreted;
         }
+        if (input->ExpectTag(42)) goto parse_pathsym;
+        break;
+      }
+      
+      // optional .PathSymProto pathsym = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_pathsym:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_pathsym()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(48)) goto parse_join;
+        break;
+      }
+      
+      // optional .LineJoin join = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_join:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (LineJoin_IsValid(value)) {
+            set_join(static_cast< LineJoin >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(6, value);
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(56)) goto parse_cap;
+        break;
+      }
+      
+      // optional .LineCap cap = 7;
+      case 7: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_cap:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (LineCap_IsValid(value)) {
+            set_cap(static_cast< LineCap >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(7, value);
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
         if (input->ExpectAtEnd()) return true;
         break;
       }
@@ -840,6 +1282,24 @@ void LineRuleProto::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output);
   }
   
+  // optional .PathSymProto pathsym = 5;
+  if (has_pathsym()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->pathsym(), output);
+  }
+  
+  // optional .LineJoin join = 6;
+  if (has_join()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      6, this->join(), output);
+  }
+  
+  // optional .LineCap cap = 7;
+  if (has_cap()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      7, this->cap(), output);
+  }
+  
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -870,6 +1330,25 @@ void LineRuleProto::SerializeWithCachedSizes(
     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->priority(), target);
   }
   
+  // optional .PathSymProto pathsym = 5;
+  if (has_pathsym()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->pathsym(), target);
+  }
+  
+  // optional .LineJoin join = 6;
+  if (has_join()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      6, this->join(), target);
+  }
+  
+  // optional .LineCap cap = 7;
+  if (has_cap()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      7, this->cap(), target);
+  }
+  
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -907,6 +1386,25 @@ int LineRuleProto::ByteSize() const {
           this->priority());
     }
     
+    // optional .PathSymProto pathsym = 5;
+    if (has_pathsym()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->pathsym());
+    }
+    
+    // optional .LineJoin join = 6;
+    if (has_join()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->join());
+    }
+    
+    // optional .LineCap cap = 7;
+    if (has_cap()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->cap());
+    }
+    
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -946,6 +1444,15 @@ void LineRuleProto::MergeFrom(const LineRuleProto& from) {
     if (from.has_priority()) {
       set_priority(from.priority());
     }
+    if (from.has_pathsym()) {
+      mutable_pathsym()->::PathSymProto::MergeFrom(from.pathsym());
+    }
+    if (from.has_join()) {
+      set_join(from.join());
+    }
+    if (from.has_cap()) {
+      set_cap(from.cap());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -965,6 +1472,9 @@ void LineRuleProto::CopyFrom(const LineRuleProto& from) {
 bool LineRuleProto::IsInitialized() const {
   if ((_has_bits_[0] & 0x0000000b) != 0x0000000b) return false;
   
+  if (has_pathsym()) {
+    if (!this->pathsym().IsInitialized()) return false;
+  }
   return true;
 }
 
@@ -974,6 +1484,9 @@ void LineRuleProto::Swap(LineRuleProto* other) {
     std::swap(color_, other->color_);
     std::swap(dashdot_, other->dashdot_);
     std::swap(priority_, other->priority_);
+    std::swap(pathsym_, other->pathsym_);
+    std::swap(join_, other->join_);
+    std::swap(cap_, other->cap_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -995,6 +1508,9 @@ void LineRuleProto::Swap(LineRuleProto* other) {
 const int LineDefProto::kWidthFieldNumber;
 const int LineDefProto::kColorFieldNumber;
 const int LineDefProto::kDashdotFieldNumber;
+const int LineDefProto::kPathsymFieldNumber;
+const int LineDefProto::kJoinFieldNumber;
+const int LineDefProto::kCapFieldNumber;
 #endif  // !_MSC_VER
 
 LineDefProto::LineDefProto()
@@ -1004,6 +1520,7 @@ LineDefProto::LineDefProto()
 
 void LineDefProto::InitAsDefaultInstance() {
   dashdot_ = const_cast< ::DashDotProto*>(&::DashDotProto::default_instance());
+  pathsym_ = const_cast< ::PathSymProto*>(&::PathSymProto::default_instance());
 }
 
 LineDefProto::LineDefProto(const LineDefProto& from)
@@ -1017,6 +1534,9 @@ void LineDefProto::SharedCtor() {
   width_ = 0;
   color_ = 0u;
   dashdot_ = NULL;
+  pathsym_ = NULL;
+  join_ = 0;
+  cap_ = 0;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -1027,6 +1547,7 @@ LineDefProto::~LineDefProto() {
 void LineDefProto::SharedDtor() {
   if (this != default_instance_) {
     delete dashdot_;
+    delete pathsym_;
   }
 }
 
@@ -1057,6 +1578,11 @@ void LineDefProto::Clear() {
     if (has_dashdot()) {
       if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear();
     }
+    if (has_pathsym()) {
+      if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear();
+    }
+    join_ = 0;
+    cap_ = 0;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -1109,6 +1635,62 @@ bool LineDefProto::MergePartialFromCodedStream(
         } else {
           goto handle_uninterpreted;
         }
+        if (input->ExpectTag(34)) goto parse_pathsym;
+        break;
+      }
+      
+      // optional .PathSymProto pathsym = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_pathsym:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_pathsym()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(48)) goto parse_join;
+        break;
+      }
+      
+      // optional .LineJoin join = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_join:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (LineJoin_IsValid(value)) {
+            set_join(static_cast< LineJoin >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(6, value);
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(56)) goto parse_cap;
+        break;
+      }
+      
+      // optional .LineCap cap = 7;
+      case 7: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_cap:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (LineCap_IsValid(value)) {
+            set_cap(static_cast< LineCap >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(7, value);
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
         if (input->ExpectAtEnd()) return true;
         break;
       }
@@ -1147,6 +1729,24 @@ void LineDefProto::SerializeWithCachedSizes(
       3, this->dashdot(), output);
   }
   
+  // optional .PathSymProto pathsym = 4;
+  if (has_pathsym()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->pathsym(), output);
+  }
+  
+  // optional .LineJoin join = 6;
+  if (has_join()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      6, this->join(), output);
+  }
+  
+  // optional .LineCap cap = 7;
+  if (has_cap()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      7, this->cap(), output);
+  }
+  
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -1172,6 +1772,25 @@ void LineDefProto::SerializeWithCachedSizes(
         3, this->dashdot(), target);
   }
   
+  // optional .PathSymProto pathsym = 4;
+  if (has_pathsym()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->pathsym(), target);
+  }
+  
+  // optional .LineJoin join = 6;
+  if (has_join()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      6, this->join(), target);
+  }
+  
+  // optional .LineCap cap = 7;
+  if (has_cap()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      7, this->cap(), target);
+  }
+  
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -1202,6 +1821,25 @@ int LineDefProto::ByteSize() const {
           this->dashdot());
     }
     
+    // optional .PathSymProto pathsym = 4;
+    if (has_pathsym()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->pathsym());
+    }
+    
+    // optional .LineJoin join = 6;
+    if (has_join()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->join());
+    }
+    
+    // optional .LineCap cap = 7;
+    if (has_cap()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->cap());
+    }
+    
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -1238,6 +1876,15 @@ void LineDefProto::MergeFrom(const LineDefProto& from) {
     if (from.has_dashdot()) {
       mutable_dashdot()->::DashDotProto::MergeFrom(from.dashdot());
     }
+    if (from.has_pathsym()) {
+      mutable_pathsym()->::PathSymProto::MergeFrom(from.pathsym());
+    }
+    if (from.has_join()) {
+      set_join(from.join());
+    }
+    if (from.has_cap()) {
+      set_cap(from.cap());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -1257,6 +1904,9 @@ void LineDefProto::CopyFrom(const LineDefProto& from) {
 bool LineDefProto::IsInitialized() const {
   if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
   
+  if (has_pathsym()) {
+    if (!this->pathsym().IsInitialized()) return false;
+  }
   return true;
 }
 
@@ -1265,6 +1915,9 @@ void LineDefProto::Swap(LineDefProto* other) {
     std::swap(width_, other->width_);
     std::swap(color_, other->color_);
     std::swap(dashdot_, other->dashdot_);
+    std::swap(pathsym_, other->pathsym_);
+    std::swap(join_, other->join_);
+    std::swap(cap_, other->cap_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
diff --git a/indexer/drules_struct.pb.h b/indexer/drules_struct.pb.h
index 9d3b27ba46..4fed524db7 100644
--- a/indexer/drules_struct.pb.h
+++ b/indexer/drules_struct.pb.h
@@ -31,6 +31,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto();
 void protobuf_ShutdownFile_drules_5fstruct_2eproto();
 
 class DashDotProto;
+class PathSymProto;
 class LineRuleProto;
 class LineDefProto;
 class AreaRuleProto;
@@ -43,6 +44,44 @@ class DrawElementProto;
 class ClassifElementProto;
 class ContainerProto;
 
+enum LineJoin {
+  ROUNDJOIN = 0,
+  BEVELJOIN = 1
+};
+bool LineJoin_IsValid(int value);
+const LineJoin LineJoin_MIN = ROUNDJOIN;
+const LineJoin LineJoin_MAX = BEVELJOIN;
+const int LineJoin_ARRAYSIZE = LineJoin_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* LineJoin_descriptor();
+inline const ::std::string& LineJoin_Name(LineJoin value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    LineJoin_descriptor(), value);
+}
+inline bool LineJoin_Parse(
+    const ::std::string& name, LineJoin* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<LineJoin>(
+    LineJoin_descriptor(), name, value);
+}
+enum LineCap {
+  ROUNDCAP = 0,
+  BUTTCAP = 1
+};
+bool LineCap_IsValid(int value);
+const LineCap LineCap_MIN = ROUNDCAP;
+const LineCap LineCap_MAX = BUTTCAP;
+const int LineCap_ARRAYSIZE = LineCap_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* LineCap_descriptor();
+inline const ::std::string& LineCap_Name(LineCap value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    LineCap_descriptor(), value);
+}
+inline bool LineCap_Parse(
+    const ::std::string& name, LineCap* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<LineCap>(
+    LineCap_descriptor(), name, value);
+}
 // ===================================================================
 
 class DashDotProto : public ::google::protobuf::Message {
@@ -140,6 +179,112 @@ class DashDotProto : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
+class PathSymProto : public ::google::protobuf::Message {
+ public:
+  PathSymProto();
+  virtual ~PathSymProto();
+  
+  PathSymProto(const PathSymProto& from);
+  
+  inline PathSymProto& operator=(const PathSymProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const PathSymProto& default_instance();
+  
+  void Swap(PathSymProto* other);
+  
+  // implements Message ----------------------------------------------
+  
+  PathSymProto* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const PathSymProto& from);
+  void MergeFrom(const PathSymProto& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::google::protobuf::Metadata GetMetadata() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // required string name = 1;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 1;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  
+  // required double step = 2;
+  inline bool has_step() const;
+  inline void clear_step();
+  static const int kStepFieldNumber = 2;
+  inline double step() const;
+  inline void set_step(double value);
+  
+  // optional double offset = 3;
+  inline bool has_offset() const;
+  inline void clear_offset();
+  static const int kOffsetFieldNumber = 3;
+  inline double offset() const;
+  inline void set_offset(double value);
+  
+  // @@protoc_insertion_point(class_scope:PathSymProto)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_step();
+  inline void clear_has_step();
+  inline void set_has_offset();
+  inline void clear_has_offset();
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
+  ::std::string* name_;
+  double step_;
+  double offset_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
+  friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
+  friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
+  
+  void InitAsDefaultInstance();
+  static PathSymProto* default_instance_;
+};
+// -------------------------------------------------------------------
+
 class LineRuleProto : public ::google::protobuf::Message {
  public:
   LineRuleProto();
@@ -223,6 +368,28 @@ class LineRuleProto : public ::google::protobuf::Message {
   inline ::google::protobuf::int32 priority() const;
   inline void set_priority(::google::protobuf::int32 value);
   
+  // optional .PathSymProto pathsym = 5;
+  inline bool has_pathsym() const;
+  inline void clear_pathsym();
+  static const int kPathsymFieldNumber = 5;
+  inline const ::PathSymProto& pathsym() const;
+  inline ::PathSymProto* mutable_pathsym();
+  inline ::PathSymProto* release_pathsym();
+  
+  // optional .LineJoin join = 6;
+  inline bool has_join() const;
+  inline void clear_join();
+  static const int kJoinFieldNumber = 6;
+  inline LineJoin join() const;
+  inline void set_join(LineJoin value);
+  
+  // optional .LineCap cap = 7;
+  inline bool has_cap() const;
+  inline void clear_cap();
+  static const int kCapFieldNumber = 7;
+  inline LineCap cap() const;
+  inline void set_cap(LineCap value);
+  
   // @@protoc_insertion_point(class_scope:LineRuleProto)
  private:
   inline void set_has_width();
@@ -233,6 +400,12 @@ class LineRuleProto : public ::google::protobuf::Message {
   inline void clear_has_dashdot();
   inline void set_has_priority();
   inline void clear_has_priority();
+  inline void set_has_pathsym();
+  inline void clear_has_pathsym();
+  inline void set_has_join();
+  inline void clear_has_join();
+  inline void set_has_cap();
+  inline void clear_has_cap();
   
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
   
@@ -240,9 +413,12 @@ class LineRuleProto : public ::google::protobuf::Message {
   ::DashDotProto* dashdot_;
   ::google::protobuf::uint32 color_;
   ::google::protobuf::int32 priority_;
+  ::PathSymProto* pathsym_;
+  int join_;
+  int cap_;
   
   mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
+  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
   
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
@@ -329,6 +505,28 @@ class LineDefProto : public ::google::protobuf::Message {
   inline ::DashDotProto* mutable_dashdot();
   inline ::DashDotProto* release_dashdot();
   
+  // optional .PathSymProto pathsym = 4;
+  inline bool has_pathsym() const;
+  inline void clear_pathsym();
+  static const int kPathsymFieldNumber = 4;
+  inline const ::PathSymProto& pathsym() const;
+  inline ::PathSymProto* mutable_pathsym();
+  inline ::PathSymProto* release_pathsym();
+  
+  // optional .LineJoin join = 6;
+  inline bool has_join() const;
+  inline void clear_join();
+  static const int kJoinFieldNumber = 6;
+  inline LineJoin join() const;
+  inline void set_join(LineJoin value);
+  
+  // optional .LineCap cap = 7;
+  inline bool has_cap() const;
+  inline void clear_cap();
+  static const int kCapFieldNumber = 7;
+  inline LineCap cap() const;
+  inline void set_cap(LineCap value);
+  
   // @@protoc_insertion_point(class_scope:LineDefProto)
  private:
   inline void set_has_width();
@@ -337,15 +535,24 @@ class LineDefProto : public ::google::protobuf::Message {
   inline void clear_has_color();
   inline void set_has_dashdot();
   inline void clear_has_dashdot();
+  inline void set_has_pathsym();
+  inline void clear_has_pathsym();
+  inline void set_has_join();
+  inline void clear_has_join();
+  inline void set_has_cap();
+  inline void clear_has_cap();
   
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
   
   double width_;
   ::DashDotProto* dashdot_;
   ::google::protobuf::uint32 color_;
+  int join_;
+  ::PathSymProto* pathsym_;
+  int cap_;
   
   mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
+  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
   
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
@@ -1376,6 +1583,112 @@ inline void DashDotProto::set_offset(double value) {
 
 // -------------------------------------------------------------------
 
+// PathSymProto
+
+// required string name = 1;
+inline bool PathSymProto::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void PathSymProto::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void PathSymProto::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void PathSymProto::clear_name() {
+  if (name_ != &::google::protobuf::internal::kEmptyString) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& PathSymProto::name() const {
+  return *name_;
+}
+inline void PathSymProto::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+}
+inline void PathSymProto::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+}
+inline void PathSymProto::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* PathSymProto::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  return name_;
+}
+inline ::std::string* PathSymProto::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+
+// required double step = 2;
+inline bool PathSymProto::has_step() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void PathSymProto::set_has_step() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void PathSymProto::clear_has_step() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void PathSymProto::clear_step() {
+  step_ = 0;
+  clear_has_step();
+}
+inline double PathSymProto::step() const {
+  return step_;
+}
+inline void PathSymProto::set_step(double value) {
+  set_has_step();
+  step_ = value;
+}
+
+// optional double offset = 3;
+inline bool PathSymProto::has_offset() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void PathSymProto::set_has_offset() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void PathSymProto::clear_has_offset() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void PathSymProto::clear_offset() {
+  offset_ = 0;
+  clear_has_offset();
+}
+inline double PathSymProto::offset() const {
+  return offset_;
+}
+inline void PathSymProto::set_offset(double value) {
+  set_has_offset();
+  offset_ = value;
+}
+
+// -------------------------------------------------------------------
+
 // LineRuleProto
 
 // required double width = 1;
@@ -1473,6 +1786,81 @@ inline void LineRuleProto::set_priority(::google::protobuf::int32 value) {
   priority_ = value;
 }
 
+// optional .PathSymProto pathsym = 5;
+inline bool LineRuleProto::has_pathsym() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void LineRuleProto::set_has_pathsym() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void LineRuleProto::clear_has_pathsym() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void LineRuleProto::clear_pathsym() {
+  if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear();
+  clear_has_pathsym();
+}
+inline const ::PathSymProto& LineRuleProto::pathsym() const {
+  return pathsym_ != NULL ? *pathsym_ : *default_instance_->pathsym_;
+}
+inline ::PathSymProto* LineRuleProto::mutable_pathsym() {
+  set_has_pathsym();
+  if (pathsym_ == NULL) pathsym_ = new ::PathSymProto;
+  return pathsym_;
+}
+inline ::PathSymProto* LineRuleProto::release_pathsym() {
+  clear_has_pathsym();
+  ::PathSymProto* temp = pathsym_;
+  pathsym_ = NULL;
+  return temp;
+}
+
+// optional .LineJoin join = 6;
+inline bool LineRuleProto::has_join() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void LineRuleProto::set_has_join() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void LineRuleProto::clear_has_join() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void LineRuleProto::clear_join() {
+  join_ = 0;
+  clear_has_join();
+}
+inline LineJoin LineRuleProto::join() const {
+  return static_cast< LineJoin >(join_);
+}
+inline void LineRuleProto::set_join(LineJoin value) {
+  GOOGLE_DCHECK(LineJoin_IsValid(value));
+  set_has_join();
+  join_ = value;
+}
+
+// optional .LineCap cap = 7;
+inline bool LineRuleProto::has_cap() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void LineRuleProto::set_has_cap() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void LineRuleProto::clear_has_cap() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void LineRuleProto::clear_cap() {
+  cap_ = 0;
+  clear_has_cap();
+}
+inline LineCap LineRuleProto::cap() const {
+  return static_cast< LineCap >(cap_);
+}
+inline void LineRuleProto::set_cap(LineCap value) {
+  GOOGLE_DCHECK(LineCap_IsValid(value));
+  set_has_cap();
+  cap_ = value;
+}
+
 // -------------------------------------------------------------------
 
 // LineDefProto
@@ -1550,6 +1938,81 @@ inline ::DashDotProto* LineDefProto::release_dashdot() {
   return temp;
 }
 
+// optional .PathSymProto pathsym = 4;
+inline bool LineDefProto::has_pathsym() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void LineDefProto::set_has_pathsym() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void LineDefProto::clear_has_pathsym() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void LineDefProto::clear_pathsym() {
+  if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear();
+  clear_has_pathsym();
+}
+inline const ::PathSymProto& LineDefProto::pathsym() const {
+  return pathsym_ != NULL ? *pathsym_ : *default_instance_->pathsym_;
+}
+inline ::PathSymProto* LineDefProto::mutable_pathsym() {
+  set_has_pathsym();
+  if (pathsym_ == NULL) pathsym_ = new ::PathSymProto;
+  return pathsym_;
+}
+inline ::PathSymProto* LineDefProto::release_pathsym() {
+  clear_has_pathsym();
+  ::PathSymProto* temp = pathsym_;
+  pathsym_ = NULL;
+  return temp;
+}
+
+// optional .LineJoin join = 6;
+inline bool LineDefProto::has_join() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void LineDefProto::set_has_join() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void LineDefProto::clear_has_join() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void LineDefProto::clear_join() {
+  join_ = 0;
+  clear_has_join();
+}
+inline LineJoin LineDefProto::join() const {
+  return static_cast< LineJoin >(join_);
+}
+inline void LineDefProto::set_join(LineJoin value) {
+  GOOGLE_DCHECK(LineJoin_IsValid(value));
+  set_has_join();
+  join_ = value;
+}
+
+// optional .LineCap cap = 7;
+inline bool LineDefProto::has_cap() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void LineDefProto::set_has_cap() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void LineDefProto::clear_has_cap() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void LineDefProto::clear_cap() {
+  cap_ = 0;
+  clear_has_cap();
+}
+inline LineCap LineDefProto::cap() const {
+  return static_cast< LineCap >(cap_);
+}
+inline void LineDefProto::set_cap(LineCap value) {
+  GOOGLE_DCHECK(LineCap_IsValid(value));
+  set_has_cap();
+  cap_ = value;
+}
+
 // -------------------------------------------------------------------
 
 // AreaRuleProto
@@ -2389,6 +2852,14 @@ ContainerProto::mutable_cont() {
 namespace google {
 namespace protobuf {
 
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< LineJoin>() {
+  return LineJoin_descriptor();
+}
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< LineCap>() {
+  return LineCap_descriptor();
+}
 
 }  // namespace google
 }  // namespace protobuf
diff --git a/indexer/drules_struct.proto b/indexer/drules_struct.proto
index 9edb326051..25a32fc767 100644
--- a/indexer/drules_struct.proto
+++ b/indexer/drules_struct.proto
@@ -6,12 +6,34 @@ message DashDotProto
   optional double offset = 2;
 }
 
+message PathSymProto
+{
+  required string name = 1;
+  required double step = 2;
+  optional double offset = 3;
+}
+
+enum LineJoin
+{
+  ROUNDJOIN = 0;
+  BEVELJOIN = 1;
+}
+
+enum LineCap
+{
+  ROUNDCAP = 0;
+  BUTTCAP = 1;
+}
+
 message LineRuleProto
 {
   required double width = 1;
   required uint32 color = 2;
   optional DashDotProto dashdot = 3;
   required int32 priority = 4;
+  optional PathSymProto pathsym = 5;
+  optional LineJoin join = 6;
+  optional LineCap cap = 7;
 }
 
 message LineDefProto
@@ -19,6 +41,9 @@ message LineDefProto
   required double width = 1;
   required uint32 color = 2;
   optional DashDotProto dashdot = 3;
+  optional PathSymProto pathsym = 4;
+  optional LineJoin join = 6;
+  optional LineCap cap = 7;
 }
 
 message AreaRuleProto
diff --git a/indexer/drules_struct_lite.pb.cc b/indexer/drules_struct_lite.pb.cc
index a8d8d91a31..aa31b5fcc4 100644
--- a/indexer/drules_struct_lite.pb.cc
+++ b/indexer/drules_struct_lite.pb.cc
@@ -12,6 +12,7 @@
 
 void protobuf_ShutdownFile_drules_5fstruct_2eproto() {
   delete DashDotProto::default_instance_;
+  delete PathSymProto::default_instance_;
   delete LineRuleProto::default_instance_;
   delete LineDefProto::default_instance_;
   delete AreaRuleProto::default_instance_;
@@ -32,6 +33,7 @@ void protobuf_AddDesc_drules_5fstruct_2eproto() {
   GOOGLE_PROTOBUF_VERIFY_VERSION;
 
   DashDotProto::default_instance_ = new DashDotProto();
+  PathSymProto::default_instance_ = new PathSymProto();
   LineRuleProto::default_instance_ = new LineRuleProto();
   LineDefProto::default_instance_ = new LineDefProto();
   AreaRuleProto::default_instance_ = new AreaRuleProto();
@@ -44,6 +46,7 @@ void protobuf_AddDesc_drules_5fstruct_2eproto() {
   ClassifElementProto::default_instance_ = new ClassifElementProto();
   ContainerProto::default_instance_ = new ContainerProto();
   DashDotProto::default_instance_->InitAsDefaultInstance();
+  PathSymProto::default_instance_->InitAsDefaultInstance();
   LineRuleProto::default_instance_->InitAsDefaultInstance();
   LineDefProto::default_instance_->InitAsDefaultInstance();
   AreaRuleProto::default_instance_->InitAsDefaultInstance();
@@ -65,6 +68,26 @@ struct StaticDescriptorInitializer_drules_5fstruct_2eproto {
   }
 } static_descriptor_initializer_drules_5fstruct_2eproto_;
 
+bool LineJoin_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool LineCap_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
 
 // ===================================================================
 
@@ -152,7 +175,7 @@ bool DashDotProto::MergePartialFromCodedStream(
         if (input->ExpectTag(17)) goto parse_offset;
         break;
       }
-
+      
       // optional double offset = 2;
       case 2: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -168,7 +191,7 @@ bool DashDotProto::MergePartialFromCodedStream(
         if (input->ExpectAtEnd()) return true;
         break;
       }
-
+      
       default: {
       handle_uninterpreted:
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -191,23 +214,23 @@ void DashDotProto::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteDouble(
       1, this->dd(i), output);
   }
-
+  
   // optional double offset = 2;
   if (has_offset()) {
     ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->offset(), output);
   }
-
+  
 }
 
 int DashDotProto::ByteSize() const {
   int total_size = 0;
-
+  
   if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
     // optional double offset = 2;
     if (has_offset()) {
       total_size += 1 + 8;
     }
-
+    
   }
   // repeated double dd = 1;
   {
@@ -215,7 +238,7 @@ int DashDotProto::ByteSize() const {
     data_size = 8 * this->dd_size();
     total_size += 1 * this->dd_size() + data_size;
   }
-
+  
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = total_size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
@@ -244,7 +267,7 @@ void DashDotProto::CopyFrom(const DashDotProto& from) {
 }
 
 bool DashDotProto::IsInitialized() const {
-
+  
   return true;
 }
 
@@ -265,10 +288,244 @@ void DashDotProto::Swap(DashDotProto* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
+const int PathSymProto::kNameFieldNumber;
+const int PathSymProto::kStepFieldNumber;
+const int PathSymProto::kOffsetFieldNumber;
+#endif  // !_MSC_VER
+
+PathSymProto::PathSymProto()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+}
+
+void PathSymProto::InitAsDefaultInstance() {
+}
+
+PathSymProto::PathSymProto(const PathSymProto& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void PathSymProto::SharedCtor() {
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  step_ = 0;
+  offset_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PathSymProto::~PathSymProto() {
+  SharedDtor();
+}
+
+void PathSymProto::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::kEmptyString) {
+    delete name_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void PathSymProto::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const PathSymProto& PathSymProto::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
+}
+
+PathSymProto* PathSymProto::default_instance_ = NULL;
+
+PathSymProto* PathSymProto::New() const {
+  return new PathSymProto;
+}
+
+void PathSymProto::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::kEmptyString) {
+        name_->clear();
+      }
+    }
+    step_ = 0;
+    offset_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+bool PathSymProto::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required string name = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(17)) goto parse_step;
+        break;
+      }
+      
+      // required double step = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+         parse_step:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &step_)));
+          set_has_step();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(25)) goto parse_offset;
+        break;
+      }
+      
+      // optional double offset = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
+         parse_offset:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &offset_)));
+          set_has_offset();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+      
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void PathSymProto::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      1, this->name(), output);
+  }
+  
+  // required double step = 2;
+  if (has_step()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->step(), output);
+  }
+  
+  // optional double offset = 3;
+  if (has_offset()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(3, this->offset(), output);
+  }
+  
+}
+
+int PathSymProto::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required string name = 1;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+    
+    // required double step = 2;
+    if (has_step()) {
+      total_size += 1 + 8;
+    }
+    
+    // optional double offset = 3;
+    if (has_offset()) {
+      total_size += 1 + 8;
+    }
+    
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void PathSymProto::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const PathSymProto*>(&from));
+}
+
+void PathSymProto::MergeFrom(const PathSymProto& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_step()) {
+      set_step(from.step());
+    }
+    if (from.has_offset()) {
+      set_offset(from.offset());
+    }
+  }
+}
+
+void PathSymProto::CopyFrom(const PathSymProto& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PathSymProto::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+  
+  return true;
+}
+
+void PathSymProto::Swap(PathSymProto* other) {
+  if (other != this) {
+    std::swap(name_, other->name_);
+    std::swap(step_, other->step_);
+    std::swap(offset_, other->offset_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string PathSymProto::GetTypeName() const {
+  return "PathSymProto";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
 const int LineRuleProto::kWidthFieldNumber;
 const int LineRuleProto::kColorFieldNumber;
 const int LineRuleProto::kDashdotFieldNumber;
 const int LineRuleProto::kPriorityFieldNumber;
+const int LineRuleProto::kPathsymFieldNumber;
+const int LineRuleProto::kJoinFieldNumber;
+const int LineRuleProto::kCapFieldNumber;
 #endif  // !_MSC_VER
 
 LineRuleProto::LineRuleProto()
@@ -278,6 +535,7 @@ LineRuleProto::LineRuleProto()
 
 void LineRuleProto::InitAsDefaultInstance() {
   dashdot_ = const_cast< ::DashDotProto*>(&::DashDotProto::default_instance());
+  pathsym_ = const_cast< ::PathSymProto*>(&::PathSymProto::default_instance());
 }
 
 LineRuleProto::LineRuleProto(const LineRuleProto& from)
@@ -292,6 +550,9 @@ void LineRuleProto::SharedCtor() {
   color_ = 0u;
   dashdot_ = NULL;
   priority_ = 0;
+  pathsym_ = NULL;
+  join_ = 0;
+  cap_ = 0;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -302,6 +563,7 @@ LineRuleProto::~LineRuleProto() {
 void LineRuleProto::SharedDtor() {
   if (this != default_instance_) {
     delete dashdot_;
+    delete pathsym_;
   }
 }
 
@@ -328,6 +590,11 @@ void LineRuleProto::Clear() {
       if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear();
     }
     priority_ = 0;
+    if (has_pathsym()) {
+      if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear();
+    }
+    join_ = 0;
+    cap_ = 0;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
@@ -352,7 +619,7 @@ bool LineRuleProto::MergePartialFromCodedStream(
         if (input->ExpectTag(16)) goto parse_color;
         break;
       }
-
+      
       // required uint32 color = 2;
       case 2: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -368,7 +635,7 @@ bool LineRuleProto::MergePartialFromCodedStream(
         if (input->ExpectTag(26)) goto parse_dashdot;
         break;
       }
-
+      
       // optional .DashDotProto dashdot = 3;
       case 3: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -382,7 +649,7 @@ bool LineRuleProto::MergePartialFromCodedStream(
         if (input->ExpectTag(32)) goto parse_priority;
         break;
       }
-
+      
       // required int32 priority = 4;
       case 4: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -395,10 +662,62 @@ bool LineRuleProto::MergePartialFromCodedStream(
         } else {
           goto handle_uninterpreted;
         }
+        if (input->ExpectTag(42)) goto parse_pathsym;
+        break;
+      }
+      
+      // optional .PathSymProto pathsym = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_pathsym:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_pathsym()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(48)) goto parse_join;
+        break;
+      }
+      
+      // optional .LineJoin join = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_join:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (LineJoin_IsValid(value)) {
+            set_join(static_cast< LineJoin >(value));
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(56)) goto parse_cap;
+        break;
+      }
+      
+      // optional .LineCap cap = 7;
+      case 7: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_cap:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (LineCap_IsValid(value)) {
+            set_cap(static_cast< LineCap >(value));
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
         if (input->ExpectAtEnd()) return true;
         break;
       }
-
+      
       default: {
       handle_uninterpreted:
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -420,55 +739,92 @@ void LineRuleProto::SerializeWithCachedSizes(
   if (has_width()) {
     ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->width(), output);
   }
-
+  
   // required uint32 color = 2;
   if (has_color()) {
     ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output);
   }
-
+  
   // optional .DashDotProto dashdot = 3;
   if (has_dashdot()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       3, this->dashdot(), output);
   }
-
+  
   // required int32 priority = 4;
   if (has_priority()) {
     ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output);
   }
-
+  
+  // optional .PathSymProto pathsym = 5;
+  if (has_pathsym()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      5, this->pathsym(), output);
+  }
+  
+  // optional .LineJoin join = 6;
+  if (has_join()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      6, this->join(), output);
+  }
+  
+  // optional .LineCap cap = 7;
+  if (has_cap()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      7, this->cap(), output);
+  }
+  
 }
 
 int LineRuleProto::ByteSize() const {
   int total_size = 0;
-
+  
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     // required double width = 1;
     if (has_width()) {
       total_size += 1 + 8;
     }
-
+    
     // required uint32 color = 2;
     if (has_color()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt32Size(
           this->color());
     }
-
+    
     // optional .DashDotProto dashdot = 3;
     if (has_dashdot()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->dashdot());
     }
-
+    
     // required int32 priority = 4;
     if (has_priority()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::Int32Size(
           this->priority());
     }
-
+    
+    // optional .PathSymProto pathsym = 5;
+    if (has_pathsym()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->pathsym());
+    }
+    
+    // optional .LineJoin join = 6;
+    if (has_join()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->join());
+    }
+    
+    // optional .LineCap cap = 7;
+    if (has_cap()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->cap());
+    }
+    
   }
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = total_size;
@@ -496,6 +852,15 @@ void LineRuleProto::MergeFrom(const LineRuleProto& from) {
     if (from.has_priority()) {
       set_priority(from.priority());
     }
+    if (from.has_pathsym()) {
+      mutable_pathsym()->::PathSymProto::MergeFrom(from.pathsym());
+    }
+    if (from.has_join()) {
+      set_join(from.join());
+    }
+    if (from.has_cap()) {
+      set_cap(from.cap());
+    }
   }
 }
 
@@ -507,7 +872,10 @@ void LineRuleProto::CopyFrom(const LineRuleProto& from) {
 
 bool LineRuleProto::IsInitialized() const {
   if ((_has_bits_[0] & 0x0000000b) != 0x0000000b) return false;
-
+  
+  if (has_pathsym()) {
+    if (!this->pathsym().IsInitialized()) return false;
+  }
   return true;
 }
 
@@ -517,6 +885,9 @@ void LineRuleProto::Swap(LineRuleProto* other) {
     std::swap(color_, other->color_);
     std::swap(dashdot_, other->dashdot_);
     std::swap(priority_, other->priority_);
+    std::swap(pathsym_, other->pathsym_);
+    std::swap(join_, other->join_);
+    std::swap(cap_, other->cap_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     std::swap(_cached_size_, other->_cached_size_);
   }
@@ -533,6 +904,9 @@ void LineRuleProto::Swap(LineRuleProto* other) {
 const int LineDefProto::kWidthFieldNumber;
 const int LineDefProto::kColorFieldNumber;
 const int LineDefProto::kDashdotFieldNumber;
+const int LineDefProto::kPathsymFieldNumber;
+const int LineDefProto::kJoinFieldNumber;
+const int LineDefProto::kCapFieldNumber;
 #endif  // !_MSC_VER
 
 LineDefProto::LineDefProto()
@@ -542,6 +916,7 @@ LineDefProto::LineDefProto()
 
 void LineDefProto::InitAsDefaultInstance() {
   dashdot_ = const_cast< ::DashDotProto*>(&::DashDotProto::default_instance());
+  pathsym_ = const_cast< ::PathSymProto*>(&::PathSymProto::default_instance());
 }
 
 LineDefProto::LineDefProto(const LineDefProto& from)
@@ -555,6 +930,9 @@ void LineDefProto::SharedCtor() {
   width_ = 0;
   color_ = 0u;
   dashdot_ = NULL;
+  pathsym_ = NULL;
+  join_ = 0;
+  cap_ = 0;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -565,6 +943,7 @@ LineDefProto::~LineDefProto() {
 void LineDefProto::SharedDtor() {
   if (this != default_instance_) {
     delete dashdot_;
+    delete pathsym_;
   }
 }
 
@@ -590,6 +969,11 @@ void LineDefProto::Clear() {
     if (has_dashdot()) {
       if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear();
     }
+    if (has_pathsym()) {
+      if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear();
+    }
+    join_ = 0;
+    cap_ = 0;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
@@ -614,7 +998,7 @@ bool LineDefProto::MergePartialFromCodedStream(
         if (input->ExpectTag(16)) goto parse_color;
         break;
       }
-
+      
       // required uint32 color = 2;
       case 2: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -630,7 +1014,7 @@ bool LineDefProto::MergePartialFromCodedStream(
         if (input->ExpectTag(26)) goto parse_dashdot;
         break;
       }
-
+      
       // optional .DashDotProto dashdot = 3;
       case 3: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -641,10 +1025,62 @@ bool LineDefProto::MergePartialFromCodedStream(
         } else {
           goto handle_uninterpreted;
         }
+        if (input->ExpectTag(34)) goto parse_pathsym;
+        break;
+      }
+      
+      // optional .PathSymProto pathsym = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_pathsym:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_pathsym()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(48)) goto parse_join;
+        break;
+      }
+      
+      // optional .LineJoin join = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_join:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (LineJoin_IsValid(value)) {
+            set_join(static_cast< LineJoin >(value));
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(56)) goto parse_cap;
+        break;
+      }
+      
+      // optional .LineCap cap = 7;
+      case 7: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_cap:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (LineCap_IsValid(value)) {
+            set_cap(static_cast< LineCap >(value));
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
         if (input->ExpectAtEnd()) return true;
         break;
       }
-
+      
       default: {
       handle_uninterpreted:
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -666,43 +1102,80 @@ void LineDefProto::SerializeWithCachedSizes(
   if (has_width()) {
     ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->width(), output);
   }
-
+  
   // required uint32 color = 2;
   if (has_color()) {
     ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output);
   }
-
+  
   // optional .DashDotProto dashdot = 3;
   if (has_dashdot()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       3, this->dashdot(), output);
   }
-
+  
+  // optional .PathSymProto pathsym = 4;
+  if (has_pathsym()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      4, this->pathsym(), output);
+  }
+  
+  // optional .LineJoin join = 6;
+  if (has_join()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      6, this->join(), output);
+  }
+  
+  // optional .LineCap cap = 7;
+  if (has_cap()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      7, this->cap(), output);
+  }
+  
 }
 
 int LineDefProto::ByteSize() const {
   int total_size = 0;
-
+  
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     // required double width = 1;
     if (has_width()) {
       total_size += 1 + 8;
     }
-
+    
     // required uint32 color = 2;
     if (has_color()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt32Size(
           this->color());
     }
-
+    
     // optional .DashDotProto dashdot = 3;
     if (has_dashdot()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->dashdot());
     }
-
+    
+    // optional .PathSymProto pathsym = 4;
+    if (has_pathsym()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->pathsym());
+    }
+    
+    // optional .LineJoin join = 6;
+    if (has_join()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->join());
+    }
+    
+    // optional .LineCap cap = 7;
+    if (has_cap()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->cap());
+    }
+    
   }
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = total_size;
@@ -727,6 +1200,15 @@ void LineDefProto::MergeFrom(const LineDefProto& from) {
     if (from.has_dashdot()) {
       mutable_dashdot()->::DashDotProto::MergeFrom(from.dashdot());
     }
+    if (from.has_pathsym()) {
+      mutable_pathsym()->::PathSymProto::MergeFrom(from.pathsym());
+    }
+    if (from.has_join()) {
+      set_join(from.join());
+    }
+    if (from.has_cap()) {
+      set_cap(from.cap());
+    }
   }
 }
 
@@ -738,7 +1220,10 @@ void LineDefProto::CopyFrom(const LineDefProto& from) {
 
 bool LineDefProto::IsInitialized() const {
   if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
+  
+  if (has_pathsym()) {
+    if (!this->pathsym().IsInitialized()) return false;
+  }
   return true;
 }
 
@@ -747,6 +1232,9 @@ void LineDefProto::Swap(LineDefProto* other) {
     std::swap(width_, other->width_);
     std::swap(color_, other->color_);
     std::swap(dashdot_, other->dashdot_);
+    std::swap(pathsym_, other->pathsym_);
+    std::swap(join_, other->join_);
+    std::swap(cap_, other->cap_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     std::swap(_cached_size_, other->_cached_size_);
   }
@@ -844,7 +1332,7 @@ bool AreaRuleProto::MergePartialFromCodedStream(
         if (input->ExpectTag(18)) goto parse_border;
         break;
       }
-
+      
       // optional .LineDefProto border = 2;
       case 2: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -858,7 +1346,7 @@ bool AreaRuleProto::MergePartialFromCodedStream(
         if (input->ExpectTag(24)) goto parse_priority;
         break;
       }
-
+      
       // required int32 priority = 3;
       case 3: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -874,7 +1362,7 @@ bool AreaRuleProto::MergePartialFromCodedStream(
         if (input->ExpectAtEnd()) return true;
         break;
       }
-
+      
       default: {
       handle_uninterpreted:
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -896,23 +1384,23 @@ void AreaRuleProto::SerializeWithCachedSizes(
   if (has_color()) {
     ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->color(), output);
   }
-
+  
   // optional .LineDefProto border = 2;
   if (has_border()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       2, this->border(), output);
   }
-
+  
   // required int32 priority = 3;
   if (has_priority()) {
     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
   }
-
+  
 }
 
 int AreaRuleProto::ByteSize() const {
   int total_size = 0;
-
+  
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     // required uint32 color = 1;
     if (has_color()) {
@@ -920,21 +1408,21 @@ int AreaRuleProto::ByteSize() const {
         ::google::protobuf::internal::WireFormatLite::UInt32Size(
           this->color());
     }
-
+    
     // optional .LineDefProto border = 2;
     if (has_border()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->border());
     }
-
+    
     // required int32 priority = 3;
     if (has_priority()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::Int32Size(
           this->priority());
     }
-
+    
   }
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = total_size;
@@ -970,7 +1458,7 @@ void AreaRuleProto::CopyFrom(const AreaRuleProto& from) {
 
 bool AreaRuleProto::IsInitialized() const {
   if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;
-
+  
   if (has_border()) {
     if (!this->border().IsInitialized()) return false;
   }
@@ -1080,7 +1568,7 @@ bool SymbolRuleProto::MergePartialFromCodedStream(
         if (input->ExpectTag(16)) goto parse_apply_for_type;
         break;
       }
-
+      
       // optional int32 apply_for_type = 2;
       case 2: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1096,7 +1584,7 @@ bool SymbolRuleProto::MergePartialFromCodedStream(
         if (input->ExpectTag(24)) goto parse_priority;
         break;
       }
-
+      
       // required int32 priority = 3;
       case 3: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1112,7 +1600,7 @@ bool SymbolRuleProto::MergePartialFromCodedStream(
         if (input->ExpectAtEnd()) return true;
         break;
       }
-
+      
       default: {
       handle_uninterpreted:
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1135,22 +1623,22 @@ void SymbolRuleProto::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteString(
       1, this->name(), output);
   }
-
+  
   // optional int32 apply_for_type = 2;
   if (has_apply_for_type()) {
     ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->apply_for_type(), output);
   }
-
+  
   // required int32 priority = 3;
   if (has_priority()) {
     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
   }
-
+  
 }
 
 int SymbolRuleProto::ByteSize() const {
   int total_size = 0;
-
+  
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     // required string name = 1;
     if (has_name()) {
@@ -1158,21 +1646,21 @@ int SymbolRuleProto::ByteSize() const {
         ::google::protobuf::internal::WireFormatLite::StringSize(
           this->name());
     }
-
+    
     // optional int32 apply_for_type = 2;
     if (has_apply_for_type()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::Int32Size(
           this->apply_for_type());
     }
-
+    
     // required int32 priority = 3;
     if (has_priority()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::Int32Size(
           this->priority());
     }
-
+    
   }
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = total_size;
@@ -1208,7 +1696,7 @@ void SymbolRuleProto::CopyFrom(const SymbolRuleProto& from) {
 
 bool SymbolRuleProto::IsInitialized() const {
   if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;
-
+  
   return true;
 }
 
@@ -1310,7 +1798,7 @@ bool CaptionDefProto::MergePartialFromCodedStream(
         if (input->ExpectTag(16)) goto parse_color;
         break;
       }
-
+      
       // required uint32 color = 2;
       case 2: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1326,7 +1814,7 @@ bool CaptionDefProto::MergePartialFromCodedStream(
         if (input->ExpectTag(24)) goto parse_stroke_color;
         break;
       }
-
+      
       // optional uint32 stroke_color = 3;
       case 3: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1342,7 +1830,7 @@ bool CaptionDefProto::MergePartialFromCodedStream(
         if (input->ExpectAtEnd()) return true;
         break;
       }
-
+      
       default: {
       handle_uninterpreted:
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1364,22 +1852,22 @@ void CaptionDefProto::SerializeWithCachedSizes(
   if (has_height()) {
     ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->height(), output);
   }
-
+  
   // required uint32 color = 2;
   if (has_color()) {
     ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output);
   }
-
+  
   // optional uint32 stroke_color = 3;
   if (has_stroke_color()) {
     ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->stroke_color(), output);
   }
-
+  
 }
 
 int CaptionDefProto::ByteSize() const {
   int total_size = 0;
-
+  
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     // required int32 height = 1;
     if (has_height()) {
@@ -1387,21 +1875,21 @@ int CaptionDefProto::ByteSize() const {
         ::google::protobuf::internal::WireFormatLite::Int32Size(
           this->height());
     }
-
+    
     // required uint32 color = 2;
     if (has_color()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt32Size(
           this->color());
     }
-
+    
     // optional uint32 stroke_color = 3;
     if (has_stroke_color()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt32Size(
           this->stroke_color());
     }
-
+    
   }
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = total_size;
@@ -1437,7 +1925,7 @@ void CaptionDefProto::CopyFrom(const CaptionDefProto& from) {
 
 bool CaptionDefProto::IsInitialized() const {
   if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
+  
   return true;
 }
 
@@ -1545,7 +2033,7 @@ bool CaptionRuleProto::MergePartialFromCodedStream(
         if (input->ExpectTag(18)) goto parse_secondary;
         break;
       }
-
+      
       // optional .CaptionDefProto secondary = 2;
       case 2: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1559,7 +2047,7 @@ bool CaptionRuleProto::MergePartialFromCodedStream(
         if (input->ExpectTag(24)) goto parse_priority;
         break;
       }
-
+      
       // required int32 priority = 3;
       case 3: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1575,7 +2063,7 @@ bool CaptionRuleProto::MergePartialFromCodedStream(
         if (input->ExpectAtEnd()) return true;
         break;
       }
-
+      
       default: {
       handle_uninterpreted:
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1598,23 +2086,23 @@ void CaptionRuleProto::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       1, this->primary(), output);
   }
-
+  
   // optional .CaptionDefProto secondary = 2;
   if (has_secondary()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       2, this->secondary(), output);
   }
-
+  
   // required int32 priority = 3;
   if (has_priority()) {
     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
   }
-
+  
 }
 
 int CaptionRuleProto::ByteSize() const {
   int total_size = 0;
-
+  
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     // required .CaptionDefProto primary = 1;
     if (has_primary()) {
@@ -1622,21 +2110,21 @@ int CaptionRuleProto::ByteSize() const {
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->primary());
     }
-
+    
     // optional .CaptionDefProto secondary = 2;
     if (has_secondary()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->secondary());
     }
-
+    
     // required int32 priority = 3;
     if (has_priority()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::Int32Size(
           this->priority());
     }
-
+    
   }
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = total_size;
@@ -1672,7 +2160,7 @@ void CaptionRuleProto::CopyFrom(const CaptionRuleProto& from) {
 
 bool CaptionRuleProto::IsInitialized() const {
   if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;
-
+  
   if (has_primary()) {
     if (!this->primary().IsInitialized()) return false;
   }
@@ -1787,7 +2275,7 @@ bool CircleRuleProto::MergePartialFromCodedStream(
         if (input->ExpectTag(16)) goto parse_color;
         break;
       }
-
+      
       // required uint32 color = 2;
       case 2: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1803,7 +2291,7 @@ bool CircleRuleProto::MergePartialFromCodedStream(
         if (input->ExpectTag(26)) goto parse_border;
         break;
       }
-
+      
       // optional .LineDefProto border = 3;
       case 3: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1817,7 +2305,7 @@ bool CircleRuleProto::MergePartialFromCodedStream(
         if (input->ExpectTag(32)) goto parse_priority;
         break;
       }
-
+      
       // required int32 priority = 4;
       case 4: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1833,7 +2321,7 @@ bool CircleRuleProto::MergePartialFromCodedStream(
         if (input->ExpectAtEnd()) return true;
         break;
       }
-
+      
       default: {
       handle_uninterpreted:
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -1855,55 +2343,55 @@ void CircleRuleProto::SerializeWithCachedSizes(
   if (has_radius()) {
     ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->radius(), output);
   }
-
+  
   // required uint32 color = 2;
   if (has_color()) {
     ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output);
   }
-
+  
   // optional .LineDefProto border = 3;
   if (has_border()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       3, this->border(), output);
   }
-
+  
   // required int32 priority = 4;
   if (has_priority()) {
     ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output);
   }
-
+  
 }
 
 int CircleRuleProto::ByteSize() const {
   int total_size = 0;
-
+  
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     // required double radius = 1;
     if (has_radius()) {
       total_size += 1 + 8;
     }
-
+    
     // required uint32 color = 2;
     if (has_color()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt32Size(
           this->color());
     }
-
+    
     // optional .LineDefProto border = 3;
     if (has_border()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->border());
     }
-
+    
     // required int32 priority = 4;
     if (has_priority()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::Int32Size(
           this->priority());
     }
-
+    
   }
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = total_size;
@@ -1942,7 +2430,7 @@ void CircleRuleProto::CopyFrom(const CircleRuleProto& from) {
 
 bool CircleRuleProto::IsInitialized() const {
   if ((_has_bits_[0] & 0x0000000b) != 0x0000000b) return false;
-
+  
   if (has_border()) {
     if (!this->border().IsInitialized()) return false;
   }
@@ -2054,7 +2542,7 @@ bool PathTextRuleProto::MergePartialFromCodedStream(
         if (input->ExpectTag(18)) goto parse_secondary;
         break;
       }
-
+      
       // optional .CaptionDefProto secondary = 2;
       case 2: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2068,7 +2556,7 @@ bool PathTextRuleProto::MergePartialFromCodedStream(
         if (input->ExpectTag(24)) goto parse_priority;
         break;
       }
-
+      
       // required int32 priority = 3;
       case 3: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2084,7 +2572,7 @@ bool PathTextRuleProto::MergePartialFromCodedStream(
         if (input->ExpectAtEnd()) return true;
         break;
       }
-
+      
       default: {
       handle_uninterpreted:
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2107,23 +2595,23 @@ void PathTextRuleProto::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       1, this->primary(), output);
   }
-
+  
   // optional .CaptionDefProto secondary = 2;
   if (has_secondary()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       2, this->secondary(), output);
   }
-
+  
   // required int32 priority = 3;
   if (has_priority()) {
     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
   }
-
+  
 }
 
 int PathTextRuleProto::ByteSize() const {
   int total_size = 0;
-
+  
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     // required .CaptionDefProto primary = 1;
     if (has_primary()) {
@@ -2131,21 +2619,21 @@ int PathTextRuleProto::ByteSize() const {
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->primary());
     }
-
+    
     // optional .CaptionDefProto secondary = 2;
     if (has_secondary()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->secondary());
     }
-
+    
     // required int32 priority = 3;
     if (has_priority()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::Int32Size(
           this->priority());
     }
-
+    
   }
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = total_size;
@@ -2181,7 +2669,7 @@ void PathTextRuleProto::CopyFrom(const PathTextRuleProto& from) {
 
 bool PathTextRuleProto::IsInitialized() const {
   if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;
-
+  
   if (has_primary()) {
     if (!this->primary().IsInitialized()) return false;
   }
@@ -2320,7 +2808,7 @@ bool DrawElementProto::MergePartialFromCodedStream(
         if (input->ExpectTag(18)) goto parse_lines;
         break;
       }
-
+      
       // repeated .LineRuleProto lines = 2;
       case 2: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2335,7 +2823,7 @@ bool DrawElementProto::MergePartialFromCodedStream(
         if (input->ExpectTag(26)) goto parse_area;
         break;
       }
-
+      
       // optional .AreaRuleProto area = 3;
       case 3: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2349,7 +2837,7 @@ bool DrawElementProto::MergePartialFromCodedStream(
         if (input->ExpectTag(34)) goto parse_symbol;
         break;
       }
-
+      
       // optional .SymbolRuleProto symbol = 4;
       case 4: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2363,7 +2851,7 @@ bool DrawElementProto::MergePartialFromCodedStream(
         if (input->ExpectTag(42)) goto parse_caption;
         break;
       }
-
+      
       // optional .CaptionRuleProto caption = 5;
       case 5: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2377,7 +2865,7 @@ bool DrawElementProto::MergePartialFromCodedStream(
         if (input->ExpectTag(50)) goto parse_circle;
         break;
       }
-
+      
       // optional .CircleRuleProto circle = 6;
       case 6: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2391,7 +2879,7 @@ bool DrawElementProto::MergePartialFromCodedStream(
         if (input->ExpectTag(58)) goto parse_path_text;
         break;
       }
-
+      
       // optional .PathTextRuleProto path_text = 7;
       case 7: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2405,7 +2893,7 @@ bool DrawElementProto::MergePartialFromCodedStream(
         if (input->ExpectAtEnd()) return true;
         break;
       }
-
+      
       default: {
       handle_uninterpreted:
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2427,48 +2915,48 @@ void DrawElementProto::SerializeWithCachedSizes(
   if (has_scale()) {
     ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->scale(), output);
   }
-
+  
   // repeated .LineRuleProto lines = 2;
   for (int i = 0; i < this->lines_size(); i++) {
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       2, this->lines(i), output);
   }
-
+  
   // optional .AreaRuleProto area = 3;
   if (has_area()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       3, this->area(), output);
   }
-
+  
   // optional .SymbolRuleProto symbol = 4;
   if (has_symbol()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       4, this->symbol(), output);
   }
-
+  
   // optional .CaptionRuleProto caption = 5;
   if (has_caption()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       5, this->caption(), output);
   }
-
+  
   // optional .CircleRuleProto circle = 6;
   if (has_circle()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       6, this->circle(), output);
   }
-
+  
   // optional .PathTextRuleProto path_text = 7;
   if (has_path_text()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       7, this->path_text(), output);
   }
-
+  
 }
 
 int DrawElementProto::ByteSize() const {
   int total_size = 0;
-
+  
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     // required int32 scale = 1;
     if (has_scale()) {
@@ -2476,42 +2964,42 @@ int DrawElementProto::ByteSize() const {
         ::google::protobuf::internal::WireFormatLite::Int32Size(
           this->scale());
     }
-
+    
     // optional .AreaRuleProto area = 3;
     if (has_area()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->area());
     }
-
+    
     // optional .SymbolRuleProto symbol = 4;
     if (has_symbol()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->symbol());
     }
-
+    
     // optional .CaptionRuleProto caption = 5;
     if (has_caption()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->caption());
     }
-
+    
     // optional .CircleRuleProto circle = 6;
     if (has_circle()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->circle());
     }
-
+    
     // optional .PathTextRuleProto path_text = 7;
     if (has_path_text()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->path_text());
     }
-
+    
   }
   // repeated .LineRuleProto lines = 2;
   total_size += 1 * this->lines_size();
@@ -2520,7 +3008,7 @@ int DrawElementProto::ByteSize() const {
       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
         this->lines(i));
   }
-
+  
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = total_size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
@@ -2565,7 +3053,7 @@ void DrawElementProto::CopyFrom(const DrawElementProto& from) {
 
 bool DrawElementProto::IsInitialized() const {
   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+  
   for (int i = 0; i < lines_size(); i++) {
     if (!this->lines(i).IsInitialized()) return false;
   }
@@ -2690,7 +3178,7 @@ bool ClassifElementProto::MergePartialFromCodedStream(
         if (input->ExpectTag(18)) goto parse_element;
         break;
       }
-
+      
       // repeated .DrawElementProto element = 2;
       case 2: {
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2705,7 +3193,7 @@ bool ClassifElementProto::MergePartialFromCodedStream(
         if (input->ExpectAtEnd()) return true;
         break;
       }
-
+      
       default: {
       handle_uninterpreted:
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2728,18 +3216,18 @@ void ClassifElementProto::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteString(
       1, this->name(), output);
   }
-
+  
   // repeated .DrawElementProto element = 2;
   for (int i = 0; i < this->element_size(); i++) {
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       2, this->element(i), output);
   }
-
+  
 }
 
 int ClassifElementProto::ByteSize() const {
   int total_size = 0;
-
+  
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     // required string name = 1;
     if (has_name()) {
@@ -2747,7 +3235,7 @@ int ClassifElementProto::ByteSize() const {
         ::google::protobuf::internal::WireFormatLite::StringSize(
           this->name());
     }
-
+    
   }
   // repeated .DrawElementProto element = 2;
   total_size += 1 * this->element_size();
@@ -2756,7 +3244,7 @@ int ClassifElementProto::ByteSize() const {
       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
         this->element(i));
   }
-
+  
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = total_size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
@@ -2786,7 +3274,7 @@ void ClassifElementProto::CopyFrom(const ClassifElementProto& from) {
 
 bool ClassifElementProto::IsInitialized() const {
   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
+  
   for (int i = 0; i < element_size(); i++) {
     if (!this->element(i).IsInitialized()) return false;
   }
@@ -2881,7 +3369,7 @@ bool ContainerProto::MergePartialFromCodedStream(
         if (input->ExpectAtEnd()) return true;
         break;
       }
-
+      
       default: {
       handle_uninterpreted:
         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -2904,12 +3392,12 @@ void ContainerProto::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteMessage(
       1, this->cont(i), output);
   }
-
+  
 }
 
 int ContainerProto::ByteSize() const {
   int total_size = 0;
-
+  
   // repeated .ClassifElementProto cont = 1;
   total_size += 1 * this->cont_size();
   for (int i = 0; i < this->cont_size(); i++) {
@@ -2917,7 +3405,7 @@ int ContainerProto::ByteSize() const {
       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
         this->cont(i));
   }
-
+  
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = total_size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
@@ -2941,7 +3429,7 @@ void ContainerProto::CopyFrom(const ContainerProto& from) {
 }
 
 bool ContainerProto::IsInitialized() const {
-
+  
   for (int i = 0; i < cont_size(); i++) {
     if (!this->cont(i).IsInitialized()) return false;
   }
diff --git a/indexer/drules_struct_lite.pb.h b/indexer/drules_struct_lite.pb.h
index 38b11b5d7c..f7de5bbe9f 100644
--- a/indexer/drules_struct_lite.pb.h
+++ b/indexer/drules_struct_lite.pb.h
@@ -30,6 +30,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto();
 void protobuf_ShutdownFile_drules_5fstruct_2eproto();
 
 class DashDotProto;
+class PathSymProto;
 class LineRuleProto;
 class LineDefProto;
 class AreaRuleProto;
@@ -42,33 +43,51 @@ class DrawElementProto;
 class ClassifElementProto;
 class ContainerProto;
 
+enum LineJoin {
+  ROUNDJOIN = 0,
+  BEVELJOIN = 1
+};
+bool LineJoin_IsValid(int value);
+const LineJoin LineJoin_MIN = ROUNDJOIN;
+const LineJoin LineJoin_MAX = BEVELJOIN;
+const int LineJoin_ARRAYSIZE = LineJoin_MAX + 1;
+
+enum LineCap {
+  ROUNDCAP = 0,
+  BUTTCAP = 1
+};
+bool LineCap_IsValid(int value);
+const LineCap LineCap_MIN = ROUNDCAP;
+const LineCap LineCap_MAX = BUTTCAP;
+const int LineCap_ARRAYSIZE = LineCap_MAX + 1;
+
 // ===================================================================
 
 class DashDotProto : public ::google::protobuf::MessageLite {
  public:
   DashDotProto();
   virtual ~DashDotProto();
-
+  
   DashDotProto(const DashDotProto& from);
-
+  
   inline DashDotProto& operator=(const DashDotProto& from) {
     CopyFrom(from);
     return *this;
   }
-
+  
   static const DashDotProto& default_instance();
-
+  
   void Swap(DashDotProto* other);
-
+  
   // implements Message ----------------------------------------------
-
+  
   DashDotProto* New() const;
   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
   void CopyFrom(const DashDotProto& from);
   void MergeFrom(const DashDotProto& from);
   void Clear();
   bool IsInitialized() const;
-
+  
   int ByteSize() const;
   bool MergePartialFromCodedStream(
       ::google::protobuf::io::CodedInputStream* input);
@@ -80,13 +99,13 @@ class DashDotProto : public ::google::protobuf::MessageLite {
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
+  
   ::std::string GetTypeName() const;
-
+  
   // nested types ----------------------------------------------------
-
+  
   // accessors -------------------------------------------------------
-
+  
   // repeated double dd = 1;
   inline int dd_size() const;
   inline void clear_dd();
@@ -98,59 +117,152 @@ class DashDotProto : public ::google::protobuf::MessageLite {
       dd() const;
   inline ::google::protobuf::RepeatedField< double >*
       mutable_dd();
-
+  
   // optional double offset = 2;
   inline bool has_offset() const;
   inline void clear_offset();
   static const int kOffsetFieldNumber = 2;
   inline double offset() const;
   inline void set_offset(double value);
-
+  
   // @@protoc_insertion_point(class_scope:DashDotProto)
  private:
   inline void set_has_offset();
   inline void clear_has_offset();
-
+  
   ::google::protobuf::RepeatedField< double > dd_;
   double offset_;
-
+  
   mutable int _cached_size_;
   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
+  
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
   friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
-
+  
   void InitAsDefaultInstance();
   static DashDotProto* default_instance_;
 };
 // -------------------------------------------------------------------
 
+class PathSymProto : public ::google::protobuf::MessageLite {
+ public:
+  PathSymProto();
+  virtual ~PathSymProto();
+  
+  PathSymProto(const PathSymProto& from);
+  
+  inline PathSymProto& operator=(const PathSymProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  
+  static const PathSymProto& default_instance();
+  
+  void Swap(PathSymProto* other);
+  
+  // implements Message ----------------------------------------------
+  
+  PathSymProto* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const PathSymProto& from);
+  void MergeFrom(const PathSymProto& from);
+  void Clear();
+  bool IsInitialized() const;
+  
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  
+  ::std::string GetTypeName() const;
+  
+  // nested types ----------------------------------------------------
+  
+  // accessors -------------------------------------------------------
+  
+  // required string name = 1;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 1;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  
+  // required double step = 2;
+  inline bool has_step() const;
+  inline void clear_step();
+  static const int kStepFieldNumber = 2;
+  inline double step() const;
+  inline void set_step(double value);
+  
+  // optional double offset = 3;
+  inline bool has_offset() const;
+  inline void clear_offset();
+  static const int kOffsetFieldNumber = 3;
+  inline double offset() const;
+  inline void set_offset(double value);
+  
+  // @@protoc_insertion_point(class_scope:PathSymProto)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_step();
+  inline void clear_has_step();
+  inline void set_has_offset();
+  inline void clear_has_offset();
+  
+  ::std::string* name_;
+  double step_;
+  double offset_;
+  
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
+  
+  friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
+  friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
+  friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
+  
+  void InitAsDefaultInstance();
+  static PathSymProto* default_instance_;
+};
+// -------------------------------------------------------------------
+
 class LineRuleProto : public ::google::protobuf::MessageLite {
  public:
   LineRuleProto();
   virtual ~LineRuleProto();
-
+  
   LineRuleProto(const LineRuleProto& from);
-
+  
   inline LineRuleProto& operator=(const LineRuleProto& from) {
     CopyFrom(from);
     return *this;
   }
-
+  
   static const LineRuleProto& default_instance();
-
+  
   void Swap(LineRuleProto* other);
-
+  
   // implements Message ----------------------------------------------
-
+  
   LineRuleProto* New() const;
   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
   void CopyFrom(const LineRuleProto& from);
   void MergeFrom(const LineRuleProto& from);
   void Clear();
   bool IsInitialized() const;
-
+  
   int ByteSize() const;
   bool MergePartialFromCodedStream(
       ::google::protobuf::io::CodedInputStream* input);
@@ -162,27 +274,27 @@ class LineRuleProto : public ::google::protobuf::MessageLite {
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
+  
   ::std::string GetTypeName() const;
-
+  
   // nested types ----------------------------------------------------
-
+  
   // accessors -------------------------------------------------------
-
+  
   // required double width = 1;
   inline bool has_width() const;
   inline void clear_width();
   static const int kWidthFieldNumber = 1;
   inline double width() const;
   inline void set_width(double value);
-
+  
   // required uint32 color = 2;
   inline bool has_color() const;
   inline void clear_color();
   static const int kColorFieldNumber = 2;
   inline ::google::protobuf::uint32 color() const;
   inline void set_color(::google::protobuf::uint32 value);
-
+  
   // optional .DashDotProto dashdot = 3;
   inline bool has_dashdot() const;
   inline void clear_dashdot();
@@ -190,14 +302,36 @@ class LineRuleProto : public ::google::protobuf::MessageLite {
   inline const ::DashDotProto& dashdot() const;
   inline ::DashDotProto* mutable_dashdot();
   inline ::DashDotProto* release_dashdot();
-
+  
   // required int32 priority = 4;
   inline bool has_priority() const;
   inline void clear_priority();
   static const int kPriorityFieldNumber = 4;
   inline ::google::protobuf::int32 priority() const;
   inline void set_priority(::google::protobuf::int32 value);
-
+  
+  // optional .PathSymProto pathsym = 5;
+  inline bool has_pathsym() const;
+  inline void clear_pathsym();
+  static const int kPathsymFieldNumber = 5;
+  inline const ::PathSymProto& pathsym() const;
+  inline ::PathSymProto* mutable_pathsym();
+  inline ::PathSymProto* release_pathsym();
+  
+  // optional .LineJoin join = 6;
+  inline bool has_join() const;
+  inline void clear_join();
+  static const int kJoinFieldNumber = 6;
+  inline LineJoin join() const;
+  inline void set_join(LineJoin value);
+  
+  // optional .LineCap cap = 7;
+  inline bool has_cap() const;
+  inline void clear_cap();
+  static const int kCapFieldNumber = 7;
+  inline LineCap cap() const;
+  inline void set_cap(LineCap value);
+  
   // @@protoc_insertion_point(class_scope:LineRuleProto)
  private:
   inline void set_has_width();
@@ -208,19 +342,28 @@ class LineRuleProto : public ::google::protobuf::MessageLite {
   inline void clear_has_dashdot();
   inline void set_has_priority();
   inline void clear_has_priority();
-
+  inline void set_has_pathsym();
+  inline void clear_has_pathsym();
+  inline void set_has_join();
+  inline void clear_has_join();
+  inline void set_has_cap();
+  inline void clear_has_cap();
+  
   double width_;
   ::DashDotProto* dashdot_;
   ::google::protobuf::uint32 color_;
   ::google::protobuf::int32 priority_;
-
+  ::PathSymProto* pathsym_;
+  int join_;
+  int cap_;
+  
   mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
-
+  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
+  
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
   friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
-
+  
   void InitAsDefaultInstance();
   static LineRuleProto* default_instance_;
 };
@@ -230,27 +373,27 @@ class LineDefProto : public ::google::protobuf::MessageLite {
  public:
   LineDefProto();
   virtual ~LineDefProto();
-
+  
   LineDefProto(const LineDefProto& from);
-
+  
   inline LineDefProto& operator=(const LineDefProto& from) {
     CopyFrom(from);
     return *this;
   }
-
+  
   static const LineDefProto& default_instance();
-
+  
   void Swap(LineDefProto* other);
-
+  
   // implements Message ----------------------------------------------
-
+  
   LineDefProto* New() const;
   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
   void CopyFrom(const LineDefProto& from);
   void MergeFrom(const LineDefProto& from);
   void Clear();
   bool IsInitialized() const;
-
+  
   int ByteSize() const;
   bool MergePartialFromCodedStream(
       ::google::protobuf::io::CodedInputStream* input);
@@ -262,27 +405,27 @@ class LineDefProto : public ::google::protobuf::MessageLite {
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
+  
   ::std::string GetTypeName() const;
-
+  
   // nested types ----------------------------------------------------
-
+  
   // accessors -------------------------------------------------------
-
+  
   // required double width = 1;
   inline bool has_width() const;
   inline void clear_width();
   static const int kWidthFieldNumber = 1;
   inline double width() const;
   inline void set_width(double value);
-
+  
   // required uint32 color = 2;
   inline bool has_color() const;
   inline void clear_color();
   static const int kColorFieldNumber = 2;
   inline ::google::protobuf::uint32 color() const;
   inline void set_color(::google::protobuf::uint32 value);
-
+  
   // optional .DashDotProto dashdot = 3;
   inline bool has_dashdot() const;
   inline void clear_dashdot();
@@ -290,7 +433,29 @@ class LineDefProto : public ::google::protobuf::MessageLite {
   inline const ::DashDotProto& dashdot() const;
   inline ::DashDotProto* mutable_dashdot();
   inline ::DashDotProto* release_dashdot();
-
+  
+  // optional .PathSymProto pathsym = 4;
+  inline bool has_pathsym() const;
+  inline void clear_pathsym();
+  static const int kPathsymFieldNumber = 4;
+  inline const ::PathSymProto& pathsym() const;
+  inline ::PathSymProto* mutable_pathsym();
+  inline ::PathSymProto* release_pathsym();
+  
+  // optional .LineJoin join = 6;
+  inline bool has_join() const;
+  inline void clear_join();
+  static const int kJoinFieldNumber = 6;
+  inline LineJoin join() const;
+  inline void set_join(LineJoin value);
+  
+  // optional .LineCap cap = 7;
+  inline bool has_cap() const;
+  inline void clear_cap();
+  static const int kCapFieldNumber = 7;
+  inline LineCap cap() const;
+  inline void set_cap(LineCap value);
+  
   // @@protoc_insertion_point(class_scope:LineDefProto)
  private:
   inline void set_has_width();
@@ -299,18 +464,27 @@ class LineDefProto : public ::google::protobuf::MessageLite {
   inline void clear_has_color();
   inline void set_has_dashdot();
   inline void clear_has_dashdot();
-
+  inline void set_has_pathsym();
+  inline void clear_has_pathsym();
+  inline void set_has_join();
+  inline void clear_has_join();
+  inline void set_has_cap();
+  inline void clear_has_cap();
+  
   double width_;
   ::DashDotProto* dashdot_;
   ::google::protobuf::uint32 color_;
-
+  int join_;
+  ::PathSymProto* pathsym_;
+  int cap_;
+  
   mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
+  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
+  
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
   friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
-
+  
   void InitAsDefaultInstance();
   static LineDefProto* default_instance_;
 };
@@ -320,27 +494,27 @@ class AreaRuleProto : public ::google::protobuf::MessageLite {
  public:
   AreaRuleProto();
   virtual ~AreaRuleProto();
-
+  
   AreaRuleProto(const AreaRuleProto& from);
-
+  
   inline AreaRuleProto& operator=(const AreaRuleProto& from) {
     CopyFrom(from);
     return *this;
   }
-
+  
   static const AreaRuleProto& default_instance();
-
+  
   void Swap(AreaRuleProto* other);
-
+  
   // implements Message ----------------------------------------------
-
+  
   AreaRuleProto* New() const;
   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
   void CopyFrom(const AreaRuleProto& from);
   void MergeFrom(const AreaRuleProto& from);
   void Clear();
   bool IsInitialized() const;
-
+  
   int ByteSize() const;
   bool MergePartialFromCodedStream(
       ::google::protobuf::io::CodedInputStream* input);
@@ -352,20 +526,20 @@ class AreaRuleProto : public ::google::protobuf::MessageLite {
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
+  
   ::std::string GetTypeName() const;
-
+  
   // nested types ----------------------------------------------------
-
+  
   // accessors -------------------------------------------------------
-
+  
   // required uint32 color = 1;
   inline bool has_color() const;
   inline void clear_color();
   static const int kColorFieldNumber = 1;
   inline ::google::protobuf::uint32 color() const;
   inline void set_color(::google::protobuf::uint32 value);
-
+  
   // optional .LineDefProto border = 2;
   inline bool has_border() const;
   inline void clear_border();
@@ -373,14 +547,14 @@ class AreaRuleProto : public ::google::protobuf::MessageLite {
   inline const ::LineDefProto& border() const;
   inline ::LineDefProto* mutable_border();
   inline ::LineDefProto* release_border();
-
+  
   // required int32 priority = 3;
   inline bool has_priority() const;
   inline void clear_priority();
   static const int kPriorityFieldNumber = 3;
   inline ::google::protobuf::int32 priority() const;
   inline void set_priority(::google::protobuf::int32 value);
-
+  
   // @@protoc_insertion_point(class_scope:AreaRuleProto)
  private:
   inline void set_has_color();
@@ -389,18 +563,18 @@ class AreaRuleProto : public ::google::protobuf::MessageLite {
   inline void clear_has_border();
   inline void set_has_priority();
   inline void clear_has_priority();
-
+  
   ::LineDefProto* border_;
   ::google::protobuf::uint32 color_;
   ::google::protobuf::int32 priority_;
-
+  
   mutable int _cached_size_;
   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
+  
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
   friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
-
+  
   void InitAsDefaultInstance();
   static AreaRuleProto* default_instance_;
 };
@@ -410,27 +584,27 @@ class SymbolRuleProto : public ::google::protobuf::MessageLite {
  public:
   SymbolRuleProto();
   virtual ~SymbolRuleProto();
-
+  
   SymbolRuleProto(const SymbolRuleProto& from);
-
+  
   inline SymbolRuleProto& operator=(const SymbolRuleProto& from) {
     CopyFrom(from);
     return *this;
   }
-
+  
   static const SymbolRuleProto& default_instance();
-
+  
   void Swap(SymbolRuleProto* other);
-
+  
   // implements Message ----------------------------------------------
-
+  
   SymbolRuleProto* New() const;
   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
   void CopyFrom(const SymbolRuleProto& from);
   void MergeFrom(const SymbolRuleProto& from);
   void Clear();
   bool IsInitialized() const;
-
+  
   int ByteSize() const;
   bool MergePartialFromCodedStream(
       ::google::protobuf::io::CodedInputStream* input);
@@ -442,13 +616,13 @@ class SymbolRuleProto : public ::google::protobuf::MessageLite {
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
+  
   ::std::string GetTypeName() const;
-
+  
   // nested types ----------------------------------------------------
-
+  
   // accessors -------------------------------------------------------
-
+  
   // required string name = 1;
   inline bool has_name() const;
   inline void clear_name();
@@ -459,21 +633,21 @@ class SymbolRuleProto : public ::google::protobuf::MessageLite {
   inline void set_name(const char* value, size_t size);
   inline ::std::string* mutable_name();
   inline ::std::string* release_name();
-
+  
   // optional int32 apply_for_type = 2;
   inline bool has_apply_for_type() const;
   inline void clear_apply_for_type();
   static const int kApplyForTypeFieldNumber = 2;
   inline ::google::protobuf::int32 apply_for_type() const;
   inline void set_apply_for_type(::google::protobuf::int32 value);
-
+  
   // required int32 priority = 3;
   inline bool has_priority() const;
   inline void clear_priority();
   static const int kPriorityFieldNumber = 3;
   inline ::google::protobuf::int32 priority() const;
   inline void set_priority(::google::protobuf::int32 value);
-
+  
   // @@protoc_insertion_point(class_scope:SymbolRuleProto)
  private:
   inline void set_has_name();
@@ -482,18 +656,18 @@ class SymbolRuleProto : public ::google::protobuf::MessageLite {
   inline void clear_has_apply_for_type();
   inline void set_has_priority();
   inline void clear_has_priority();
-
+  
   ::std::string* name_;
   ::google::protobuf::int32 apply_for_type_;
   ::google::protobuf::int32 priority_;
-
+  
   mutable int _cached_size_;
   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
+  
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
   friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
-
+  
   void InitAsDefaultInstance();
   static SymbolRuleProto* default_instance_;
 };
@@ -503,27 +677,27 @@ class CaptionDefProto : public ::google::protobuf::MessageLite {
  public:
   CaptionDefProto();
   virtual ~CaptionDefProto();
-
+  
   CaptionDefProto(const CaptionDefProto& from);
-
+  
   inline CaptionDefProto& operator=(const CaptionDefProto& from) {
     CopyFrom(from);
     return *this;
   }
-
+  
   static const CaptionDefProto& default_instance();
-
+  
   void Swap(CaptionDefProto* other);
-
+  
   // implements Message ----------------------------------------------
-
+  
   CaptionDefProto* New() const;
   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
   void CopyFrom(const CaptionDefProto& from);
   void MergeFrom(const CaptionDefProto& from);
   void Clear();
   bool IsInitialized() const;
-
+  
   int ByteSize() const;
   bool MergePartialFromCodedStream(
       ::google::protobuf::io::CodedInputStream* input);
@@ -535,34 +709,34 @@ class CaptionDefProto : public ::google::protobuf::MessageLite {
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
+  
   ::std::string GetTypeName() const;
-
+  
   // nested types ----------------------------------------------------
-
+  
   // accessors -------------------------------------------------------
-
+  
   // required int32 height = 1;
   inline bool has_height() const;
   inline void clear_height();
   static const int kHeightFieldNumber = 1;
   inline ::google::protobuf::int32 height() const;
   inline void set_height(::google::protobuf::int32 value);
-
+  
   // required uint32 color = 2;
   inline bool has_color() const;
   inline void clear_color();
   static const int kColorFieldNumber = 2;
   inline ::google::protobuf::uint32 color() const;
   inline void set_color(::google::protobuf::uint32 value);
-
+  
   // optional uint32 stroke_color = 3;
   inline bool has_stroke_color() const;
   inline void clear_stroke_color();
   static const int kStrokeColorFieldNumber = 3;
   inline ::google::protobuf::uint32 stroke_color() const;
   inline void set_stroke_color(::google::protobuf::uint32 value);
-
+  
   // @@protoc_insertion_point(class_scope:CaptionDefProto)
  private:
   inline void set_has_height();
@@ -571,18 +745,18 @@ class CaptionDefProto : public ::google::protobuf::MessageLite {
   inline void clear_has_color();
   inline void set_has_stroke_color();
   inline void clear_has_stroke_color();
-
+  
   ::google::protobuf::int32 height_;
   ::google::protobuf::uint32 color_;
   ::google::protobuf::uint32 stroke_color_;
-
+  
   mutable int _cached_size_;
   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
+  
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
   friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
-
+  
   void InitAsDefaultInstance();
   static CaptionDefProto* default_instance_;
 };
@@ -592,27 +766,27 @@ class CaptionRuleProto : public ::google::protobuf::MessageLite {
  public:
   CaptionRuleProto();
   virtual ~CaptionRuleProto();
-
+  
   CaptionRuleProto(const CaptionRuleProto& from);
-
+  
   inline CaptionRuleProto& operator=(const CaptionRuleProto& from) {
     CopyFrom(from);
     return *this;
   }
-
+  
   static const CaptionRuleProto& default_instance();
-
+  
   void Swap(CaptionRuleProto* other);
-
+  
   // implements Message ----------------------------------------------
-
+  
   CaptionRuleProto* New() const;
   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
   void CopyFrom(const CaptionRuleProto& from);
   void MergeFrom(const CaptionRuleProto& from);
   void Clear();
   bool IsInitialized() const;
-
+  
   int ByteSize() const;
   bool MergePartialFromCodedStream(
       ::google::protobuf::io::CodedInputStream* input);
@@ -624,13 +798,13 @@ class CaptionRuleProto : public ::google::protobuf::MessageLite {
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
+  
   ::std::string GetTypeName() const;
-
+  
   // nested types ----------------------------------------------------
-
+  
   // accessors -------------------------------------------------------
-
+  
   // required .CaptionDefProto primary = 1;
   inline bool has_primary() const;
   inline void clear_primary();
@@ -638,7 +812,7 @@ class CaptionRuleProto : public ::google::protobuf::MessageLite {
   inline const ::CaptionDefProto& primary() const;
   inline ::CaptionDefProto* mutable_primary();
   inline ::CaptionDefProto* release_primary();
-
+  
   // optional .CaptionDefProto secondary = 2;
   inline bool has_secondary() const;
   inline void clear_secondary();
@@ -646,14 +820,14 @@ class CaptionRuleProto : public ::google::protobuf::MessageLite {
   inline const ::CaptionDefProto& secondary() const;
   inline ::CaptionDefProto* mutable_secondary();
   inline ::CaptionDefProto* release_secondary();
-
+  
   // required int32 priority = 3;
   inline bool has_priority() const;
   inline void clear_priority();
   static const int kPriorityFieldNumber = 3;
   inline ::google::protobuf::int32 priority() const;
   inline void set_priority(::google::protobuf::int32 value);
-
+  
   // @@protoc_insertion_point(class_scope:CaptionRuleProto)
  private:
   inline void set_has_primary();
@@ -662,18 +836,18 @@ class CaptionRuleProto : public ::google::protobuf::MessageLite {
   inline void clear_has_secondary();
   inline void set_has_priority();
   inline void clear_has_priority();
-
+  
   ::CaptionDefProto* primary_;
   ::CaptionDefProto* secondary_;
   ::google::protobuf::int32 priority_;
-
+  
   mutable int _cached_size_;
   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
+  
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
   friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
-
+  
   void InitAsDefaultInstance();
   static CaptionRuleProto* default_instance_;
 };
@@ -683,27 +857,27 @@ class CircleRuleProto : public ::google::protobuf::MessageLite {
  public:
   CircleRuleProto();
   virtual ~CircleRuleProto();
-
+  
   CircleRuleProto(const CircleRuleProto& from);
-
+  
   inline CircleRuleProto& operator=(const CircleRuleProto& from) {
     CopyFrom(from);
     return *this;
   }
-
+  
   static const CircleRuleProto& default_instance();
-
+  
   void Swap(CircleRuleProto* other);
-
+  
   // implements Message ----------------------------------------------
-
+  
   CircleRuleProto* New() const;
   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
   void CopyFrom(const CircleRuleProto& from);
   void MergeFrom(const CircleRuleProto& from);
   void Clear();
   bool IsInitialized() const;
-
+  
   int ByteSize() const;
   bool MergePartialFromCodedStream(
       ::google::protobuf::io::CodedInputStream* input);
@@ -715,27 +889,27 @@ class CircleRuleProto : public ::google::protobuf::MessageLite {
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
+  
   ::std::string GetTypeName() const;
-
+  
   // nested types ----------------------------------------------------
-
+  
   // accessors -------------------------------------------------------
-
+  
   // required double radius = 1;
   inline bool has_radius() const;
   inline void clear_radius();
   static const int kRadiusFieldNumber = 1;
   inline double radius() const;
   inline void set_radius(double value);
-
+  
   // required uint32 color = 2;
   inline bool has_color() const;
   inline void clear_color();
   static const int kColorFieldNumber = 2;
   inline ::google::protobuf::uint32 color() const;
   inline void set_color(::google::protobuf::uint32 value);
-
+  
   // optional .LineDefProto border = 3;
   inline bool has_border() const;
   inline void clear_border();
@@ -743,14 +917,14 @@ class CircleRuleProto : public ::google::protobuf::MessageLite {
   inline const ::LineDefProto& border() const;
   inline ::LineDefProto* mutable_border();
   inline ::LineDefProto* release_border();
-
+  
   // required int32 priority = 4;
   inline bool has_priority() const;
   inline void clear_priority();
   static const int kPriorityFieldNumber = 4;
   inline ::google::protobuf::int32 priority() const;
   inline void set_priority(::google::protobuf::int32 value);
-
+  
   // @@protoc_insertion_point(class_scope:CircleRuleProto)
  private:
   inline void set_has_radius();
@@ -761,19 +935,19 @@ class CircleRuleProto : public ::google::protobuf::MessageLite {
   inline void clear_has_border();
   inline void set_has_priority();
   inline void clear_has_priority();
-
+  
   double radius_;
   ::LineDefProto* border_;
   ::google::protobuf::uint32 color_;
   ::google::protobuf::int32 priority_;
-
+  
   mutable int _cached_size_;
   ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
-
+  
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
   friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
-
+  
   void InitAsDefaultInstance();
   static CircleRuleProto* default_instance_;
 };
@@ -783,27 +957,27 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite {
  public:
   PathTextRuleProto();
   virtual ~PathTextRuleProto();
-
+  
   PathTextRuleProto(const PathTextRuleProto& from);
-
+  
   inline PathTextRuleProto& operator=(const PathTextRuleProto& from) {
     CopyFrom(from);
     return *this;
   }
-
+  
   static const PathTextRuleProto& default_instance();
-
+  
   void Swap(PathTextRuleProto* other);
-
+  
   // implements Message ----------------------------------------------
-
+  
   PathTextRuleProto* New() const;
   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
   void CopyFrom(const PathTextRuleProto& from);
   void MergeFrom(const PathTextRuleProto& from);
   void Clear();
   bool IsInitialized() const;
-
+  
   int ByteSize() const;
   bool MergePartialFromCodedStream(
       ::google::protobuf::io::CodedInputStream* input);
@@ -815,13 +989,13 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite {
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
+  
   ::std::string GetTypeName() const;
-
+  
   // nested types ----------------------------------------------------
-
+  
   // accessors -------------------------------------------------------
-
+  
   // required .CaptionDefProto primary = 1;
   inline bool has_primary() const;
   inline void clear_primary();
@@ -829,7 +1003,7 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite {
   inline const ::CaptionDefProto& primary() const;
   inline ::CaptionDefProto* mutable_primary();
   inline ::CaptionDefProto* release_primary();
-
+  
   // optional .CaptionDefProto secondary = 2;
   inline bool has_secondary() const;
   inline void clear_secondary();
@@ -837,14 +1011,14 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite {
   inline const ::CaptionDefProto& secondary() const;
   inline ::CaptionDefProto* mutable_secondary();
   inline ::CaptionDefProto* release_secondary();
-
+  
   // required int32 priority = 3;
   inline bool has_priority() const;
   inline void clear_priority();
   static const int kPriorityFieldNumber = 3;
   inline ::google::protobuf::int32 priority() const;
   inline void set_priority(::google::protobuf::int32 value);
-
+  
   // @@protoc_insertion_point(class_scope:PathTextRuleProto)
  private:
   inline void set_has_primary();
@@ -853,18 +1027,18 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite {
   inline void clear_has_secondary();
   inline void set_has_priority();
   inline void clear_has_priority();
-
+  
   ::CaptionDefProto* primary_;
   ::CaptionDefProto* secondary_;
   ::google::protobuf::int32 priority_;
-
+  
   mutable int _cached_size_;
   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
-
+  
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
   friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
-
+  
   void InitAsDefaultInstance();
   static PathTextRuleProto* default_instance_;
 };
@@ -874,27 +1048,27 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
  public:
   DrawElementProto();
   virtual ~DrawElementProto();
-
+  
   DrawElementProto(const DrawElementProto& from);
-
+  
   inline DrawElementProto& operator=(const DrawElementProto& from) {
     CopyFrom(from);
     return *this;
   }
-
+  
   static const DrawElementProto& default_instance();
-
+  
   void Swap(DrawElementProto* other);
-
+  
   // implements Message ----------------------------------------------
-
+  
   DrawElementProto* New() const;
   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
   void CopyFrom(const DrawElementProto& from);
   void MergeFrom(const DrawElementProto& from);
   void Clear();
   bool IsInitialized() const;
-
+  
   int ByteSize() const;
   bool MergePartialFromCodedStream(
       ::google::protobuf::io::CodedInputStream* input);
@@ -906,20 +1080,20 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
+  
   ::std::string GetTypeName() const;
-
+  
   // nested types ----------------------------------------------------
-
+  
   // accessors -------------------------------------------------------
-
+  
   // required int32 scale = 1;
   inline bool has_scale() const;
   inline void clear_scale();
   static const int kScaleFieldNumber = 1;
   inline ::google::protobuf::int32 scale() const;
   inline void set_scale(::google::protobuf::int32 value);
-
+  
   // repeated .LineRuleProto lines = 2;
   inline int lines_size() const;
   inline void clear_lines();
@@ -931,7 +1105,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
       lines() const;
   inline ::google::protobuf::RepeatedPtrField< ::LineRuleProto >*
       mutable_lines();
-
+  
   // optional .AreaRuleProto area = 3;
   inline bool has_area() const;
   inline void clear_area();
@@ -939,7 +1113,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
   inline const ::AreaRuleProto& area() const;
   inline ::AreaRuleProto* mutable_area();
   inline ::AreaRuleProto* release_area();
-
+  
   // optional .SymbolRuleProto symbol = 4;
   inline bool has_symbol() const;
   inline void clear_symbol();
@@ -947,7 +1121,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
   inline const ::SymbolRuleProto& symbol() const;
   inline ::SymbolRuleProto* mutable_symbol();
   inline ::SymbolRuleProto* release_symbol();
-
+  
   // optional .CaptionRuleProto caption = 5;
   inline bool has_caption() const;
   inline void clear_caption();
@@ -955,7 +1129,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
   inline const ::CaptionRuleProto& caption() const;
   inline ::CaptionRuleProto* mutable_caption();
   inline ::CaptionRuleProto* release_caption();
-
+  
   // optional .CircleRuleProto circle = 6;
   inline bool has_circle() const;
   inline void clear_circle();
@@ -963,7 +1137,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
   inline const ::CircleRuleProto& circle() const;
   inline ::CircleRuleProto* mutable_circle();
   inline ::CircleRuleProto* release_circle();
-
+  
   // optional .PathTextRuleProto path_text = 7;
   inline bool has_path_text() const;
   inline void clear_path_text();
@@ -971,7 +1145,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
   inline const ::PathTextRuleProto& path_text() const;
   inline ::PathTextRuleProto* mutable_path_text();
   inline ::PathTextRuleProto* release_path_text();
-
+  
   // @@protoc_insertion_point(class_scope:DrawElementProto)
  private:
   inline void set_has_scale();
@@ -986,7 +1160,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
   inline void clear_has_circle();
   inline void set_has_path_text();
   inline void clear_has_path_text();
-
+  
   ::google::protobuf::RepeatedPtrField< ::LineRuleProto > lines_;
   ::AreaRuleProto* area_;
   ::SymbolRuleProto* symbol_;
@@ -994,14 +1168,14 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
   ::CircleRuleProto* circle_;
   ::PathTextRuleProto* path_text_;
   ::google::protobuf::int32 scale_;
-
+  
   mutable int _cached_size_;
   ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
-
+  
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
   friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
-
+  
   void InitAsDefaultInstance();
   static DrawElementProto* default_instance_;
 };
@@ -1011,27 +1185,27 @@ class ClassifElementProto : public ::google::protobuf::MessageLite {
  public:
   ClassifElementProto();
   virtual ~ClassifElementProto();
-
+  
   ClassifElementProto(const ClassifElementProto& from);
-
+  
   inline ClassifElementProto& operator=(const ClassifElementProto& from) {
     CopyFrom(from);
     return *this;
   }
-
+  
   static const ClassifElementProto& default_instance();
-
+  
   void Swap(ClassifElementProto* other);
-
+  
   // implements Message ----------------------------------------------
-
+  
   ClassifElementProto* New() const;
   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
   void CopyFrom(const ClassifElementProto& from);
   void MergeFrom(const ClassifElementProto& from);
   void Clear();
   bool IsInitialized() const;
-
+  
   int ByteSize() const;
   bool MergePartialFromCodedStream(
       ::google::protobuf::io::CodedInputStream* input);
@@ -1043,13 +1217,13 @@ class ClassifElementProto : public ::google::protobuf::MessageLite {
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
+  
   ::std::string GetTypeName() const;
-
+  
   // nested types ----------------------------------------------------
-
+  
   // accessors -------------------------------------------------------
-
+  
   // required string name = 1;
   inline bool has_name() const;
   inline void clear_name();
@@ -1060,7 +1234,7 @@ class ClassifElementProto : public ::google::protobuf::MessageLite {
   inline void set_name(const char* value, size_t size);
   inline ::std::string* mutable_name();
   inline ::std::string* release_name();
-
+  
   // repeated .DrawElementProto element = 2;
   inline int element_size() const;
   inline void clear_element();
@@ -1072,22 +1246,22 @@ class ClassifElementProto : public ::google::protobuf::MessageLite {
       element() const;
   inline ::google::protobuf::RepeatedPtrField< ::DrawElementProto >*
       mutable_element();
-
+  
   // @@protoc_insertion_point(class_scope:ClassifElementProto)
  private:
   inline void set_has_name();
   inline void clear_has_name();
-
+  
   ::std::string* name_;
   ::google::protobuf::RepeatedPtrField< ::DrawElementProto > element_;
-
+  
   mutable int _cached_size_;
   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
+  
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
   friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
-
+  
   void InitAsDefaultInstance();
   static ClassifElementProto* default_instance_;
 };
@@ -1097,27 +1271,27 @@ class ContainerProto : public ::google::protobuf::MessageLite {
  public:
   ContainerProto();
   virtual ~ContainerProto();
-
+  
   ContainerProto(const ContainerProto& from);
-
+  
   inline ContainerProto& operator=(const ContainerProto& from) {
     CopyFrom(from);
     return *this;
   }
-
+  
   static const ContainerProto& default_instance();
-
+  
   void Swap(ContainerProto* other);
-
+  
   // implements Message ----------------------------------------------
-
+  
   ContainerProto* New() const;
   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
   void CopyFrom(const ContainerProto& from);
   void MergeFrom(const ContainerProto& from);
   void Clear();
   bool IsInitialized() const;
-
+  
   int ByteSize() const;
   bool MergePartialFromCodedStream(
       ::google::protobuf::io::CodedInputStream* input);
@@ -1129,13 +1303,13 @@ class ContainerProto : public ::google::protobuf::MessageLite {
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
+  
   ::std::string GetTypeName() const;
-
+  
   // nested types ----------------------------------------------------
-
+  
   // accessors -------------------------------------------------------
-
+  
   // repeated .ClassifElementProto cont = 1;
   inline int cont_size() const;
   inline void clear_cont();
@@ -1147,19 +1321,19 @@ class ContainerProto : public ::google::protobuf::MessageLite {
       cont() const;
   inline ::google::protobuf::RepeatedPtrField< ::ClassifElementProto >*
       mutable_cont();
-
+  
   // @@protoc_insertion_point(class_scope:ContainerProto)
  private:
-
+  
   ::google::protobuf::RepeatedPtrField< ::ClassifElementProto > cont_;
-
+  
   mutable int _cached_size_;
   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
-
+  
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
   friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
-
+  
   void InitAsDefaultInstance();
   static ContainerProto* default_instance_;
 };
@@ -1219,6 +1393,112 @@ inline void DashDotProto::set_offset(double value) {
 
 // -------------------------------------------------------------------
 
+// PathSymProto
+
+// required string name = 1;
+inline bool PathSymProto::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void PathSymProto::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void PathSymProto::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void PathSymProto::clear_name() {
+  if (name_ != &::google::protobuf::internal::kEmptyString) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& PathSymProto::name() const {
+  return *name_;
+}
+inline void PathSymProto::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+}
+inline void PathSymProto::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+}
+inline void PathSymProto::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* PathSymProto::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  return name_;
+}
+inline ::std::string* PathSymProto::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+
+// required double step = 2;
+inline bool PathSymProto::has_step() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void PathSymProto::set_has_step() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void PathSymProto::clear_has_step() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void PathSymProto::clear_step() {
+  step_ = 0;
+  clear_has_step();
+}
+inline double PathSymProto::step() const {
+  return step_;
+}
+inline void PathSymProto::set_step(double value) {
+  set_has_step();
+  step_ = value;
+}
+
+// optional double offset = 3;
+inline bool PathSymProto::has_offset() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void PathSymProto::set_has_offset() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void PathSymProto::clear_has_offset() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void PathSymProto::clear_offset() {
+  offset_ = 0;
+  clear_has_offset();
+}
+inline double PathSymProto::offset() const {
+  return offset_;
+}
+inline void PathSymProto::set_offset(double value) {
+  set_has_offset();
+  offset_ = value;
+}
+
+// -------------------------------------------------------------------
+
 // LineRuleProto
 
 // required double width = 1;
@@ -1316,6 +1596,81 @@ inline void LineRuleProto::set_priority(::google::protobuf::int32 value) {
   priority_ = value;
 }
 
+// optional .PathSymProto pathsym = 5;
+inline bool LineRuleProto::has_pathsym() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void LineRuleProto::set_has_pathsym() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void LineRuleProto::clear_has_pathsym() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void LineRuleProto::clear_pathsym() {
+  if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear();
+  clear_has_pathsym();
+}
+inline const ::PathSymProto& LineRuleProto::pathsym() const {
+  return pathsym_ != NULL ? *pathsym_ : *default_instance_->pathsym_;
+}
+inline ::PathSymProto* LineRuleProto::mutable_pathsym() {
+  set_has_pathsym();
+  if (pathsym_ == NULL) pathsym_ = new ::PathSymProto;
+  return pathsym_;
+}
+inline ::PathSymProto* LineRuleProto::release_pathsym() {
+  clear_has_pathsym();
+  ::PathSymProto* temp = pathsym_;
+  pathsym_ = NULL;
+  return temp;
+}
+
+// optional .LineJoin join = 6;
+inline bool LineRuleProto::has_join() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void LineRuleProto::set_has_join() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void LineRuleProto::clear_has_join() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void LineRuleProto::clear_join() {
+  join_ = 0;
+  clear_has_join();
+}
+inline LineJoin LineRuleProto::join() const {
+  return static_cast< LineJoin >(join_);
+}
+inline void LineRuleProto::set_join(LineJoin value) {
+  GOOGLE_DCHECK(LineJoin_IsValid(value));
+  set_has_join();
+  join_ = value;
+}
+
+// optional .LineCap cap = 7;
+inline bool LineRuleProto::has_cap() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void LineRuleProto::set_has_cap() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void LineRuleProto::clear_has_cap() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void LineRuleProto::clear_cap() {
+  cap_ = 0;
+  clear_has_cap();
+}
+inline LineCap LineRuleProto::cap() const {
+  return static_cast< LineCap >(cap_);
+}
+inline void LineRuleProto::set_cap(LineCap value) {
+  GOOGLE_DCHECK(LineCap_IsValid(value));
+  set_has_cap();
+  cap_ = value;
+}
+
 // -------------------------------------------------------------------
 
 // LineDefProto
@@ -1393,6 +1748,81 @@ inline ::DashDotProto* LineDefProto::release_dashdot() {
   return temp;
 }
 
+// optional .PathSymProto pathsym = 4;
+inline bool LineDefProto::has_pathsym() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void LineDefProto::set_has_pathsym() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void LineDefProto::clear_has_pathsym() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void LineDefProto::clear_pathsym() {
+  if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear();
+  clear_has_pathsym();
+}
+inline const ::PathSymProto& LineDefProto::pathsym() const {
+  return pathsym_ != NULL ? *pathsym_ : *default_instance_->pathsym_;
+}
+inline ::PathSymProto* LineDefProto::mutable_pathsym() {
+  set_has_pathsym();
+  if (pathsym_ == NULL) pathsym_ = new ::PathSymProto;
+  return pathsym_;
+}
+inline ::PathSymProto* LineDefProto::release_pathsym() {
+  clear_has_pathsym();
+  ::PathSymProto* temp = pathsym_;
+  pathsym_ = NULL;
+  return temp;
+}
+
+// optional .LineJoin join = 6;
+inline bool LineDefProto::has_join() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void LineDefProto::set_has_join() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void LineDefProto::clear_has_join() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void LineDefProto::clear_join() {
+  join_ = 0;
+  clear_has_join();
+}
+inline LineJoin LineDefProto::join() const {
+  return static_cast< LineJoin >(join_);
+}
+inline void LineDefProto::set_join(LineJoin value) {
+  GOOGLE_DCHECK(LineJoin_IsValid(value));
+  set_has_join();
+  join_ = value;
+}
+
+// optional .LineCap cap = 7;
+inline bool LineDefProto::has_cap() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void LineDefProto::set_has_cap() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void LineDefProto::clear_has_cap() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void LineDefProto::clear_cap() {
+  cap_ = 0;
+  clear_has_cap();
+}
+inline LineCap LineDefProto::cap() const {
+  return static_cast< LineCap >(cap_);
+}
+inline void LineDefProto::set_cap(LineCap value) {
+  GOOGLE_DCHECK(LineCap_IsValid(value));
+  set_has_cap();
+  cap_ = value;
+}
+
 // -------------------------------------------------------------------
 
 // AreaRuleProto