xsdvi 1.0.0

data/lib/xsdvi/xsd_handler.rb

@@ -0,0 +1,323 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Xsdvi
+  # Handles XSD parsing and tree building
+  class XsdHandler
+    XSD_NAMESPACE = "http://www.w3.org/2001/XMLSchema"
+
+    attr_accessor :root_node_name, :one_node_only
+    attr_reader :builder, :schema_namespace
+
+    def initialize(builder)
+      @builder = builder
+      @stack = []
+      @root_node_name = nil
+      @one_node_only = false
+      @schema_namespace = nil
+    end
+
+    def process_file(file_path)
+      doc = Nokogiri::XML(File.read(file_path))
+      process_model(doc)
+    end
+
+    def process_model(doc)
+      return unless doc
+
+      # Extract target namespace
+      schema_node = doc.at_xpath("/xs:schema", "xs" => XSD_NAMESPACE)
+      @schema_namespace = schema_node["targetNamespace"] if schema_node
+
+      # Create schema symbol when no root node specified (matches Java line 65-68)
+      if root_node_name.nil?
+        symbol = SVG::Symbols::Schema.new
+        builder.set_root(symbol)
+      end
+
+      process_element_declarations(doc)
+
+      # Level up after processing all elements (matches Java line 71-73)
+      builder.level_up if root_node_name.nil?
+    end
+
+    def get_elements_names(doc)
+      elements = doc.xpath("//xs:schema/xs:element", "xs" => XSD_NAMESPACE)
+      elements.filter_map { |elem| elem["name"] }
+    end
+
+    def set_schema_namespace(doc, element_name)
+      elements = doc.xpath("//xs:schema/xs:element", "xs" => XSD_NAMESPACE)
+      elements.each do |elem|
+        if elem["name"] == element_name
+          @schema_namespace = schema_node = doc.at_xpath("/xs:schema",
+                                                         "xs" => XSD_NAMESPACE)
+          @schema_namespace = schema_node["targetNamespace"] if schema_node
+          break
+        end
+      end
+    end
+
+    private
+
+    def process_element_declarations(doc)
+      elements = doc.xpath("//xs:schema/xs:element", "xs" => XSD_NAMESPACE)
+
+      elements.each do |elem|
+        name = elem["name"]
+        is_root = name == root_node_name
+        if is_root || root_node_name.nil?
+          process_element_declaration(elem, nil,
+                                      is_root)
+        end
+      end
+    end
+
+    def process_element_declaration(elem_node, cardinality, is_root)
+      name = elem_node["name"]
+      elem_namespace = elem_node["namespace"]
+      elem_node["ref"]
+      type_attr = elem_node["type"]
+      nillable = elem_node["nillable"] == "true"
+      abstract = elem_node["abstract"] == "true"
+
+      symbol = SVG::Symbols::Element.new
+      symbol.name = name
+
+      # Set namespace if different from schema namespace (matches Java line 228-231)
+      if elem_namespace && elem_namespace != schema_namespace
+        symbol.namespace = elem_namespace
+      elsif schema_namespace && schema_namespace != elem_namespace
+        # Show schema namespace on element when element doesn't override it
+        symbol.namespace = schema_namespace
+      end
+
+      # Get type string (matches Java getTypeString logic)
+      symbol.type = get_type_string(elem_node, type_attr)
+      symbol.cardinality = cardinality
+      symbol.nillable = nillable
+      symbol.abstract = abstract
+      symbol.description = extract_documentation(elem_node)
+      symbol.start_y_position = 20 if is_root && one_node_only
+
+      # Set root or append child (matches Java line 241-245)
+      if is_root
+        builder.set_root(symbol)
+      else
+        builder.append_child(symbol)
+      end
+
+      # Check for loops (matches Java line 247-250)
+      if process_loop?(elem_node)
+        builder.level_up
+        return
+      end
+
+      @stack.push(elem_node)
+
+      # Skip processing children if stack size > 1 and oneNodeOnly (matches Java line 253-260)
+      unless @stack.size > 1 && one_node_only
+        # Check if element has inline complexType
+        complex_type = elem_node.at_xpath("xs:complexType",
+                                          "xs" => XSD_NAMESPACE)
+        if complex_type
+          process_complex_type_node(complex_type)
+        elsif !type_attr
+          # No type means anyType - expand it
+          process_any_type_default
+        elsif type_attr == "anyType"
+          process_any_type_default
+        end
+      end
+
+      @stack.pop
+      builder.level_up
+    end
+
+    def get_type_string(elem_node, type_attr)
+      return "type: #{type_attr}" if type_attr
+
+      # Check for inline simpleType or complexType
+      complex_type = elem_node.at_xpath("xs:complexType", "xs" => XSD_NAMESPACE)
+      simple_type = elem_node.at_xpath("xs:simpleType", "xs" => XSD_NAMESPACE)
+
+      return nil if complex_type # Anonymous complex type
+
+      if simple_type
+        return "base: #{simple_type.at_xpath('xs:restriction',
+                                             'xs' => XSD_NAMESPACE)['base']}"
+      end
+
+      "type: anyType" # Default
+    end
+
+    def process_any_type_default
+      # anyType default content model: sequence containing 0..unbounded any and anyAttribute
+      symbol = SVG::Symbols::Sequence.new
+      symbol.cardinality = nil
+      builder.append_child(symbol)
+
+      # Add any element
+      any_symbol = SVG::Symbols::Any.new
+      any_symbol.namespace = "any NS"
+      any_symbol.process_contents = SVG::Symbol::PC_LAX
+      any_symbol.cardinality = "0..∞"
+      builder.append_child(any_symbol)
+      builder.level_up
+
+      builder.level_up
+
+      # Add anyAttribute
+      any_attr_symbol = SVG::Symbols::AnyAttribute.new
+      any_attr_symbol.namespace = "any NS"
+      any_attr_symbol.process_contents = SVG::Symbol::PC_LAX
+      builder.append_child(any_attr_symbol)
+      builder.level_up
+    end
+
+    def process_complex_type_node(complex_type_node)
+      # Process particles (sequence/choice/all)
+      sequence = complex_type_node.at_xpath("xs:sequence",
+                                            "xs" => XSD_NAMESPACE)
+      process_sequence(sequence, nil) if sequence
+
+      choice = complex_type_node.at_xpath("xs:choice", "xs" => XSD_NAMESPACE)
+      process_choice(choice, nil) if choice
+
+      all_node = complex_type_node.at_xpath("xs:all", "xs" => XSD_NAMESPACE)
+      process_all(all_node, nil) if all_node
+
+      # Process attributes
+      attributes = complex_type_node.xpath("xs:attribute",
+                                           "xs" => XSD_NAMESPACE)
+      attributes.each { |attr| process_attribute(attr) }
+
+      # Process attribute wildcard
+      any_attr = complex_type_node.at_xpath("xs:anyAttribute",
+                                            "xs" => XSD_NAMESPACE)
+      process_any_attribute(any_attr) if any_attr
+    end
+
+    def process_sequence(sequence_node, cardinality)
+      card = cardinality || get_cardinality(sequence_node)
+      symbol = SVG::Symbols::Sequence.new
+      symbol.cardinality = card
+      symbol.description = extract_documentation(sequence_node)
+      builder.append_child(symbol)
+
+      # Process child elements
+      sequence_node.xpath("xs:element", "xs" => XSD_NAMESPACE).each do |elem|
+        process_element_declaration(elem, get_cardinality(elem), false)
+      end
+
+      # Process any
+      sequence_node.xpath("xs:any", "xs" => XSD_NAMESPACE).each do |any|
+        process_any(any)
+      end
+
+      builder.level_up
+    end
+
+    def process_choice(choice_node, cardinality)
+      card = cardinality || get_cardinality(choice_node)
+      symbol = SVG::Symbols::Choice.new
+      symbol.cardinality = card
+      symbol.description = extract_documentation(choice_node)
+      builder.append_child(symbol)
+
+      # Process child elements
+      choice_node.xpath("xs:element", "xs" => XSD_NAMESPACE).each do |elem|
+        process_element_declaration(elem, get_cardinality(elem), false)
+      end
+
+      builder.level_up
+    end
+
+    def process_all(all_node, cardinality)
+      card = cardinality || get_cardinality(all_node)
+      symbol = SVG::Symbols::All.new
+      symbol.cardinality = card
+      symbol.description = extract_documentation(all_node)
+      builder.append_child(symbol)
+
+      # Process child elements
+      all_node.xpath("xs:element", "xs" => XSD_NAMESPACE).each do |elem|
+        process_element_declaration(elem, get_cardinality(elem), false)
+      end
+
+      builder.level_up
+    end
+
+    def process_any(any_node)
+      symbol = SVG::Symbols::Any.new
+      namespace = any_node["namespace"]
+      symbol.namespace = namespace || "any NS"
+      process_contents = any_node["processContents"]
+      symbol.process_contents = case process_contents
+                                when "skip" then SVG::Symbol::PC_SKIP
+                                when "lax" then SVG::Symbol::PC_LAX
+                                when "strict" then SVG::Symbol::PC_STRICT
+                                else SVG::Symbol::PC_LAX  # Default is lax for anyType
+                                end
+      symbol.cardinality = get_cardinality(any_node)
+      symbol.description = extract_documentation(any_node)
+      builder.append_child(symbol)
+      builder.level_up
+    end
+
+    def process_attribute(attr_node)
+      symbol = SVG::Symbols::Attribute.new
+      symbol.name = attr_node["name"]
+      namespace = attr_node["namespace"]
+      symbol.namespace = namespace if namespace && namespace != schema_namespace
+      symbol.type = attr_node["type"] ? "type: #{attr_node['type']}" : nil
+      symbol.required = attr_node["use"] == "required"
+      symbol.description = extract_documentation(attr_node)
+
+      builder.append_child(symbol)
+      builder.level_up
+    end
+
+    def process_any_attribute(any_attr_node)
+      symbol = SVG::Symbols::AnyAttribute.new
+      namespace = any_attr_node["namespace"]
+      symbol.namespace = namespace || "any NS"
+      process_contents = any_attr_node["processContents"]
+      symbol.process_contents = case process_contents
+                                when "skip" then SVG::Symbol::PC_SKIP
+                                when "lax" then SVG::Symbol::PC_LAX
+                                when "strict" then SVG::Symbol::PC_STRICT
+                                else SVG::Symbol::PC_LAX  # Default is lax for anyType
+                                end
+      symbol.description = extract_documentation(any_attr_node)
+      builder.append_child(symbol)
+      builder.level_up
+    end
+
+    def process_loop?(elem_node)
+      @stack.any?(elem_node)
+    end
+
+    def get_cardinality(node)
+      min_occurs = node["minOccurs"]&.to_i || 1
+      max_occurs = node["maxOccurs"]
+
+      return nil if min_occurs == 1 && (max_occurs.nil? || max_occurs == "1")
+
+      if max_occurs == "unbounded"
+        "#{min_occurs}..∞"
+      elsif max_occurs
+        "#{min_occurs}..#{max_occurs}"
+      end
+    end
+
+    def extract_documentation(node)
+      docs = node.xpath(
+        ".//xs:annotation/xs:documentation",
+        "xs" => XSD_NAMESPACE,
+      )
+      docs.map(&:text).map { |text| text.gsub(/\n[ \t]+/, "\n") }
+    end
+  end
+end

