/// <summary>
/// Reads the given attribute into the specified object.
/// </summary>
protected void DecodeAttribute(mxCodec dec, XmlNode attr, Object obj)
{
string name = attr.Name;
if (!name.ToLower().Equals("as") &&
!name.ToLower().Equals("id"))
{
Object value = attr.Value;
string fieldname = GetFieldName(name);
if (IsReference(obj, fieldname, value, false))
{
Object tmp = dec.GetObject(value.ToString());
if (tmp == null)
{
Trace.WriteLine("mxObjectCodec.decode: No object for " +
GetName() + "." + fieldname + "=" + value);
return; // exit
}
value = tmp;
}
if (!IsExcluded(obj, fieldname, value, false))
{
SetFieldValue(obj, fieldname, value);
}
}
}
/// <summary>
/// Parses the given node into the object or returns a new object
/// representing the given node.
/// Dec is a reference to the calling decoder. It is used to decode
/// complex objects and resolve references.
/// If a node has an id attribute then the object cache is checked for the
/// object. If the object is not yet in the cache then it is constructed
/// using the constructor of template and cached in mxCodec.objects.
/// This implementation decodes all attributes and childs of a node
/// according to the following rules:
/// - If the variable name is in exclude or if the attribute name is "id"
/// or "as" then it is ignored.
/// - If the variable name is in idrefs then mxCodec.getObject is used
/// to replace the reference with an object.
/// - The variable name is mapped using a reverse mapping.
/// - If the value has a child node, then the codec is used to create a
/// child object with the variable name taken from the "as" attribute.
/// - If the object is an array and the variable name is empty then the
/// value or child object is appended to the array.
/// - If an add child has no value or the object is not an array then
/// the child text content is evaluated using mxUtils.eval.
/// If no object exists for an ID in idrefs a warning is issued
/// using mxLog.warn.
/// Returns the resulting object that represents the given XML
/// node or the configured given object.
/// </summary>
/// <param name="dec">Codec that controls the encoding process.</param>
/// <param name="node">XML node to be decoded.</param>
/// <param name="into">Optional objec to encode the node into.</param>
/// <returns>Returns the resulting object that represents the given XML node
/// or the object given to the method as the into parameter.</returns>
public virtual Object Decode(mxCodec dec, XmlNode node, Object into)
{
Object obj = null;
if (node is XmlElement)
{
string id = ((XmlElement)node).GetAttribute("id");
obj = (dec.Objects.ContainsKey(id)) ? dec.Objects[id] : null;
if (obj == null)
{
obj = into;
if (obj == null)
{
obj = CloneTemplate(node);
}
if (id != null && id.Length > 0)
{
dec.PutObject(id, obj);
}
}
node = BeforeDecode(dec, node, obj);
DecodeNode(dec, node, obj);
obj = AfterDecode(dec, node, obj);
}
return(obj);
}
/// <summary>
/// Encodes an mxCell and wraps the XML up inside the
/// XML of the user object (inversion).
/// </summary>
public override XmlNode AfterEncode(mxCodec enc, Object obj, XmlNode node)
{
if (obj is mxCell && node is XmlElement)
{
mxCell cell = (mxCell)obj;
if (cell.Value != null)
{
if (cell.Value is XmlNode)
{
// Wraps the graphical annotation up in the
// user object (inversion) by putting the
// result of the default encoding into
// a clone of the user object (node type 1)
// and returning this cloned user object.
XmlElement tmp = (XmlElement)node;
node = enc.Document.ImportNode((XmlNode)cell.Value, true);
node.AppendChild(tmp);
// Moves the id attribute to the outermost
// XML node, namely the node which denotes
// the object boundaries in the file.
String id = tmp.GetAttribute("id");
((XmlElement)node).SetAttribute("id", id);
tmp.RemoveAttribute("id");
}
}
}
return node;
}
/// <summary>
/// Reads the specified child into the given object.
/// </summary>
protected void DecodeChild(mxCodec dec, XmlNode child, Object obj)
{
string fieldname = GetFieldName(((XmlElement)child).GetAttribute("as"));
if (fieldname == null || !IsExcluded(obj, fieldname, child, false))
{
Object template = GetFieldTemplate(obj, fieldname, child);
Object value = null;
if (child.Name.Equals("add"))
{
value = ((XmlElement)child).GetAttribute("value");
if (value == null)
{
value = child.InnerText;
}
}
else
{
value = dec.Decode(child, template);
}
AddObjectValue(obj, fieldname, value, template);
}
}
/// <summary>
/// Converts the given value according to the mappings and id-refs in
/// this codec and uses writeAttribute to write the attribute into the
/// given node.
/// </summary>
/// <param name="enc">Codec that controls the encoding process.</param>
/// <param name="obj">Object whose member is going to be encoded.</param>
/// <param name="fieldname"></param>
/// <param name="value">Value of the property to be encoded.</param>
/// <param name="node">XML node that contains the encoded object.</param>
protected void EncodeValue(mxCodec enc, Object obj, string fieldname,
Object value, XmlNode node)
{
if (value != null && !IsExcluded(obj, fieldname, value, true))
{
if (IsReference(obj, fieldname, value, true))
{
Object tmp = enc.GetId(value);
if (tmp == null)
{
Trace.WriteLine("mxObjectCodec.encode: No ID for " +
GetName() + "." + fieldname + "=" + value);
return; // exit
}
value = tmp;
}
Object defaultValue = GetFieldValue(template, fieldname);
if (fieldname == null || enc.IsEncodeDefaults ||
defaultValue == null || !defaultValue.Equals(value))
{
WriteAttribute(enc, obj, GetAttributeName(fieldname), value,
node);
}
}
}
/// <summary>
/// Encodes an mxCell and wraps the XML up inside the
/// XML of the user object (inversion).
/// </summary>
public override XmlNode AfterEncode(mxCodec enc, Object obj, XmlNode node)
{
if (obj is mxCell && node is XmlElement)
{
mxCell cell = (mxCell)obj;
if (cell.Value != null)
{
if (cell.Value is XmlNode)
{
// Wraps the graphical annotation up in the
// user object (inversion) by putting the
// result of the default encoding into
// a clone of the user object (node type 1)
// and returning this cloned user object.
XmlElement tmp = (XmlElement)node;
node = enc.Document.ImportNode((XmlNode)cell.Value, true);
node.AppendChild(tmp);
// Moves the id attribute to the outermost
// XML node, namely the node which denotes
// the object boundaries in the file.
String id = tmp.GetAttribute("id");
((XmlElement)node).SetAttribute("id", id);
tmp.RemoveAttribute("id");
}
}
}
return(node);
}
public static void Main()
{
// Creates graph with model
mxGraph graph = new mxGraph();
// Adds cells into the model
Object parent = graph.GetDefaultParent();
graph.Model.BeginUpdate();
Object v1, v2, e1;
try
{
v1 = graph.InsertVertex(parent, null, "Hello", 20, 20, 80, 30);
v2 = graph.InsertVertex(parent, null, "World!", 200, 150, 80, 30);
e1 = graph.InsertEdge(parent, null, "e1", v1, v2);
}
finally
{
graph.Model.EndUpdate();
}
mxCodec codec = new mxCodec();
XmlNode node = codec.Encode(graph.Model);
string xml1 = mxUtils.GetPrettyXml(node);
codec = new mxCodec();
Object model = codec.Decode(node);
codec = new mxCodec();
node = codec.Encode(model);
string xml2 = mxUtils.GetPrettyXml(node);
Console.WriteLine("mxCodecTest Passed: "+(xml1.Equals(xml2)));
Thread.Sleep(100000);
}
/// <summary>
/// Encode the given mxStylesheet.
/// </summary>
public override XmlNode Encode(mxCodec enc, Object obj)
{
XmlElement node = enc.Document.CreateElement(GetName());
if (obj is mxStylesheet)
{
mxStylesheet stylesheet = (mxStylesheet)obj;
foreach (KeyValuePair <string, Dictionary <string, Object> > entry in stylesheet.Styles)
{
XmlElement styleNode = enc.Document.CreateElement("add");
styleNode.SetAttribute("as", entry.Key);
foreach (KeyValuePair <string, Object> entry2 in entry.Value)
{
XmlElement entryNode = enc.Document.CreateElement("add");
entryNode.SetAttribute("as", entry2.Key);
entryNode.SetAttribute("value", getStringValue(entry2));
styleNode.AppendChild(entryNode);
}
if (styleNode.ChildNodes.Count > 0)
{
node.AppendChild(styleNode);
}
}
}
return(node);
}
protected void Page_Load(object sender, EventArgs e)
{
// Creates an instance of a graph to add vertices and edges. The instance can
// then be used to create the corresponding XML using a codec. Note that this
// is only required if a graph is programmatically created. If the XML for the
// graph is already at hand, it can be sent directly here.
mxGraph graph = new mxGraph();
Object parent = graph.GetDefaultParent();
// Adds vertices and edges to the graph.
graph.Model.BeginUpdate();
try
{
Object v1 = graph.InsertVertex(parent, null, "Hello,", 20, 20, 80, 30);
Object v2 = graph.InsertVertex(parent, null, "World!", 200, 150, 80, 30);
Object e1 = graph.InsertEdge(parent, null, "Edge", v1, v2);
}
finally
{
graph.Model.EndUpdate();
}
// Encodes the model into XML and passes the resulting XML string into a page
// variable, so it can be read when the page is rendered on the server. Note
// that the page instance is destroyed after the page was sent to the client.
mxCodec codec = new mxCodec();
Xml = mxUtils.GetXml(codec.Encode(graph.Model));
}
/// <summary>
/// Calls decodeAttributes and decodeChildren for the given node.
/// </summary>
protected void DecodeNode(mxCodec dec, XmlNode node, Object obj)
{
if (node != null)
{
DecodeAttributes(dec, node, obj);
DecodeChildren(dec, node, obj);
}
}
/// <summary>
/// Encodes the specified object and returns a node
/// representing then given object. Calls beforeEncode
/// after creating the node and afterEncode with the
/// resulting node after processing.
/// Enc is a reference to the calling encoder. It is used
/// to encode complex objects and create references.
/// </summary>
/// <param name="enc">Codec that controls the encoding process.</param>
/// <param name="obj">Object to be encoded.</param>
/// <returns>Returns the resulting XML node that represents the given object.</returns>
public virtual XmlNode Encode(mxCodec enc, Object obj)
{
XmlNode node = enc.Document.CreateElement(GetName());
obj = BeforeEncode(enc, obj, node);
EncodeObject(enc, obj, node);
return(AfterEncode(enc, obj, node));
}
/// <summary>
/// Encodes the given mxGraphModel by writing a (flat) XML sequence
/// of cell nodes as produced by the mxCellCodec. The sequence is
/// wrapped-up in a node with the name root.
/// </summary>
protected override void EncodeObject(mxCodec enc, Object obj, XmlNode node)
{
if (obj is mxGraphModel)
{
XmlNode rootNode = enc.Document.CreateElement("root");
mxGraphModel model = (mxGraphModel)obj;
enc.EncodeCell((mxICell)model.Root, rootNode, true);
node.AppendChild(rootNode);
}
}
/// <summary>
/// Decodes all attributes of the given node using decodeAttribute.
/// </summary>
protected void DecodeAttributes(mxCodec dec, XmlNode node, Object obj)
{
XmlAttributeCollection attrs = node.Attributes;
if (attrs != null)
{
foreach (XmlAttribute attr in attrs)
{
DecodeAttribute(dec, attr, obj);
}
}
}
/// <summary>
/// Writes the given value into node using writePrimitiveAttribute
/// or writeComplexAttribute depending on the type of the value.
/// </summary>
///
protected void WriteAttribute(mxCodec enc, Object obj, string attr,
Object value, XmlNode node)
{
value = ConvertValueToXml(value);
if (IsPrimitiveValue(value))
{
WritePrimitiveAttribute(enc, obj, attr, value, node);
}
else
{
WriteComplexAttribute(enc, obj, attr, value, node);
}
}
/// <summary>
/// Reads the cells into the graph model. All cells are children of the root
/// element in the node.
/// </summary>
public override XmlNode BeforeDecode(mxCodec dec, XmlNode node, Object into)
{
if (node is XmlElement)
{
XmlElement elt = (XmlElement)node;
mxGraphModel model = null;
if (into is mxGraphModel)
{
model = (mxGraphModel)into;
}
else
{
model = new mxGraphModel();
}
// Reads the cells into the graph model. All cells
// are children of the root element in the node.
XmlNode root = elt.GetElementsByTagName("root")[0];
mxICell rootCell = null;
if (root != null)
{
XmlNode tmp = root.FirstChild;
while (tmp != null)
{
mxICell cell = dec.DecodeCell(tmp, true);
if (cell != null && cell.Parent == null)
{
rootCell = cell;
}
tmp = tmp.NextSibling;
}
root.ParentNode.RemoveChild(root);
}
// Sets the root on the model if one has been decoded
if (rootCell != null)
{
model.Root = rootCell;
}
}
return(node);
}
/// <summary>
/// Reads the cells into the graph model. All cells are children of the root
/// element in the node.
/// </summary>
public override XmlNode BeforeDecode(mxCodec dec, XmlNode node, Object into)
{
if (node is XmlElement)
{
XmlElement elt = (XmlElement)node;
mxGraphModel model = null;
if (into is mxGraphModel)
{
model = (mxGraphModel)into;
}
else
{
model = new mxGraphModel();
}
// Reads the cells into the graph model. All cells
// are children of the root element in the node.
XmlNode root = elt.GetElementsByTagName("root")[0];
mxICell rootCell = null;
if (root != null)
{
XmlNode tmp = root.FirstChild;
while (tmp != null)
{
mxICell cell = dec.DecodeCell(tmp, true);
if (cell != null && cell.Parent == null)
{
rootCell = cell;
}
tmp = tmp.NextSibling;
}
root.ParentNode.RemoveChild(root);
}
// Sets the root on the model if one has been decoded
if (rootCell != null)
{
model.Root = rootCell;
}
}
return node;
}
/// <summary>
/// Reads the given attribute into the specified object.
/// </summary>
protected void DecodeChildren(mxCodec dec, XmlNode node, Object obj)
{
XmlNode child = node.FirstChild;
while (child != null)
{
if (child.NodeType == XmlNodeType.Element &&
!ProcessInclude(dec, child, obj))
{
DecodeChild(dec, child, obj);
}
child = child.NextSibling;
}
}
/// <summary>
/// Writes the given value as an attribute of the given node.
/// </summary>
protected void WritePrimitiveAttribute(mxCodec enc, Object obj,
string attr, Object value, XmlNode node)
{
if (attr == null || obj is IDictionary)
{
XmlNode child = enc.Document.CreateElement("add");
if (attr != null)
{
mxCodec.SetAttribute(child, "as", attr);
}
mxCodec.SetAttribute(child, "value", value);
node.AppendChild(child);
}
else
{
mxCodec.SetAttribute(node, attr, value);
}
}
/// <summary>
/// Writes the given value as a child node of the given node.
/// </summary>
protected void WriteComplexAttribute(mxCodec enc, Object obj, string attr,
Object value, XmlNode node)
{
XmlNode child = enc.Encode(value);
if (child != null)
{
if (attr != null)
{
mxCodec.SetAttribute(child, "as", attr);
}
node.AppendChild(child);
}
else
{
Trace.WriteLine("mxObjectCodec.encode: No node for " +
GetName() + "." + attr + ": " + value);
}
}
/// <summary>
///
/// </summary>
/// <param name="dec">Codec that controls the encoding/decoding process.</param>
/// <param name="node">XML node to be checked.</param>
/// <param name="into">Optional object to pass-thru to the codec.</param>
/// <returns>Returns true if the given node was processed as an include.</returns>
public bool ProcessInclude(mxCodec dec, XmlNode node, Object into)
{
if (node.NodeType == XmlNodeType.Element &&
node.Name.ToLower().Equals("include"))
{
string name = ((XmlElement)node).GetAttribute("name");
if (name != null)
{
XmlNode xml = mxUtils.LoadDocument(name).DocumentElement;
if (xml != null)
{
dec.Decode(xml, into);
}
}
return(true);
}
return(false);
}
/// <summary>
/// Encodes the members of the given object into the given node.
/// </summary>
/// <param name="enc">Codec that controls the encoding process.</param>
/// <param name="obj">Object whose fields should be encoded.</param>
/// <param name="node">XML node that contains the encoded object.</param>
protected void EncodeFields(mxCodec enc, Object obj, XmlNode node)
{
Type type = obj.GetType();
PropertyInfo[] properties = type.GetProperties();
foreach (PropertyInfo property in properties)
{
if (property.CanRead && property.CanWrite)
{
string name = property.Name;
Object value = GetFieldValue(obj, name);
// Removes Is-Prefix from bool properties
if (value is bool && name.StartsWith("Is"))
{
name = name.Substring(2);
}
name = name.Substring(0, 1).ToLower() + name.Substring(1);
EncodeValue(enc, obj, name, value, node);
}
}
}
/// <summary>
/// Encodes the child objects of arrays, dictionaries and enumerables.
/// </summary>
/// <param name="enc">Codec that controls the encoding process.</param>
/// <param name="obj">Object whose child objects should be encoded.</param>
/// <param name="node">XML node that contains the encoded object.</param>
protected void EncodeElements(mxCodec enc, Object obj, XmlNode node)
{
if (obj.GetType().IsArray)
{
foreach (Object o in ((Object[])obj))
{
EncodeValue(enc, obj, null, o, node);
}
}
else if (obj is IDictionary)
{
foreach (KeyValuePair <string, string> entry in ((IDictionary)mapping))
{
EncodeValue(enc, obj, entry.Key, entry.Value, node);
}
}
else if (obj is IEnumerable)
{
foreach (Object value in ((IEnumerable)obj))
{
EncodeValue(enc, obj, null, value, node);
}
}
}
/// <summary>
/// Hook for subclassers to pre-process the object before
/// encoding. This returns the input object. The return
/// value of this function is used in encode to perform
/// the default encoding into the given node.
/// </summary>
/// <param name="enc">Codec that controls the encoding process.</param>
/// <param name="obj">Object to be encoded.</param>
/// <param name="node">XML node to encode the object into.</param>
/// <returns>Returns the object to be encoded by the default encoding.</returns>
public virtual Object BeforeEncode(mxCodec enc, Object obj, XmlNode node)
{
return obj;
}
/// <summary>
/// Hook for subclassers to pre-process the node for
/// the specified object and return the node to be
/// used for further processing by decode.
/// The object is created based on the template in the
/// calling method and is never null. This implementation
/// returns the input node. The return value of this
/// function is used in decode to perform
/// the default decoding into the given object.
/// </summary>
/// <param name="dec">Codec that controls the decoding process.</param>
/// <param name="node">XML node to be decoded.</param>
/// <param name="obj">Object to encode the node into.</param>
/// <returns>Returns the node used for the default decoding.</returns>
public virtual XmlNode BeforeDecode(mxCodec dec, XmlNode node, Object obj)
{
return node;
}
/// <summary>
/// Hook for subclassers to Receive-process the node
/// for the given object after encoding and return the
/// Receive-processed node. This implementation returns
/// the input node. The return value of this method
/// is returned to the encoder from encode.
/// </summary>
/// <param name="enc">Codec that controls the encoding process.</param>
/// <param name="obj">Object to be encoded.</param>
/// <param name="node">XML node that represents the default encoding.</param>
/// <returns>Returns the resulting node of the encoding.</returns>
public virtual XmlNode AfterEncode(mxCodec enc, Object obj, XmlNode node)
{
return(node);
}
/// <summary>
/// Writes the given value as a child node of the given node.
/// </summary>
protected void WriteComplexAttribute(mxCodec enc, Object obj, string attr,
Object value, XmlNode node)
{
XmlNode child = enc.Encode(value);
if (child != null)
{
if (attr != null)
{
mxCodec.SetAttribute(child, "as", attr);
}
node.AppendChild(child);
}
else
{
Trace.WriteLine("mxObjectCodec.encode: No node for " +
GetName() + "." + attr + ": " + value);
}
}
/// <summary>
/// Decodes an mxCell and uses the enclosing XML node as
/// the user object for the cell (inversion).
/// </summary>
public override XmlNode BeforeDecode(mxCodec dec, XmlNode node, Object obj)
{
XmlElement inner = (XmlElement)node;
if (obj is mxCell)
{
mxCell cell = (mxCell)obj;
String classname = GetName();
if (!node.Name.Equals(classname))
{
// Passes the inner graphical annotation node to the
// object codec for further processing of the cell.
XmlNode tmp = inner.GetElementsByTagName(classname)[0];
if (tmp != null && tmp.ParentNode == node)
{
inner = (XmlElement)tmp;
// Removes annotation and whitespace from node
XmlNode tmp2 = tmp.PreviousSibling;
while (tmp2 != null && tmp2.NodeType == XmlNodeType.Text)
{
XmlNode tmp3 = tmp2.PreviousSibling;
if (tmp2.Value.Trim().Length == 0)
{
tmp2.ParentNode.RemoveChild(tmp2);
}
tmp2 = tmp3;
}
// Removes more whitespace
tmp2 = tmp.NextSibling;
while (tmp2 != null && tmp2.NodeType == XmlNodeType.Text)
{
XmlNode tmp3 = tmp2.PreviousSibling;
if (tmp2.Value.Trim().Length == 0)
{
tmp2.ParentNode.RemoveChild(tmp2);
}
tmp2 = tmp3;
}
tmp.ParentNode.RemoveChild(tmp);
}
else
{
inner = null;
}
// Creates the user object out of the XML node
XmlElement value = (XmlElement)node.CloneNode(true);
cell.Value = value;
String id = value.GetAttribute("id");
if (id != null)
{
cell.Id = id;
value.RemoveAttribute("id");
}
}
else
{
cell.Id = ((XmlElement)node).GetAttribute("id");
}
// Preprocesses and removes all Id-references
// in order to use the correct encoder (this)
// for the known references to cells (all).
if (inner != null && idrefs != null)
{
foreach (string attr in idrefs)
{
string rf = inner.GetAttribute(attr);
if (rf != null && rf.Length > 0)
{
inner.RemoveAttribute(attr);
Object tmp = (dec.Objects.ContainsKey(rf)) ? dec.Objects[rf] : null;
if (tmp == null)
{
tmp = dec.Lookup(rf);
}
if (tmp == null)
{
// Needs to decode forward reference
XmlNode element = dec.GetElementById(rf);
if (element != null)
{
mxObjectCodec decoder = mxCodecRegistry
.GetCodec(element.Name);
if (decoder == null)
{
decoder = this;
}
tmp = decoder.Decode(dec, element);
}
}
SetFieldValue(obj, attr, tmp);
}
}
}
}
return inner;
}
/// <summary>
/// Reads the given attribute into the specified object.
/// </summary>
protected void DecodeAttribute(mxCodec dec, XmlNode attr, Object obj)
{
string name = attr.Name;
if (!name.ToLower().Equals("as") &&
!name.ToLower().Equals("id"))
{
Object value = attr.Value;
string fieldname = GetFieldName(name);
if (IsReference(obj, fieldname, value, false))
{
Object tmp = dec.GetObject(value.ToString());
if (tmp == null)
{
Trace.WriteLine("mxObjectCodec.decode: No object for " +
GetName() + "." + fieldname + "=" + value);
return; // exit
}
value = tmp;
}
if (!IsExcluded(obj, fieldname, value, false))
{
SetFieldValue(obj, fieldname, value);
}
}
}
/// <summary>
/// Encodes the specified object and returns a node
/// representing then given object. Calls beforeEncode
/// after creating the node and afterEncode with the
/// resulting node after processing.
/// Enc is a reference to the calling encoder. It is used
/// to encode complex objects and create references.
/// </summary>
/// <param name="enc">Codec that controls the encoding process.</param>
/// <param name="obj">Object to be encoded.</param>
/// <returns>Returns the resulting XML node that represents the given object.</returns>
public virtual XmlNode Encode(mxCodec enc, Object obj)
{
XmlNode node = enc.Document.CreateElement(GetName());
obj = BeforeEncode(enc, obj, node);
EncodeObject(enc, obj, node);
return AfterEncode(enc, obj, node);
}
/// <summary>
/// Reads the specified child into the given object.
/// </summary>
protected void DecodeChild(mxCodec dec, XmlNode child, Object obj)
{
string fieldname = GetFieldName(((XmlElement)child).GetAttribute("as"));
if (fieldname == null || !IsExcluded(obj, fieldname, child, false))
{
Object template = GetFieldTemplate(obj, fieldname, child);
Object value = null;
if (child.Name.Equals("add"))
{
value = ((XmlElement)child).GetAttribute("value");
if (value == null)
{
value = child.InnerText;
}
}
else
{
value = dec.Decode(child, template);
}
AddObjectValue(obj, fieldname, value, template);
}
}
/// <summary>
/// Encode the given mxStylesheet.
/// </summary>
public override XmlNode Encode(mxCodec enc, Object obj)
{
XmlElement node = enc.Document.CreateElement(GetName());
if (obj is mxStylesheet)
{
mxStylesheet stylesheet = (mxStylesheet) obj;
foreach (KeyValuePair<string, Dictionary<string, Object>> entry in stylesheet.Styles)
{
XmlElement styleNode = enc.Document.CreateElement("add");
styleNode.SetAttribute("as", entry.Key);
foreach (KeyValuePair<string, Object> entry2 in entry.Value)
{
XmlElement entryNode = enc.Document.CreateElement("add");
entryNode.SetAttribute("as", entry2.Key);
entryNode.SetAttribute("value", getStringValue(entry2));
styleNode.AppendChild(entryNode);
}
if (styleNode.ChildNodes.Count > 0)
{
node.AppendChild(styleNode);
}
}
}
return node;
}
/// <summary>
/// Hook for subclassers to pre-process the node for
/// the specified object and return the node to be
/// used for further processing by decode.
/// The object is created based on the template in the
/// calling method and is never null. This implementation
/// returns the input node. The return value of this
/// function is used in decode to perform
/// the default decoding into the given object.
/// </summary>
/// <param name="dec">Codec that controls the decoding process.</param>
/// <param name="node">XML node to be decoded.</param>
/// <param name="obj">Object to encode the node into.</param>
/// <returns>Returns the node used for the default decoding.</returns>
public virtual XmlNode BeforeDecode(mxCodec dec, XmlNode node, Object obj)
{
return(node);
}
/// <summary>
/// Decodes an mxCell and uses the enclosing XML node as
/// the user object for the cell (inversion).
/// </summary>
public override XmlNode BeforeDecode(mxCodec dec, XmlNode node, Object obj)
{
XmlElement inner = (XmlElement)node;
if (obj is mxCell)
{
mxCell cell = (mxCell)obj;
String classname = GetName();
if (!node.Name.Equals(classname))
{
// Passes the inner graphical annotation node to the
// object codec for further processing of the cell.
XmlNode tmp = inner.GetElementsByTagName(classname)[0];
if (tmp != null && tmp.ParentNode == node)
{
inner = (XmlElement)tmp;
// Removes annotation and whitespace from node
XmlNode tmp2 = tmp.PreviousSibling;
while (tmp2 != null && tmp2.NodeType == XmlNodeType.Text)
{
XmlNode tmp3 = tmp2.PreviousSibling;
if (tmp2.Value.Trim().Length == 0)
{
tmp2.ParentNode.RemoveChild(tmp2);
}
tmp2 = tmp3;
}
// Removes more whitespace
tmp2 = tmp.NextSibling;
while (tmp2 != null && tmp2.NodeType == XmlNodeType.Text)
{
XmlNode tmp3 = tmp2.PreviousSibling;
if (tmp2.Value.Trim().Length == 0)
{
tmp2.ParentNode.RemoveChild(tmp2);
}
tmp2 = tmp3;
}
tmp.ParentNode.RemoveChild(tmp);
}
else
{
inner = null;
}
// Creates the user object out of the XML node
XmlElement value = (XmlElement)node.CloneNode(true);
cell.Value = value;
String id = value.GetAttribute("id");
if (id != null)
{
cell.Id = id;
value.RemoveAttribute("id");
}
}
else
{
cell.Id = ((XmlElement)node).GetAttribute("id");
}
// Preprocesses and removes all Id-references
// in order to use the correct encoder (this)
// for the known references to cells (all).
if (inner != null && idrefs != null)
{
foreach (string attr in idrefs)
{
string rf = inner.GetAttribute(attr);
if (rf != null && rf.Length > 0)
{
inner.RemoveAttribute(attr);
Object tmp = (dec.Objects.ContainsKey(rf)) ? dec.Objects[rf] : null;
if (tmp == null)
{
tmp = dec.Lookup(rf);
}
if (tmp == null)
{
// Needs to decode forward reference
XmlNode element = dec.GetElementById(rf);
if (element != null)
{
mxObjectCodec decoder = mxCodecRegistry
.GetCodec(element.Name);
if (decoder == null)
{
decoder = this;
}
tmp = decoder.Decode(dec, element);
}
}
SetFieldValue(obj, attr, tmp);
}
}
}
}
return(inner);
}
/// <summary>
/// Hook for subclassers to Receive-process the object after
/// decoding. This implementation returns the given object
/// without any changes. The return value of this method
/// is returned to the decoder from decode.
/// </summary>
/// <param name="dec">Codec that controls the decoding process.</param>
/// <param name="node">XML node to be decoded.</param>
/// <param name="obj">Object that represents the default decoding.</param>
/// <returns>Returns the result of the decoding process.</returns>
public virtual Object AfterDecode(mxCodec dec, XmlNode node, Object obj)
{
return(obj);
}
/// <summary>
/// Parses the given node into the object or returns a new object
/// representing the given node.
/// </summary>
/// <param name="dec">Codec that controls the encoding process.</param>
/// <param name="node">XML node to be decoded.</param>
/// <returns>Returns the resulting object that represents the given XML node.</returns>
public virtual Object Decode(mxCodec dec, XmlNode node)
{
return Decode(dec, node, null);
}
/// <summary>
/// Calls decodeAttributes and decodeChildren for the given node.
/// </summary>
protected void DecodeNode(mxCodec dec, XmlNode node, Object obj)
{
if (node != null)
{
DecodeAttributes(dec, node, obj);
DecodeChildren(dec, node, obj);
}
}
/// <summary>
/// Parses the given node into the object or returns a new object
/// representing the given node.
/// Dec is a reference to the calling decoder. It is used to decode
/// complex objects and resolve references.
/// If a node has an id attribute then the object cache is checked for the
/// object. If the object is not yet in the cache then it is constructed
/// using the constructor of template and cached in mxCodec.objects.
/// This implementation decodes all attributes and childs of a node
/// according to the following rules:
/// - If the variable name is in exclude or if the attribute name is "id"
/// or "as" then it is ignored.
/// - If the variable name is in idrefs then mxCodec.getObject is used
/// to replace the reference with an object.
/// - The variable name is mapped using a reverse mapping.
/// - If the value has a child node, then the codec is used to create a
/// child object with the variable name taken from the "as" attribute.
/// - If the object is an array and the variable name is empty then the
/// value or child object is appended to the array.
/// - If an add child has no value or the object is not an array then
/// the child text content is evaluated using mxUtils.eval.
/// If no object exists for an ID in idrefs a warning is issued
/// using mxLog.warn.
/// Returns the resulting object that represents the given XML
/// node or the configured given object.
/// </summary>
/// <param name="dec">Codec that controls the encoding process.</param>
/// <param name="node">XML node to be decoded.</param>
/// <param name="into">Optional objec to encode the node into.</param>
/// <returns>Returns the resulting object that represents the given XML node
/// or the object given to the method as the into parameter.</returns>
public virtual Object Decode(mxCodec dec, XmlNode node, Object into)
{
Object obj = null;
if (node is XmlElement)
{
string id = ((XmlElement)node).GetAttribute("id");
obj = (dec.Objects.ContainsKey(id)) ? dec.Objects[id] : null;
if (obj == null)
{
obj = into;
if (obj == null)
{
obj = CloneTemplate(node);
}
if (id != null && id.Length > 0)
{
dec.PutObject(id, obj);
}
}
node = BeforeDecode(dec, node, obj);
DecodeNode(dec, node, obj);
obj = AfterDecode(dec, node, obj);
}
return obj;
}
/// <summary>
/// Encodes the members of the given object into the given node.
/// </summary>
/// <param name="enc">Codec that controls the encoding process.</param>
/// <param name="obj">Object whose fields should be encoded.</param>
/// <param name="node">XML node that contains the encoded object.</param>
protected void EncodeFields(mxCodec enc, Object obj, XmlNode node)
{
Type type = obj.GetType();
PropertyInfo[] properties = type.GetProperties();
foreach (PropertyInfo property in properties)
{
if (property.CanRead && property.CanWrite)
{
string name = property.Name;
Object value = GetFieldValue(obj, name);
// Removes Is-Prefix from bool properties
if (value is bool && name.StartsWith("Is"))
{
name = name.Substring(2);
}
name = name.Substring(0, 1).ToLower() + name.Substring(1);
EncodeValue(enc, obj, name, value, node);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="dec">Codec that controls the encoding/decoding process.</param>
/// <param name="node">XML node to be checked.</param>
/// <param name="into">Optional object to pass-thru to the codec.</param>
/// <returns>Returns true if the given node was processed as an include.</returns>
public bool ProcessInclude(mxCodec dec, XmlNode node, Object into)
{
if (node.NodeType == XmlNodeType.Element
&& node.Name.ToLower().Equals("include"))
{
string name = ((XmlElement)node).GetAttribute("name");
if (name != null)
{
XmlNode xml = mxUtils.LoadDocument(name).DocumentElement;
if (xml != null)
{
dec.Decode(xml, into);
}
}
return true;
}
return false;
}
/// <summary>
/// Converts the given value according to the mappings and id-refs in
/// this codec and uses writeAttribute to write the attribute into the
/// given node.
/// </summary>
/// <param name="enc">Codec that controls the encoding process.</param>
/// <param name="obj">Object whose member is going to be encoded.</param>
/// <param name="fieldname"></param>
/// <param name="value">Value of the property to be encoded.</param>
/// <param name="node">XML node that contains the encoded object.</param>
protected void EncodeValue(mxCodec enc, Object obj, string fieldname,
Object value, XmlNode node)
{
if (value != null && !IsExcluded(obj, fieldname, value, true))
{
if (IsReference(obj, fieldname, value, true))
{
Object tmp = enc.GetId(value);
if (tmp == null)
{
Trace.WriteLine("mxObjectCodec.encode: No ID for " +
GetName() + "." + fieldname + "=" + value);
return; // exit
}
value = tmp;
}
Object defaultValue = GetFieldValue(template, fieldname);
if (fieldname == null || enc.IsEncodeDefaults
|| defaultValue == null || !defaultValue.Equals(value))
{
WriteAttribute(enc, obj, GetAttributeName(fieldname), value,
node);
}
}
}
/// <summary>
/// Decodes all attributes of the given node using decodeAttribute.
/// </summary>
protected void DecodeAttributes(mxCodec dec, XmlNode node, Object obj)
{
XmlAttributeCollection attrs = node.Attributes;
if (attrs != null)
{
foreach (XmlAttribute attr in attrs)
{
DecodeAttribute(dec, attr, obj);
}
}
}
/// <summary>
/// Hook for subclassers to pre-process the object before
/// encoding. This returns the input object. The return
/// value of this function is used in encode to perform
/// the default encoding into the given node.
/// </summary>
/// <param name="enc">Codec that controls the encoding process.</param>
/// <param name="obj">Object to be encoded.</param>
/// <param name="node">XML node to encode the object into.</param>
/// <returns>Returns the object to be encoded by the default encoding.</returns>
public virtual Object BeforeEncode(mxCodec enc, Object obj, XmlNode node)
{
return(obj);
}
/// <summary>
/// Reads the given attribute into the specified object.
/// </summary>
protected void DecodeChildren(mxCodec dec, XmlNode node, Object obj)
{
XmlNode child = node.FirstChild;
while (child != null)
{
if (child.NodeType == XmlNodeType.Element
&& !ProcessInclude(dec, child, obj))
{
DecodeChild(dec, child, obj);
}
child = child.NextSibling;
}
}
/// <summary>
/// Encodes the value of each member in then given obj
/// into the given node using encodeFields and encodeElements.
/// </summary>
/// <param name="enc">Codec that controls the encoding process.</param>
/// <param name="obj">Object to be encoded.</param>
/// <param name="node">XML node that contains the encoded object.</param>
protected virtual void EncodeObject(mxCodec enc, Object obj, XmlNode node)
{
mxCodec.SetAttribute(node, "id", enc.GetId(obj));
EncodeFields(enc, obj, node);
EncodeElements(enc, obj, node);
}
/// <summary>
/// Encodes the child objects of arrays, dictionaries and enumerables.
/// </summary>
/// <param name="enc">Codec that controls the encoding process.</param>
/// <param name="obj">Object whose child objects should be encoded.</param>
/// <param name="node">XML node that contains the encoded object.</param>
protected void EncodeElements(mxCodec enc, Object obj, XmlNode node)
{
if (obj.GetType().IsArray)
{
foreach (Object o in ((Object[])obj))
{
EncodeValue(enc, obj, null, o, node);
}
}
else if (obj is IDictionary)
{
foreach (KeyValuePair<string, string> entry in ((IDictionary)mapping))
{
EncodeValue(enc, obj, entry.Key, entry.Value, node);
}
}
else if (obj is IEnumerable)
{
foreach (Object value in ((IEnumerable)obj))
{
EncodeValue(enc, obj, null, value, node);
}
}
}
/// <summary>
/// Decodes the given mxStylesheet.
/// </summary>
public override Object Decode(mxCodec dec, XmlNode node, Object into)
{
Object obj = null;
if (node is XmlElement)
{
string id = ((XmlElement)node).GetAttribute("id");
obj = (dec.Objects.ContainsKey(id)) ? dec.Objects[id] : null;
if (obj == null)
{
obj = into;
if (obj == null)
{
obj = CloneTemplate(node);
}
if (id != null && id.Length > 0)
{
dec.PutObject(id, obj);
}
}
node = node.FirstChild;
while (node != null)
{
if (!ProcessInclude(dec, node, obj) && node.Name.Equals("add") && node is XmlElement)
{
string name = ((XmlElement)node).GetAttribute("as");
if (name != null && name.Length > 0)
{
string extend = ((XmlElement)node).GetAttribute("extend");
Dictionary <string, Object> style = (extend != null && ((mxStylesheet)obj).Styles.ContainsKey(extend)) ?
((mxStylesheet)obj).Styles[extend] : null;
if (style == null)
{
style = new Dictionary <string, Object>();
}
else
{
style = new Dictionary <string, Object>(style);
}
XmlNode entry = node.FirstChild;
while (entry != null)
{
if (entry is XmlElement)
{
XmlElement entryElement = (XmlElement)entry;
string key = entryElement.GetAttribute("as");
if (entry.Name.Equals("add"))
{
string text = entryElement.Value;
Object value = null;
if (text != null && text.Length > 0)
{
value = mxUtils.Eval(text);
}
else
{
value = entryElement.GetAttribute("value");
}
if (value != null)
{
style[key] = value;
}
}
else if (entry.Name.Equals("remove"))
{
style.Remove(key);
}
}
entry = entry.NextSibling;
}
((mxStylesheet)obj).PutCellStyle(name, style);
}
}
node = node.NextSibling;
}
}
return(obj);
}
/// <summary>
/// Encodes the value of each member in then given obj
/// into the given node using encodeFields and encodeElements.
/// </summary>
/// <param name="enc">Codec that controls the encoding process.</param>
/// <param name="obj">Object to be encoded.</param>
/// <param name="node">XML node that contains the encoded object.</param>
protected virtual void EncodeObject(mxCodec enc, Object obj, XmlNode node)
{
mxCodec.SetAttribute(node, "id", enc.GetId(obj));
EncodeFields(enc, obj, node);
EncodeElements(enc, obj, node);
}
/// <summary>
/// Hook for subclassers to Receive-process the object after
/// decoding. This implementation returns the given object
/// without any changes. The return value of this method
/// is returned to the decoder from decode.
/// </summary>
/// <param name="dec">Codec that controls the decoding process.</param>
/// <param name="node">XML node to be decoded.</param>
/// <param name="obj">Object that represents the default decoding.</param>
/// <returns>Returns the result of the decoding process.</returns>
public virtual Object AfterDecode(mxCodec dec, XmlNode node, Object obj)
{
return obj;
}
/// <summary>
/// Writes the given value into node using writePrimitiveAttribute
/// or writeComplexAttribute depending on the type of the value.
/// </summary>
///
protected void WriteAttribute(mxCodec enc, Object obj, string attr,
Object value, XmlNode node)
{
value = ConvertValueToXml(value);
if (IsPrimitiveValue(value))
{
WritePrimitiveAttribute(enc, obj, attr, value, node);
}
else
{
WriteComplexAttribute(enc, obj, attr, value, node);
}
}
/// <summary>
/// Hook for subclassers to Receive-process the node
/// for the given object after encoding and return the
/// Receive-processed node. This implementation returns
/// the input node. The return value of this method
/// is returned to the encoder from encode.
/// </summary>
/// <param name="enc">Codec that controls the encoding process.</param>
/// <param name="obj">Object to be encoded.</param>
/// <param name="node">XML node that represents the default encoding.</param>
/// <returns>Returns the resulting node of the encoding.</returns>
public virtual XmlNode AfterEncode(mxCodec enc, Object obj, XmlNode node)
{
return node;
}
/// <summary>
/// Writes the given value as an attribute of the given node.
/// </summary>
protected void WritePrimitiveAttribute(mxCodec enc, Object obj,
string attr, Object value, XmlNode node)
{
if (attr == null || obj is IDictionary)
{
XmlNode child = enc.Document.CreateElement("add");
if (attr != null)
{
mxCodec.SetAttribute(child, "as", attr);
}
mxCodec.SetAttribute(child, "value", value);
node.AppendChild(child);
}
else
{
mxCodec.SetAttribute(node, attr, value);
}
}
/// <summary>
/// Parses the given node into the object or returns a new object
/// representing the given node.
/// </summary>
/// <param name="dec">Codec that controls the encoding process.</param>
/// <param name="node">XML node to be decoded.</param>
/// <returns>Returns the resulting object that represents the given XML node.</returns>
public virtual Object Decode(mxCodec dec, XmlNode node)
{
return(Decode(dec, node, null));
}
/// <summary>
/// Decodes the given mxStylesheet.
/// </summary>
public override Object Decode(mxCodec dec, XmlNode node, Object into)
{
Object obj = null;
if (node is XmlElement)
{
string id = ((XmlElement)node).GetAttribute("id");
obj = (dec.Objects.ContainsKey(id)) ? dec.Objects[id] : null;
if (obj == null)
{
obj = into;
if (obj == null)
{
obj = CloneTemplate(node);
}
if (id != null && id.Length > 0)
{
dec.PutObject(id, obj);
}
}
node = node.FirstChild;
while (node != null)
{
if (!ProcessInclude(dec, node, obj) && node.Name.Equals("add") && node is XmlElement)
{
string name = ((XmlElement) node).GetAttribute("as");
if (name != null && name.Length > 0)
{
string extend = ((XmlElement) node).GetAttribute("extend");
Dictionary<string, Object> style = (extend != null && ((mxStylesheet)obj).Styles.ContainsKey(extend)) ?
((mxStylesheet)obj).Styles[extend] : null;
if (style == null)
{
style = new Dictionary<string, Object>();
}
else
{
style = new Dictionary<string, Object>(style);
}
XmlNode entry = node.FirstChild;
while (entry != null)
{
if (entry is XmlElement)
{
XmlElement entryElement = (XmlElement)entry;
string key = entryElement.GetAttribute("as");
if (entry.Name.Equals("add"))
{
string text = entryElement.Value;
Object value = null;
if (text != null && text.Length > 0)
{
value = mxUtils.Eval(text);
}
else
{
value = entryElement.GetAttribute("value");
}
if (value != null)
{
style[key] = value;
}
}
else if (entry.Name.Equals("remove"))
{
style.Remove(key);
}
}
entry = entry.NextSibling;
}
((mxStylesheet) obj).PutCellStyle(name, style);
}
}
node = node.NextSibling;
}
}
return obj;
}
/// <summary>
/// Encodes the given mxGraphModel by writing a (flat) XML sequence
/// of cell nodes as produced by the mxCellCodec. The sequence is
/// wrapped-up in a node with the name root.
/// </summary>
protected override void EncodeObject(mxCodec enc, Object obj, XmlNode node)
{
if (obj is mxGraphModel)
{
XmlNode rootNode = enc.Document.CreateElement("root");
mxGraphModel model = (mxGraphModel)obj;
enc.EncodeCell((mxICell)model.Root, rootNode, true);
node.AppendChild(rootNode);
}
}