data/lib/xsdvi.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "xsdvi/version"
+require_relative "xsdvi/cli"
+require_relative "xsdvi/xsd_handler"
+require_relative "xsdvi/tree/element"
+require_relative "xsdvi/tree/builder"
+require_relative "xsdvi/svg/generator"
+require_relative "xsdvi/svg/symbol"
+require_relative "xsdvi/svg/symbols/all"
+require_relative "xsdvi/svg/symbols/any"
+require_relative "xsdvi/svg/symbols/any_attribute"
+require_relative "xsdvi/svg/symbols/attribute"
+require_relative "xsdvi/svg/symbols/choice"
+require_relative "xsdvi/svg/symbols/element"
+require_relative "xsdvi/svg/symbols/field"
+require_relative "xsdvi/svg/symbols/key"
+require_relative "xsdvi/svg/symbols/keyref"
+require_relative "xsdvi/svg/symbols/loop"
+require_relative "xsdvi/svg/symbols/schema"
+require_relative "xsdvi/svg/symbols/selector"
+require_relative "xsdvi/svg/symbols/sequence"
+require_relative "xsdvi/svg/symbols/unique"
+require_relative "xsdvi/utils/writer"
+require_relative "xsdvi/utils/resource_loader"
+require_relative "xsdvi/utils/width_calculator"
+
+module Xsdvi
+  class Error < StandardError; end
+end

data/resources/svg/defined_symbols.svg

@@ -0,0 +1,9 @@
+  <symbol class='button' id='plus'>
+    <rect x='1' y='1' width='10' height='10'/>
+    <line x1='3' y1='6' x2='9' y2='6'/>
+    <line x1='6' y1='3' x2='6' y2='9'/>
+  </symbol>
+  <symbol class='button' id='minus'>
+    <rect x='1' y='1' width='10' height='10'/>
+    <line x1='3' y1='6' x2='9' y2='6'/>
+  </symbol>

data/resources/svg/doctype.txt

@@ -0,0 +1 @@
+<!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN' 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'>

data/resources/svg/menu_buttons.svg

@@ -0,0 +1,7 @@
+<rect class='button' x='300' y='10' width='20' height='20' onclick='collapseAll()'/>
+<line x1='303' y1='20' x2='317' y2='20'/>
+<text x='330' y='20'>collapse all</text>
+<rect class='button' x='400' y='10' width='20' height='20' onclick='expandAll()'/>
+<line x1='403' y1='20' x2='417' y2='20'/>
+<line x1='410' y1='13' x2='410' y2='27'/>
+<text x='430' y='20'>expand all</text>

data/resources/svg/script.js

@@ -0,0 +1,265 @@
+<script type='text/ecmascript'><![CDATA[
+
+  var efBoxes = [];
+  var eSvg = null;
+
+////////// loadSVG()
+  function loadSVG() {
+    efBoxes = getElementsByClassName('box', document.getElementsByTagName('g'));
+    eSvg = document.getElementById('svg');
+    expandAll();
+  }
+
+////////// getElementsByClassName(string, nodeList)
+  function getElementsByClassName(sClass, nlNodes) {
+    var elements = [];
+    for (var i=0; i<nlNodes.length; i++) {
+      if(nlNodes.item(i).nodeType==1 && sClass==nlNodes.item(i).getAttribute('class')) {
+        elements.push(nlNodes.item(i));
+      }
+    }
+    return elements;
+  }
+
+////////// show(string)
+  function show(sId) {
+    var useElement = document.getElementById('s'+sId);
+    var moveNext = false;
+    var eBoxLast;
+    var maxX = 500;
+    
+    if (notPlus(useElement)) {
+      eBoxLast = document.getElementById(sId);
+      setPlus(useElement);
+      for (var i=0; i<efBoxes.length; i++) {
+        var eBox = efBoxes[i];
+        if (moveNext) {
+          move(eBoxLast, eBox);
+        }
+        else if (isDescendant(sId, eBox.id)) {
+          eBox.setAttribute('visibility', 'hidden');
+        }
+        else if (isHigherBranch(sId, eBox.id)) {
+          move(eBoxLast, eBox);
+          moveNext = true;
+        }
+        if (eBox.getAttribute('visibility') != 'hidden') {
+          eBoxLast = eBox;
+          x = xTrans(eBox);
+          if (x > maxX) maxX = x;
+        }
+      }
+    }
+
+    else {
+      setMinus(useElement);
+      var skipDescendantsOf;
+      for (var i=0; i<efBoxes.length; i++) {
+        var eBox = efBoxes[i];
+        if (moveNext) {
+          move(eBoxLast, eBox);
+        }
+        else if (isDescendant(sId, eBox.id) && (!skipDescendantsOf || !isDescendant(skipDescendantsOf.id, eBox.id))) {
+          eBox.setAttribute('visibility', 'visible');
+          move(eBoxLast, eBox);
+          if (nextClosed(eBox)) skipDescendantsOf = eBox;
+        }
+        else if (isHigherBranch(sId, eBox.id)) {
+          move(eBoxLast, eBox);
+          moveNext = true;
+        }
+        if (eBox.getAttribute('visibility') != 'hidden') {
+          eBoxLast = eBox;
+          x = xTrans(eBox);
+          if (x > maxX) maxX = x;
+        }
+      }
+    }
+    //setHeight(yTrans(eBoxLast)+"+(AbstractSymbol.MAX_HEIGHT+AbstractSymbol.Y_INDENT)+");\n"+
+    setHeight(yTrans(eBoxLast)+%HEIGHT_SUM%);
+    setWidth(maxX+360);
+  }
+
+////////// collapseAll()
+  function collapseAll() {
+    for (var i=0; i<efBoxes.length; i++) {
+      var eBox = efBoxes[i];
+      var useElement = document.getElementById('s'+eBox.id);
+      if (useElement) setPlus(useElement);
+      if (eBox.id != '_1') eBox.setAttribute('visibility', 'hidden');
+    }
+    setHeight(400);
+    setWidth(500);
+  }
+
+////////// expandAll()
+  function expandAll() {
+    var eBoxLast;
+    var maxX = 0;
+    for (var i=0; i<efBoxes.length; i++) {
+      var eBox = efBoxes[i];
+      var useElement = document.getElementById('s'+eBox.id);
+      if (useElement) setMinus(useElement);
+      move(eBoxLast, eBox);
+      eBox.setAttribute('visibility', 'visible');
+      eBoxLast = eBox;
+      var x = xTrans(eBox);
+      if (x > maxX) maxX = x;
+    }
+    //setHeight(yTrans(eBoxLast)+"+(AbstractSymbol.MAX_HEIGHT+AbstractSymbol.Y_INDENT)+");\n"+
+    setHeight(yTrans(eBoxLast)+%HEIGHT_SUM%);
+    setWidth(maxX+360);
+  }
+
+////////// makeVisible(string)
+  function makeVisible(sId) {
+    var childNodes = document.getElementById(sId).childNodes;
+    var hidden = getElementsByClassName('hidden', childNodes);
+    var visible = getElementsByClassName('visible', childNodes);
+    inheritVisibility(hidden);
+    hiddenVisibility(visible);
+  }
+
+////////// makeHidden(string)
+  function makeHidden(sId) {
+    var childNodes = document.getElementById(sId).childNodes;
+    var hidden = getElementsByClassName('hidden', childNodes);
+    var visible = getElementsByClassName('visible', childNodes);
+    inheritVisibility(visible);
+    hiddenVisibility(hidden);
+  }
+
+////////// inheritVisibility(element[])
+  function inheritVisibility(efElements) {
+    for (var i=0; i<efElements.length; i++) {
+      efElements[i].setAttribute('visibility', 'inherit');
+    }
+  }
+
+////////// hiddenVisibility(element[])
+  function hiddenVisibility(efElements) {
+    for (var i=0; i<efElements.length; i++) {
+      efElements[i].setAttribute('visibility', 'hidden');
+    }
+  }
+
+////////// nextClosed(element)
+  function nextClosed(eBox) {
+    var useElement = document.getElementById('s'+eBox.id);
+    return (useElement && !notPlus(useElement));
+  }
+
+////////// isHigherBranch(string, string)
+  function isHigherBranch(sSerialLower, sSerialHigher) {
+    var sLower = sSerialLower.split('_');
+    var sHigher = sSerialHigher.split('_');
+    for (var i=0; i<sLower.length; i++) {
+      if (Number(sHigher[i]) > Number(sLower[i])) return true;
+      else if (Number(sHigher[i]) < Number(sLower[i])) return false;
+    }
+    return false;
+  }
+
+////////// isOnHigherLevel(element, element)
+  function isOnHigherLevel(eBoxLower, eBoxHigher) {
+    var sLower = eBoxLower.id.split('_');
+    var sHigher = eBoxHigher.id.split('_');
+    for (var i=0; i<sLower.length; i++) {
+      if (Number(sHigher[i]) > Number(sLower[i])) return true;
+    }
+    return false;
+  }
+
+////////// isDescendant(string, string)
+  function isDescendant(sSerialAsc, sSerialDesc) {
+    return (sSerialDesc.length > sSerialAsc.length && sSerialDesc.indexOf(sSerialAsc) === 0);
+  }
+
+////////// getParent(element)
+  function getParent(eBox) {
+    var serial = eBox.id.substring(0, eBox.id.lastIndexOf('_'));
+    return document.getElementById(serial);
+  }
+
+////////// move(element, element)
+  function move(eBoxLast, eBox) {
+    if (!eBoxLast) return;
+    if (isOnHigherLevel(eBoxLast, eBox)) {
+      //setYTrans(eBox, yTrans(eBoxLast)+"+(AbstractSymbol.MAX_HEIGHT+AbstractSymbol.Y_INDENT)+");\n"+
+      var attDescHeight = eBoxLast.getAttribute('data-desc-height-rest');
+      var attDescX = Number(eBoxLast.getAttribute('data-desc-x'));
+      var attX = xTrans(eBox);
+      var descHeight = Number(attDescHeight);
+      var heightAddon = 0;
+
+      var currWidth = eBox.getElementsByClassName("shadow")[0];
+      if (currWidth) {
+        currWidth = Number(currWidth.getAttribute("width"));
+      } else {
+        currWidth = 0;
+      }
+      if(descHeight && ((attDescX >= attX && attDescX < attX + currWidth) || (attX < attDescX))) heightAddon = descHeight;
+
+      setYTrans(eBox, yTrans(eBoxLast)+%HEIGHT_SUM%+heightAddon);
+      var parent = getParent(eBox);
+      var line = document.getElementById('p'+eBox.id);
+      if (!parent || !line) return;
+		//"      line.y1.baseVal.valueInSpecifiedUnits = yTrans(parent)-yTrans(eBox)+"+AbstractSymbol.MAX_HEIGHT/2+";
+      //line.setAttribute('y1', String(yTrans(parent)-yTrans(eBox)+"+AbstractSymbol.MAX_HEIGHT/2+"));\n"+
+      line.setAttribute('y1', String(yTrans(parent)-yTrans(eBox)+%HEIGHT_HALF%));
+    }
+    else {
+      setYTrans(eBox, yTrans(eBoxLast));
+    }
+  }
+
+////////// notPlus(element)
+  function notPlus(eUseElement) {
+    return (eUseElement.getAttributeNS('http://www.w3.org/1999/xlink', 'href') != '#plus');
+  }
+
+////////// setPlus(element)
+  function setPlus(eUseElement) {
+    eUseElement.setAttributeNS('http://www.w3.org/1999/xlink', 'href', '#plus');
+  }
+
+////////// setMinus(element)
+  function setMinus(eUseElement) {
+    eUseElement.setAttributeNS('http://www.w3.org/1999/xlink', 'href', '#minus');
+  }
+
+////////// setHeight(number)
+  function setHeight(nHeight) {
+    eSvg.setAttribute('height', nHeight);
+  }
+
+////////// setWidth(number)
+  function setWidth(nWidth) {
+    eSvg.setAttribute('width', nWidth);
+  }
+
+////////// xyTrans(element)
+  function xTrans(eBox) {
+		//"    return eBox.transform.baseVal.getItem(0).matrix.e;
+    var transform = eBox.getAttribute('transform');
+    var x = Number(transform.substring(10, Number(transform.length)-1).split(',')[0]);
+    if(!x) x = 0;
+    return x;
+  }
+
+////////// yTrans(element)
+  function yTrans(eBox) {
+		//"    return eBox.transform.baseVal.getItem(0).matrix.f;
+    var transform = eBox.getAttribute('transform');
+    var y = Number(transform.substring(10, Number(transform.length)-1).split(',')[1]);
+    if(!y) y = 0;
+    return y;
+  }
+
+////////// setYTrans(element, number)
+  function setYTrans(eBox, nValue) {
+		//"    return eBox.transform.baseVal.getItem(0).matrix.f = nValue;
+    eBox.setAttribute('transform', 'translate('+xTrans(eBox)+','+nValue+')');
+  }
+
+]]></script>

data/resources/svg/style.css

@@ -0,0 +1,29 @@
+svg {pointer-events: none;}
+text {font-family: arial; font-size: 11px;}
+line, polyline, polygon {fill: none; stroke: black;}
+
+.strong {font-size: 12px; font-weight: bold;}
+.small {font-size: 10px;}
+.big {font-size: 15px; fill: #882222;}
+
+.button {fill: white; stroke: black; pointer-events: all;}
+.shadow {fill: #ccccd8; stroke: none;}
+.connection {fill: none; stroke: #666666;}
+.empty {fill: none; stroke: black;}
+.filled {fill: black; stroke: none;}
+
+.boxelement, .boxany, .boxattribute1, .boxanyattribute {fill: #FFFFBB; stroke: #776633; pointer-events: all;}
+.boxelementoptional {fill: #FFFFBB; stroke: #776633; pointer-events: all; stroke-dasharray: 2;}
+.boxattribute2 {fill: #FFFFBB; stroke: #776633; pointer-events: all; stroke-dasharray: 2;}
+.boxschema, .boxloop, .boxcompositor {fill: #E7EBF3; stroke: #666677;}
+.boxselector, .boxfield, .boxidc {fill: #E0F7B7; stroke: #667733;}
+
+.lax {fill: white; stroke: black;}
+.skip {fill: #cc6666; stroke: black;}
+.strict {fill: black; stroke: none;}
+
+.border {fill: #f9f9f9; stroke: #dddddd;}
+
+.elementlink {fill: blue;}
+
+.desc {fill: #888888;}

data/resources/svg/style.html

@@ -0,0 +1,3 @@
+<style type='text/css'><![CDATA[
+%STYLE%
+]]></style>

data/resources/svg/style.xml

@@ -0,0 +1 @@
+<?xml-stylesheet href='%STYLE_URI%' type='text/css'?>

data/resources/svg/svg_end.txt

@@ -0,0 +1 @@
+</svg>

data/resources/svg/svg_start.txt

@@ -0,0 +1 @@
+<svg id='svg' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' onload='loadSVG();'>

data/resources/svg/title.txt

@@ -0,0 +1 @@
+<title>XsdVi</title>

data/resources/svg/xml_declaration.xml

@@ -0,0 +1 @@
+<?xml version='1.0' encoding='UTF-8'?>